/******************************************************************************/
/*!
\file GameFunctions.cs
\author Kevin Carey

    Contains many objects and functions specific to the game
    Copyright © 2007 DigiPen(USA) Corporation. All rights reserved.

*/
/******************************************************************************/

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

namespace Shooting_Range
{
    // Game enums
    enum GameState { MENU, GAME, STATS, CREDITS };
    enum GameType { TARGETS, LOGIC };

    // GameFunctions Class
    // Contains many objects and functions specific to the game
    class GameFunctions
    {
        // Constructor
        public GameFunctions(Game1 game)
        {
            m_Game = game;
            m_GraphicsManager = new GraphicsManager(game);
            m_ModelDictionary = new Dictionary<string, Model>();
            m_Sound = new Sound();
            m_TargetEventList = new List<IEvent>();
            m_LogicEventList = new List<IEvent>();
            m_BulletList = new List<Object>();
            m_BulletIndex = 0;
            m_BulletRayList = new List<BulletRay>();
            m_BulletRayIndex = 0;
            m_ButtonList = new List<Button>();
            m_FailTimer = TimeSpan.MinValue;
            m_GameState = GameState.MENU;
            m_GameType = GameType.TARGETS;
            m_Statistics = new Statistics();
            m_MaxRounds = int.MaxValue;
            m_GunBarrelPosition = Vector3.Zero;
            random = new Random();
        }

        // Initialize function
        public void Initialize()
        {
            // Start playing the background music
            Sounds.Play("Background");
        }

        // LoadGraphicsContent function
        // This ends up being an initialize function for much more than it should be.
        public void LoadGraphicsContent()
        {
            // Target Object (world position)
            ModelDictionary.Add("Target", Graphics.Content.Load<Model>("Content\\Models\\target"));
            Object targetObject = new Object(ModelDictionary["Target"], ObjectType.TARGET, 
                                             new Vector3(0.5f, 0.5f, 0.5f), new Vector3(90.0f, 0.0f, 0.0f), 
                                             Vector3.Zero, Vector3.Zero, 0.0f, false);
            targetObject.AddCollisionData(new CirclePlane(
                                            new Plane(targetObject.Position,
                                                      targetObject.Position + new Vector3(1.0f, 0.0f, 0.0f),
                                                      targetObject.Position + new Vector3(0.0f, 1.0f, 0.0f)),
                                            new Circle(new Vector2(targetObject.PositionX, targetObject.PositionY),
                                                       15.0f)));

            // Gun Object (view position)
            ModelDictionary.Add("Gun", Graphics.Content.Load<Model>("Content\\Models\\gun"));
            GunObject = new Object(ModelDictionary["Gun"], ObjectType.GUN,
                                   new Vector3(0.05f, 0.1f, 0.05f), new Vector3(80.0f, 190.0f, 0.0f), 
                                   new Vector3(1.5f, -1.5f, -5.0f));
            GunObject.IsActive = true;
            Graphics.AddViewObject(GunObject);
            
            // Shooting range Object (world position)
            ModelDictionary.Add("Range", Graphics.Content.Load<Model>("Content\\Models\\range"));
            Graphics.AddWorldObject(new Object(ModelDictionary["Range"],
                                           ObjectType.RANGE, new Vector3(1.5f, 2.0f, 1.0f),
                                           new Vector3(90.0f, 180.0f, 0.0f), new Vector3(0.0f, 0.0f, 160.0f),
                                           Vector3.Zero, 0.0f, true));

            // Bullet object
            ModelDictionary.Add("Bullet", Graphics.Content.Load<Model>("Content\\Models\\bullet"));
            Object bullet = new Object(ModelDictionary["Bullet"], ObjectType.BULLET);
            bullet.Scale = new Vector3(0.3f, 0.3f, 0.3f);
            bullet.IsActive = false;

            // Default point locations for bullet rays
            Vector3[] brList = new Vector3[2] { Vector3.Zero, Vector3.Zero };

            // Bullet pool
            // For 256 times
            for (int i = 0; i < 256; ++i)
            {
                // Clone the bullet
                Object clone = bullet.CloneObject();
                // Add it to the list of bullets
                BulletList.Add(clone);
                // Add it to the world objects list
                Graphics.AddWorldObject(clone);
                // Add a bullet ray to the BulletRay list
                BulletRayList.Add(new BulletRay(brList));
                // Add that bullet ray to the graphics list
                Graphics.AddBulletRay(BulletRayList[i]);
            }

            // Title Page Sprite
            TitlePageSprite = new Sprite(Graphics.Content.Load<Texture2D>("Content\\Sprites\\titlePage"));
            Graphics.AddSprite(TitlePageSprite);

            // Background sprite for the stats and credits screens
            StatsBackgroundSprite = new Sprite(Graphics.Content.Load<Texture2D>("Content\\Sprites\\statsBackground"));
            StatsBackgroundSprite.IsActive = false;
            Graphics.AddSprite(StatsBackgroundSprite);

            // Screen coordinates for the center of the window
            int centerX = Graphics.DeviceManager.GraphicsDevice.Viewport.Width / 2;
            int centerY = Graphics.DeviceManager.GraphicsDevice.Viewport.Height / 2;

            // Target Button Sprite
            Texture2D targetButtonTexture = Graphics.Content.Load<Texture2D>("Content\\Sprites\\targetsButton");
            Sprite TargetButtonSprite = new Sprite(targetButtonTexture);
            TargetButtonSprite.PositionX = centerX;
            TargetButtonSprite.PositionY = centerY;
            Graphics.AddSprite(TargetButtonSprite);

            m_TargetButton = new Button(m_Game, TargetButtonSprite, 
                                        targetButtonTexture, 
                                        Graphics.Content.Load<Texture2D>("Content\\Sprites\\targetsButtonOver"));
            m_TargetButton.OnClickFunction = new Button.OnClick(OnClickTarget);

            m_ButtonList.Add(m_TargetButton);

            // Logic Button Sprite
            Texture2D logicButtonTexture = Graphics.Content.Load<Texture2D>("Content\\Sprites\\logicButton");
            Sprite LogicButtonSprite = new Sprite(logicButtonTexture);
            LogicButtonSprite.PositionX = centerX;
            LogicButtonSprite.PositionY = TargetButtonSprite.PositionY + TargetButtonSprite.Height + 40;
            Graphics.AddSprite(LogicButtonSprite);

            m_LogicButton = new Button(m_Game, LogicButtonSprite,
                                       logicButtonTexture,
                                       Graphics.Content.Load<Texture2D>("Content\\Sprites\\logicButtonOver"));
            m_LogicButton.OnClickFunction = new Button.OnClick(OnClickLogic);

            m_ButtonList.Add(m_LogicButton);

            // Exit Button Sprite
            Texture2D exitButtonTexture = Graphics.Content.Load<Texture2D>("Content\\Sprites\\exitButton");
            Sprite ExitButtonSprite = new Sprite(exitButtonTexture);
            ExitButtonSprite.PositionX = centerX;
            ExitButtonSprite.PositionY = LogicButtonSprite.PositionY + LogicButtonSprite.Height + 40;
            Graphics.AddSprite(ExitButtonSprite);

            m_ExitButton = new Button(m_Game, ExitButtonSprite,
                                      exitButtonTexture,
                                      Graphics.Content.Load<Texture2D>("Content\\Sprites\\exitButtonOver"));
            m_ExitButton.OnClickFunction = new Button.OnClick(OnClickExit);

            m_ButtonList.Add(m_ExitButton);

            // Menu Button Sprite
            Texture2D menuButtonTexture = Graphics.Content.Load<Texture2D>("Content\\Sprites\\menuButton");
            Sprite MenuButtonSprite = new Sprite(menuButtonTexture);
            MenuButtonSprite.PositionX = Graphics.DeviceManager.GraphicsDevice.Viewport.Width - (MenuButtonSprite.Width / 2) - 20;
            MenuButtonSprite.PositionY = Graphics.DeviceManager.GraphicsDevice.Viewport.Height - MenuButtonSprite.Height - ExitButtonSprite.Height - 20;
            MenuButtonSprite.IsActive = false;
            Graphics.AddSprite(MenuButtonSprite);

            m_MenuButton = new Button(m_Game, MenuButtonSprite,
                                      menuButtonTexture,
                                      Graphics.Content.Load<Texture2D>("Content\\Sprites\\menuButtonOver"), false);
            m_MenuButton.OnClickFunction = new Button.OnClick(OnClickMenu);

            m_ButtonList.Add(m_MenuButton);

            // Credits Button Sprite
            Texture2D creditsButtonTexture = Graphics.Content.Load<Texture2D>("Content\\Sprites\\creditsButton");
            Sprite CreditsButtonSprite = new Sprite(creditsButtonTexture);
            CreditsButtonSprite.PositionX = Graphics.DeviceManager.GraphicsDevice.Viewport.Width - (CreditsButtonSprite.Width / 2) - 20;
            CreditsButtonSprite.PositionY = Graphics.DeviceManager.GraphicsDevice.Viewport.Height - CreditsButtonSprite.Height;
            Graphics.AddSprite(CreditsButtonSprite);

            m_CreditsButton = new Button(m_Game, CreditsButtonSprite,
                                         creditsButtonTexture,
                                         Graphics.Content.Load<Texture2D>("Content\\Sprites\\creditsButtonOver"));
            m_CreditsButton.OnClickFunction = new Button.OnClick(OnClickCredits);

            m_ButtonList.Add(m_CreditsButton);

            // Cursor Sprite
            CursorSprite = new Sprite(Graphics.Content.Load<Texture2D>("Content\\Sprites\\mousePointer"),
                                      centerX, centerY);
            Graphics.AddSprite(CursorSprite);

            // Models used in color related events
            ModelDictionary.Add("BlueDisk", Graphics.Content.Load<Model>("Content\\Models\\BlueDisk"));
            ModelDictionary.Add("GreenDisk", Graphics.Content.Load<Model>("Content\\Models\\GreenDisk"));
            ModelDictionary.Add("RedDisk", Graphics.Content.Load<Model>("Content\\Models\\RedDisk"));
            ModelDictionary.Add("YellowDisk", Graphics.Content.Load<Model>("Content\\Models\\YellowDisk"));
            ModelDictionary.Add("WhiteDisk", Graphics.Content.Load<Model>("Content\\Models\\WhiteDisk"));

            // Models used in number related events
            ModelDictionary.Add("OneDisk", Graphics.Content.Load<Model>("Content\\Models\\OneDisk"));
            ModelDictionary.Add("TwoDisk", Graphics.Content.Load<Model>("Content\\Models\\TwoDisk"));
            ModelDictionary.Add("ThreeDisk", Graphics.Content.Load<Model>("Content\\Models\\ThreeDisk"));
            ModelDictionary.Add("FourDisk", Graphics.Content.Load<Model>("Content\\Models\\FourDisk"));
            ModelDictionary.Add("FiveDisk", Graphics.Content.Load<Model>("Content\\Models\\FiveDisk"));

            // Models used in letter related events
            ModelDictionary.Add("ADisk", Graphics.Content.Load<Model>("Content\\Models\\ADisk"));
            ModelDictionary.Add("BDisk", Graphics.Content.Load<Model>("Content\\Models\\BDisk"));
            ModelDictionary.Add("CDisk", Graphics.Content.Load<Model>("Content\\Models\\CDisk"));
            ModelDictionary.Add("DDisk", Graphics.Content.Load<Model>("Content\\Models\\DDisk"));
            ModelDictionary.Add("EDisk", Graphics.Content.Load<Model>("Content\\Models\\EDisk"));

            // Font
            GameFont = Graphics.Content.Load<SpriteFont>("Content\\Sprites\\Font");

            // List of targets for target events
            List<Object> targetList = new List<Object>();
            // For 5
            for (int i = 0; i < 5; ++i)
            {
                // Clone the target
                Object clone = targetObject.CloneObject();
                // Move the clone
                clone.Move(new Vector3(35.0f * i, 0.0f, 0.0f));
                // Add to the world objects list
                Graphics.AddWorldObject(clone);
                // Add to the list of targets
                targetList.Add(clone);
            }

            // Add new target events to the target event list
            TargetEventList.Add(new TargetsJumpUpEvent(targetList, Sounds, GameStats));
            TargetEventList.Add(new TargetsFallDownEvent(targetList, Sounds, GameStats));
            TargetEventList.Add(new TargetsSideToSideEvent(targetList, Sounds, GameStats));
            TargetEventList.Add(new TargetsFallRandomEvent(targetList, Sounds, GameStats));
            TargetEventList.Add(new TargetsArcEvent(targetList, Sounds, GameStats));

            // Timer text for various events
            Text timerText = new Text("0.000", GameFont, Color.Yellow, new Vector2(350, 5), new Vector2(1.5f, 1.5f), false);
            Graphics.AddText(timerText);

            // Target object for RandomEvent
            Object randomEventTarget = new Object(ModelDictionary["BlueDisk"], ObjectType.TARGET);
            randomEventTarget.AddCollisionData(new CirclePlane(
                                                new Plane(randomEventTarget.Position,
                                                          randomEventTarget.Position + new Vector3(1.0f, 0.0f, 0.0f),
                                                          randomEventTarget.Position + new Vector3(0.0f, 1.0f, 0.0f)),
                                                new Circle(new Vector2(randomEventTarget.PositionX, randomEventTarget.PositionY),
                                                           15.0f)));
            randomEventTarget.IsActive = false;
            Graphics.AddWorldObject(randomEventTarget);

            // Goal object for RandomEvent (view object)
            Object randomEventGoal = new Object(ModelDictionary["BlueDisk"], ObjectType.TARGET);
            randomEventGoal.IsActive = false;
            Graphics.AddViewObject(randomEventGoal);

            // Text object for RandomEvent
            Text randomEventInstructions = new Text("Shoot this target:", GameFont, Color.GreenYellow,
                                                    new Vector2(200.0f, 280.0f), Vector2.One,
                                                    false);
            Graphics.AddText(randomEventInstructions);

            // Add RandomEvent to the logic event list
            LogicEventList.Add(new RandomEvent(randomEventTarget, randomEventGoal, ModelDictionary, randomEventInstructions,
                                               timerText, Sounds, GameStats));

            // New list of objects for OrderedEvent
            List<Object> orderedEventObjectList = new List<Object>();

            // First object for OrderedEvent
            Object oneObject = new Object(ModelDictionary["OneDisk"], ObjectType.TARGET,
                                          new Vector3(0.5f, 0.5f, 0.5f), Vector3.Zero,
                                          new Vector3(0.0f, 0.0f, 80.0f));
            oneObject.AddCollisionData(new CirclePlane(
                                            new Plane(oneObject.Position,
                                                      oneObject.Position + new Vector3(1.0f, 0.0f, 0.0f),
                                                      oneObject.Position + new Vector3(0.0f, 1.0f, 0.0f)),
                                            new Circle(new Vector2(oneObject.PositionX, oneObject.PositionY),
                                                       15.0f)));
            Graphics.AddWorldObject(oneObject);
            orderedEventObjectList.Add(oneObject);

            // Second object for OrderedEvent
            Object twoObject = new Object(ModelDictionary["TwoDisk"], ObjectType.TARGET,
                                          new Vector3(0.5f, 0.5f, 0.5f), Vector3.Zero,
                                          new Vector3(0.0f, 0.0f, 60.0f));
            twoObject.AddCollisionData(new CirclePlane(
                                            new Plane(twoObject.Position,
                                                      twoObject.Position + new Vector3(1.0f, 0.0f, 0.0f),
                                                      twoObject.Position + new Vector3(0.0f, 1.0f, 0.0f)),
                                            new Circle(new Vector2(twoObject.PositionX, twoObject.PositionY),
                                                       15.0f)));
            Graphics.AddWorldObject(twoObject);
            orderedEventObjectList.Add(twoObject);

            // Third object for OrderedEvent
            Object threeObject = new Object(ModelDictionary["ThreeDisk"], ObjectType.TARGET,
                                          new Vector3(0.5f, 0.5f, 0.5f), Vector3.Zero,
                                          new Vector3(0.0f, 0.0f, 40.0f));
            threeObject.AddCollisionData(new CirclePlane(
                                            new Plane(threeObject.Position,
                                                      threeObject.Position + new Vector3(1.0f, 0.0f, 0.0f),
                                                      threeObject.Position + new Vector3(0.0f, 1.0f, 0.0f)),
                                            new Circle(new Vector2(threeObject.PositionX, threeObject.PositionY),
                                                       15.0f)));
            Graphics.AddWorldObject(threeObject);
            orderedEventObjectList.Add(threeObject);

            // Fourth object for OrderedEvent
            Object fourObject = new Object(ModelDictionary["FourDisk"], ObjectType.TARGET,
                                          new Vector3(0.5f, 0.5f, 0.5f), Vector3.Zero,
                                          new Vector3(0.0f, 0.0f, 20.0f));
            fourObject.AddCollisionData(new CirclePlane(
                                            new Plane(fourObject.Position,
                                                      fourObject.Position + new Vector3(1.0f, 0.0f, 0.0f),
                                                      fourObject.Position + new Vector3(0.0f, 1.0f, 0.0f)),
                                            new Circle(new Vector2(fourObject.PositionX, fourObject.PositionY),
                                                       15.0f)));
            Graphics.AddWorldObject(fourObject);
            orderedEventObjectList.Add(fourObject);

            // Fifth object for OrderedEvent
            Object fiveObject = new Object(ModelDictionary["FiveDisk"], ObjectType.TARGET,
                                          new Vector3(0.5f, 0.5f, 0.5f), Vector3.Zero,
                                          Vector3.Zero);
            fiveObject.AddCollisionData(new CirclePlane(
                                            new Plane(fiveObject.Position,
                                                      fiveObject.Position + new Vector3(1.0f, 0.0f, 0.0f),
                                                      fiveObject.Position + new Vector3(0.0f, 1.0f, 0.0f)),
                                            new Circle(new Vector2(fiveObject.PositionX, fiveObject.PositionY),
                                                       15.0f)));
            Graphics.AddWorldObject(fiveObject);
            orderedEventObjectList.Add(fiveObject);

            //Instructions text for OrderedEvent
            Text orderedEventText = new Text("Hit the targets in order", GameFont, Color.GreenYellow, 
                                             new Vector2(220.0f, 280.0f), Vector2.One, false);
            Graphics.AddText(orderedEventText);

            // Add OrderedEvent to the logic evennt list
            LogicEventList.Add(new OrderedEvent(orderedEventObjectList, ModelDictionary, orderedEventText, timerText, Sounds, GameStats));

            // New list of objects for the grid event
            List<Object> gridObjectList = new List<Object>();
            // For 3 rows
            for (int y = 0; y < 3; ++y)
            {
                // For 7 columns
                for (int x = 0; x < 7; ++x)
                {
                    // Make a new object
                    Object obj = new Object(ModelDictionary["Target"], ObjectType.TARGET, 
                                            new Vector3(0.35f, 0.35f, 0.35f), Vector3.Zero, Vector3.Zero);
                    // Position it
                    obj.PositionX = -60.0f + (21.0f * x);
                    obj.PositionY = -24.0f + (21.0f * y);
                    obj.PositionZ = 50.0f;
                    // Add colision data
                    obj.AddCollisionData(new CirclePlane(
                                            new Plane(obj.Position,
                                                      obj.Position + new Vector3(1.0f, 0.0f, 0.0f),
                                                      obj.Position + new Vector3(0.0f, 1.0f, 0.0f)),
                                            new Circle(new Vector2(obj.PositionX, obj.PositionY),
                                                       10.5f)));

                    // Add it to the object list
                    gridObjectList.Add(obj);
                    // Add it to the graphics engine
                    Graphics.AddWorldObject(obj);
                }
            }

            // Instructions text for the grid event
            Text gridInstructions = new Text("Hit all of this target:", GameFont, Color.GreenYellow, 
                                             new Vector2(185.0f, 280.0f), Vector2.One, false);
            Graphics.AddText(gridInstructions);

            // Add the grid event to the logic event list
            LogicEventList.Add(new GridTargetEvent(gridObjectList, ModelDictionary, randomEventGoal,
                                                   gridInstructions, timerText, Sounds, GameStats));

            // New list for the switch event
            List<Object> switchObjectList = new List<Object>();

            // For 3
            for (int i = 0; i < 3; ++i)
            {
                // Make a new object
                Object obj = new Object(ModelDictionary["Target"], ObjectType.TARGET,
                                        new Vector3(0.5f, 0.5f, 0.5f), Vector3.Zero, Vector3.Zero);

                // Add collision data
                obj.AddCollisionData(new CirclePlane(
                                        new Plane(obj.Position,
                                                  obj.Position + new Vector3(1.0f, 0.0f, 0.0f),
                                                  obj.Position + new Vector3(0.0f, 1.0f, 0.0f)),
                                        new Circle(new Vector2(obj.PositionX, obj.PositionY),
                                                   15.0f)));

                // Add it to the object list
                switchObjectList.Add(obj);
                // Add it to the graphics engine
                Graphics.AddWorldObject(obj);
            }

            // Instructions text for the switch event
            Text switchInstructions = new Text("Follow the different one", GameFont, Color.GreenYellow,
                                               new Vector2(240.0f, 280.0f), Vector2.One, false);
            Graphics.AddText(switchInstructions);

            // Add the switching event to the logic event list
            LogicEventList.Add(new SwitchingEvent(switchObjectList, ModelDictionary, switchInstructions, timerText,
                                                  Sounds, GameStats));

            // Default the event list to the logic event list
            EventList = LogicEventList;

            // Text objects for displaying stats
            StatsTitle = new Text("Game Statistics", GameFont, Color.GreenYellow, new Vector2(centerX - 100, 10));
            StatsTitle.IsActive = false;
            Graphics.AddText(StatsTitle);

            StatsText = new Text("", GameFont, Color.GreenYellow, new Vector2(10, 50));
            StatsText.IsActive = false;
            Graphics.AddText(StatsText);

            // Text for the credits
            CreditsText = new Text("", GameFont, Color.GreenYellow, new Vector2(10, 10), new Vector2(1.2f, 1.9f));
            CreditsText.TextString =
                "Egnar 85521C\n" +
                "A game by Kevin Carey\n\n" +
                "Executive Producers:\n" +
                "   Benjamin Ellinger\n" +
                "   Rachel Rutherford\n" +
                "   Chris Peters\n\n" +
                "All content (c) 2007 DigiPen (USA) Corporation,\nall rights reserved.";
            CreditsText.IsActive = false;
            Graphics.AddText(CreditsText);

            // Initialize the sprite batch
            Graphics.InitializeSpriteBatch();

            // Initialize the BasicEffect for bullet rays
            Graphics.InitializeBulletRayEffect();
        }

        // Update function
        public void Update(TimeSpan deltaTime)
        {
            switch(State)
            {
                // In the GAME state
                case GameState.GAME:
                    // Update each object
                    UpdateObjects(deltaTime);

                    // Check collisions
                    UpdateCollision(deltaTime);

                    // Update the current event
                    UpdateCurrentEvent(deltaTime);

                    // Update the position of the gun barrel
                    UpdateGunBarrelPosition();

                    // Update the time in the stats
                    GameStats.TotalTime += deltaTime;

                    break;

                // In the other states
                case GameState.MENU:
                case GameState.STATS:
                case GameState.CREDITS:
                    // Update each button
                    UpdateButtons();
                    break;
            }

            // Update the sound engine
            Sounds.Update();
        }

        // UpdateObjects function
        private void UpdateObjects(TimeSpan deltaTime)
        {
            // Update each object
            // For each object
            for (int i = 0; i < Graphics.WorldObjects.Count; ++i)
            {
                // Update the object
                Graphics.WorldObjects[i].Update();

                // If the object is active
                if (Graphics.WorldObjects[i].IsActive)
                {
                    // If the target is out of range
                    if (Graphics.WorldObjects[i].PositionZ < -100.0f)
                    {
                        // If the object is a bullet
                        if (Graphics.WorldObjects[i].Type == ObjectType.BULLET)
                        {
                            // Update the stats
                            ++GameStats.TargetsMissed;
                        }
                        // Make it inactive
                        Graphics.WorldObjects[i].IsActive = false;
                    }
                }
            }

            // For each bullet ray
            for (int i = 0; i < Graphics.BulletRayList.Count; ++i)
            {
                // Update the bullet ray
                Graphics.BulletRayList[i].Update();
            }
        }

        // UpdateButtons function
        void UpdateButtons()
        {
            for (int i = 0; i < m_ButtonList.Count; ++i)
            {
                if (m_ButtonList[i].IsActive)
                {
                    if (!m_ButtonList[i].Update())
                    {
                        break;
                    }
                }
            }
        }

        // UpdateCollision function
        private void UpdateCollision(TimeSpan deltaTime)
        {
            // Check each bullet for a collision
            // For each bullet
            for (int i = 0; i < BulletList.Count; ++i)
            {
                // If the bullet is inactive
                if (!BulletList[i].IsActive)
                {
                    // Skip it
                    continue;
                }

                // For each object
                for (int j = 0; j < Graphics.WorldObjects.Count; ++j)
                {
                    // If the object is inactive, or the object is not a target
                    if (!Graphics.WorldObjects[j].IsActive ||
                        Graphics.WorldObjects[j].Type != ObjectType.TARGET)
                    {
                        // Skip it
                        continue;
                    }

                    // Get the point of collision
                    Vector3? collision = CheckCollision(BulletList[i], Graphics.WorldObjects[j]);
                    // If there is a point of collision
                    if (collision != null)
                    {
                        // Handle the collision
                        CurrentEvent.HandleCollision(BulletList[i], Graphics.WorldObjects[j]);
                        // End loop
                        break;
                    }
                }
            }
        }

        // UpdateCurrentEvent function
        private void UpdateCurrentEvent(TimeSpan deltaTime)
        {
            // Update the event
            CurrentEvent.Update(deltaTime);

            // Update the fail timer
            if (FailTimer != TimeSpan.MinValue)
            {
                FailTimer -= deltaTime;
            }

            // Check for failure reset
            if (CurrentEvent.IsActive && FailTimer != TimeSpan.MinValue && FailTimer < new TimeSpan(0, 0, 0))
            {
                CurrentEvent.ResetFail();
                FailTimer = TimeSpan.MinValue;
            }

            // If the failure state has been reached
            if (CurrentEvent.Fail() && FailTimer == TimeSpan.MinValue)
            {
                // Set a new fail time
                FailTimer = new TimeSpan(0, 0, 1);
            }

            // If the event has ended
            if (CurrentEvent.End())
            {
                // Shutdown the event
                CurrentEvent.Shutdown();

                // If the event ended in failure
                if (CurrentEvent.Fail())
                {
                    // End the game
                    ShutdownGameState();
                    InitStatsState();
                }
                // If the event was completed successfully
                else
                {
                    // Get the next random event
                    CurrentEvent = EventList[random.Next(EventList.Count)];
                    // Increment the round
                    ++Round;
                    // Init the next event
                    CurrentEvent.Init(Round);
                    // Increment stats
                    ++GameStats.RoundsPassed;
                }
            }

            // If the max number of rounds has been reached
            if (Round >= MaxRounds)
            {
                // End the game
                ShutdownGameState();
                InitStatsState();
            }
        }

        // Draw function
        public void Draw()
        {
            // Draw objects in world space
            Graphics.DrawWorldObjects();

            // Draw BulletRays
            Graphics.DrawBulletRays();

            // Draw objects in view space
            Graphics.DrawViewObjects();

            // Draw sprites
            Graphics.DrawSprites();

            // Draw text
            Graphics.DrawText();
        }

        // SpawnBullet functions
        // Sets a bullet from the pool to active
        public void SpawnBullet()
        {
            // Set the bullet to active
            BulletList[BulletIndex].IsActive = true;
            // Set the buller's position
            BulletList[BulletIndex].Position = GunBarrelPosition;
            // Set the bullet's direction
            BulletList[BulletIndex].PhysicsData.VelocityDirection =
                Graphics.CameraData.LookAtPosition - BulletList[BulletIndex].Position;
            // Set the bullet's speed
            Vector3 dir = BulletList[BulletIndex].PhysicsData.VelocityDirection;
            dir.Normalize();
            BulletList[BulletIndex].PhysicsData.VelocityDirection = dir * 100.0f;
            // Set up the ray of the bullet to be drawn
            Vector3[] bulletRayPointList = new Vector3[2];
            bulletRayPointList[0] = BulletList[BulletIndex].Position;
            bulletRayPointList[1] = Graphics.CameraData.LookAtPosition;
            // Init the next bullet ray
            BulletRayList[BulletRayIndex].LinePoints = bulletRayPointList;
            BulletRayList[BulletRayIndex].Alpha = 1.2f;
            BulletRayList[BulletRayIndex].IsActive = true;

            // Set the index for the next bullet to be fired
            ++BulletIndex;
            ++BulletRayIndex;

            // Update the stats
            ++GameStats.ShotsFired;

            // Play the shoot sound
            Sounds.Play("Shoot");
        }

        // CheckCollision function
        // Returns the position that a specified bullet collides with a specified object
        // Returns null if there is no collision
        private Vector3? CheckCollision(Object bullet, Object obj)
        {
            // return the collision of the bullet's ray with the object's data
            return obj.PhysicsData.CheckRayCollision(
                new Ray(bullet.Position, bullet.PhysicsData.VelocityDirection)
                                                    );
        }

        public void OnClickTarget()
        {
            // Start the game in Target Mode
            ShutdownMenuState();
            InitGameState(GameType.TARGETS);
        }

        public void OnClickLogic()
        {
            // Start the game in Logic Mode
            ShutdownMenuState();
            InitGameState(GameType.LOGIC);
        }

        public void OnClickMenu()
        {
            // Go back to the main menu
            if (State == GameState.STATS)
            {
                ShutdownStatsState();
            }
            else
            {
                ShutdownCreditsState();
            }
            InitMenuState();
        }

        public void OnClickCredits()
        {
            // Show the credits
            ShutdownMenuState();
            InitCreditsState();
        }

        public void OnClickExit()
        {
            // Exit the game
            m_Game.Exit();
        }

        // SetStatsText function
        // Updates the text that displays the stats of the game
        public void SetStatsText()
        {
            // If in target mode
            if(GameMode == GameType.TARGETS)
            {
                // Calculate accuracy, checking for 0 divide
                if (GameStats.ShotsFired == 0)
                {
                    GameStats.ShotAccuracy = 0.0f;
                }
                else
                {
                    GameStats.ShotAccuracy = (float)GameStats.TargetsHit / (float)GameStats.ShotsFired;
                }

                // Calculate the score
                GameStats.Score = (int)((float)(GameStats.TargetsHit * 1000) * GameStats.ShotAccuracy);

                // Update the text
                StatsText.TextString =
                    "Score: " + GameStats.Score.ToString() + '\n' +
                    "Shots Fired: " + GameStats.ShotsFired.ToString() + '\n' +
                    "Shots Missed: " + GameStats.TargetsMissed.ToString() + '\n' +
                    "Targets Spawned: " + GameStats.TotalTargets.ToString() + '\n' +
                    "Targets Hit: " + GameStats.TargetsHit.ToString() + '\n' +
                    "Targets Missed: " + GameStats.TargetsNotHit.ToString() + '\n' +
                    "Accuracy: " + (GameStats.ShotAccuracy * 100.0f).ToString() + '%';

            }
            // If in logic mode
            else if (GameMode == GameType.LOGIC)
            {
                // Calculate accuracy, checking for 0 divide
                if (GameStats.ShotsFired == 0)
                {
                    GameStats.ShotAccuracy = 0.0f;
                }
                else
                {
                    GameStats.ShotAccuracy = (float)(GameStats.TargetsHit + GameStats.FailedTargetsHit) / (float)GameStats.ShotsFired;
                }

                if ((GameStats.TargetsHit + GameStats.FailedTargetsHit) == 0)
                {
                    GameStats.LogicAccuracy = 0.0f;
                }
                else
                {
                    GameStats.LogicAccuracy = (float)GameStats.TargetsHit / (float)(GameStats.TargetsHit + GameStats.FailedTargetsHit);
                }

                // Calculate the score
                GameStats.Score = (int)((float)((int)GameStats.LeftoverTime.TotalSeconds * 1000) * GameStats.LogicAccuracy);
                // Update the text
                String seconds = ((int)(GameStats.TotalTime.TotalSeconds) % 60).ToString();
                StatsText.TextString =
                    "Score: " + GameStats.Score.ToString() + '\n' +
                    "Rounds Passed: " + GameStats.RoundsPassed.ToString() + '\n' +
                    "Total Time: " + ((int)(GameStats.TotalTime.TotalMinutes)).ToString() + ':' + ((int)(GameStats.TotalTime.TotalSeconds) % 60).ToString().PadLeft(2, '0') + ':' + ((int)(GameStats.TotalTime.TotalMilliseconds) % 1000).ToString().PadLeft(3, '0') + '\n' +
                    "Extra Time: " + ((int)(GameStats.LeftoverTime.TotalMinutes)).ToString() + ':' + ((int)(GameStats.LeftoverTime.TotalSeconds) % 60).ToString().PadLeft(2, '0') + ':' + ((int)(GameStats.LeftoverTime.TotalMilliseconds) % 1000).ToString().PadLeft(3, '0') + '\n' +
                    "Shots Fired: " + GameStats.ShotsFired.ToString() + '\n' +
                    "Shots Missed: " + GameStats.TargetsMissed.ToString() + '\n' +
                    "Shot Accuracy: " + (GameStats.ShotAccuracy * 100.0f).ToString() + '%' + '\n' +
                    "Correct Targets Hit: " + GameStats.TargetsHit.ToString() + '\n' +
                    "Incorrect Targets Hit: " + GameStats.FailedTargetsHit.ToString() + '\n' +
                    "Logic Accuracy: " + (GameStats.LogicAccuracy * 100.0f).ToString() + '%';
            }
        }

        // InitMenuState function
        public void InitMenuState()
        {
            // Set the state
            State = GameState.MENU;

            // Set the flags
            TitlePageSprite.IsActive = true;
            TargetButton.IsActive = true;
            LogicButton.IsActive = true;
            ExitButton.IsActive = true;
            CreditsButton.IsActive = true;

            // Position the exit button
            int centerX = Graphics.DeviceManager.GraphicsDevice.Viewport.Width / 2;
            int centerY = Graphics.DeviceManager.GraphicsDevice.Viewport.Height / 2;
            ExitButton.ButtonSprite.PositionX = centerX;
            ExitButton.ButtonSprite.PositionY = LogicButton.ButtonSprite.PositionY + LogicButton.ButtonSprite.Height + 40;
        }

        // ShutdownMenuState function
        public void ShutdownMenuState()
        {
            // Set the flags
            TitlePageSprite.IsActive = false;
            TargetButton.IsActive = false;
            LogicButton.IsActive = false;
            ExitButton.IsActive = false;
            CreditsButton.IsActive = false;
        }

        // InitGameState function
        public void InitGameState(GameType type)
        {
            // Set the states
            State = GameState.GAME;
            // Set the game mode
            GameMode = type;

            // If target mode
            if (type == GameType.TARGETS)
            {
                // Set the max rounds to 10
                MaxRounds = 10;
                // Set the event list to the target list
                EventList = TargetEventList;
            }
            // If logic mode
            else
            {
                // Set the max rounds to infinite
                MaxRounds = int.MaxValue;
                // Set the event list to the logic list
                EventList = LogicEventList;
            }

            // Reset the current round
            Round = 0;

            // Set the mouse position
            int centerX = Graphics.DeviceManager.GraphicsDevice.Viewport.Width / 2;
            int centerY = Graphics.DeviceManager.GraphicsDevice.Viewport.Height / 2;
            Mouse.SetPosition(centerX, centerY);

            // Position the cursor sprite
            CursorSprite.PositionX = centerX;
            CursorSprite.PositionY = centerY;
            // Get the first event
            CurrentEvent = EventList[random.Next(EventList.Count)];
            // Init the first event
            CurrentEvent.Init(Round);
            // Reset the stats
            GameStats.Reset(); 
        }

        // ShutdownGameState function
        public void ShutdownGameState()
        {
            // Shutdown the current event
            CurrentEvent.Shutdown();
            // For each bullet ray
            for (int i = 0; i < BulletRayList.Count; ++i)
            {
                // Make it inactive
                BulletRayList[i].IsActive = false;
            }
        }

        // InitStatsState function
        public void InitStatsState()
        {
            // Set the state
            State = GameState.STATS;

            // Set the text to be displayed
            SetStatsText();

            // Set the flags
            StatsText.IsActive = true;
            StatsTitle.IsActive = true;
            StatsBackgroundSprite.IsActive = true;
            MenuButton.IsActive = true;
            ExitButton.IsActive = true;

            // Set the button positions
            ExitButton.ButtonSprite.PositionX = Graphics.DeviceManager.GraphicsDevice.Viewport.Width - (ExitButton.ButtonSprite.Width / 2) - 20;
            ExitButton.ButtonSprite.PositionY = Graphics.DeviceManager.GraphicsDevice.Viewport.Height - ExitButton.ButtonSprite.Height - 10;
            MenuButton.ButtonSprite.PositionX = Graphics.DeviceManager.GraphicsDevice.Viewport.Width - (MenuButton.ButtonSprite.Width / 2) - 20;
            MenuButton.ButtonSprite.PositionY = Graphics.DeviceManager.GraphicsDevice.Viewport.Height - MenuButton.ButtonSprite.Height - ExitButton.ButtonSprite.Height - 20;
        }

        // ShutdownStatsState function
        public void ShutdownStatsState()
        {
            // Set the flags
            StatsText.IsActive = false;
            StatsTitle.IsActive = false;
            StatsBackgroundSprite.IsActive = false;
            MenuButton.IsActive = false;
            ExitButton.IsActive = false;
        }

        // InitCreidtsState function
        public void InitCreditsState()
        {
            // Set teh state
            State = GameState.CREDITS;

            // Set the flags
            StatsBackgroundSprite.IsActive = true;
            MenuButton.IsActive = true;
            CreditsText.IsActive = true;

            // Position the menu button
            MenuButton.ButtonSprite.PositionX = Graphics.DeviceManager.GraphicsDevice.Viewport.Width - (MenuButton.ButtonSprite.Width / 2) - 20;
            MenuButton.ButtonSprite.PositionY = Graphics.DeviceManager.GraphicsDevice.Viewport.Height - MenuButton.ButtonSprite.Height;
        }

        // ShutdonCreditsState function
        public void ShutdownCreditsState()
        {
            // Set the flags
            StatsBackgroundSprite.IsActive = false;
            MenuButton.IsActive = false;
            CreditsText.IsActive = false;
        }

        // UpdateGunBarrelPosition function
        public void UpdateGunBarrelPosition()
        {
            // Get the transformations matrices
            Matrix lookAt = Matrix.CreateLookAt(Graphics.CameraData.WorldPosition, Graphics.CameraData.LookAtPosition, Graphics.CameraData.Up);
            Matrix world = Matrix.CreateScale(GunObject.Scale)
                         * Matrix.CreateFromYawPitchRoll(MathHelper.ToRadians(GunObject.YawY),
                                                         MathHelper.ToRadians(GunObject.PitchX),
                                                         MathHelper.ToRadians(GunObject.RollZ))
                         * Matrix.CreateTranslation(GunObject.Position)
                         * Matrix.Invert(lookAt);

            // Position in model space
            Vector3 modelPosition = new Vector3(0.0f, 10.0f, 0.0f);
            // Transform the position
            GunBarrelPosition = Vector3.Transform(modelPosition, world);
        }

        // Graphics
        // Graphics manager
        public GraphicsManager Graphics
        {
            get
            {
                return m_GraphicsManager;
            }
            set
            {
                m_GraphicsManager = value;
            }
        }

        // ModelDictionary
        // Dictionary to store all models
        public Dictionary<String, Model> ModelDictionary
        {
            get
            {
                return m_ModelDictionary;
            }
            set
            {
                m_ModelDictionary = value;
            }
        }

        // Sounds
        // Sound engine.  Sould of been a static class.  That was silly of me
        public Sound Sounds
        {
            get
            {
                return m_Sound;
            }
            set
            {
                m_Sound = value;
            }
        }

        // EventList
        // List of possible events for the current game
        public List<IEvent> EventList
        {
            get
            {
                return m_EventList;
            }
            set
            {
                m_EventList = value;
            }
        }

        // TargetEventList
        // List of possible events for target mode
        public List<IEvent> TargetEventList
        {
            get
            {
                return m_TargetEventList;
            }
            set
            {
                m_TargetEventList = value;
            }
        }

        // LogicEventList
        // List of possible events for logic mode
        public List<IEvent> LogicEventList
        {
            get
            {
                return m_LogicEventList;
            }
            set
            {
                m_LogicEventList = value;
            }
        }

        // CurrentEvent
        // The event that is currently happening in the game
        public IEvent CurrentEvent
        {
            get
            {
                return m_CurrentEvent;
            }
            set
            {
                m_CurrentEvent = value;
            }
        }

        // BulletList
        // Pool of bullet objects
        public List<Object> BulletList
        {
            get
            {
                return m_BulletList;
            }
            set
            {
                m_BulletList = value;
            }
        }

        // BulletRayList
        // Pool of BulletRays
        public List<BulletRay> BulletRayList
        {
            get
            {
                return m_BulletRayList;
            }
            set
            {
                m_BulletRayList = value;
            }
        }

        // BulletIndex
        // Current index of the bullet pool
        public byte BulletIndex
        {
            get
            {
                return m_BulletIndex;
            }
            set
            {
                m_BulletIndex = value;
            }
        }

        // BulletRayIndex
        // Current index of the bullet ray pool
        public byte BulletRayIndex
        {
            get
            {
                return m_BulletRayIndex;
            }
            set
            {
                m_BulletRayIndex = value;
            }
        }

        // GunObject
        // The objct that is the gun in viewspace.  Might not be necessary to store anymore
        public Object GunObject
        {
            get
            {
                return m_GunObject;
            }
            set
            {
                m_GunObject = value;
            }
        }

        // GameFont
        // The font used by all of the text in the game
        public SpriteFont GameFont
        {
            get
            {
                return m_Font;
            }
            set
            {
                m_Font = value;
            }
        }

        // CursorSprite
        // Sprite representing the cursor
        public Sprite CursorSprite
        {
            get
            {
                return m_CursorSprite;
            }
            set
            {
                m_CursorSprite = value;
            }
        }

        // TitlePageSprite
        // Background for the title page
        public Sprite TitlePageSprite
        {
            get
            {
                return m_TitlePageSprite;
            }
            set
            {
                m_TitlePageSprite = value;
            }
        }

        // StatsBackgroundSprite
        // Background for the stats and credits pages
        public Sprite StatsBackgroundSprite
        {
            get
            {
                return m_StatsBackgroundSprite;
            }
            set
            {
                m_StatsBackgroundSprite = value;
            }
        }

        // TargetButton
        // Sprite for the Target Mode button
        public Button TargetButton
        {
            get
            {
                return m_TargetButton;
            }
            set
            {
                m_TargetButton = value;
            }
        }

        // LogicButton
        // Sprite for the Logic Mode button
        public Button LogicButton
        {
            get
            {
                return m_LogicButton;
            }
            set
            {
                m_LogicButton = value;
            }
        }

        // ExitButton
        // Sprite for the Exit Game button
        public Button ExitButton
        {
            get
            {
                return m_ExitButton;
            }
            set
            {
                m_ExitButton = value;
            }
        }

        // MenuButton
        // Sprite for the Main Menu button
        public Button MenuButton
        {
            get
            {
                return m_MenuButton;
            }
            set
            {
                m_MenuButton = value;
            }
        }

        // CreditsButton
        // Sprite for the Credits button
        public Button CreditsButton
        {
            get
            {
                return m_CreditsButton;
            }
            set
            {
                m_CreditsButton = value;
            }
        }

        // FailTimer
        // Timer indicating how long until a fail reset occurs
        public TimeSpan FailTimer
        {
            get
            {
                return m_FailTimer;
            }
            set
            {
                m_FailTimer = value;
            }
        }

        // Round
        // The number of events the palyer has passed
        public int Round
        {
            get
            {
                return m_Round;
            }
            set
            {
                m_Round = value;
            }
        }

        // State
        // The current GameState the state is in
        public GameState State
        {
            get
            {
                return m_GameState;
            }
            set
            {
                m_GameState = value;
            }
        }

        // GameMode
        // The current type of game that is beign played
        public GameType GameMode
        {
            get
            {
                return m_GameType;
            }
            set
            {
                m_GameType = value;
            }
        }

        // GameStats
        // Statistics for the current game being played
        public Statistics GameStats
        {
            get
            {
                return m_Statistics;
            }
            set
            {
                m_Statistics = value;
            }
        }

        // MaxRounds
        // The number of rounds that occur before the game ends
        public int MaxRounds
        {
            get
            {
                return m_MaxRounds;
            }
            set
            {
                m_MaxRounds = value;
            }
        }

        // StatsTitle
        // The text on the statistics page that say "Statistics"
        public Text StatsTitle
        {
            get
            {
                return m_StatsTitle;
            }
            set
            {
                m_StatsTitle = value;
            }
        }

        // StatsText
        // The text on the statistics page that give the statistics
        public Text StatsText
        {
            get
            {
                return m_StatsText;
            }
            set
            {
                m_StatsText = value;
            }
        }

        // GunBarrelPosition
        // World position indicating the tip of the barrel of the gun
        public Vector3 GunBarrelPosition
        {
            get
            {
                return m_GunBarrelPosition;
            }
            set
            {
                m_GunBarrelPosition = value;
            }
        }

        // CreditsText
        // The text that displays on the credits screen
        public Text CreditsText
        {
            get
            {
                return m_CreditsText;
            }
            set
            {
                m_CreditsText = value;
            }
        }

        // Private memebers
        private GraphicsManager m_GraphicsManager;
        private Dictionary<String, Model> m_ModelDictionary;
        private Sound m_Sound;
        private List<IEvent> m_EventList;
        private List<IEvent> m_TargetEventList;
        private List<IEvent> m_LogicEventList;
        private IEvent m_CurrentEvent;
        private List<Object> m_BulletList;
        private List<BulletRay> m_BulletRayList;
        private byte m_BulletIndex;
        private byte m_BulletRayIndex;
        private Object m_GunObject;
        private SpriteFont m_Font;
        private Sprite m_CursorSprite;
        private Sprite m_TitlePageSprite;
        private Sprite m_StatsBackgroundSprite;
        private Button m_TargetButton;
        private Button m_LogicButton;
        private Button m_ExitButton;
        private Button m_MenuButton;
        private Button m_CreditsButton;
        private List<Button> m_ButtonList;
        private TimeSpan m_FailTimer;
        private int m_Round;
        private GameState m_GameState;
        private GameType m_GameType;
        private Statistics m_Statistics;
        private Game1 m_Game;
        private int m_MaxRounds;
        private Text m_StatsTitle;
        private Text m_StatsText;
        private Vector3 m_GunBarrelPosition;
        private Text m_CreditsText;
        private Random random;
    }
}