Getting really frustrated with implementing input handling for real-time strategy games.

Unity Engine
1

For TL;DR - Read just the boldfaced text. :slight_smile:

I have a simple setup of using A, S, and D keys with the combination of left and right mouse buttons. No scrolling with the mouse wheel, and no other keys needed (other than exiting the game).

I’ve been tackling the issue of handling the input combinations in regards to the 3 keys and 2 buttons. A, S, and D all have their own respective commands the player can use, while the left mouse button is for selection /canceling selection only, and right mouse button is for issuing orders and targets.

The code below is me handling only the inputs, and setting the variables around to accommodate the issuing of orders and the states the controlled unit is doing. States are split into pending and current action states.

private void HandleOrders() {
        bool waitOrders = this.commandState.Equals(UnitCommand.ATTACK_ORDER) || this.commandState.Equals(UnitCommand.SPLIT_ORDER) || this.commandState.Equals(UnitCommand.MERGE_ORDER);
        if (Input.GetKeyDown(KeyCode.A) && !waitOrders) {
            this.pendingActionState = UnitState.WAITING;
            this.commandState = UnitCommand.ATTACK_ORDER;
        }
        else if (Input.GetKeyDown(KeyCode.S) && !waitOrders) {
            this.pendingActionState = UnitState.WAITING;
            this.commandState = UnitCommand.SPLIT_ORDER;
        }
        else if (Input.GetKeyDown(KeyCode.D) && !waitOrders) {
            this.pendingActionState = UnitState.WAITING;
            this.commandState = UnitCommand.MERGE_ORDER;
        }
        else if (Input.GetMouseButtonDown(0) && this.pendingActionState.Equals(UnitState.WAITING) && waitOrders) {
            Debug.Log("Hit");
            this.commandState = UnitCommand.NO_ORDERS;
            this.pendingActionState = this.actionState;
        }
        else if (Input.GetMouseButtonUp(1)) {
            if (this.pendingActionState.Equals(UnitState.WAITING) && waitOrders) {
                switch (this.commandState) {
                    case UnitCommand.NO_ORDERS:
                        this.pendingActionState = UnitState.MOVING;
                        this.actionState = this.pendingActionState;
                        Move();
                        break;
                    case UnitCommand.MOVE_ORDER:
                        this.pendingActionState = UnitState.MOVING;
                        this.actionState = this.pendingActionState;
                        Move();
                        break;
                    case UnitCommand.ATTACK_ORDER:
                        this.pendingActionState = UnitState.ATTACKING;
                        this.actionState = this.pendingActionState;
                        AttackAction();
                        break;
                    default:
                        break;
                }
            }
            else if (!this.pendingActionState.Equals(UnitState.WAITING) && waitOrders){
                if (Input.GetKeyDown(KeyCode.A) && !waitOrders) {
                    this.pendingActionState = UnitState.WAITING;
                    this.commandState = UnitCommand.ATTACK_ORDER;
                }
                else if (Input.GetKeyDown(KeyCode.S) && !waitOrders) {
                    this.pendingActionState = UnitState.WAITING;
                    this.commandState = UnitCommand.SPLIT_ORDER;
                }
                else if (Input.GetKeyDown(KeyCode.D) && !waitOrders) {
                    this.pendingActionState = UnitState.WAITING;
                    this.commandState = UnitCommand.MERGE_ORDER;
                }
                else if (Input.GetMouseButtonDown(0) && this.pendingActionState.Equals(UnitState.WAITING) && waitOrders) {
                    Debug.Log("Hit");
                    this.commandState = UnitCommand.NO_ORDERS;
                    this.pendingActionState = this.actionState;
                }
            }
            else {
                this.pendingActionState = UnitState.MOVING;
                this.actionState = this.pendingActionState;
                Move();
            }
        }
    }

Full code can be seen at the very end of this post.

Not considering refactoring and other ways of better usages of if…else, or switch statements, I am defeated by the complexity of the input combinations, and trying to get it so the players can issue their orders/commands correctly. I am trying to handle corner cases and cases that players with high APM could easily do that my HandleOrders() can break. For instance, units are quickly issued in succession, attack, move, attack, attack, move, select, deselect, and attack. Just the first three commands will break the HandleOrders().

All I am asking for is either a better way of handling input combinations, or some way to handle the aggressive inputs coming into their way. Does anyone know how?

Full code:

using UnityEngine;
using System.Collections;

public enum UnitState {
    IDLING,
    ATTACKING,
    SCOUTING,
    MOVING,
    DIVIDING,
    MERGING,
    WAITING,
    DYING
}

public enum UnitCommand {
    ATTACK_ORDER,
    SPLIT_ORDER,
    MERGE_ORDER,
    MOVE_ORDER,
    WAITING_FOR_ORDERS,
    NO_ORDERS
}

public class UnitStateManager : MonoBehaviour {
    public UnitState actionState;
    public UnitState pendingActionState;
    public bool selectFlag;
    public UnitCommand commandState;

    private GameObject attackee;
    private NavMeshAgent agent;
    private float countdown;

    private void Start() {
        this.actionState = UnitState.IDLING;
        this.agent = this.GetComponent<NavMeshAgent>();
        if (this.agent == null) {
            Debug.LogError(new System.NullReferenceException("No nav mesh agent detected."));
        }
        this.agent.updateRotation = true;
        this.agent.stoppingDistance = 0.85f;
        this.selectFlag = false;
        this.commandState = UnitCommand.NO_ORDERS;
    }

    private void Update() {
        if (this.selectFlag) {
            DetectInput();
        }
    }

    private void DetectInput() {
        if (Input.GetMouseButtonDown(0)) {
          
        }
        else if (Input.GetMouseButtonDown(1)) {

        }
    }


    private void WaitingOnOrders() {
        if (this.commandState.Equals(UnitCommand.WAITING_FOR_ORDERS)) {
            if (Input.GetMouseButtonUp(0)) {
                this.commandState = UnitCommand.NO_ORDERS;
                this.actionState = UnitState.IDLING;
                Debug.Log("CANCEL ORDER");
            }
        }
    }

    private void HandleOrders() {
        bool waitOrders = this.commandState.Equals(UnitCommand.ATTACK_ORDER) || this.commandState.Equals(UnitCommand.SPLIT_ORDER) || this.commandState.Equals(UnitCommand.MERGE_ORDER);
        if (Input.GetKeyDown(KeyCode.A) && !waitOrders) {
            this.pendingActionState = UnitState.WAITING;
            this.commandState = UnitCommand.ATTACK_ORDER;
        }
        else if (Input.GetKeyDown(KeyCode.S) && !waitOrders) {
            this.pendingActionState = UnitState.WAITING;
            this.commandState = UnitCommand.SPLIT_ORDER;
        }
        else if (Input.GetKeyDown(KeyCode.D) && !waitOrders) {
            this.pendingActionState = UnitState.WAITING;
            this.commandState = UnitCommand.MERGE_ORDER;
        }
        else if (Input.GetMouseButtonDown(0) && this.pendingActionState.Equals(UnitState.WAITING) && waitOrders) {
            Debug.Log("Hit");
            this.commandState = UnitCommand.NO_ORDERS;
            this.pendingActionState = this.actionState;
        }
        else if (Input.GetMouseButtonUp(1)) {
            if (this.pendingActionState.Equals(UnitState.WAITING) && waitOrders) {
                switch (this.commandState) {
                    case UnitCommand.NO_ORDERS:
                        this.pendingActionState = UnitState.MOVING;
                        this.actionState = this.pendingActionState;
                        Move();
                        break;
                    case UnitCommand.MOVE_ORDER:
                        this.pendingActionState = UnitState.MOVING;
                        this.actionState = this.pendingActionState;
                        Move();
                        break;
                    case UnitCommand.ATTACK_ORDER:
                        this.pendingActionState = UnitState.ATTACKING;
                        this.actionState = this.pendingActionState;
                        AttackAction();
                        break;
                    default:
                        break;
                }
            }
            else if (!this.pendingActionState.Equals(UnitState.WAITING) && waitOrders){
                if (Input.GetKeyDown(KeyCode.A) && !waitOrders) {
                    this.pendingActionState = UnitState.WAITING;
                    this.commandState = UnitCommand.ATTACK_ORDER;
                }
                else if (Input.GetKeyDown(KeyCode.S) && !waitOrders) {
                    this.pendingActionState = UnitState.WAITING;
                    this.commandState = UnitCommand.SPLIT_ORDER;
                }
                else if (Input.GetKeyDown(KeyCode.D) && !waitOrders) {
                    this.pendingActionState = UnitState.WAITING;
                    this.commandState = UnitCommand.MERGE_ORDER;
                }
                else if (Input.GetMouseButtonDown(0) && this.pendingActionState.Equals(UnitState.WAITING) && waitOrders) {
                    Debug.Log("Hit");
                    this.commandState = UnitCommand.NO_ORDERS;
                    this.pendingActionState = this.actionState;
                }
            }
            else {
                this.pendingActionState = UnitState.MOVING;
                this.actionState = this.pendingActionState;
                Move();
            }
        }
    }

    private void HandleAction() {
        ReachingDestination();
    }

    private void AttackAction() {
        if (this.attackee != null) {
            if (!this.agent.pathPending) {
                if (this.agent.remainingDistance <= this.agent.stoppingDistance) {
                    if (this.agent.hasPath || this.agent.velocity.sqrMagnitude == 0f) {
                        //Stopped.
                        float distance = Vector3.Distance(this.transform.position, this.attackee.transform.position);
                        if (distance >= 1f) {
                            this.agent.stoppingDistance = 0.9f;
                            this.agent.SetDestination(this.attackee.transform.position);
                        }
                    }
                }
            }
            //Do attack here.
            UnitHealth health = this.attackee.GetComponent<UnitHealth>();
            if (health != null && health.healthPoints > 0) {
                this.attackee.SendMessage("DoDamage");
            }
            return;
        }
        else {
            CheckSurroundings();
            if (this.attackee == null) {
                AttackMove();
            }
            ReachingDestination();
        }
    }

    private void AttackObject(GameObject victim) {
        Debug.Log("Attacking the " + victim.name.ToString());
        this.actionState = UnitState.ATTACKING;
        Vector3 spacing = victim.transform.position - this.transform.position;
        spacing *= 0.8f;
        spacing += this.transform.position;
        this.agent.SetDestination(spacing);
    }

    private void AttackMove() {
        this.actionState = UnitState.ATTACKING;
        this.countdown = 2f;
        if (Input.GetMouseButtonUp(1)) {
            Debug.Log("Giving attack order and setting new destination.");
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit hitInfo;
            if (Physics.Raycast(ray, out hitInfo)) {
                Debug.Log("New move target position: " + hitInfo.point);
                this.agent.SetDestination(hitInfo.point);
            }
        }
    }

    private void DivideAction() {
    }

    private void DeathAction() {
    }

    private void IdleAction() {
        CheckSurroundings();
    }

    private void MergeAction() {
    }

    private void ScoutAction() {
    }

    private void MoveAction() {
        ReachingDestination();
    }

    private void CheckSurroundings() {
        //Check if enemies are nearby.
        bool currentState = this.actionState.Equals(UnitState.IDLING) || this.actionState.Equals(UnitState.ATTACKING);
        if (currentState) {
            Collider[] colliders = Physics.OverlapSphere(this.transform.position, 3f);
            bool enemyNearby = false;
            for (int i = 0; i < colliders.Length; i++) {
                if (!colliders[i].name.Equals("Floor") && !colliders[i].gameObject.Equals(this.gameObject)) {
                    float distance = Vector3.Distance(colliders[i].transform.position, this.transform.position);
                    if (distance < 4f) {
                        this.attackee = colliders[i].gameObject;
                        this.SendMessage("AttackObject", this.attackee);
                        enemyNearby = true;
                        break;
                    }
                }
            }
            if (this.attackee != null && !enemyNearby) {
                this.attackee = null;
            }
        }
    }

    private void Move() {
        Debug.Log("Giving attack order and setting new destination.");
        this.actionState = UnitState.MOVING;
        this.commandState = UnitCommand.MOVE_ORDER;
        this.countdown = 2f;
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        RaycastHit hitInfo;
        if (Physics.Raycast(ray, out hitInfo)) {
            Debug.Log("New move target position: " + hitInfo.point);
            this.agent.SetDestination(hitInfo.point);
        }
    }

    private void ReachingDestination() {
        if (!this.agent.pathPending) {
            if (this.agent.remainingDistance <= this.agent.stoppingDistance) {
                if (this.agent.hasPath || this.agent.velocity.sqrMagnitude == 0f) {
                    if (!this.pendingActionState.Equals(UnitState.WAITING)) {
                        this.commandState = UnitCommand.NO_ORDERS;
                        this.pendingActionState = UnitState.IDLING;
                        if (this.countdown > 0f) {
                            this.countdown -= Time.deltaTime;
                        }
                        else if (!this.actionState.Equals(UnitState.WAITING)) {
                            this.actionState = this.pendingActionState;
                        }
                    }
                }
            }
        }
    }
}
2

Your input should be on a single MonoBehaviour, not every unit. Then you can throw out your whole pending action thing (which should be a finite state machine implementation BTW).

We basically do this:
If user presses left mouse button - register cursor location.
If left mouse button is down - check if they moved the cursor far enough from initial location to start drawing a selection box
If the user releases the left mouse button - are we drawing a box? If so get all the units in the box and add them to our selected units list. If not - see if there is a unit underneath the cursor. If we get a unit, select it. If we don’t then clear the current selection list.

If user presses right mouse button - register cursor location.
If right mouse button is down - check if they moved the cursor far enough from initial location to allow the camera to drag-move.
If user releases right mouse button - do we have any units selected? If so check for an enemy under the cursor. If we get an enemy change all the selected units to an attack state. If we don’t change to a move state. If we have no selected units then don’t do anything.

1 Like
3

As @KelsoMRK mentioned, it looks like you are trying to do too many jobs in a single script.

Provide a single global “Input Manager” that handles all of the user input. This also makes it possible to do things like change keys. The input manager should keep a List of selected units, and also fire off events to the selected Units.

Each unit should then handle its own state based on orders received. This can also include a list or queue of actions if you like.

4

Oh. Well, it never occurred to me that I can separate input handling from a prefab to a single game object. But I have a few questions about that idea if implemented:

@KelsoMRK For the input manager, do you specifically use SendMessage() so that it propagates through all other scripts in the Hierarchy? Or, I use it like setting static flags in that one InputManager class, and let all other units go check the flags (peeking)?

@Kiwasi For the global InputManager, do I keep the “IF…ELSE” statements I have in my script in my first post? Like, I check for inputs in the Update() functions, and then I would try to set/toggle/flip flags and send it off to other game objects? Or, redesign it in a way that checks individual inputs, rather than a group of inputs altogether (the way I was using in the first place)?

I have some trouble designing and coding how Unity handles individual inputs when I require a specific order of inputs to make it work, especially for high APM players. It’s like chaining a certain combo that, when input correctly, it will send off a message to the unit telling the unit to do this order/command or that order/command.

I’ll figure something out, but I really am grateful for both of your replies. I really do appreciated your helps.

5

Our list of selected units is a list of MonoBehaviours called UnitManager that expose methods to change a unit’s state. So no, we don’t use SendMessage. And I don’t get why units would constantly check input. The input should go tell the units what to do directly. Don’t mess with setting a million flags to track input state for what amounts to a single frame.

I don’t understand your concern about high APM players. The fastest pro SC players hit about 500 APM which is 1 action every 120ms. If your game is running at 60fps (hell, a lot less than that even) then it would be impossible, for the fastest RTS players on the planet, to issue multiple commands in a single frame.

If you’re worried about issuing conflicting commands (ie I right click and press A at exactly the same time) then it still doesn’t matter because whatever command is processed last in Update() will win.

6

A player with high APM means a player that simultaneously input multiple keys at similar times. So, yes, I didn’t think of Update() seeing only 1 input per update tick. It now makes more sense than my rubbish “High APM player” explanation.

I get it now. Thank you.