RobotRampage updated to SDK and MG 3.8.*

XNAGameDevelopmentbyExample/RobotRampage/.vscode/launch.json

@@ -0,0 +1,27 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch DesktopGL",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build-desktopgl",
+            "program": "${workspaceFolder}/Platforms/Desktop/bin/Debug/net8.0/RobotRampage",
+            "args": [],
+            "cwd": "${workspaceFolder}",
+            "console": "internalConsole",
+            "stopAtEntry": false
+        },
+        {
+            "name": "Launch Windows",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build-windows",
+            "program": "${workspaceFolder}/Platforms/Windows/bin/Debug/net8.0-windows/RobotRampage.exe",
+            "args": [],
+            "cwd": "${workspaceFolder}",
+            "console": "internalConsole",
+            "stopAtEntry": false
+        }
+    ]
+}

XNAGameDevelopmentbyExample/RobotRampage/.vscode/tasks.json

@@ -0,0 +1,53 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build-desktopgl",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/Platforms/Desktop/RobotRampage.DesktopGL.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "group": "build",
+            "presentation": {
+                "reveal": "silent"
+            },
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "build-windows",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/Platforms/Windows/RobotRampage.Windows.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "group": "build",
+            "presentation": {
+                "reveal": "silent"
+            },
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "build-android",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}//Platforms/Android/RobotRampage.Android.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "group": "build",
+            "presentation": {
+                "reveal": "silent"
+            },
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/Camera.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+
+namespace Robot_Rampage
+{
+    public static class Camera
+    {
+        #region Declarations
+        private static Vector2 position = Vector2.Zero;
+        private static Vector2 viewPortSize = Vector2.Zero;
+        private static Rectangle worldRectangle = new Rectangle(0, 0, 0, 0);
+        #endregion
+
+        #region Properties
+        public static Vector2 Position
+        {
+            get { return position; }
+            set
+            {
+                position = new Vector2(
+                    MathHelper.Clamp(value.X,
+                        worldRectangle.X,
+                        worldRectangle.Width - ViewPortWidth),
+                    MathHelper.Clamp(value.Y,
+                        worldRectangle.Y,
+                        worldRectangle.Height - ViewPortHeight));
+            }
+        }
+
+        public static Rectangle WorldRectangle
+        {
+            get { return worldRectangle; }
+            set { worldRectangle = value; }
+        }
+
+        public static int ViewPortWidth
+        {
+            get { return (int)viewPortSize.X; }
+            set { viewPortSize.X = value; }
+        }
+
+        public static int ViewPortHeight
+        {
+            get { return (int)viewPortSize.Y; }
+            set { viewPortSize.Y = value; }
+        }
+
+        public static Rectangle ViewPort
+        {
+            get
+            {
+                return new Rectangle(
+                    (int)Position.X, (int)Position.Y,
+                    ViewPortWidth, ViewPortHeight);
+            }
+        }
+        #endregion
+
+        #region Public Methods
+        public static void Move(Vector2 offset)
+        {
+            Position += offset;
+        }
+
+        public static bool ObjectIsVisible(Rectangle bounds)
+        {
+            return (ViewPort.Intersects(bounds));
+        }
+
+        public static Vector2 Transform(Vector2 point)
+        {
+            return point - position;
+        }
+
+        public static Rectangle Transform(Rectangle rectangle)
+        {
+            return new Rectangle(
+                rectangle.Left - (int)position.X,
+                rectangle.Top - (int)position.Y,
+                rectangle.Width,
+                rectangle.Height);
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/ComputerTerminal.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Robot_Rampage
+{
+    class ComputerTerminal
+    {
+        #region Declarations
+        private Sprite activeSprite;
+        private Sprite inactiveSprite;
+        public Vector2 MapLocation;
+        public bool Active = true;
+        public float LastSpawnCounter = 0;
+        public float minSpawnTime = 6.0f;
+        #endregion
+
+        #region Constructor
+        public ComputerTerminal(
+            Sprite activeSprite,
+            Sprite inactiveSprite,
+            Vector2 mapLocation)
+        {
+            MapLocation = mapLocation;
+            this.activeSprite = activeSprite;
+            this.inactiveSprite = inactiveSprite;
+        }
+        #endregion
+
+        #region Public Methods
+        public bool IsCircleColliding(Vector2 otherCenter, float radius)
+        {
+            if (!Active)
+            {
+                return false;
+            }
+
+            return activeSprite.IsCircleColliding(otherCenter, radius);
+        }
+
+        public void Deactivate()
+        {
+            Active = false;
+        }
+
+        public void Update(GameTime gameTime)
+        {
+            if (Active)
+            {
+                float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
+
+                LastSpawnCounter += elapsed;
+                if (LastSpawnCounter > minSpawnTime)
+                {
+                    if (Vector2.Distance(activeSprite.WorldCenter,
+                        Player.BaseSprite.WorldCenter) > 128)
+                    {
+                        if (EnemyManager.Enemies.Count <
+                            EnemyManager.MaxActiveEnemies)
+                        {
+                            EnemyManager.AddEnemy(MapLocation);
+                            LastSpawnCounter = 0;
+                        }
+                    }
+                }
+
+                activeSprite.Update(gameTime);
+            }
+            else
+            {
+                inactiveSprite.Update(gameTime);
+            }
+        }
+
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            if (Active)
+            {
+                activeSprite.Draw(spriteBatch);
+            }
+            else
+            {
+                inactiveSprite.Draw(spriteBatch);
+            }
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/Content/app.manifest

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity version="1.0.0.0" name="RobotRampage"/>
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
+    <security>
+      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
+        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <!-- A list of the Windows versions that this application has been tested on and is
+           is designed to work with. Uncomment the appropriate elements and Windows will 
+           automatically selected the most compatible environment. -->
+
+      <!-- Windows Vista -->
+      <!--<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" />-->
+
+      <!-- Windows 7 -->
+      <!--<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />-->
+
+      <!-- Windows 8 -->
+      <!--<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />-->
+
+      <!-- Windows 8.1 -->
+      <!--<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />-->
+
+      <!-- Windows 10 -->
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
+
+    </application>
+  </compatibility>
+
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware>
+      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">permonitorv2,permonitor</dpiAwareness>
+    </windowsSettings>
+  </application>
+
+</assembly>

XNAGameDevelopmentbyExample/RobotRampage/Core/EffectsManager.cs

@@ -0,0 +1,184 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Robot_Rampage
+{
+    static class EffectsManager
+    {
+        #region Declarations
+        static public List<Particle> Effects = new List<Particle>();
+        static Random rand = new Random();
+        static public Texture2D Texture;
+        static public Rectangle ParticleFrame = new Rectangle(0, 288, 2, 2);
+        static public List<Rectangle> ExplosionFrames =
+            new List<Rectangle>();
+        #endregion
+
+        #region Initialization
+        public static void Initialize(
+            Texture2D texture,
+            Rectangle particleFrame,
+            Rectangle explosionFrame,
+            int explosionFrameCount)
+        {
+            Texture = texture;
+            ParticleFrame = particleFrame;
+            ExplosionFrames.Clear();
+            ExplosionFrames.Add(explosionFrame);
+            for (int x = 1; x < explosionFrameCount; x++)
+            {
+                explosionFrame.Offset(explosionFrame.Width, 0);
+                ExplosionFrames.Add(explosionFrame);
+            }
+        }
+        #endregion
+
+        #region Helper Methods
+        public static Vector2 randomDirection(float scale)
+        {
+            Vector2 direction;
+            do
+            {
+                direction = new Vector2(
+                rand.Next(0, 100) - 50,
+                rand.Next(0, 100) - 50);
+            } while (direction.Length() == 0);
+            direction.Normalize();
+            direction *= scale;
+
+            return direction;
+        }
+        #endregion
+
+        #region Public Methods
+        static public void Update(GameTime gameTime)
+        {
+            for (int x = Effects.Count - 1; x >= 0; x--)
+            {
+                Effects[x].Update(gameTime);
+                if (Effects[x].Expired)
+                {
+                    Effects.RemoveAt(x);
+                }
+            }
+        }
+
+        static public void Draw(SpriteBatch spriteBatch)
+        {
+            foreach (Sprite sprite in Effects)
+            {
+                sprite.Draw(spriteBatch);
+            }
+        }
+
+        public static void AddExplosion(
+            Vector2 location,
+            Vector2 momentum,
+            int minPointCount,
+            int maxPointCount,
+            int minPieceCount,
+            int maxPieceCount,
+            float pieceSpeedScale,
+            int duration,
+            Color initialColor,
+            Color finalColor)
+        {
+            float explosionMaxSpeed = 30f;
+            int pointSpeedMin = (int)pieceSpeedScale * 2;
+            int pointSpeedMax = (int)pieceSpeedScale * 3;
+
+            Vector2 pieceLocation = location -
+                new Vector2(ExplosionFrames[0].Width / 2,
+                    ExplosionFrames[0].Height / 2);
+
+            int pieces = rand.Next(minPieceCount, maxPieceCount + 1);
+            for (int x = 0; x < pieces; x++)
+            {
+                Effects.Add(new Particle(
+                    pieceLocation,
+                    Texture,
+                    ExplosionFrames[rand.Next(0, ExplosionFrames.Count)],
+                    randomDirection(pieceSpeedScale) + momentum,
+                    Vector2.Zero,
+                    explosionMaxSpeed,
+                    duration,
+                    initialColor,
+                    finalColor));
+            }
+
+            int points = rand.Next(minPointCount, maxPointCount + 1);
+            for (int x = 0; x < points; x++)
+            {
+                Effects.Add(new Particle(
+                    location,
+                    Texture,
+                    ParticleFrame,
+                    randomDirection((float)rand.Next(
+                        pointSpeedMin, pointSpeedMax)) + momentum,
+                    Vector2.Zero,
+                    explosionMaxSpeed,
+                    duration,
+                    initialColor,
+                    finalColor));
+
+            }
+        }
+
+        public static void AddExplosion(Vector2 location, Vector2 momentum)
+        {
+            AddExplosion(
+                location,
+                momentum,
+                15,
+                20,
+                2,
+                4,
+                6.0f,
+                90,
+                new Color(1.0f, 0.3f, 0f, 0.5f),
+                new Color(0.0f, 0.0f, 0f, 0f));
+        }
+
+        public static void AddLargeExplosion(Vector2 location)
+        {
+            AddExplosion(
+                location,
+                Vector2.Zero,
+                15,
+                20,
+                4,
+                6,
+                30f,
+                90,
+                new Color(1.0f, 0.3f, 0f, 0.5f),
+                new Color(0.0f, 0.0f, 0f, 0f));
+        }
+
+        public static void AddSparksEffect(
+            Vector2 location,
+            Vector2 impactVelocity)
+        {
+            int particleCount = rand.Next(10, 20);
+            for (int x = 0; x < particleCount; x++)
+            {
+                Particle particle = new Particle(
+                    location - (impactVelocity / 60),
+                    Texture,
+                    ParticleFrame,
+                    randomDirection((float)rand.Next(10, 20)),
+                    Vector2.Zero,
+                    60,
+                    20,
+                    Color.Yellow,
+                    Color.Orange);
+                Effects.Add(particle);
+            }
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/Enemy.cs

@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Robot_Rampage
+{
+    class Enemy
+    {
+        #region Declarations
+        public Sprite EnemyBase;
+        public Sprite EnemyClaws;
+        public float EnemySpeed = 60f;
+        public Vector2 currentTargetSquare;
+        public bool Destroyed = false;
+        private int collisionRadius = 14;
+        #endregion
+
+        #region Constructor
+        public Enemy(
+            Vector2 worldLocation,
+            Texture2D texture,
+            Rectangle initialFrame)
+        {
+            EnemyBase = new Sprite(
+                worldLocation,
+                texture,
+                initialFrame,
+                Vector2.Zero);
+
+            EnemyBase.CollisionRadius = collisionRadius;
+
+            Rectangle turretFrame = initialFrame;
+
+            turretFrame.Offset(0, initialFrame.Height);
+            EnemyClaws = new Sprite(
+                worldLocation,
+                texture,
+                turretFrame,
+                Vector2.Zero);
+        }
+        #endregion
+
+        #region AI Methods
+        private Vector2 determineMoveDirection()
+        {
+            if (reachedTargetSquare())
+            {
+                currentTargetSquare = getNewTargetSquare();
+            }
+
+            Vector2 squareCenter = TileMap.GetSquareCenter(
+                currentTargetSquare);
+
+            return squareCenter - EnemyBase.WorldCenter;
+        }
+
+        private bool reachedTargetSquare()
+        {
+            return (
+                Vector2.Distance(
+                    EnemyBase.WorldCenter,
+                    TileMap.GetSquareCenter(currentTargetSquare))
+                <= 2);
+        }
+
+        private Vector2 getNewTargetSquare()
+        {
+            List<Vector2> path = PathFinder.FindPath(
+                TileMap.GetSquareAtPixel(EnemyBase.WorldCenter),
+                TileMap.GetSquareAtPixel(Player.BaseSprite.WorldCenter));
+
+            if (path.Count > 1)
+            {
+                return new Vector2(path[1].X, path[1].Y);
+            }
+            else
+            {
+                return TileMap.GetSquareAtPixel(
+                    Player.BaseSprite.WorldCenter);
+            }
+        }
+        #endregion
+
+        #region Public Methods
+        public void Update(GameTime gameTime)
+        {
+            if (!Destroyed)
+            {
+                Vector2 direction = determineMoveDirection();
+                direction.Normalize();
+
+                EnemyBase.Velocity = direction * EnemySpeed;
+                EnemyBase.RotateTo(direction);
+                EnemyBase.Update(gameTime);
+
+                Vector2 directionToPlayer =
+                    Player.BaseSprite.WorldCenter -
+                    EnemyBase.WorldCenter;
+                directionToPlayer.Normalize();
+
+                EnemyClaws.WorldLocation = EnemyBase.WorldLocation;
+                EnemyClaws.RotateTo(directionToPlayer);
+            }
+        }
+
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            if (!Destroyed)
+            {
+                EnemyBase.Draw(spriteBatch);
+                EnemyClaws.Draw(spriteBatch);
+            }
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/EnemyManager.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Robot_Rampage
+{
+    static class EnemyManager
+    {
+        #region Declarations
+        public static List<Enemy> Enemies = new List<Enemy>();
+        public static Texture2D enemyTexture;
+        public static Rectangle enemyInitialFrame;
+        public static int MaxActiveEnemies = 30;
+        #endregion
+
+        #region Initialization
+        public static void Initialize(
+            Texture2D texture,
+            Rectangle initialFrame)
+        {
+            enemyTexture = texture;
+            enemyInitialFrame = initialFrame;
+        }
+        #endregion
+
+        #region Enemy Management
+        public static void AddEnemy(Vector2 squareLocation)
+        {
+            int startX = (int)squareLocation.X;
+            int startY = (int)squareLocation.Y;
+
+            Rectangle squareRect =
+                TileMap.SquareWorldRectangle(startX, startY);
+
+            Enemy newEnemy = new Enemy(
+                new Vector2(squareRect.X, squareRect.Y),
+                enemyTexture,
+                enemyInitialFrame);
+
+            newEnemy.currentTargetSquare = squareLocation;
+            Enemies.Add(newEnemy);
+        }
+        #endregion
+
+        #region Update and Draw
+        public static void Update(GameTime gameTime)
+        {
+            for (int x = Enemies.Count - 1; x >= 0; x--)
+            {
+                Enemies[x].Update(gameTime);
+                if (Enemies[x].Destroyed)
+                {
+                    Enemies.RemoveAt(x);
+                }
+            }
+        }
+
+        public static void Draw(SpriteBatch spriteBatch)
+        {
+            foreach (Enemy enemy in Enemies)
+            {
+                enemy.Draw(spriteBatch);
+            }
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/Game1.cs

@@ -0,0 +1,263 @@
+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 Robot_Rampage
+{
+    /// <summary>
+    /// This is the main type for your game
+    /// </summary>
+    public class Game1 : Game
+    {
+        GraphicsDeviceManager graphics;
+        SpriteBatch spriteBatch;
+
+        Texture2D spriteSheet;
+        Texture2D titleScreen;
+        SpriteFont pericles14;
+
+        enum GameStates { TitleScreen, Playing, WaveComplete, GameOver };
+        GameStates gameState = GameStates.TitleScreen;
+
+        float gameOverTimer = 0.0f;
+        float gameOverDelay = 6.0f;
+
+        float waveCompleteTimer = 0.0f;
+        float waveCompleteDelay = 6.0f;
+
+
+        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
+            this.graphics.PreferredBackBufferWidth = 800;
+            this.graphics.PreferredBackBufferHeight = 600;
+            this.graphics.ApplyChanges();
+            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);
+
+            spriteSheet = Content.Load<Texture2D>(@"Textures\SpriteSheet");
+            titleScreen = Content.Load<Texture2D>(@"Textures\TitleScreen");
+            pericles14 = Content.Load<SpriteFont>(@"Fonts\Pericles14");
+
+            Camera.WorldRectangle = new Rectangle(0, 0, 1600, 1600);
+            Camera.ViewPortWidth = 800;
+            Camera.ViewPortHeight = 600;
+
+            TileMap.Initialize(spriteSheet);
+
+            Player.Initialize(
+                spriteSheet,
+                new Rectangle(0, 64, 32, 32),
+                6,
+                new Rectangle(0, 96, 32, 32),
+                1,
+                new Vector2(32, 32));
+
+            EffectsManager.Initialize(
+                spriteSheet,
+                new Rectangle(0, 288, 2, 2),
+                new Rectangle(0, 256, 32, 32),
+                3);
+
+            WeaponManager.Texture = spriteSheet;
+
+            GoalManager.Initialize(
+                spriteSheet,
+                new Rectangle(0, 7 * 32, 32, 32),
+                new Rectangle(3 * 32, 7 * 32, 32, 32),
+                3,
+                1);
+
+            EnemyManager.Initialize(
+                spriteSheet,
+                new Rectangle(0, 160, 32, 32));
+
+
+
+            // 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
+        }
+
+        private void checkPlayerDeath()
+        {
+            foreach (Enemy enemy in EnemyManager.Enemies)
+            {
+                if (enemy.EnemyBase.IsCircleColliding(
+                    Player.BaseSprite.WorldCenter,
+                    Player.BaseSprite.CollisionRadius))
+                {
+                    gameState = GameStates.GameOver;
+                }
+            }
+        }
+
+        /// <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();
+
+            switch (gameState)
+            {
+                case GameStates.TitleScreen:
+                    if ((GamePad.GetState(PlayerIndex.One).Buttons.A ==
+                        ButtonState.Pressed) ||
+                        (Keyboard.GetState().IsKeyDown(Keys.Space)))
+                    {
+                        GameManager.StartNewGame();
+                        gameState = GameStates.Playing;
+                    }
+                    break;
+
+                case GameStates.Playing:
+                    Player.Update(gameTime);
+                    WeaponManager.Update(gameTime);
+                    EnemyManager.Update(gameTime);
+                    EffectsManager.Update(gameTime);
+                    GoalManager.Update(gameTime);
+                    if (GoalManager.ActiveTerminals == 0)
+                    {
+                        gameState = GameStates.WaveComplete;
+                    }
+                    break;
+
+                case GameStates.WaveComplete:
+                    waveCompleteTimer +=
+                        (float)gameTime.ElapsedGameTime.TotalSeconds;
+                    if (waveCompleteTimer > waveCompleteDelay)
+                    {
+                        GameManager.StartNewWave();
+                        gameState = GameStates.Playing;
+                        waveCompleteTimer = 0.0f;
+                    }
+                    break;
+
+                case GameStates.GameOver:
+                    gameOverTimer +=
+                        (float)gameTime.ElapsedGameTime.TotalSeconds;
+                    if (gameOverTimer > gameOverDelay)
+                    {
+                        gameState = GameStates.TitleScreen;
+                        gameOverTimer = 0.0f;
+                    }
+                    break;
+            }
+
+            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);
+
+            spriteBatch.Begin();
+
+            if (gameState == GameStates.TitleScreen)
+            {
+                spriteBatch.Draw(
+                    titleScreen,
+                    new Rectangle(0, 0, 800, 600),
+                    Color.White);
+            }
+
+            if ((gameState == GameStates.Playing) ||
+                (gameState == GameStates.WaveComplete) ||
+                (gameState == GameStates.GameOver))
+            {
+                TileMap.Draw(spriteBatch);
+                WeaponManager.Draw(spriteBatch);
+                Player.Draw(spriteBatch);
+                EnemyManager.Draw(spriteBatch);
+                EffectsManager.Draw(spriteBatch);
+                GoalManager.Draw(spriteBatch);
+
+                checkPlayerDeath();
+
+                spriteBatch.DrawString(
+                    pericles14,
+                    "Score: " + GameManager.Score.ToString(),
+                    new Vector2(30, 5),
+                    Color.White);
+
+                spriteBatch.DrawString(
+                    pericles14,
+                    "Terminals Remaining: " +
+                        GoalManager.ActiveTerminals,
+                    new Vector2(520, 5),
+                    Color.White);
+            }
+
+            if (gameState == GameStates.WaveComplete)
+            {
+                spriteBatch.DrawString(
+                    pericles14,
+                    "Beginning Wave " +
+                        (GameManager.CurrentWave + 1).ToString(),
+                    new Vector2(300, 300),
+                    Color.White);
+            }
+
+            if (gameState == GameStates.GameOver)
+            {
+                spriteBatch.DrawString(
+                    pericles14,
+                    "G A M E O V E R!",
+                    new Vector2(300, 300),
+                    Color.White);
+            }
+
+            spriteBatch.End();
+
+            base.Draw(gameTime);
+        }
+
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/GameManager.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+
+namespace Robot_Rampage
+{
+    static class GameManager
+    {
+        #region Declarations
+        public static int Score = 0;
+        public static int CurrentWave = 0;
+        public static int BaseTerminalCount = 8;
+        public static int MaxTerminalCount = 15;
+        public static int CurrentTerminalCount = 8;
+        public static Vector2 PlayerStartLoc = new Vector2(32, 32);
+        #endregion
+
+        #region Public Methods
+        public static void StartNewWave()
+        {
+            CurrentWave++;
+            if (CurrentTerminalCount < MaxTerminalCount)
+            {
+                CurrentTerminalCount++;
+            }
+
+            Player.BaseSprite.WorldLocation = PlayerStartLoc;
+            Camera.Position = Vector2.Zero;
+            WeaponManager.CurrentWeaponType =
+                WeaponManager.WeaponType.Normal;
+            WeaponManager.Shots.Clear();
+            WeaponManager.PowerUps.Clear();
+            EffectsManager.Effects.Clear();
+            EnemyManager.Enemies.Clear();
+            TileMap.GenerateRandomMap();
+            GoalManager.GenerateComputers(CurrentTerminalCount);
+        }
+
+        public static void StartNewGame()
+        {
+            CurrentWave = 0;
+            Score = 0;
+            StartNewWave();
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/GoalManager.cs

@@ -0,0 +1,187 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Robot_Rampage
+{
+    static class GoalManager
+    {
+        #region Declarations
+        private static List<ComputerTerminal> computerTerminals =
+            new List<ComputerTerminal>();
+        private static int activeCount = 0;
+
+        private static int minDistanceFromPlayer = 250;
+
+        private static Random rand = new Random();
+
+        private static Texture2D texture;
+        private static Rectangle initialActiveFrame;
+        private static Rectangle initialDisabledFrame;
+        private static int activeFrameCount;
+        private static int disabledFrameCount;
+        #endregion
+
+        #region Properties
+        public static int ActiveTerminals
+        {
+            get { return activeCount; }
+        }
+        #endregion
+
+        #region Initialization
+        public static void Initialize(
+            Texture2D textureSheet,
+            Rectangle initialActiveRectangle,
+            Rectangle initialDisabledRectangle,
+            int activeFrames,
+            int disabledFrames)
+        {
+            texture = textureSheet;
+            initialActiveFrame = initialActiveRectangle;
+            initialDisabledFrame = initialDisabledRectangle;
+            activeFrameCount = activeFrames;
+            disabledFrameCount = disabledFrames;
+        }
+        #endregion
+
+        #region Terminal Management
+        public static ComputerTerminal TerminalInSquare(
+            Vector2 mapLocation)
+        {
+            foreach (ComputerTerminal terminal in computerTerminals)
+            {
+                if (terminal.MapLocation == mapLocation)
+                {
+                    return terminal;
+                }
+            }
+
+            return null;
+        }
+
+        public static void DetectShutdowns()
+        {
+            foreach (ComputerTerminal terminal in computerTerminals)
+            {
+                if (terminal.Active)
+                {
+                    if (terminal.IsCircleColliding(
+                        Player.BaseSprite.WorldCenter,
+                        Player.BaseSprite.CollisionRadius))
+                    {
+                        terminal.Deactivate();
+                        activeCount--;
+                        GameManager.Score += 100;
+                    }
+                }
+            }
+        }
+
+        public static void AddComputerTerminal()
+        {
+            int startX = rand.Next(2, TileMap.MapWidth - 2);
+            int startY = rand.Next(0, TileMap.MapHeight - 2);
+
+            Vector2 tileLocation = new Vector2(startX, startY);
+
+            if ((TerminalInSquare(tileLocation) != null) ||
+                (TileMap.IsWallTile(tileLocation)))
+            {
+                return;
+            }
+
+            if (Vector2.Distance(
+                TileMap.GetSquareCenter(startX, startY),
+                Player.BaseSprite.WorldCenter) < minDistanceFromPlayer)
+            {
+                return;
+            }
+
+            List<Vector2> path =
+                PathFinder.FindPath(
+                    new Vector2(startX, startY),
+                    TileMap.GetSquareAtPixel(
+                        Player.BaseSprite.WorldCenter));
+
+            if (path != null)
+            {
+                Rectangle squareRect =
+                    TileMap.SquareWorldRectangle(startX, startY);
+
+                Sprite activeSprite = new Sprite(
+                    new Vector2(squareRect.X, squareRect.Y),
+                    texture,
+                    initialActiveFrame,
+                    Vector2.Zero);
+
+                for (int x = 1; x < 3; x++)
+                {
+                    activeSprite.AddFrame(
+                        new Rectangle(
+                        initialActiveFrame.X + (x *
+                            initialActiveFrame.Width),
+                        initialActiveFrame.Y,
+                        initialActiveFrame.Width,
+                        initialActiveFrame.Height));
+                }
+                activeSprite.CollisionRadius = 15;
+
+                Sprite disabledSprite = new Sprite(
+                    new Vector2(squareRect.X, squareRect.Y),
+                        texture,
+                        initialDisabledFrame,
+                        Vector2.Zero);
+
+                ComputerTerminal terminal = new ComputerTerminal(
+                        activeSprite,
+                        disabledSprite,
+                        new Vector2(startX, startY));
+
+                float timerOffset = (float)rand.Next(1, 100);
+                terminal.LastSpawnCounter = timerOffset / 100f;
+
+                computerTerminals.Add(terminal);
+
+                activeCount++;
+            }
+        }
+        #endregion
+
+        #region Public Methods
+        public static void GenerateComputers(int computerCount)
+        {
+            computerTerminals.Clear();
+            activeCount = 0;
+
+            while (activeCount < computerCount)
+            {
+                AddComputerTerminal();
+            }
+        }
+
+        public static void Update(GameTime gameTime)
+        {
+            DetectShutdowns();
+            foreach (ComputerTerminal terminal in
+                computerTerminals)
+            {
+                terminal.Update(gameTime);
+            }
+        }
+
+        public static void Draw(SpriteBatch spriteBatch)
+        {
+            foreach (ComputerTerminal terminal in
+                computerTerminals)
+            {
+                terminal.Draw(spriteBatch);
+            }
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/Particle.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Robot_Rampage
+{
+    class Particle : Sprite
+    {
+        #region Declarations
+        private Vector2 acceleration;
+        private float maxSpeed;
+        private int initialDuration;
+        private int remainingDuration;
+        private Color initialColor;
+        private Color finalColor;
+        #endregion
+
+        #region Properties
+        public int ElapsedDuration
+        {
+            get
+            {
+                return initialDuration - remainingDuration;
+            }
+        }
+
+        public float DurationProgress
+        {
+            get
+            {
+                return (float)ElapsedDuration /
+                    (float)initialDuration;
+            }
+        }
+
+        public bool IsActive
+        {
+            get
+            {
+                return (remainingDuration > 0);
+            }
+        }
+        #endregion
+
+        #region Constructor
+        public Particle(
+            Vector2 location,
+            Texture2D texture,
+            Rectangle initialFrame,
+            Vector2 velocity,
+            Vector2 acceleration,
+            float maxSpeed,
+            int duration,
+            Color initialColor,
+            Color finalColor)
+            : base(location, texture, initialFrame, velocity)
+        {
+            initialDuration = duration;
+            remainingDuration = duration;
+            this.acceleration = acceleration;
+            this.initialColor = initialColor;
+            this.maxSpeed = maxSpeed;
+            this.finalColor = finalColor;
+        }
+        #endregion
+
+        #region Update and Draw
+        public override void Update(GameTime gameTime)
+        {
+            if (remainingDuration <= 0)
+            {
+                Expired = true;
+            }
+
+            if (!Expired)
+            {
+                Velocity += acceleration;
+                if (Velocity.Length() > maxSpeed)
+                {
+                    Vector2 vel = Velocity;
+                    vel.Normalize();
+                    Velocity = vel * maxSpeed;
+                }
+                TintColor = Color.Lerp(
+                    initialColor,
+                    finalColor,
+                    DurationProgress);
+                remainingDuration--;
+            }
+
+            base.Update(gameTime);
+        }
+
+        public override void Draw(SpriteBatch spriteBatch)
+        {
+            if (IsActive)
+            {
+                base.Draw(spriteBatch);
+            }
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/PathFinder.cs

@@ -0,0 +1,232 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+
+namespace Robot_Rampage
+{
+    static class PathFinder
+    {
+        #region Declarations
+        private enum NodeStatus { Open, Closed };
+
+        private static Dictionary<Vector2, NodeStatus> nodeStatus =
+            new Dictionary<Vector2, NodeStatus>();
+
+        private const int CostStraight = 10;
+        private const int CostDiagonal = 15;
+
+        private static List<PathNode> openList = new List<PathNode>();
+
+        private static Dictionary<Vector2, float> nodeCosts =
+            new Dictionary<Vector2, float>();
+        #endregion
+
+        #region Helper Methods
+        static private void addNodeToOpenList(PathNode node)
+        {
+            int index = 0;
+            float cost = node.TotalCost;
+
+            while ((openList.Count() > index) &&
+                (cost < openList[index].TotalCost))
+            {
+                index++;
+            }
+
+            openList.Insert(index, node);
+            nodeCosts[node.GridLocation] = node.TotalCost;
+            nodeStatus[node.GridLocation] = NodeStatus.Open;
+        }
+
+        static private List<PathNode> findAdjacentNodes(
+    PathNode currentNode,
+    PathNode endNode)
+        {
+            List<PathNode> adjacentNodes = new List<PathNode>();
+
+            int X = currentNode.GridX;
+            int Y = currentNode.GridY;
+
+            bool upLeft = true;
+            bool upRight = true;
+            bool downLeft = true;
+            bool downRight = true;
+
+            if ((X > 0) && (!TileMap.IsWallTile(X - 1, Y)))
+            {
+                adjacentNodes.Add(new PathNode(
+                        currentNode,
+                        endNode,
+                        new Vector2(X - 1, Y),
+                        CostStraight + currentNode.DirectCost));
+            }
+            else
+            {
+                upLeft = false;
+                downLeft = false;
+            }
+
+            if ((X < 49) && (!TileMap.IsWallTile(X + 1, Y)))
+            {
+                adjacentNodes.Add(new PathNode(
+                        currentNode,
+                        endNode,
+                        new Vector2(X + 1, Y),
+                        CostStraight + currentNode.DirectCost));
+            }
+            else
+            {
+                upRight = false;
+                downRight = false;
+            }
+
+
+            if ((Y > 0) && (!TileMap.IsWallTile(X, Y - 1)))
+            {
+                adjacentNodes.Add(new PathNode(
+                    currentNode,
+                    endNode,
+                    new Vector2(X, Y - 1),
+                    CostStraight + currentNode.DirectCost));
+            }
+            else
+            {
+                upLeft = false;
+                upRight = false;
+            }
+
+            if ((Y < 49) && (!TileMap.IsWallTile(X, Y + 1)))
+            {
+                adjacentNodes.Add(new PathNode(
+                    currentNode,
+                    endNode,
+                    new Vector2(X, Y + 1),
+                    CostStraight + currentNode.DirectCost));
+            }
+            else
+            {
+                downLeft = false;
+                downRight = false;
+            }
+
+
+            if ((upLeft) && (!TileMap.IsWallTile(X - 1, Y - 1)))
+            {
+                adjacentNodes.Add(new PathNode(
+                    currentNode,
+                    endNode,
+                    new Vector2(X - 1, Y - 1),
+                    CostDiagonal + currentNode.DirectCost));
+            }
+
+            if ((upRight) && (!TileMap.IsWallTile(X + 1, Y - 1)))
+            {
+                adjacentNodes.Add(new PathNode(
+                    currentNode,
+                    endNode,
+                    new Vector2(X + 1, Y - 1),
+                    CostDiagonal + currentNode.DirectCost));
+            }
+
+            if ((downLeft) && (!TileMap.IsWallTile(X - 1, Y + 1)))
+            {
+                adjacentNodes.Add(new PathNode(
+                    currentNode,
+                    endNode,
+                    new Vector2(X - 1, Y + 1),
+                    CostDiagonal + currentNode.DirectCost));
+            }
+
+            if ((downRight) && (!TileMap.IsWallTile(X + 1, Y + 1)))
+            {
+                adjacentNodes.Add(new PathNode(
+                    currentNode,
+                    endNode,
+                    new Vector2(X + 1, Y + 1),
+                    CostDiagonal + currentNode.DirectCost));
+            }
+
+            return adjacentNodes;
+        }
+
+        #endregion
+
+        #region Public Methods
+        static public List<Vector2> FindPath(
+            Vector2 startTile,
+            Vector2 endTile)
+        {
+            if (TileMap.IsWallTile(endTile) ||
+                TileMap.IsWallTile(startTile))
+            {
+                return null;
+            }
+
+            openList.Clear();
+            nodeCosts.Clear();
+            nodeStatus.Clear();
+
+            PathNode startNode;
+            PathNode endNode;
+
+            endNode = new PathNode(null, null, endTile, 0);
+            startNode = new PathNode(null, endNode, startTile, 0);
+
+            addNodeToOpenList(startNode);
+
+            while (openList.Count > 0)
+            {
+                PathNode currentNode = openList[openList.Count - 1];
+
+                if (currentNode.IsEqualToNode(endNode))
+                {
+                    List<Vector2> bestPath = new List<Vector2>();
+                    while (currentNode != null)
+                    {
+                        bestPath.Insert(0, currentNode.GridLocation);
+                        currentNode = currentNode.ParentNode;
+                    }
+                    return bestPath;
+                }
+
+                openList.Remove(currentNode);
+                nodeCosts.Remove(currentNode.GridLocation);
+
+                foreach (
+                    PathNode possibleNode in
+                    findAdjacentNodes(currentNode, endNode))
+                {
+                    if (nodeStatus.ContainsKey(possibleNode.GridLocation))
+                    {
+                        if (nodeStatus[possibleNode.GridLocation] ==
+                            NodeStatus.Closed)
+                        {
+                            continue;
+                        }
+
+                        if (
+                            nodeStatus[possibleNode.GridLocation] ==
+                            NodeStatus.Open)
+                        {
+                            if (possibleNode.TotalCost >=
+                                nodeCosts[possibleNode.GridLocation])
+                            {
+                                continue;
+                            }
+                        }
+                    }
+
+                    addNodeToOpenList(possibleNode);
+                }
+
+                nodeStatus[currentNode.GridLocation] = NodeStatus.Closed;
+            }
+
+            return null;
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/PathNode.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+
+namespace Robot_Rampage
+{
+    class PathNode
+    {
+        #region Declarations
+        public PathNode ParentNode;
+        public PathNode EndNode;
+        private Vector2 gridLocation;
+        public float TotalCost;
+        public float DirectCost;
+        #endregion
+
+        #region Properties
+        public Vector2 GridLocation
+        {
+            get { return gridLocation; }
+            set
+            {
+                gridLocation = new Vector2(
+                    (float)MathHelper.Clamp(value.X, 0f, (float)TileMap.MapWidth),
+                    (float)MathHelper.Clamp(value.Y, 0f, (float)TileMap.MapHeight));
+            }
+        }
+
+        public int GridX
+        {
+            get { return (int)gridLocation.X; }
+        }
+
+        public int GridY
+        {
+            get { return (int)gridLocation.Y; }
+        }
+        #endregion
+
+        #region Constructor
+        public PathNode(
+            PathNode parentNode,
+            PathNode endNode,
+            Vector2 gridLocation,
+            float cost)
+        {
+            ParentNode = parentNode;
+            GridLocation = gridLocation;
+            EndNode = endNode;
+            DirectCost = cost;
+            if (!(endNode == null))
+            {
+                TotalCost = DirectCost + LinearCost();
+            }
+        }
+        #endregion
+
+        #region Helper Methods
+        public float LinearCost()
+        {
+            return (
+                Vector2.Distance(
+                EndNode.GridLocation,
+                this.GridLocation));
+        }
+        #endregion
+
+        #region Public Methods
+        public bool IsEqualToNode(PathNode node)
+        {
+            return (GridLocation == node.GridLocation);
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/Player.cs

@@ -0,0 +1,359 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+
+namespace Robot_Rampage
+{
+    static class Player
+    {
+        #region Declarations
+        public static Sprite BaseSprite;
+        public static Sprite TurretSprite;
+
+        private static Vector2 baseAngle = Vector2.Zero;
+        private static Vector2 turretAngle = Vector2.Zero;
+        private static float playerSpeed = 90f;
+
+        private static Rectangle scrollArea = new Rectangle(150, 100, 500, 400);
+
+        #endregion
+
+        #region Properties
+        public static Vector2 PathingNodePosition
+        {
+            get
+            {
+                return TileMap.GetSquareAtPixel(BaseSprite.WorldCenter);
+            }
+        }
+        #endregion
+
+        #region Initialization
+        public static void Initialize(
+            Texture2D texture,
+            Rectangle baseInitialFrame,
+            int baseFrameCount,
+            Rectangle turretInitialFrame,
+            int turretFrameCount,
+            Vector2 worldLocation)
+        {
+            int frameWidth = baseInitialFrame.Width;
+            int frameHeight = baseInitialFrame.Height;
+
+            BaseSprite = new Sprite(
+                worldLocation,
+                texture,
+                baseInitialFrame,
+                Vector2.Zero);
+
+            BaseSprite.BoundingXPadding = 4;
+            BaseSprite.BoundingYPadding = 4;
+            BaseSprite.AnimateWhenStopped = false;
+            for (int x = 1; x < baseFrameCount; x++)
+            {
+                BaseSprite.AddFrame(
+                    new Rectangle(
+                        baseInitialFrame.X + (frameHeight * x),
+                        baseInitialFrame.Y,
+                        frameWidth,
+                        frameHeight));
+            }
+
+            TurretSprite = new Sprite(
+                worldLocation,
+                texture,
+                turretInitialFrame,
+                Vector2.Zero);
+
+            TurretSprite.Animate = false;
+
+            for (int x = 1; x < turretFrameCount; x++)
+            {
+                BaseSprite.AddFrame(
+                    new Rectangle(
+                    turretInitialFrame.X + (frameHeight * x),
+                    turretInitialFrame.Y,
+                    frameWidth,
+                    frameHeight));
+            }
+        }
+        #endregion
+
+        #region Input Handling
+        private static Vector2 handleKeyboardMovement(KeyboardState keyState)
+        {
+            Vector2 keyMovement = Vector2.Zero;
+            if (keyState.IsKeyDown(Keys.W))
+                keyMovement.Y--;
+
+            if (keyState.IsKeyDown(Keys.A))
+                keyMovement.X--;
+
+            if (keyState.IsKeyDown(Keys.S))
+                keyMovement.Y++;
+
+            if (keyState.IsKeyDown(Keys.D))
+                keyMovement.X++;
+
+            return keyMovement;
+        }
+
+        private static Vector2 handleGamePadMovement(GamePadState gamepadState)
+        {
+            return new Vector2(
+                gamepadState.ThumbSticks.Left.X,
+                -gamepadState.ThumbSticks.Left.Y);
+        }
+
+        private static Vector2 handleKeyboardShots(KeyboardState keyState)
+        {
+            Vector2 keyShots = Vector2.Zero;
+
+            if (keyState.IsKeyDown(Keys.NumPad1))
+                keyShots = new Vector2(-1, 1);
+
+            if (keyState.IsKeyDown(Keys.NumPad2))
+                keyShots = new Vector2(0, 1);
+
+            if (keyState.IsKeyDown(Keys.NumPad3))
+                keyShots = new Vector2(1, 1);
+
+            if (keyState.IsKeyDown(Keys.NumPad4))
+                keyShots = new Vector2(-1, 0);
+
+            if (keyState.IsKeyDown(Keys.NumPad6))
+                keyShots = new Vector2(1, 0);
+
+            if (keyState.IsKeyDown(Keys.NumPad7))
+                keyShots = new Vector2(-1, -1);
+
+            if (keyState.IsKeyDown(Keys.NumPad8))
+                keyShots = new Vector2(0, -1);
+
+            if (keyState.IsKeyDown(Keys.NumPad9))
+                keyShots = new Vector2(1, -1);
+
+            return keyShots;
+        }
+
+        private static Vector2 handleGamePadShots(GamePadState gamepadState)
+        {
+            return new Vector2(
+                gamepadState.ThumbSticks.Right.X,
+                -gamepadState.ThumbSticks.Right.Y);
+        }
+
+        private static void handleInput(GameTime gameTime)
+        {
+            float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
+
+            Vector2 moveAngle = Vector2.Zero;
+            Vector2 fireAngle = Vector2.Zero;
+
+            moveAngle += handleKeyboardMovement(Keyboard.GetState());
+            moveAngle +=
+                handleGamePadMovement(GamePad.GetState(PlayerIndex.One));
+
+            fireAngle += handleKeyboardShots(Keyboard.GetState());
+            fireAngle +=
+                handleGamePadShots(GamePad.GetState(PlayerIndex.One));
+
+            if (moveAngle != Vector2.Zero)
+            {
+                moveAngle.Normalize();
+                baseAngle = moveAngle;
+                moveAngle = checkTileObstacles(elapsed, moveAngle);
+            }
+
+            if (fireAngle != Vector2.Zero)
+            {
+                fireAngle.Normalize();
+
+                turretAngle = fireAngle;
+
+                if (WeaponManager.CanFireWeapon)
+                {
+                    WeaponManager.FireWeapon(
+                        TurretSprite.WorldLocation,
+                        fireAngle * WeaponManager.WeaponSpeed);
+                }
+            }
+
+            BaseSprite.RotateTo(baseAngle);
+            TurretSprite.RotateTo(turretAngle);
+            BaseSprite.Velocity = moveAngle * playerSpeed;
+
+            repositionCamera(gameTime, moveAngle);
+        }
+        #endregion
+
+        #region Movement Limitations
+        private static void clampToWorld()
+        {
+            float currentX = BaseSprite.WorldLocation.X;
+            float currentY = BaseSprite.WorldLocation.Y;
+
+            currentX = MathHelper.Clamp(
+                currentX,
+                0,
+                Camera.WorldRectangle.Right - BaseSprite.FrameWidth);
+
+            currentY = MathHelper.Clamp(
+                currentY,
+                0,
+                Camera.WorldRectangle.Bottom - BaseSprite.FrameHeight);
+
+            BaseSprite.WorldLocation = new Vector2(currentX, currentY);
+        }
+
+        private static void repositionCamera(    
+            GameTime gameTime,
+            Vector2 moveAngle)
+        {
+            float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
+            float moveScale = playerSpeed * elapsed;
+
+            if ((BaseSprite.ScreenRectangle.X < scrollArea.X) &&
+                (moveAngle.X < 0))
+            {
+                Camera.Move(new Vector2(moveAngle.X, 0) * moveScale);
+            }
+
+            if ((BaseSprite.ScreenRectangle.Right > scrollArea.Right) &&
+                (moveAngle.X > 0))
+            {
+                Camera.Move(new Vector2(moveAngle.X, 0) * moveScale);
+            }
+
+            if ((BaseSprite.ScreenRectangle.Y < scrollArea.Y) &&
+                (moveAngle.Y < 0))
+            {
+                Camera.Move(new Vector2(0, moveAngle.Y) * moveScale);
+            }
+
+            if ((BaseSprite.ScreenRectangle.Bottom > scrollArea.Bottom) &&
+                (moveAngle.Y > 0))
+            {
+                Camera.Move(new Vector2(0, moveAngle.Y) * moveScale);
+            }
+        }
+
+        private static Vector2 checkTileObstacles(
+            float elapsedTime,
+            Vector2 moveAngle)
+        {
+            Vector2 newHorizontalLocation = BaseSprite.WorldLocation +
+                (new Vector2(moveAngle.X, 0) * (playerSpeed * elapsedTime));
+
+            Vector2 newVerticalLocation = BaseSprite.WorldLocation +
+                (new Vector2(0, moveAngle.Y) * (playerSpeed * elapsedTime));
+
+            Rectangle newHorizontalRect = new Rectangle(
+                (int)newHorizontalLocation.X,
+                (int)BaseSprite.WorldLocation.Y,
+                BaseSprite.FrameWidth,
+                BaseSprite.FrameHeight);
+
+            Rectangle newVerticalRect = new Rectangle(
+                (int)BaseSprite.WorldLocation.X,
+                (int)newVerticalLocation.Y,
+                BaseSprite.FrameWidth,
+                BaseSprite.FrameHeight);
+
+            int horizLeftPixel = 0;
+            int horizRightPixel = 0;
+
+            int vertTopPixel = 0;
+            int vertBottomPixel = 0;
+
+            if (moveAngle.X < 0)
+            {
+                horizLeftPixel = (int)newHorizontalRect.Left;
+                horizRightPixel = (int)BaseSprite.WorldRectangle.Left;
+            }
+
+            if (moveAngle.X > 0)
+            {
+                horizLeftPixel = (int)BaseSprite.WorldRectangle.Right;
+                horizRightPixel = (int)newHorizontalRect.Right;
+            }
+
+            if (moveAngle.Y < 0)
+            {
+                vertTopPixel = (int)newVerticalRect.Top;
+                vertBottomPixel = (int)BaseSprite.WorldRectangle.Top;
+            }
+
+            if (moveAngle.Y > 0)
+            {
+                vertTopPixel = (int)BaseSprite.WorldRectangle.Bottom;
+                vertBottomPixel = (int)newVerticalRect.Bottom;
+            }
+
+            if (moveAngle.X != 0)
+            {
+                for (int x = horizLeftPixel; x < horizRightPixel; x++)
+                {
+                    for (int y = 0; y < BaseSprite.FrameHeight; y++)
+                    {
+                        if (TileMap.IsWallTileByPixel(
+                            new Vector2(x, newHorizontalLocation.Y + y)))
+                        {
+                            moveAngle.X = 0;
+                            break;
+                        }
+                    }
+                    if (moveAngle.X == 0)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            if (moveAngle.Y != 0)
+            {
+                for (int y = vertTopPixel; y < vertBottomPixel; y++)
+                {
+                    for (int x = 0; x < BaseSprite.FrameWidth; x++)
+                    {
+                        if (TileMap.IsWallTileByPixel(
+                            new Vector2(newVerticalLocation.X + x, y)))
+                        {
+                            moveAngle.Y = 0;
+                            break;
+                        }
+                    }
+                    if (moveAngle.Y == 0)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            return moveAngle;
+        }
+
+        #endregion
+
+        #region Update and Draw
+        public static void Update(GameTime gameTime)
+        {
+            handleInput(gameTime);
+            BaseSprite.Update(gameTime);
+            clampToWorld();
+            TurretSprite.WorldLocation = BaseSprite.WorldLocation;
+        }
+
+        public static void Draw(SpriteBatch spriteBatch)
+        {
+            BaseSprite.Draw(spriteBatch);
+            TurretSprite.Draw(spriteBatch);
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/RobotRampage.Core.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>RobotRampage.Core</RootNamespace>
+    <AssemblyName>RobotRampage.Core</AssemblyName>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <LangVersion>latest</LangVersion>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <PackageReference Include="MonoGame.Framework.DesktopGL" Version="3.8.*" />
+  </ItemGroup>
+</Project>

XNAGameDevelopmentbyExample/RobotRampage/Core/Sprite.cs

@@ -0,0 +1,265 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework;
+
+namespace Robot_Rampage
+{
+    class Sprite
+    {
+        #region Declarations
+        public Texture2D Texture;
+
+        private Vector2 worldLocation = Vector2.Zero;
+        private Vector2 velocity = Vector2.Zero;
+
+        private List<Rectangle> frames = new List<Rectangle>();
+
+        private int currentFrame;
+        private float frameTime = 0.1f;
+        private float timeForCurrentFrame = 0.0f;
+
+        private Color tintColor = Color.White;
+
+        private float rotation = 0.0f;
+
+        public bool Expired = false;
+        public bool Animate = true;
+        public bool AnimateWhenStopped = true;
+
+        public bool Collidable = true;
+        public int CollisionRadius = 0;
+        public int BoundingXPadding = 0;
+        public int BoundingYPadding = 0;
+        #endregion
+
+        #region Constructors
+        public Sprite(
+            Vector2 worldLocation,
+            Texture2D texture,
+            Rectangle initialFrame,
+            Vector2 velocity)
+        {
+            this.worldLocation = worldLocation;
+            Texture = texture;
+            this.velocity = velocity;
+
+            frames.Add(initialFrame);
+        }
+        #endregion
+
+        #region Drawing and Animation Properties
+        public int FrameWidth
+        {
+            get { return frames[0].Width; }
+        }
+
+        public int FrameHeight
+        {
+            get { return frames[0].Height; }
+        }
+
+        public Color TintColor
+        {
+            get { return tintColor; }
+            set { tintColor = value; }
+        }
+
+        public float Rotation
+        {
+            get { return rotation; }
+            set { rotation = value % MathHelper.TwoPi; }
+        }
+
+        public int Frame
+        {
+            get { return currentFrame; }
+            set
+            {
+                currentFrame = (int)MathHelper.Clamp(value, 0,
+                    frames.Count - 1);
+            }
+        }
+
+        public float FrameTime
+        {
+            get { return frameTime; }
+            set { frameTime = MathHelper.Max(0, value); }
+        }
+
+        public Rectangle Source
+        {
+            get { return frames[currentFrame]; }
+        }
+        #endregion
+
+        #region Positional Properties
+        public Vector2 WorldLocation
+        {
+            get { return worldLocation; }
+            set { worldLocation = value; }
+        }
+
+        public Vector2 ScreenLocation
+        {
+            get
+            {
+                return Camera.Transform(worldLocation);
+            }
+        }
+
+        public Vector2 Velocity
+        {
+            get { return velocity; }
+            set { velocity = value; }
+        }
+
+        public Rectangle WorldRectangle
+        {
+            get
+            {
+                return new Rectangle(
+                    (int)worldLocation.X,
+                    (int)worldLocation.Y,
+                    FrameWidth,
+                    FrameHeight);
+            }
+        }
+
+        public Rectangle ScreenRectangle
+        {
+            get
+            {
+                return Camera.Transform(WorldRectangle);
+            }
+        }
+
+        public Vector2 RelativeCenter
+        {
+            get { return new Vector2(FrameWidth / 2, FrameHeight / 2); }
+        }
+
+        public Vector2 WorldCenter
+        {
+            get { return worldLocation + RelativeCenter; }
+        }
+
+        public Vector2 ScreenCenter
+        {
+            get
+            {
+                return Camera.Transform(worldLocation + RelativeCenter);
+            }
+        }
+        #endregion
+
+        #region Collision Related Properties
+        public Rectangle BoundingBoxRect
+        {
+            get
+            {
+                return new Rectangle(
+                    (int)worldLocation.X + BoundingXPadding,
+                    (int)worldLocation.Y + BoundingYPadding,
+                    FrameWidth - (BoundingXPadding * 2),
+                    FrameHeight - (BoundingYPadding * 2));
+            }
+        }
+        #endregion
+
+        #region Collision Detection Methods
+        public bool IsBoxColliding(Rectangle OtherBox)
+        {
+            if ((Collidable) && (!Expired))
+            {
+                return BoundingBoxRect.Intersects(OtherBox);
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public bool IsCircleColliding(
+            Vector2 otherCenter,
+            float otherRadius)
+        {
+            if ((Collidable) && (!Expired))
+            {
+                if (Vector2.Distance(WorldCenter, otherCenter) <
+                    (CollisionRadius + otherRadius))
+                    return true;
+                else
+                    return false;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        #endregion
+
+        #region Animation-Related Methods
+        public void AddFrame(Rectangle frameRectangle)
+        {
+            frames.Add(frameRectangle);
+        }
+
+        public void RotateTo(Vector2 direction)
+        {
+            Rotation = (float)Math.Atan2(direction.Y, direction.X);
+        }
+        #endregion
+
+        #region Update and Draw Methods
+        public virtual void Update(GameTime gameTime)
+        {
+            if (!Expired)
+            {
+                float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
+
+                timeForCurrentFrame += elapsed;
+
+                if (Animate)
+                {
+                    if (timeForCurrentFrame >= FrameTime)
+                    {
+                        if ((AnimateWhenStopped) ||
+                            (velocity != Vector2.Zero))
+                        {
+                            currentFrame = (currentFrame + 1) %
+                                (frames.Count);
+                            timeForCurrentFrame = 0.0f;
+                        }
+                    }
+                }
+
+                worldLocation += (velocity * elapsed);
+            }
+        }
+
+        public virtual void Draw(SpriteBatch spriteBatch)
+        {
+            if (!Expired)
+            {
+                if (Camera.ObjectIsVisible(WorldRectangle))
+                {
+                    spriteBatch.Draw(
+                        Texture,
+                        ScreenCenter,
+                        Source,
+                        tintColor,
+                        rotation,
+                        RelativeCenter,
+                        1.0f,
+                        SpriteEffects.None,
+                        0.0f);
+                }
+            }
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/TileMap.cs

@@ -0,0 +1,238 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Robot_Rampage
+{
+    static class TileMap
+    {
+        #region Declarations
+        public const int TileWidth = 32;
+        public const int TileHeight = 32;
+        public const int MapWidth = 50;
+        public const int MapHeight = 50;
+
+        public const int FloorTileStart = 0;
+        public const int FloorTileEnd = 3;
+        public const int WallTileStart = 4;
+        public const int WallTileEnd = 7;
+
+        static private Texture2D texture;
+        static private List<Rectangle> tiles = new List<Rectangle>();
+
+        static private int[,] mapSquares = new int[MapWidth, MapHeight];
+
+        static private Random rand = new Random();
+        #endregion
+
+        #region Initialization
+        static public void Initialize(Texture2D tileTexture)
+        {
+            texture = tileTexture;
+            tiles.Clear();
+            tiles.Add(new Rectangle(0, 0, TileWidth, TileHeight));
+            tiles.Add(new Rectangle(32, 0, TileWidth, TileHeight));
+            tiles.Add(new Rectangle(64, 0, TileWidth, TileHeight));
+            tiles.Add(new Rectangle(96, 0, TileWidth, TileHeight));
+            tiles.Add(new Rectangle(0, 32, TileWidth, TileHeight));
+            tiles.Add(new Rectangle(32, 32, TileWidth, TileHeight));
+            tiles.Add(new Rectangle(64, 32, TileWidth, TileHeight));
+            tiles.Add(new Rectangle(96, 32, TileWidth, TileHeight));
+
+            for (int x = 0; x < MapWidth; x++)
+                for (int y = 0; y < MapHeight; y++)
+                {
+                    mapSquares[x, y] = FloorTileStart;
+                }
+            GenerateRandomMap();
+        }
+        #endregion
+
+        #region Information about Map Squares
+
+        static public int GetSquareByPixelX(int pixelX)
+        {
+            return pixelX / TileWidth;
+        }
+
+        static public int GetSquareByPixelY(int pixelY)
+        {
+            return pixelY / TileHeight;
+        }
+
+        static public Vector2 GetSquareAtPixel(Vector2 pixelLocation)
+        {
+            return new Vector2(
+                GetSquareByPixelX((int)pixelLocation.X),
+                GetSquareByPixelY((int)pixelLocation.Y));
+        }
+
+        static public Vector2 GetSquareCenter(int squareX, int squareY)
+        {
+            return new Vector2(
+                (squareX * TileWidth) + (TileWidth / 2),
+                (squareY * TileHeight) + (TileHeight / 2));
+        }
+
+        static public Vector2 GetSquareCenter(Vector2 square)
+        {
+            return GetSquareCenter(
+                (int)square.X,
+                (int)square.Y);
+        }
+
+        static public Rectangle SquareWorldRectangle(int x, int y)
+        {
+            return new Rectangle(
+                x * TileWidth,
+                y * TileHeight,
+                TileWidth,
+                TileHeight);
+        }
+
+        static public Rectangle SquareWorldRectangle(Vector2 square)
+        {
+            return SquareWorldRectangle(
+                (int)square.X,
+                (int)square.Y);
+        }
+
+        static public Rectangle SquareScreenRectangle(int x, int y)
+        {
+            return Camera.Transform(SquareWorldRectangle(x, y));
+        }
+
+        static public Rectangle SquareSreenRectangle(Vector2 square)
+        {
+            return SquareScreenRectangle((int)square.X, (int)square.Y);
+        }
+        #endregion
+
+        #region Information about Map Tiles
+
+        static public int GetTileAtSquare(int tileX, int tileY)
+        {
+            if ((tileX >= 0) && (tileX < MapWidth) &&
+                (tileY >= 0) && (tileY < MapHeight))
+            {
+                return mapSquares[tileX, tileY];
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        static public void SetTileAtSquare(int tileX, int tileY, int tile)
+        {
+            if ((tileX >= 0) && (tileX < MapWidth) &&
+                (tileY >= 0) && (tileY < MapHeight))
+            {
+                mapSquares[tileX, tileY] = tile;
+            }
+        }
+
+        static public int GetTileAtPixel(int pixelX, int pixelY)
+        {
+            return GetTileAtSquare(
+                GetSquareByPixelX(pixelX),
+                GetSquareByPixelY(pixelY));
+        }
+
+        static public int GetTileAtPixel(Vector2 pixelLocation)
+        {
+            return GetTileAtPixel(
+                (int)pixelLocation.X,
+                (int)pixelLocation.Y);
+        }
+
+        static public bool IsWallTile(int tileX, int tileY)
+        {
+            int tileIndex = GetTileAtSquare(tileX, tileY);
+
+            if (tileIndex == -1)
+            {
+                return false;
+            }
+
+            return tileIndex >= WallTileStart;
+        }
+
+        static public bool IsWallTile(Vector2 square)
+        {
+            return IsWallTile((int)square.X, (int)square.Y);
+        }
+
+        static public bool IsWallTileByPixel(Vector2 pixelLocation)
+        {
+            return IsWallTile(
+                GetSquareByPixelX((int)pixelLocation.X),
+                GetSquareByPixelY((int)pixelLocation.Y));
+        }
+
+        #endregion
+
+        #region Map Generation
+        static public void GenerateRandomMap()
+        {
+            int wallChancePerSqare = 10;
+
+            int floorTile = rand.Next(FloorTileStart, FloorTileEnd + 1);
+            int wallTile = rand.Next(WallTileStart, WallTileEnd + 1);
+
+            for (int x = 0; x < MapWidth; x++)
+                for (int y = 0; y < MapHeight; y++)
+                {
+                    mapSquares[x, y] = floorTile;
+
+                    if ((x == 0) || (y == 0) ||
+                        (x == MapWidth - 1) || (y == MapHeight - 1))
+                    {
+                        mapSquares[x, y] = wallTile;
+                        continue;
+                    }
+
+                    if ((x == 1) || (y == 1) ||
+                        (x == MapWidth - 2) || (y == MapHeight - 2))
+                    {
+                        continue;
+                    }
+
+                    if (rand.Next(0, 100) <= wallChancePerSqare)
+                        mapSquares[x, y] = wallTile;
+                }
+        }
+        #endregion
+
+        #region Drawing
+        static public void Draw(SpriteBatch spriteBatch)
+        {
+            int startX = GetSquareByPixelX((int)Camera.Position.X);
+            int endX = GetSquareByPixelX((int)Camera.Position.X +
+                  Camera.ViewPortWidth);
+
+            int startY = GetSquareByPixelY((int)Camera.Position.Y);
+            int endY = GetSquareByPixelY((int)Camera.Position.Y +
+                      Camera.ViewPortHeight);
+
+            for (int x = startX; x <= endX; x++)
+                for (int y = startY; y <= endY; y++)
+                {
+                    if ((x >= 0) && (y >= 0) &&
+                        (x < MapWidth) && (y < MapHeight))
+                    {
+                        spriteBatch.Draw(
+                            texture,
+                            SquareScreenRectangle(x, y),
+                            tiles[GetTileAtSquare(x, y)],
+                            Color.White);
+                    }
+                }
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Core/WeaponManager.cs

@@ -0,0 +1,371 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Robot_Rampage
+{
+    static class WeaponManager
+    {
+        #region declarations
+        static public List<Particle> Shots = new List<Particle>();
+        static public Texture2D Texture;
+        static public Rectangle shotRectangle =
+            new Rectangle(0, 128, 32, 32);
+        static public float WeaponSpeed = 600f;
+
+        static private float shotTimer = 0f;
+        static private float shotMinTimer = 0.15f;
+
+        static private float rocketMinTimer = 0.5f;
+
+        public enum WeaponType { Normal, Triple, Rocket };
+        static public WeaponType CurrentWeaponType = WeaponType.Normal;
+        static public float WeaponTimeRemaining = 0.0f;
+        static private float weaponTimeDefault = 30.0f;
+        static private float tripleWeaponSplitAngle = 15;
+
+        static public List<Sprite> PowerUps = new List<Sprite>();
+        static private int maxActivePowerups = 5;
+        static private float timeSinceLastPowerup = 0.0f;
+        static private float timeBetweenPowerups = 2.0f;
+        static private Random rand = new Random();
+
+        #endregion
+
+        #region Properties
+        static public float WeaponFireDelay
+        {
+            get
+            {
+                if (CurrentWeaponType == WeaponType.Rocket)
+                {
+                    return rocketMinTimer;
+                }
+                else
+                {
+                    return shotMinTimer;
+                }
+            }
+        }
+
+
+        static public bool CanFireWeapon
+        {
+            get
+            {
+                return (shotTimer >= WeaponFireDelay);
+            }
+        }
+        #endregion
+
+        #region Effects Management Methods
+
+        private static void AddShot(
+            Vector2 location,
+            Vector2 velocity,
+            int frame)
+        {
+            Particle shot = new Particle(
+                location,
+                Texture,
+                shotRectangle,
+                velocity,
+                Vector2.Zero,
+                400f,
+                120,
+                Color.White,
+                Color.White);
+
+            shot.AddFrame(new Rectangle(
+                shotRectangle.X + shotRectangle.Width,
+                shotRectangle.Y,
+                shotRectangle.Width,
+                shotRectangle.Height));
+
+            shot.Animate = false;
+            shot.Frame = frame;
+            shot.RotateTo(velocity);
+            Shots.Add(shot);
+        }
+
+
+        private static void createLargeExplosion(Vector2 location)
+        {
+            EffectsManager.AddLargeExplosion(
+                location + new Vector2(-10, -10));
+            EffectsManager.AddLargeExplosion(
+                location + new Vector2(-10, 10));
+            EffectsManager.AddLargeExplosion(
+                location + new Vector2(10, 10));
+            EffectsManager.AddLargeExplosion(
+                location + new Vector2(10, -10));
+            EffectsManager.AddLargeExplosion(location);
+        }
+        #endregion
+
+        #region Weapons Management Methods
+        private static void checkWeaponUpgradeExpire(float elapsed)
+        {
+            if (CurrentWeaponType != WeaponType.Normal)
+            {
+                WeaponTimeRemaining -= elapsed;
+                if (WeaponTimeRemaining <= 0)
+                {
+                    CurrentWeaponType = WeaponType.Normal;
+                }
+            }
+        }
+
+        public static void FireWeapon(Vector2 location, Vector2 velocity)
+        {
+            switch (CurrentWeaponType)
+            {
+                case WeaponType.Normal:
+                    AddShot(location, velocity, 0);
+                    break;
+
+                case WeaponType.Triple:
+                    AddShot(location, velocity, 0);
+
+                    float baseAngle = (float)Math.Atan2(
+                        velocity.Y,
+                        velocity.X);
+
+                    float offset = MathHelper.ToRadians(
+                        tripleWeaponSplitAngle);
+
+                    AddShot(
+                        location,
+                        new Vector2(
+                            (float)Math.Cos(baseAngle - offset),
+                            (float)Math.Sin(baseAngle - offset)
+                        ) * velocity.Length(),
+                        0);
+
+                    AddShot(
+                        location,
+                        new Vector2(
+                            (float)Math.Cos(baseAngle + offset),
+                            (float)Math.Sin(baseAngle + offset)
+                        ) * velocity.Length(),
+                        0);
+                    break;
+
+                case WeaponType.Rocket:
+                    AddShot(location, velocity, 1);
+                    break;
+            }
+
+            shotTimer = 0.0f;
+        }
+
+
+        private static void tryToSpawnPowerup(int x, int y, WeaponType type)
+        {
+            if (PowerUps.Count >= maxActivePowerups)
+            {
+                return;
+            }
+
+            Rectangle thisDestination =
+                TileMap.SquareWorldRectangle(new Vector2(x, y));
+
+            foreach (Sprite powerup in PowerUps)
+            {
+                if (powerup.WorldRectangle == thisDestination)
+                {
+                    return;
+                }
+            }
+
+            if (!(PathFinder.FindPath(
+                new Vector2(x, y),
+                Player.PathingNodePosition) == null))
+            {
+                Sprite newPowerup = new Sprite(
+                    new Vector2(thisDestination.X, thisDestination.Y),
+                    Texture,
+                    new Rectangle(64, 128, 32, 32),
+                    Vector2.Zero);
+                newPowerup.Animate = false;
+                newPowerup.CollisionRadius = 14;
+                newPowerup.AddFrame(new Rectangle(96, 128, 32, 32));
+                if (type == WeaponType.Rocket)
+                    newPowerup.Frame = 1;
+                PowerUps.Add(newPowerup);
+                timeSinceLastPowerup = 0.0f;
+            }
+        }
+
+        private static void checkPowerupSpawns(float elapsed)
+        {
+            timeSinceLastPowerup += elapsed;
+            if (timeSinceLastPowerup >= timeBetweenPowerups)
+            {
+                WeaponType type = WeaponType.Triple;
+                if (rand.Next(0, 2) == 1)
+                {
+                    type = WeaponType.Rocket;
+                }
+                tryToSpawnPowerup(
+                    rand.Next(0, TileMap.MapWidth),
+                    rand.Next(0, TileMap.MapHeight),
+                    type);
+            }
+        }
+
+        #endregion
+
+        #region Collision Detection
+        private static void checkShotWallImpacts(Sprite shot)
+        {
+            if (shot.Expired)
+            {
+                return;
+            }
+
+            if (TileMap.IsWallTile(
+                TileMap.GetSquareAtPixel(shot.WorldCenter)))
+            {
+                shot.Expired = true;
+
+                if (shot.Frame == 0)
+                {
+                    EffectsManager.AddSparksEffect(
+                        shot.WorldCenter,
+                        shot.Velocity);
+                }
+                else
+                {
+                    createLargeExplosion(shot.WorldCenter);
+                    checkRocketSplashDamage(shot.WorldCenter);
+                }
+            }
+        }
+
+        private static void checkPowerupPickups()
+        {
+            for (int x = PowerUps.Count - 1; x >= 0; x--)
+            {
+                if (Player.BaseSprite.IsCircleColliding(
+                    PowerUps[x].WorldCenter,
+                    PowerUps[x].CollisionRadius))
+                {
+                    switch (PowerUps[x].Frame)
+                    {
+                        case 0: CurrentWeaponType = WeaponType.Triple;
+                            break;
+
+                        case 1: CurrentWeaponType = WeaponType.Rocket;
+                            break;
+                    }
+                    WeaponTimeRemaining = weaponTimeDefault;
+                    PowerUps.RemoveAt(x);
+                }
+            }
+        }
+
+        private static void checkShotEnemyImpacts(Sprite shot)
+        {
+            if (shot.Expired)
+            {
+                return;
+            }
+
+            foreach (Enemy enemy in EnemyManager.Enemies)
+            {
+                if (!enemy.Destroyed)
+                {
+                    if (shot.IsCircleColliding(
+                        enemy.EnemyBase.WorldCenter,
+                        enemy.EnemyBase.CollisionRadius))
+                    {
+                        shot.Expired = true;
+                        enemy.Destroyed = true;
+                        GameManager.Score += 10;
+                        if (shot.Frame == 0)
+                        {
+                            EffectsManager.AddExplosion(
+                                enemy.EnemyBase.WorldCenter,
+                                enemy.EnemyBase.Velocity / 30);
+                        }
+                        else
+                        {
+                            if (shot.Frame == 1)
+                            {
+                                createLargeExplosion(shot.WorldCenter);
+                                checkRocketSplashDamage(shot.WorldCenter);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private static void checkRocketSplashDamage(Vector2 location)
+        {
+            int rocketSplashRadius = 40;
+
+            foreach (Enemy enemy in EnemyManager.Enemies)
+            {
+                if (!enemy.Destroyed)
+                {
+                    if (enemy.EnemyBase.IsCircleColliding(
+                        location, rocketSplashRadius))
+                    {
+                        enemy.Destroyed = true;
+                        GameManager.Score += 10;
+                        EffectsManager.AddExplosion(
+                            enemy.EnemyBase.WorldCenter,
+                            Vector2.Zero);
+                    }
+                }
+            }
+        }
+
+
+        #endregion
+
+        #region Update and Draw
+        static public void Update(GameTime gameTime)
+        {
+            float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
+            shotTimer += elapsed;
+            checkWeaponUpgradeExpire(elapsed);
+
+            for (int x = Shots.Count - 1; x >= 0; x--)
+            {
+                Shots[x].Update(gameTime);
+
+                checkShotWallImpacts(Shots[x]);
+                checkShotEnemyImpacts(Shots[x]);
+
+                if (Shots[x].Expired)
+                {
+                    Shots.RemoveAt(x);
+                }
+            }
+
+            checkPowerupSpawns(elapsed);
+            checkPowerupPickups();
+        }
+
+        static public void Draw(SpriteBatch spriteBatch)
+        {
+            foreach (Particle sprite in Shots)
+            {
+                sprite.Draw(spriteBatch);
+            }
+
+            foreach (Sprite sprite in PowerUps)
+            {
+                sprite.Draw(spriteBatch);
+            }
+        }
+        #endregion
+
+    }
+}

XNAGameDevelopmentbyExample/RobotRampage/Platforms/Android/AndroidManifest.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          android:versionCode="1"
+          android:versionName="1.0"
+          package="com.yourcompany.robotrampage">
+    
+    <uses-sdk android:minSdkVersion="21" android:targetSdkVersion="34" />
+    
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    
+    <application android:allowBackup="true"
+                 android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
+                 android:label="Robot Rampage">
+        
+        <activity android:name="Microsoft.Xna.Framework.AndroidGameActivity"
+                  android:label="Robot Rampage"
+                  android:launchMode="singleInstance"
+                  android:screenOrientation="landscape"
+                  android:configChanges="orientation|keyboardHidden|keyboard"
+                  android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>

XNAGameDevelopmentbyExample/RobotRampage/Platforms/Android/Program.cs

@@ -0,0 +1,20 @@
+using System;
+using Robot_Rampage;
+
+namespace RobotRampage
+{
+    static class Program
+    {
+        /// <summary>
+        /// The main entry point for the application.
+        /// </summary>
+        static void Main(string[] args)
+        {
+            using (Game1 game = new Game1())
+            {
+                game.Run();
+            }
+        }
+    }
+}
+

XNAGameDevelopmentbyExample/RobotRampage/Platforms/Android/Resources/values/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">Robot Rampage</string>
+</resources>

XNAGameDevelopmentbyExample/RobotRampage/Platforms/Android/Resources/values/styles.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="AppTheme" parent="@android:style/Theme.Holo.Light">
+    </style>
+</resources>

XNAGameDevelopmentbyExample/RobotRampage/Platforms/Android/RobotRampage.Android.csproj

@@ -0,0 +1,36 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0-android</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <Nullable>disable</Nullable>
+    <UseAndroid>true</UseAndroid>
+    <SupportedOSPlatformVersion>21</SupportedOSPlatformVersion>
+    <AssemblyName>RobotRampage</AssemblyName>
+    <RootNamespace>RobotRampage</RootNamespace>
+    <ApplicationId>com.yourcompany.robotrampage</ApplicationId>
+    <ApplicationTitle>Robot Rampage</ApplicationTitle>
+    <ApplicationDisplayVersion>1.0</ApplicationDisplayVersion>
+    <ApplicationVersion>1</ApplicationVersion>
+    <ApplicationIcon>..\..\Core\Content\Game.ico</ApplicationIcon>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\..\Core\RobotRampage.Core.csproj" />
+  </ItemGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Debug|net8.0-android|AnyCPU'">
+    <EmbedAssembliesIntoApk>false</EmbedAssembliesIntoApk>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MonoGame.Framework.Android" Version="3.8.*" />
+    <PackageReference Include="MonoGame.Content.Builder.Task" Version="3.8.*" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="..\..\Core\Content\**\*.xnb" Link="Content\%(RecursiveDir)%(Filename)%(Extension)">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+</Project>

XNAGameDevelopmentbyExample/RobotRampage/Platforms/Desktop/Program.cs

@@ -0,0 +1,20 @@
+using System;
+using Robot_Rampage;
+
+namespace RobotRampage
+{
+    static class Program
+    {
+        /// <summary>
+        /// The main entry point for the application.
+        /// </summary>
+        static void Main(string[] args)
+        {
+            using (Game1 game = new Game1())
+            {
+                game.Run();
+            }
+        }
+    }
+}
+

XNAGameDevelopmentbyExample/RobotRampage/Platforms/Desktop/RobotRampage.DesktopGL.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <PublishReadyToRun>false</PublishReadyToRun>
+    <TieredCompilation>false</TieredCompilation>
+    <UseAppHost>true</UseAppHost>
+    <AssemblyName>RobotRampage</AssemblyName>
+    <RootNamespace>RobotRampage</RootNamespace>
+    <ApplicationManifest>..\..\Core\Content\app.manifest</ApplicationManifest>
+    <ApplicationIcon>..\..\Core\Content\Game.ico</ApplicationIcon>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Core\RobotRampage.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MonoGame.Framework.DesktopGL" Version="3.8.*" />
+    <PackageReference Include="MonoGame.Content.Builder.Task" Version="3.8.*" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="..\..\Core\Content\**\*.xnb" Link="Content\%(RecursiveDir)%(Filename)%(Extension)">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+</Project>

XNAGameDevelopmentbyExample/RobotRampage/Platforms/Windows/Program.cs

@@ -0,0 +1,20 @@
+using System;
+using Robot_Rampage;
+
+namespace RobotRampage
+{
+    static class Program
+    {
+        /// <summary>
+        /// The main entry point for the application.
+        /// </summary>
+        static void Main(string[] args)
+        {
+            using (Game1 game = new Game1())
+            {
+                game.Run();
+            }
+        }
+    }
+}
+

XNAGameDevelopmentbyExample/RobotRampage/Platforms/Windows/RobotRampage.Windows.csproj

@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <OutputType>WinExe</OutputType>
+    <PublishReadyToRun>false</PublishReadyToRun>
+    <TieredCompilation>false</TieredCompilation>
+    <UseWindowsForms>true</UseWindowsForms>
+    <UseAppHost>true</UseAppHost>
+    <AssemblyName>RobotRampage</AssemblyName>
+    <RootNamespace>RobotRampage</RootNamespace>
+    <ApplicationManifest>..\..\Core\Content\app.manifest</ApplicationManifest>
+    <ApplicationIcon>..\..\Core\Content\Game.ico</ApplicationIcon>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\..\Core\RobotRampage.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MonoGame.Framework.WindowsDX" Version="3.8.*" />
+    <PackageReference Include="MonoGame.Content.Builder.Task" Version="3.8.*" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="..\..\Core\Content\**\*.xnb" Link="Content\%(RecursiveDir)%(Filename)%(Extension)">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+</Project>

XNAGameDevelopmentbyExample/RobotRampage/Platforms/iOS/Program.cs

@@ -0,0 +1,20 @@
+using System;
+using Robot_Rampage;
+
+namespace RobotRampage
+{
+    static class Program
+    {
+        /// <summary>
+        /// The main entry point for the application.
+        /// </summary>
+        static void Main(string[] args)
+        {
+            using (Game1 game = new Game1())
+            {
+                game.Run();
+            }
+        }
+    }
+}
+

XNAGameDevelopmentbyExample/RobotRampage/Platforms/iOS/RobotRampage.iOS.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0-ios</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <Nullable>disable</Nullable>
+    <UseIOS>true</UseIOS>
+    <SupportedOSPlatformVersion>11.0</SupportedOSPlatformVersion>
+    <AssemblyName>RobotRampage</AssemblyName>
+    <RootNamespace>RobotRampage</RootNamespace>
+    <ApplicationId>com.yourcompany.robotrampage</ApplicationId>
+    <ApplicationTitle>Robot Rampage</ApplicationTitle>
+    <ApplicationDisplayVersion>1.0</ApplicationDisplayVersion>
+    <ApplicationVersion>1</ApplicationVersion>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\..\Core\RobotRampage.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MonoGame.Framework.iOS" Version="3.8.*" />
+    <PackageReference Include="MonoGame.Content.Builder.Task" Version="3.8.*" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="..\..\Core\Content\**\*.xnb" Link="Content\%(RecursiveDir)%(Filename)%(Extension)">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+</Project>

XNAGameDevelopmentbyExample/RobotRampage/README.md

@@ -0,0 +1,116 @@
+# Robot Rampage - MonoGame 3.8.4 Project
+
+This is a modernized version of the Robot Rampage game from the XNA Game Development by Example book, updated to use MonoGame 3.8.4 and .NET 8.0.
+
+Originally from the Book "XNA 4.0 Game Development by Example: Beginner's Guide" by Kurt Jaegers
+Published by PACKT Publishing: http://www.packtpub.com/xna-4-0-game-development-by-example-beginners-guide/book
+
+## Project Structure
+
+The project has been converted to use modern SDK-style project files and supports multiple platforms:
+
+- **RobotRampage.DesktopGL.csproj** - Cross-platform desktop version using OpenGL
+- **RobotRampage.Windows.csproj** - Windows-specific version using DirectX
+- **RobotRampage.Android.csproj** - Android version
+- **RobotRampage.iOS.csproj** - iOS version
+
+## Prerequisites
+
+- .NET 8.0 SDK or later
+- Visual Studio 2022 (recommended) or Visual Studio Code
+- For Android development: Android SDK
+- For iOS development: Xcode (macOS only)
+
+## Building
+
+### Using Visual Studio
+Open `RobotRampage.sln` in Visual Studio and build the desired project.
+
+### Using .NET CLI
+```bash
+# Build Windows version
+dotnet build RobotRampage.Windows.csproj
+
+# Build DesktopGL version
+dotnet build RobotRampage.DesktopGL.csproj
+
+# Build Android version
+dotnet build RobotRampage.Android.csproj
+```
+
+### Using Visual Studio Code
+Open the folder in VS Code and use the following tasks:
+- `Ctrl+Shift+P` → "Tasks: Run Task" → Choose build task
+- Available tasks: build-windows, build-desktopgl, build-android
+
+## Running
+
+### Using .NET CLI
+```bash
+# Run Windows version
+dotnet run --project RobotRampage.Windows.csproj
+
+# Run DesktopGL version
+dotnet run --project RobotRampage.DesktopGL.csproj
+```
+
+### Using Visual Studio Code
+- `F5` to debug with Launch DesktopGL or Launch Windows configurations
+- `Ctrl+F5` to run without debugging
+
+## Content Pipeline
+
+The project uses existing compiled content (.xnb files) from the Content folder. No additional content pipeline setup is required as the .xnb files are directly copied to the output directory.
+
+## Changes Made
+
+1. **Removed all #region/#endregion directives** for cleaner, modern code
+2. **Updated to SDK-style project files** using .NET 8.0 target frameworks
+3. **Added MonoGame 3.8.* NuGet package references** for all platforms
+4. **Fixed namespace consistency** (changed from Robot_Rampage to RobotRampage)
+5. **Removed obsolete XNA references** (like GamerServices)
+6. **Added VSCode configuration files** for building and debugging
+7. **Updated Program.cs** to modern .NET style without platform-specific conditionals
+
+## Platform-Specific Notes
+
+### Windows
+- Uses MonoGame.Framework.WindowsDX
+- Supports both windowed and fullscreen modes
+- Requires Windows 10 or later
+
+### DesktopGL
+- Uses MonoGame.Framework.DesktopGL
+- Cross-platform compatible (Windows, Linux, macOS)
+- Uses OpenGL for rendering
+
+### Android
+- Uses MonoGame.Framework.Android
+- Minimum SDK version: 21 (Android 5.0)
+- Target SDK version: 34 (Android 14)
+- Includes AndroidManifest.xml configuration
+
+### iOS
+- Uses MonoGame.Framework.iOS
+- Minimum iOS version: 11.0
+- Requires Xcode and macOS for building
+
+## Troubleshooting
+
+1. **Content Warning**: The "No Content References Found" warning is expected since we're using pre-compiled .xnb files instead of a .mgcb content pipeline project.
+
+2. **Build Errors**: Ensure you have the correct .NET 8.0 SDK installed and all required workloads for your target platform.
+
+3. **Android Build Issues**: Make sure you have the Android SDK installed and configured properly in Visual Studio.
+
+## Game Controls
+
+- Arrow keys or WASD: Move player
+- Mouse: Aim turret
+- Left click: Fire weapon
+- Escape: Exit game
+
+## License
+
+This code is based on the examples from "XNA Game Development by Example" and has been modernized for educational purposes.
+

XNAGameDevelopmentbyExample/RobotRampage/RobotRampage.sln

@@ -0,0 +1,43 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RobotRampage.DesktopGL", "RobotRampage.DesktopGL.csproj", "{9522776F-02BA-4BED-B8BB-6BAE580F4068}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RobotRampage.Windows", "RobotRampage.Windows.csproj", "{E8C1F8E8-9D8A-4B83-8A9A-6F1C8A5E7E7E}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RobotRampage.Android", "RobotRampage.Android.csproj", "{A1B2C3D4-E5F6-7890-A1B2-C3D4E5F67890}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RobotRampage.iOS", "RobotRampage.iOS.csproj", "{B2C3D4E5-F6A7-8901-B2C3-D4E5F6A78901}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9522776F-02BA-4BED-B8BB-6BAE580F4068}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9522776F-02BA-4BED-B8BB-6BAE580F4068}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9522776F-02BA-4BED-B8BB-6BAE580F4068}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9522776F-02BA-4BED-B8BB-6BAE580F4068}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E8C1F8E8-9D8A-4B83-8A9A-6F1C8A5E7E7E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E8C1F8E8-9D8A-4B83-8A9A-6F1C8A5E7E7E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E8C1F8E8-9D8A-4B83-8A9A-6F1C8A5E7E7E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E8C1F8E8-9D8A-4B83-8A9A-6F1C8A5E7E7E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A1B2C3D4-E5F6-7890-A1B2-C3D4E5F67890}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A1B2C3D4-E5F6-7890-A1B2-C3D4E5F67890}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A1B2C3D4-E5F6-7890-A1B2-C3D4E5F67890}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A1B2C3D4E5F6-7890-A1B2-C3D4E5F67890}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B2C3D4E5-F6A7-8901-B2C3-D4E5F6A78901}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B2C3D4E5-F6A7-8901-B2C3-D4E5F6A78901}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B2C3D4E5-F6A7-8901-B2C3-D4E5F6A78901}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B2C3D4E5-F6A7-8901-B2C3-D4E5F6A78901}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {ABCDEFAB-CDEF-ABCD-EFAB-CDEFABCDEFAB}
+	EndGlobalSection
+EndGlobal