Right now I am creating a game. For this game I wanted to create a good input system. The thing is I didn’t know where to start. I am a big fan of Ori and the Blind Forest, so I decided to decompile the game and see how the big guys did it. As expected, their code was huge, but I took only the parts for my needs.
Interfaces
There are 2 basic interfaces for taking raw input: IAxisInput and IButtonInput.
public interface IAxisInput
{
float GetAxis();
}
public interface IButtonInput
{
bool GetButton(); // When the button is held down
bool GetButtonDown(); // Executed once on button down
bool GetButtonUp(); // Executed once on button up
}
For the next interface you need to know exactly what the character can do. In my case the character can only move horizontally and jump, so the interface looks like this.
public interface IInputProvider
{
IAxisInput HorizontalAxisInput { get; }
IButtonInput JumpButtonInput { get; }
}
This interface provides us with input from different sources. For example, we can create a KeyboardAndMouseInputProvider, or a MobileInputProvider. Lets actually implement those two.
KeyboardAndMouseInputProvider
public class KeyboardAndMouseInputProvider : IInputProvider
{
private IAxisInput horizontalAxisInput;
private IButtonInput jumpButtonInput;
public KeyboardAndMouseInputProvider()
{
this.horizontalAxisInput = new CHorizontalAxisInput();
this.jumpButtonInput = new CJumpButtonInput();
}
public virtual IAxisInput HorizontalAxisInput
{
get
{
return this.horizontalAxisInput;
}
}
public virtual IButtonInput JumpButtonInput
{
get
{
return this.jumpButtonInput;
}
}
private class CHorizontalAxisInput : IAxisInput
{
public float GetAxis()
{
return Input.GetAxis("Horizontal");
}
}
private class CJumpButtonInput : IButtonInput
{
public bool GetButton()
{
return Input.GetButton("Jump");
}
public bool GetButtonDown()
{
return Input.GetButtonDown("Jump");
}
public bool GetButtonUp()
{
return Input.GetButtonUp("Jump");
}
}
}
MobileInputProvider
public class MobileInputProvider : MonoBehaviour, IInputProvider
{
[SerializeField]
private VirtualJoystick leftJoystick = null;
private IAxisInput horizontalAxisInput;
private IButtonInput jumpButtonInput;
public virtual IAxisInput HorizontalAxisInput
{
get
{
return this.horizontalAxisInput;
}
}
public virtual IButtonInput JumpButtonInput
{
get
{
return this.jumpButtonInput;
}
}
public void Init()
{
this.horizontalAxisInput = new CHorizontalAxisInput(this.leftJoystick);
this.jumpButtonInput = new CJumpButtonInput();
}
private class CHorizontalAxisInput : IAxisInput
{
private VirtualJoystick leftJoystick;
public CHorizontalAxisInput(VirtualJoystick leftJoystick)
{
this.leftJoystick = leftJoystick;
}
public float GetAxis()
{
return this.leftJoystick.GetAxes().x;
}
}
private class CJumpButtonInput : IButtonInput
{
private int lastJumpTouchId;
public bool GetButton()
{
if (Input.touchCount > 0)
{
foreach (var touch in Input.touches)
{
if ((touch.phase == TouchPhase.Stationary || touch.phase == TouchPhase.Moved) &&
(touch.position.x > Screen.width / 2f) &&
(touch.fingerId == this.lastJumpTouchId))
{
return true;
}
}
}
return false;
}
public bool GetButtonDown()
{
if (Input.touchCount > 0)
{
foreach (var touch in Input.touches)
{
if (touch.phase == TouchPhase.Began &&
touch.position.x > Screen.width / 2f)
{
this.lastJumpTouchId = touch.fingerId;
return true;
}
}
}
return false;
}
public bool GetButtonUp()
{
if (Input.touchCount > 0)
{
foreach (var touch in Input.touches)
{
if (touch.phase == TouchPhase.Ended &&
touch.position.x > Screen.width / 2f &&
touch.fingerId == this.lastJumpTouchId)
{
return true;
}
}
}
return false;
}
}
}
Another layer of abstraction
In Unity if we want to get an axis we just do it like this.
float horizontalAxis = Input.GetAxis("Horizontal");
But we can’t get the the horizontal axis like that if we are on a mobile device. We have a MobileInputProvider, we just need a class that uses it.
public static class PlayerInput
{
public static IInputProvider InputProvider { get; set; }
public static IAxisInput HorizontalAxisInput
{
get
{
return InputProvider.HorizontalAxisInput;
}
}
public static IButtonInput JumpButtonInput
{
get
{
return InputProvider.JumpButtonInput;
}
}
}
Now we can get the horizontal axis from a mobile device like this.
PlayerInput.InputProvider = mobileInputProvider; float horizontalAxis = PlayerInput.HorizontalAxisInput.GetAxis();
Compound Input Provider
But what if we want to be able to get input both from a keyboard and from a mobile device. Well we need a provider that gets input from both, but that will be kinda stupid, because we have them in separate, why create a third provider that is copy-paste from the first two? We just need to think of a smart way to combine both input providers. That is how we do it.
First we create an axis input that can get axes from many sources. We will call this one CompoundAxisInput. Here is the implementation.
public class CompoundAxisInput : IAxisInput
{
private const float AXIS_DEAD_ZONE = 0.2f;
private IAxisInput[] axisInputs;
private int lastPressedIndex;
public CompoundAxisInput() { }
public CompoundAxisInput(params IAxisInput[] axisInputs)
{
this.axisInputs = axisInputs;
}
public virtual float GetAxis()
{
float positiveAxis = 0f;
float negativeAxis = 0f;
if (this.axisInputs != null)
{
for (int i = 0; i < this.axisInputs.Length; i++)
{
float value = this.axisInputs[i].GetAxis();
if (Mathf.Abs(value) > AXIS_DEAD_ZONE)
{
this.lastPressedIndex = i;
}
else
{
continue;
}
if (value < 0f)
{
negativeAxis = Mathf.Min(negativeAxis, value);
}
else
{
positiveAxis = Mathf.Max(positiveAxis, value);
}
}
}
return positiveAxis + negativeAxis;
}
public IAxisInput GetLastPressed()
{
return this.axisInputs[this.lastPressedIndex];
}
public void AddAxisInput(IAxisInput axisInput)
{
if (this.axisInputs == null)
{
this.axisInputs = new IAxisInput[1];
this.axisInputs[0] = axisInput;
}
else
{
Array.Resize(ref this.axisInputs, this.axisInputs.Length + 1);
this.axisInputs[this.axisInputs.Length - 1] = axisInput;
}
}
public void ClearAxisInputs()
{
this.axisInputs = null;
}
}
It’s an axis input that internally has an array of axis inputs. When we call the GetAxis() method, we find the most negative one and most positive one from all of the axis inputs and return the sum of them. That way if we press left on a keyboard and right on a joystick for example, the character will stay in one place, because the horizontal axis will be zero.
Now we have to do the same for the button input. Lets call the class CompoundButtonInput.
public class CompoundButtonInput : IButtonInput
{
private IButtonInput[] buttonInputs;
private int lastPressedIndex;
public CompoundButtonInput() { }
public CompoundButtonInput(params IButtonInput[] buttonInputs)
{
this.buttonInputs = buttonInputs;
}
public virtual bool GetButton()
{
if (this.buttonInputs != null)
{
for (int i = 0; i < this.buttonInputs.Length; i++)
{
if (this.buttonInputs[i].GetButton())
{
this.lastPressedIndex = i;
return true;
}
}
}
return false;
}
public virtual bool GetButtonDown()
{
if (this.buttonInputs != null)
{
for (int i = 0; i < this.buttonInputs.Length; i++)
{
if (this.buttonInputs[i].GetButtonDown())
{
this.lastPressedIndex = i;
return true;
}
}
}
return false;
}
public virtual bool GetButtonUp()
{
if (this.buttonInputs != null)
{
for (int i = 0; i < this.buttonInputs.Length; i++)
{
if (this.buttonInputs[i].GetButtonUp())
{
this.lastPressedIndex = i;
return true;
}
}
}
return false;
}
public IButtonInput GetLastPressed()
{
return this.buttonInputs[this.lastPressedIndex];
}
public void AddButtonInput(IButtonInput buttonInput)
{
if (this.buttonInputs == null)
{
this.buttonInputs = new IButtonInput[1];
this.buttonInputs[0] = buttonInput;
}
else
{
Array.Resize(ref this.buttonInputs, this.buttonInputs.Length + 1);
this.buttonInputs[this.buttonInputs.Length - 1] = buttonInput;
}
}
public void ClearButtonInputs()
{
this.buttonInputs = null;
}
}
Finally we create a CompoundInputProvider
public class CompoundInputProvider : IInputProvider
{
private IInputProvider[] inputProviders;
private CompoundAxisInput horizontalAxisInput;
private CompoundButtonInput jumpButtonInput;
public CompoundInputProvider()
: this(null)
{ }
public CompoundInputProvider(params IInputProvider[] inputProviders)
{
this.horizontalAxisInput = new CompoundAxisInput();
this.jumpButtonInput = new CompoundButtonInput();
if (inputProviders != null)
{
for (int i = 0; i < inputProviders.Length; i++)
{
this.AddInputProvider(inputProviders[i]);
}
}
}
public virtual IAxisInput HorizontalAxisInput
{
get
{
return this.horizontalAxisInput;
}
}
public virtual IButtonInput JumpButtonInput
{
get
{
return this.jumpButtonInput;
}
}
public void AddInputProvider(IInputProvider inputProvider)
{
if (this.inputProviders == null)
{
this.inputProviders = new IInputProvider[1];
this.inputProviders[0] = inputProvider;
}
else
{
Array.Resize(ref this.inputProviders, this.inputProviders.Length + 1);
this.inputProviders[this.inputProviders.Length - 1] = inputProvider;
}
this.horizontalAxisInput.AddAxisInput(inputProvider.HorizontalAxisInput);
this.jumpButtonInput.AddButtonInput(inputProvider.JumpButtonInput);
}
public void ClearInputProviders()
{
this.inputProviders = null;
this.horizontalAxisInput.ClearAxisInputs();
this.jumpButtonInput.ClearButtonInputs();
}
}
All that’s left is to provide our PlayerInput class with the right CompoundInputProvider. I do this in an InputManager script.
public class InputManager : MonoBehaviour
{
[SerializeField]
private MobileInputProvider mobileInputProvider = null;
protected virtual void Awake()
{
this.InitInputProvider();
}
private void InitInputProvider()
{
CompoundInputProvider compoundInputProvider = new CompoundInputProvider();
if (this.mobileInputProvider != null)
{
this.mobileInputProvider.Init();
compoundInputProvider.AddInputProvider(this.mobileInputProvider);
}
#if UNITY_EDITOR
compoundInputProvider.AddInputProvider(new KeyboardAndMouseInputProvider());
#endif
PlayerInput.InputProvider = compoundInputProvider;
}
}
Now we are ready to use our PlayerInput class instead of the Input class that Unity gives us.
Programming Tutorials 