[Kilorn]

Let me start off by saying that this challenge will not be a contest. There will be no end date, and there will be no winners. What I want to do with this challenge is to challenge each and every person out there that is interested in XNA to create a reusable class(es) that can be "plugged" into an existing codebase and, with the addition of the appropriate logic for instances and method calls in other areas of that codebase, will easily work to achieve the desired results.

In this challenge the only requirement that I'm going to place is that the code must work as is when added to an existing project. That means all of the variables and methods needed to use the class(es) that you have created must be contained within the class.

This challenge is very open to submissions and I'm sure you can all think of things that once upon a time you've thought "Wow, if only there was already a plug and play piece of code that would prevent me from having to re-invent the wheel." That is where this challenge comes in. I want as many people to participate in this as possible and together we can all get a large collection of reusable classes together that will help us all out in the long run.

The submission could range from a simple screen manager, game state manager, input manager, to much more complex things such as tile map editors, collision editors that allow the creation of "polygons" to use as custom collision bounds, physics and math calculators that make working with complex math a little simpler. There are no real limits as to what can be done here. If you wanted to create a complex 3D character creation system with multiple predefined characteristics for bodies, faces, hair, etc. then you're welcome to do that. Like I said, I'm going to leave this very open ended and allow each of you to let your creativity flow.

So let's see what you've got! EVERYONE is welcome, and encouraged to participate in this challenge, from pure beginner to the experts, there is no time limit, there are no winners, there are no losers. Submit what you create here inside code tags, inside spoiler tags to keep the posts from getting too long and also feel free to submit them as snippets here at the site to gain yourself some kudos!

Already a submission that handles the idea that you've chosen? No worries, so long as the code isn't identical, feel free to upload your version of it as it might handle a specific thing better than the previous one(s) do. I want everyone to feel as though they are contributing to this challenge as well as the XNA community as a whole.

Feedback welcome, and changes can be made to this challenge at any time. I'll keep the original post here updated with any changes.

[MATTtheSEAHAWK]

Well I guess I'll start it off. Right now I'm working on a game modifying application written in XNA and I'm mainly working on writing a whole GUI framework. Currently I have one mostly final base class. The base class itself is a control base class for creating a GUI control. It has worked great for me so far providing basic logic for every control I've done so far (Button, CheckBox, TextBox, and a Container and Scrollable Container). Anyways here's a paste-bin of the class:

http://pastebin.com/JQyQgj0P

[Kilorn]

That's exactly the sort of thing I was talking about for this challenge, very well done, MATTtheSEAHAWK! SixOfEleven was also trying to put together a GUI library for XNA once upon a time, and I was planning on contributing to it, but things kept getting in the way and I just didn't have time to do it. He might have some of his code left over that might be worth looking into for you if you're planning on extending this to other types of controls.

[MATTtheSEAHAWK]

Thanks Kilorn! I actually have a GitHub repository for the application/library. I can't wait to get into XNA more!

http://www.github.co...heSEAHAWK/Redux

[ShadowsEdge19]

I started working on a simple Primitives project that could be implemented into any other project. I have the basic Rectangle and Squares sorted but I'm probably going to need some help with the Ellipsis' and Triangles when they are displayed.

This post has been edited by ShadowsEdge19: 25 October 2011 - 06:07 AM

[Fib]

I have a few things that I can add here. I'll add them here as soon as I can.

[SixOfEleven]

I will also share a few classes that I have that might be helpful, including my input handling class. I'm sure that will be helpful. Just let me clean it up a bit and include a couple things.

[Kilorn]

I've actually been using your input handler for a while now, Jamie. With a few modifications of my own to suit my needs.

EDIT: Also, it sucks that we no longer have a member of the moderator staff from the XNA community. Sorry to see that you stepped down, man.

This post has been edited by Kilorn: 04 November 2011 - 08:24 AM

[Scorpion1122]

I've got a simple Key Binding library that i would like to share, what is a good place to upload it?

[lordofduct]

most of my library either is tied to existing 3rd party libraries out there, or I can't share for various reasons.

But here are a couple util classes.

Collections.Pool<T> - a managed pool of objects of type T
Collections.WeakList<T> - a list of weak references to a specific type T

Utils.Easing - a collection of easing/interpolation methods
Utils.GameTimer - a simple timer updated by the main Game.Update loop (manually call GameTimer.Update)
Utils.MathUtil - a collection of math functions
Utils.StopWatch - similar to GameTimer
Utils.Tweener - interpolates a numeric value by some easing method for a duration of time. Each step and on completion a delegate is called to use the updated numeric value for changing properties.

Attached File(s)

•  TegestaFramework_someutils.zip (17.14K)
  Number of downloads: 39

[Kilorn]

Nice collection of goodies, lordofduct. I'll definitely be looking a little deeper into these when I get home tonight.

[Scorpion1122]

*self facepalm* you can upload on the post itself, didnt know that.

Wel here is a simple library which enables you to create key bindings defined by a xml document. Feel free to change it to your liking and feel free to give tips/ideas to expand it.

Attached File(s)

•  KeyBindingsLibrary.zip (40.49K)
  Number of downloads: 41

[SixOfEleven]

This is a version of my input handling class, Xin. Took forever to strip the comments out of it so it wouldn't break the Javascript that highlights code on DIC. It is pretty easy to use, just add an instance of Xin to the components in your game.

Spoiler

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

namespace Psilibrary
{
    #region Enumeration Region
#if !XBOX360
    public enum MouseButton { None, Left, Right, Middle, X1, X2 };
#endif
    #endregion

    public sealed class Xin : Microsoft.Xna.Framework.GameComponent
    {
        #region General Region

        private static void SetStates()
        {
            lastKeyboardState = keyboardState;
#if !XBOX360
            lastMouseState = mouseState;
#endif
            for (int i = 0; i < gamePadState.Length; i++)
                lastGamePadState[i] = gamePadState[i];

            keyboardState = Keyboard.GetState();
#if !XBOX360
            mouseState = Mouse.GetState();
#endif
            gamePadState[0] = GamePad.GetState(PlayerIndex.One);
            gamePadState[1] = GamePad.GetState(PlayerIndex.Two);
            gamePadState[2] = GamePad.GetState(PlayerIndex.Three);
            gamePadState[3] = GamePad.GetState(PlayerIndex.Four);
        }

        public static void FlushInput()
        {
            SetStates();
        }

        #endregion

        public Xin(Game game)
            : base(game)
        {
            keyboardState = Keyboard.GetState();
#if !XBOX360
            mouseState = Mouse.GetState();
#endif
            gamePadState[0] = GamePad.GetState(PlayerIndex.One);
            gamePadState[1] = GamePad.GetState(PlayerIndex.Two);
            gamePadState[2] = GamePad.GetState(PlayerIndex.Three);
            gamePadState[3] = GamePad.GetState(PlayerIndex.Four);
        }

        public sealed override void Initialize()
        {
            base.Initialize();
        }

        public sealed override void Update(GameTime gameTime)
        {
            SetStates();
            base.Update(gameTime);
        }

        public static bool WasReleased(PlayerIndex? playerInControl, Buttons button, Keys key, out PlayerIndex playerIndex)
        {
            if (playerInControl.HasValue)
            {
                playerIndex = playerInControl.Value;

                if (WasKeyReleased(key) || WasButtonReleased(playerInControl, button, out playerIndex))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return (WasReleased(PlayerIndex.One, button, key, out playerIndex) ||
                    WasReleased(PlayerIndex.Two, button, key, out playerIndex) ||
                    WasReleased(PlayerIndex.Three, button, key, out playerIndex) ||
                    WasReleased(PlayerIndex.Four, button, key, out playerIndex));
            }
        }

        public static bool WasButtonReleased(PlayerIndex? playerInControl, Buttons button, out PlayerIndex playerIndex)
        {
            if (playerInControl.HasValue)
            {
                playerIndex = playerInControl.Value;

                int i = (int)playerIndex;

                return (gamePadState[i].IsButtonUp(button) &&
                    lastGamePadState[i].IsButtonDown(button));
            }
            else
            {
                return (WasButtonReleased(PlayerIndex.One, button, out playerIndex) ||
                    WasButtonReleased(PlayerIndex.Two, button, out playerIndex) ||
                    WasButtonReleased(PlayerIndex.Three, button, out playerIndex) ||
                    WasButtonReleased(PlayerIndex.Four, button, out playerIndex));
            }
        }

        public static bool WasKeyReleased(Keys key)
        {
            if (keyboardState.IsKeyUp(key) &&
                lastKeyboardState.IsKeyDown(key))
                return true;
            return false;
        }

        public static bool WasKeyPressed(Keys key)
        {
            return keyboardState.IsKeyDown(key) && lastKeyboardState.IsKeyUp(key);
        }

        #region Mouse Region
#if !XBOX360


        static MouseState mouseState;
        static MouseState lastMouseState;

        public static MouseState MouseState
        {
            get { return mouseState; }
        }

        public static MouseState LastMouseState
        {
            get { return lastMouseState; }
        }

        public static Point MouseAsPoint
        {
            get { return new Point(mouseState.X, mouseState.Y); }
        }

        public static Vector2 MouseAsVector2
        {
            get { return new Vector2(mouseState.X, mouseState.Y); }
        }

        public static Point LastMouseAsPoint
        {
            get { return new Point(lastMouseState.X, lastMouseState.Y); }
        }

        public static Vector2 LastMouseAsVector2
        {
            get { return new Vector2(lastMouseState.X, lastMouseState.Y); }
        }

        public static bool CheckMousePress(MouseButton button)
        {
            bool result = false;

            switch (button)
            {
                case MouseButton.Left:
                    result = CheckLeftButtonPress();
                    break;
                case MouseButton.Right:
                    result = CheckRightButtonPress();
                    break;
                case MouseButton.Middle:
                    result = CheckMiddleButtonPress();
                    break;
                case MouseButton.X1:
                    result = CheckXButton1Press();
                    break;
                case MouseButton.X2:
                    result = CheckXButton2Press();
                    break;
            }
            return result;
        }

        public static bool IsMouseDown(MouseButton button)
        {
            bool result = false;

            switch (button)
            {
                case MouseButton.None:
                    break;
                case MouseButton.Left:
                    result = mouseState.LeftButton == ButtonState.Pressed;
                    break;
                case MouseButton.Right:
                    result = mouseState.RightButton == ButtonState.Pressed;
                    break;
                case MouseButton.Middle:
                    result = mouseState.MiddleButton == ButtonState.Pressed;
                    break;
                case MouseButton.X1:
                    result = mouseState.XButton1 == ButtonState.Pressed;
                    break;
                case MouseButton.X2:
                    result = mouseState.XButton2 == ButtonState.Pressed;
                    break;
            }
            return result;
        }

        public static bool IsMouseUp(MouseButton button)
        {
            bool result = false;

            switch (button)
            {
                case MouseButton.Left:
                    result = mouseState.LeftButton == ButtonState.Released;
                    break;
                case MouseButton.Right:
                    result = mouseState.RightButton == ButtonState.Released;
                    break;
                case MouseButton.Middle:
                    result = mouseState.MiddleButton == ButtonState.Released;
                    break;
                case MouseButton.X1:
                    result = mouseState.XButton1 == ButtonState.Released;
                    break;
                case MouseButton.X2:
                    result = mouseState.XButton2 == ButtonState.Released;
                    break;
            }
            return result;
        }

        public static bool IsLastMouseDown(MouseButton button)
        {
            bool result = false;

            switch (button)
            {
                case MouseButton.Left:
                    result = lastMouseState.LeftButton == ButtonState.Pressed;
                    break;
                case MouseButton.Right:
                    result = lastMouseState.RightButton == ButtonState.Pressed;
                    break;
                case MouseButton.Middle:
                    result = lastMouseState.MiddleButton == ButtonState.Pressed;
                    break;
                case MouseButton.X1:
                    result = lastMouseState.XButton1 == ButtonState.Pressed;
                    break;
                case MouseButton.X2:
                    result = lastMouseState.XButton2 == ButtonState.Pressed;
                    break;
            }
            return result;
        }

        public static bool LastIsMouseUp(MouseButton button)
        {
            bool result = false;

            switch (button)
            {
                case MouseButton.Left:
                    result = lastMouseState.LeftButton == ButtonState.Released;
                    break;
                case MouseButton.Right:
                    result = lastMouseState.RightButton == ButtonState.Released;
                    break;
                case MouseButton.Middle:
                    result = lastMouseState.MiddleButton == ButtonState.Released;
                    break;
                case MouseButton.X1:
                    result = lastMouseState.XButton1 == ButtonState.Released;
                    break;
                case MouseButton.X2:
                    result = lastMouseState.XButton2 == ButtonState.Released;
                    break;
            }
            return result;
        }

        private static bool CheckLeftButtonPress()
        {
            return (mouseState.LeftButton == ButtonState.Released) &&
                (lastMouseState.LeftButton == ButtonState.Pressed);
        }

        private static bool CheckRightButtonPress()
        {
            return (mouseState.RightButton == ButtonState.Released) &&
                (lastMouseState.RightButton == ButtonState.Pressed);
        }

        private static bool CheckMiddleButtonPress()
        {
            return (mouseState.MiddleButton == ButtonState.Released) &&
                (lastMouseState.MiddleButton == ButtonState.Pressed);
        }

        private static bool CheckXButton1Press()
        {
            return (mouseState.XButton1 == ButtonState.Released) &&
                (lastMouseState.XButton1 == ButtonState.Pressed);
        }

        private static bool CheckXButton2Press()
        {
            return (mouseState.XButton2 == ButtonState.Released) &&
                (lastMouseState.XButton2 == ButtonState.Pressed);
        }
#endif
        #endregion


        #region Keyboard Region

        #region Keyboard Event Region

        private bool CheckPressedKeys()
        {
            bool keyPressed = false;

            foreach (Keys key in keyboardState.GetPressedKeys())
            {
                if (lastKeyboardState.IsKeyUp(key))
                {
                    keyPressed = true;
                }
            }
            return keyPressed;
        }

        private bool CheckReleasedKeys()
        {
            bool keyPressed = false;

            foreach (Keys key in lastKeyboardState.GetPressedKeys())
            {
                if (keyboardState.IsKeyUp(key))
                {
                }
            }
            return keyPressed;
        }

        private void CheckKeysDown()
        {
            bool altState = keyboardState.IsKeyDown(Keys.LeftAlt) ||
                keyboardState.IsKeyDown(Keys.RightAlt);
            bool controlState = keyboardState.IsKeyDown(Keys.LeftControl) ||
                keyboardState.IsKeyDown(Keys.RightControl);
            bool shiftState = keyboardState.IsKeyDown(Keys.LeftShift) ||
                keyboardState.IsKeyDown(Keys.RightShift);
        }

        #endregion

        static KeyboardState keyboardState;
        static KeyboardState lastKeyboardState;


        public static KeyboardState KeyboardState
        {
            get { return keyboardState; }
        }

        public static KeyboardState LastKeyboardState
        {
            get { return lastKeyboardState; }
        }

        public static bool CheckKeyPress(Keys key)
        {
            return keyboardState.IsKeyUp(key) && lastKeyboardState.IsKeyDown(key);
        }

        public static bool IsKeyDown(Keys key)
        {
            return keyboardState.IsKeyDown(key);
        }

        public static bool IsKeyUp(Keys key)
        {
            return keyboardState.IsKeyUp(key);
        }

        public static bool LastIsKeyDown(Keys key)
        {
            return lastKeyboardState.IsKeyDown(key);
        }

        public static bool LastIsKeyUp(Keys key)
        {
            return lastKeyboardState.IsKeyUp(key);
        }

        public static Keys[] GetPressedKeys()
        {
            return keyboardState.GetPressedKeys();
        }

        public static Keys[] GetLastPressedKeys()
        {
            return lastKeyboardState.GetPressedKeys();
        }

        #endregion

        #region Game Pad Region


        static GamePadState[] gamePadState = new GamePadState[4];
        static GamePadState[] lastGamePadState = new GamePadState[4];

        public static GamePadState[] GamePadStates
        {
            get { return gamePadState; }
        }

        public static GamePadState GamePadState(PlayerIndex index)
        {
            return gamePadState[Index(index)];
        }

        public static GamePadState GamePadState()
        {
            return gamePadState[0];
        }

        public static GamePadState LastGamePadState(PlayerIndex index)
        {
            return lastGamePadState[Index(index)];
        }

        public static GamePadState LastGamePadState()
        {
            return lastGamePadState[0];            
        }

        public static bool IsConnected(PlayerIndex index)
        {
            return gamePadState[Index(index)].IsConnected;
        }

        public static bool IsConnected()
        {
            return gamePadState[0].IsConnected;
        }

        private static int Index(PlayerIndex index)
        {
            if (index == PlayerIndex.One)
                return 0;
            if (index == PlayerIndex.Two)
                return 1;
            if (index == PlayerIndex.Three)
                return 2;
            return 3;
        }

        public static GamePadButtons GamePadButtons(PlayerIndex index)
        {
            return gamePadState[Index(index)].Buttons;
        }

        public static GamePadButtons GamePadButtons()
        {
            return gamePadState[0].Buttons;
        }

        public static GamePadButtons LastGamePadButtons(PlayerIndex index)
        {
            return lastGamePadState[Index(index)].Buttons;
        }

        public static GamePadButtons LastGamePadButtons()
        {
            return lastGamePadState[0].Buttons;
        }

        public static bool CheckButtonRelease(PlayerIndex index, Buttons button)
        {
            return gamePadState[Index(index)].IsButtonUp(button) &&
                lastGamePadState[Index(index)].IsButtonDown(button);
        }

        public static bool CheckButtonRelease(Buttons button)
        {
            return gamePadState[0].IsButtonUp(button) &&
                lastGamePadState[0].IsButtonDown(button);
        }

        public static bool CheckButtonPress(PlayerIndex index, Buttons button)
        {
            return gamePadState[Index(index)].IsButtonDown(button) &&
                lastGamePadState[Index(index)].IsButtonUp(button);
        }

        public static bool CheckButtonPress(Buttons button)
        {
            return gamePadState[0].IsButtonDown(button) &&
                lastGamePadState[0].IsButtonUp(button);
        }

        public static bool IsButtonDown(PlayerIndex index, Buttons button)
        {
            return gamePadState[Index(index)].IsButtonDown(button);
        }

        public static bool IsButtonDown(Buttons button)
        {
            return gamePadState[0].IsButtonDown(button);
        }

        public static bool IsButtonUp(PlayerIndex index, Buttons button)
        {
            return gamePadState[Index(index)].IsButtonUp(button);
        }

        public static bool IsButtonUp(Buttons button)
        {
            return gamePadState[0].IsButtonUp(button);
        }

        public static bool LastIsButtonDown(PlayerIndex index, Buttons button)
        {
            return lastGamePadState[Index(index)].IsButtonDown(button);
        }

        public static bool LastIsButtonDown(Buttons button)
        {
            return lastGamePadState[0].IsButtonDown(button);
        }

        public static bool LastIsButtonUp(PlayerIndex index, Buttons button)
        {
            return lastGamePadState[Index(index)].IsButtonUp(button);
        }

        public static bool LastIsButtonUp(Buttons button)
        {
            return lastGamePadState[0].IsButtonUp(button);
        }

        public static void Vibrate(PlayerIndex index, float leftMotor, float rightMotor)
        {
            // Restrict parameters so that the values passed to the method are between
            // 0.0f and 1.0f, the minimum and maximum speeds of the motors in the game
            // pad
            leftMotor = MathHelper.Clamp(leftMotor, 0.0f, 1.0f);
            rightMotor = MathHelper.Clamp(rightMotor, 0.0f, 1.0f);

            // Set the frequency of the vibration of the motors
            GamePad.SetVibration(index, leftMotor, rightMotor);
        }

        public static void Vibrate(float leftMotor, float rightMotor)
        {
            // Restrict parameters so that the values passed to the method are between
            // 0.0f and 1.0f, the minimum and maximum speeds of the motors in the game
            // pad
            leftMotor = MathHelper.Clamp(leftMotor, 0.0f, 1.0f);
            rightMotor = MathHelper.Clamp(rightMotor, 0.0f, 1.0f);

            // Set the frequency of the vibration of the motors
            GamePad.SetVibration(PlayerIndex.One, leftMotor, rightMotor);
        }

        public static void StopVibration(PlayerIndex index)
        {
            GamePad.SetVibration(index, 0f, 0f);
        }

        public static void StopVibration()
        {
            GamePad.SetVibration(0, 0f, 0f);
        }

        public static Vector2 LeftThumb(PlayerIndex index)
        {
            return gamePadState[Index(index)].ThumbSticks.Left;
        }

        public static Vector2 LeftThumb()
        {
            return gamePadState[0].ThumbSticks.Left;
        }

        public static Vector2 RightThumb(PlayerIndex index)
        {
            return gamePadState[Index(index)].ThumbSticks.Right;
        }

        public static Vector2 RightThumb()
        {
            return gamePadState[0].ThumbSticks.Right;
        }

        public static Vector2 LastLeftThumb(PlayerIndex index)
        {
            return lastGamePadState[Index(index)].ThumbSticks.Left;
        }

        public static Vector2 LastLeftThumb()
        {
            return lastGamePadState[0].ThumbSticks.Left;
        }

        public static Vector2 LastRightThumb(PlayerIndex index)
        {
            return lastGamePadState[Index(index)].ThumbSticks.Right;
        }

        public static Vector2 LastRightThumb()
        {
            return lastGamePadState[0].ThumbSticks.Right;
        }

        public static GamePadDPad DPad(PlayerIndex index)
        {
            return gamePadState[Index(index)].DPad;
        }

        public static GamePadDPad DPad()
        {
            return gamePadState[0].DPad;
        }

        public static GamePadDPad LastDPad(PlayerIndex index)
        {
            return lastGamePadState[Index(index)].DPad;
        }

        public static GamePadDPad LastDPad()
        {
            return lastGamePadState[0].DPad;
        }

        public static GamePadTriggers Triggers(PlayerIndex index)
        {
            return gamePadState[Index(index)].Triggers;
        }

        public static GamePadTriggers Triggers()
        {
            return gamePadState[0].Triggers;
        }

        public static GamePadTriggers LastTriggers(PlayerIndex index)
        {
            return lastGamePadState[Index(index)].Triggers;
        }

        public static GamePadTriggers LastTriggers()
        {
            return lastGamePadState[0].Triggers;
        }

        public static float LeftTrigger(PlayerIndex index)
        {
            return gamePadState[Index(index)].Triggers.Left;
        }

        public static float LeftTrigger()
        {
            return gamePadState[0].Triggers.Left;
        }

        public static float LastLeftTrigger(PlayerIndex index)
        {
            return lastGamePadState[Index(index)].Triggers.Left;
        }

        public static float LastLeftTrigger()
        {
            return lastGamePadState[0].Triggers.Left;
        }

        public static float RightTrigger(PlayerIndex index)
        {
            return gamePadState[Index(index)].Triggers.Right;
        }

        public static float RightTrigger()
        {
            return gamePadState[0].Triggers.Right;
        }

        public static float LastRightTrigger(PlayerIndex index)
        {
            return lastGamePadState[Index(index)].Triggers.Right;
        }

        public static float LastRightTrigger()
        {
            return lastGamePadState[0].Triggers.Right;
        }

        #endregion
    }
}

[Ntwiles]

Here's a simple debug tool I've started using in my games. This first version has a static output as well as a dynamic value display off to the side. It's extremely plug and play; it takes a minimum of 4 lines of simple code to use (it does assume use of the content manager and at least one installed spritefont). It should be pretty self explanatory. I'm inexperienced with XNA so I would love any feedback on it.

Spoiler

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Text;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

namespace NameSpace
{
    class DebugTool
    {
        const Keys TOGGLE_KEY = Keys.OemTilde;
        const Buttons TOGGLE_BUTTON = Buttons.LeftShoulder;
        const string DEBUG_FONT_NAME = "font_debug";
        const string CONTENT_ROOT_DIR = "Content";
        const int MENU_HEIGHT = 450;
        const int WATCH_COL_OFFSET = 475;
        const int LINE_HEIGHT = 16;

        static StringCollection output_main = new StringCollection();
        static StringDictionary output_watched = new StringDictionary();
        static StringCollection keys = new StringCollection();

        static SpriteFont font_debug;
        static Vector2 draw_location, shadow_location;

        public static bool show_menu = false;
        public static bool toggle_hit = false;

        //Adds an item to output in left-hand column.
        public static void addLine(string dt)
        {
            output_main.Add(dt);
            if (output_main.Count * LINE_HEIGHT > MENU_HEIGHT)
            {
                output_main.RemoveAt(0);
            }
        }

        //Adds a variable to the right-hand column for dynamic value display
        public static void watch(string key, string val)
        {
            if (!output_watched.ContainsKey(key))
            {
                output_watched.Add(key, val);
                keys.Add(key);
            }
            else output_watched[key] = val;
        }

        public static void load(ContentManager content)
        {
            content.RootDirectory = CONTENT_ROOT_DIR;
            font_debug = content.Load<SpriteFont>(DEBUG_FONT_NAME);
            addLine("Debug tool started.");
        }

        public static void update()
        {
            //Toggles menu display
            if ((Keyboard.GetState().IsKeyDown(TOGGLE_KEY) || GamePad.GetState(PlayerIndex.One).IsButtonDown(TOGGLE_BUTTON)))
            {
                if (!toggle_hit)
                {
                    toggle_hit = true;
                    if (show_menu == false) { show_menu = true; }
                    else { show_menu = false; }
                }
            }
            else { toggle_hit = false; }
        }

        public static void draw(SpriteBatch spriteBatch)
        {
            if (show_menu)
            {
                //Draws left column; static output.
                for (int i = 0; i < output_main.Count; i++)
                {
                    shadow_location = new Vector2(11, 11 + i * LINE_HEIGHT);
                    draw_location = new Vector2(10, 10 + i * LINE_HEIGHT);
                    spriteBatch.DrawString(font_debug, output_main[i], shadow_location, Color.Black);
                    spriteBatch.DrawString(font_debug, output_main[i], draw_location, Color.White);
                }

                //Draws right column; dynamic value display.
                for (int i = 0; i < output_watched.Count; i++)
                {
                    shadow_location = new Vector2(WATCH_COL_OFFSET + 1, 10 + 1 + i * LINE_HEIGHT);
                    draw_location = new Vector2(WATCH_COL_OFFSET, 10 + i * LINE_HEIGHT);
                    spriteBatch.DrawString(font_debug, keys[i] + " : " + output_watched[keys[i]], shadow_location, Color.Black);
                    spriteBatch.DrawString(font_debug, keys[i] + " : " + output_watched[keys[i]], draw_location, Color.White);
                }
            }
        }
    }
}

This post has been edited by Ntwiles: 22 November 2011 - 07:21 PM

[Fib]

Very nice and practical class you got there Ntwiles. It will be very helpful.