This is a basic keyboard input class to be customized for a particular game’s needs and loaded depending on device.

Keyboard_Input.cs

using UnityEngine;
using System.Collections;

public class Keyboard_Input : BaseInputController {
    
    public override void CheckInput () {    
        // get input data from vertical and horizontal axis and store them internally in vert and horz so we don't
        // have to access them every time we need to relay input data.
        vert = Input.GetAxis ("Vertical");
        horz = Input.GetAxis ("Horizontal");
        
        // set up some boolean values for up, down, left and right
        Up      = (vert > 0);
        Down    = (vert < 0);
        Left    = (horz < 0);
        Right   = (horz > 0);    
        
        // get fire / action keys
        Fire1 = Input.GetButton ("Fire1");
        shouldRespawn = Input.GetButton ("Fire3");
    }
    
    public void LateUpdate () {
        // check inputs each LateUpdate() ready for the next tick
        CheckInput ();
    }
}

The reason why we check for input in LateUpdate() is to ensure all physics handling to have resolved by the time we handle new input. This is particularly important when physics may impact the position of the camera and player object.

Up Next: Mouse_Input

Along the same lines as keyboard input, most developers coding on desktops will have access to a mouse and choose to use it as part of the game’s desktop controls if that is the target platform. Find the Mouse_Input script here: https://www.zesix.com/2015/02/unity-mouse_input-c/

BaseInputController is an extendable class for building input-specific controllers such as keyboard and touch controllers. This script is not intended to be used directly but instead extended, with an extended script loaded based on what platform and/or inputs the project is currently targeting. Later on, I will provide a generic keyboard input controller that extends BaseInputController. This will be the script you will use most in this framework for handling keyboard input. For now, this script is provided as a reference in case you want to build your own input controllers.

BaseInputController.cs

using UnityEngine;
using System.Collections;

public class BaseInputController : MonoBehaviour {
    
    // directional buttons
    public bool Up;
    public bool Down;
    public bool Left;
    public bool Right;
    
    // fire / action buttons
    public bool Fire1;
    
    // weapon slots
    public bool Slot1;
    public bool Slot2;
    public bool Slot3;
    public bool Slot4;
    public bool Slot5;
    public bool Slot6;
    public bool Slot7;
    public bool Slot8;
    public bool Slot9;
    
    public float vert;
    public float horz;
    public bool shouldRespawn;
    
    public Vector3 TEMPVec3;
    private Vector3 zeroVector = new Vector3(0,0,0);
    
    public virtual void CheckInput () {    
        // override with your own code to deal with input
        horz=Input.GetAxis ("Horizontal");
        vert=Input.GetAxis ("Vertical");
    }
    
    public virtual float GetHorizontal() {
        // returns our cached horizontal input axis value
        return horz;
    }
    
    public virtual float GetVertical() {
        // returns our cached vertical input axis value
        return vert;
    }
    
    public virtual bool GetFire() {
        return Fire1;
    }
    
    public bool GetRespawn() {
        return shouldRespawn;    
    }
    
    public virtual Vector3 GetMovementDirectionVector() {
        // temp vector for movement dir gets set to the value of an otherwise unused vector that always have the value of 0,0,0
        TEMPVec3=zeroVector;
        
        TEMPVec3.x=horz;
        TEMPVec3.y=vert;

        // return the movement vector
        return TEMPVec3;
    }

}

Usage

All input scripts use CheckInput() as their default update function. This is intended to be called by the player class (since enemies generally don’t move to player input). This function just takes the axis input from Unity’s default Input class, which already sets up a horizontal and vertical axis. To return a specific axis, the GetHorizontal() and GetVertical() functions can be used. Both of these are virtual in case the developer wants to add additional information depending on the device.

The script assumes the game will utilize some kind of firing input. The GetFire() function is handy for this.

GetRespawn() returns the bool of the variable shouldRespawn. Not every game will have lives, but most games nowadays have a respawn system (meaning shouldRespawn will always be true), so we provide it here for convenience.

Note that GetFire() and GetRespawn() currently are just empty virtual functions – these should be built upon based on game requirements.

GetMovementDirectionVector() will return a Vector3 type based on the current state of input, which is useful for processing movement without having to check individual horizontal and vertical components.

Up Next: Keyboard_Input

The BaseInputController is great for creating specific input controllers, but since most developers will be working on a device with a keyboard, it is handy to have a default keyboard input controller for testing and possibly production use. Read about Keyboard_Input here: https://www.zesix.com/2015/02/unity-keyboard_input-c/

The BaseObjManager interprets and manipulates an object based on its stats, which are controlled by the BaseStatsManager. It is also in charge of communicating with the GameManager and letting it know when something significant happens to the object it is attached to. Here’s a high-level example of how a character might work:

• A projectile collides with the character. The character’s controller parses this collision and then invokes a function in BaseStatsManager to modify the character’s health (take damage).
• BaseStatsManager subtracts the health accordingly, but then realizes the character’s health is now zero. It calls a function in BaseObjManager to handle character death.
• BaseObjManager sends a message to the GameManager that this character is now dead and then calls an internal function that destroys the character.
• The GameManager subtracts one life from the player’s total ‘lives’ pool and then spawns a new character for the player, which has a character controller, BaseStatsManager, and BaseObjManager attached.

BaseObjManager.cs

using UnityEngine;
using System.Collections;

public class BaseObjManager : MonoBehaviour {
    public bool didInit;

    public BaseStatsManager DataManager;
    
    // note that we initialize on Awake in this class so that it is ready for other classes to
    // access our details when they initialize on Start.
    public virtual void Awake () {
        didInit=false;
        
        // rather than clutter up the start() func, we call Init to do any
        // startup specifics
        Init();
    }
    
    public virtual void Init () {
        // cache ref to our stats manager 
        DataManager= gameObject.GetComponent<BaseStatsManager>();

        // throw error if object is missing a BaseStatsManager
        if(DataManager == null)
            Debug.LogError ("GameObject is missing a BaseStatsManager: " + gameObject.name);
        
        // do play init things in this function
        didInit= true;
    }

}

The script is designed with the theory that it will be reused, so it includes a didInit boolean for easier debugging of initialization commands. We then check if there is a BaseStatsManager attached, and throw an error if there is not.

Up Next: Input

The input controller abstracts input so that a game may compensate for different control schemes. This is useful for porting a game to another device such as mobile. The BaseInputController is intended to be extended, with each extension loaded as needed depending on the target platform or device. Read about it here: https://www.zesix.com/2015/02/unity-baseinputcontroller-c/