Adds instructions to readme

[rbdr/super-polarity] / SuperPolarity / InputController.cs

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

namespace SuperPolarity
{
    static class InputController
    {
        static Dictionary<string, List<Action<float>>> Listeners;
        static Dictionary<string, List<Keys>> RegisteredKeys;
        static Dictionary<string, List<Buttons>> RegisteredButtons;
        static List<string> BlockedKeys;
        static List<string> BlockedButtons;

        static GamePadState InputGamePadState;
        static KeyboardState InputKeyboardState;

        /*
         * Registered Events.
         * 
         * You register: name of the event (ie. attack) and a key associated with it.
         * or button... Left Stick /always/ dispatches move event.
         */

        static InputController()
        {
            Listeners = new Dictionary<string,List<Action<float>>>();
            RegisteredButtons = new Dictionary<string, List<Buttons>>();
            RegisteredKeys = new Dictionary<string, List<Keys>>();
            BlockedKeys = new List<string>();
            BlockedButtons = new List<string>();
            InputKeyboardState = new KeyboardState();
            InputGamePadState = new GamePadState();
        }

        public static void UpdateInput()
        {
            DispatchMoveEvents();
            DispatchRegisteredEvents();
        }

        public static void UpdateInput(bool highPriorityOnly) 
        {
            Poll();
            DispatchPauseEvent();
            if (!highPriorityOnly)
            {
                UpdateInput();
            }
        }

        public static void DispatchPauseEvent()
        {
            // OK THIS IS ALL KINDS OF WRONG. THIS IS A PLACEHOLDER BECAUSE DEMO!
            var keyPressed = false;
            if ((InputKeyboardState.IsKeyDown(Keys.Enter) || InputGamePadState.IsButtonDown(Buttons.Start))) {
                keyPressed = true;
                if(!BlockedButtons.Contains("pause") && !BlockedKeys.Contains("pause"))
                {
                    BlockedButtons.Add("pause");
                    BlockedKeys.Add("pause");
                    Console.WriteLine("Dispatch");
                    Dispatch("pause", 0);
                }
            }

            if (!keyPressed)
            {
                BlockedButtons.Remove("pause");
                BlockedKeys.Remove("pause");
            }
        }

        private static void Poll()
        {
            InputGamePadState = GamePad.GetState(Microsoft.Xna.Framework.PlayerIndex.One);
            InputKeyboardState = Keyboard.GetState();
        }

        public static void RegisterEventForKey(string eventName, Keys key)
        {
            List<Keys> newKeyList;
            if (!RegisteredKeys.ContainsKey(eventName))
            {
                newKeyList = new List<Keys>();
                RegisteredKeys.Add(eventName, newKeyList);
            }

            RegisteredKeys.TryGetValue(eventName, out newKeyList);

            newKeyList.Add(key);
        }

        public static void RegisterEventForButton(string eventName, Buttons button)
        {
            List<Buttons> newButtonList;
            if (!RegisteredButtons.ContainsKey(eventName))
            {
                newButtonList = new List<Buttons>();
                RegisteredButtons.Add(eventName, newButtonList);
            }

            RegisteredButtons.TryGetValue(eventName, out newButtonList);

            newButtonList.Add(button);
        }

        private static void DispatchRegisteredEvents()
        {
            var keyFired = false;

            foreach (KeyValuePair<string,List<Keys>> entry in RegisteredKeys) {
                keyFired = false;
                foreach (Keys key in entry.Value)
                {
                    if (InputKeyboardState.IsKeyDown(key))
                    {
                        if (!BlockedKeys.Contains(entry.Key))
                        {
                            BlockedKeys.Add(entry.Key);
                            Dispatch(entry.Key, 1);
                        }
                        keyFired = true;
                        break;
                    }
                }

                if (!keyFired)
                {
                    BlockedKeys.Remove(entry.Key);
                }
            }

            foreach (KeyValuePair<string, List<Buttons>> entry in RegisteredButtons)
            {
                keyFired = false;
                foreach (Buttons button in entry.Value)
                {
                    if (InputGamePadState.IsButtonDown(button))
                    {
                        if (!BlockedButtons.Contains(entry.Key))
                        {
                            BlockedButtons.Add(entry.Key);
                            Dispatch(entry.Key, 1);
                        }
                        keyFired = true;
                        break;
                    };
                }

                if (!keyFired)
                {
                    BlockedButtons.Remove(entry.Key);
                }
            }
        }

        private static void DispatchMoveEvents()
        {
            float xMovement = 0.0f;
            float yMovement = 0.0f;
            // Dispatch the moveX / MoveY events every frame.

            xMovement = InputGamePadState.ThumbSticks.Left.X;
            yMovement = -InputGamePadState.ThumbSticks.Left.Y;

            if (InputKeyboardState.IsKeyDown(Keys.Left))
            {
                xMovement = -1.0f;
            }

            if (InputKeyboardState.IsKeyDown(Keys.Right))
            {
                xMovement = 1.0f;
            }

            if (InputKeyboardState.IsKeyDown(Keys.Up))
            {
                yMovement = -1.0f;
            }

            if (InputKeyboardState.IsKeyDown(Keys.Down))
            {
                yMovement = 1.0f;
            }

            Dispatch("moveX", xMovement);
            Dispatch("moveY", yMovement);
        }

        public static void Bind(string eventName, Action<float> listener)
        {
            List<Action<float>> newListenerList;
            List<Action<float>> listenerList;
            bool               foundListeners;

            if (!Listeners.ContainsKey(eventName)) {
               newListenerList = new List<Action<float>>();
               Listeners.Add(eventName, newListenerList);
            }

            foundListeners = Listeners.TryGetValue(eventName, out listenerList);

            listenerList.Add(listener);
        }

        public static void Unbind(string eventName, Action<float> listener)
        {
            List<Action<float>> listenerList;
            bool foundListeners;

            if (!Listeners.ContainsKey(eventName))
            {
                return;
            }

            foundListeners = Listeners.TryGetValue(eventName, out listenerList);

            listenerList.Remove(listener);
        }

        public static void Dispatch(string eventName, float value)
        {
            List<Action<float>> listenerList;
            bool foundListeners;

            foundListeners = Listeners.TryGetValue(eventName, out listenerList);

            if (!foundListeners)
            {
                return;
            }

            for (var i = listenerList.Count - 1; i >= 0; i--)
            {
                listenerList[i](value);
            }
        }

        public static void Unlock(string eventName)
        {
            BlockedButtons.Remove(eventName);
            BlockedKeys.Remove(eventName);
        }
    }
}