Controls.cs

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

public enum ControlsAction : byte
{
    Primary,
    Secondary,
    CycleNext,
    CyclePrevious,
    Menu,
    Back
}

public class Controls : MonoBehaviour
{
    public static float Power
    {
        get { return _instance._power; }
    }

    public static Vector3 Direction
    {
        get { return _instance._direction; }
    }

    public static float RawCadence
    {
        get { return _instance._smoothCadence; }
    }

    public AnimationCurve PowerCurve;

    static Controls _instance;

    public float MinPower = .05f;

    float _power;
    float _smoothCadence;
    Vector3 _direction;
    Dictionary<int, bool> _actionPrevStates;
    Dictionary<int, bool> _actionStates;
    Dictionary<int, float> _actionHoldTimes;
    Dictionary<int, List<IActionInfoProvider>> _actionInfoProviders;
    static PlayerHealthProfile _health;

    public static void RegisterActionInfoProvider (ControlsAction action, IActionInfoProvider actionInfoProvider)
    {
        _instance._actionInfoProviders[(int)action].Insert(0, actionInfoProvider);
    }

    public static void UnregisterActionInfoProvider (ControlsAction action, IActionInfoProvider actionInfoProvider)
    {
        _instance._actionInfoProviders[(int)action].Remove(actionInfoProvider);
    }
    
    public static void InjectSmoothCadence (float cadence)
    {
        _instance._smoothCadence = cadence;

        if (_health != null)
        {
            float power = cadence / _health.CadenceCap;

            if (power < _instance.MinPower)
                power = 0f;

            if (power > 1f)
                power = 1f;
            
            //float precurve = power;
            power = _instance.PowerCurve.Evaluate(power);

            _instance._power = power;

            //print("Raw: " + cadence + " Power: " + power + " PreCurve: " + precurve);
        }
    }

    public static void InjectDirection (Vector3 direction)
    {
        _instance._direction = direction.normalized;
    }

    public static void InjectActionState (ControlsAction action, bool state)
    {
        if (state && !_instance._actionStates[(int)action])
            Study.LogEvent(ControlsLogEvent.ActionDown, action);
        else if (!state && _instance._actionStates[(int)action])
            Study.LogEvent(ControlsLogEvent.ActionUp, action);

        _instance._actionStates[(int)action] = state;
    }

    public static string GetActionCaption (ControlsAction action)
    {
        var providers = _instance._actionInfoProviders[(int)action];
        
        if (providers.Count != 0)
            return providers[0].GetActionCaption(action);

        return "";
    }

    public static bool IsActionEnabled (ControlsAction action)
    {
        var providers = _instance._actionInfoProviders[(int)action];

        if (providers.Count != 0)
            return providers[0].IsActionEnabled(action);

        return false;
    }

    public static bool GetAction (ControlsAction action)
    {
        return _instance._actionStates[(int)action];
    }

    public static bool GetActionDown (ControlsAction action)
    {
        return _instance._actionStates[(int)action] && !_instance._actionPrevStates[(int)action];
    }

    public static bool GetActionUp (ControlsAction action)
    {
        return !_instance._actionStates[(int)action] && _instance._actionPrevStates[(int)action];
    }

    public static float GetActionHoldTime (ControlsAction action)
    {
        return _instance._actionHoldTimes[(int)action];
    }
    
    public static void ResetHoldTime (ControlsAction action)
    {
        _instance._actionHoldTimes[(int)action] = 0;
    }

    void Awake ()
    {
        _instance = this;

        _actionStates = new Dictionary<int, bool>();
        _actionPrevStates = new Dictionary<int, bool>();
        _actionHoldTimes = new Dictionary<int, float>();
        _actionInfoProviders = new Dictionary<int, List<IActionInfoProvider>>();

        foreach (var action in Enum.GetValues(typeof(ControlsAction)))
        {
            _actionStates[(int)(ControlsAction)action] = false;
            _actionPrevStates[(int)(ControlsAction)action] = false;
            _actionHoldTimes[(int)(ControlsAction)action] = 0f;
            _actionInfoProviders[(int)(ControlsAction)action] = new List<IActionInfoProvider>();
        }
    }

    void LateUpdate ()
    {
        foreach (var action in _actionStates.Keys)
        {
            _actionPrevStates[(int)action] = _actionStates[action];

            if (_actionStates[(int)action])
                _actionHoldTimes[(int)action] += Time.deltaTime;
            else
                _actionHoldTimes[(int)action] = 0;
        }
    }

    void Start()
    {
        GameClient.Instance.ConnectedToWorldServer += OnConnectedToWorldServer;
        GameClient.Instance.DisconnectedFromWorldServer += OnDisconnectedFromWorldServer;
    }

    void OnConnectedToWorldServer()
    {
        _health = Game.LocalPlayerProfile.Health;
    }

    void OnDisconnectedFromWorldServer()
    {
        _health = null;
    }
}