Creating an RTS in Unity: Part VIII

Update: This can now also be found at stormtek.geek.nz/rts_tutorial/part8.php, where the entire tutorial is now being hosted.

This time we will look at implementing something a little more interactive – we will add some basic movement to our units.

Movement Cursor

First up, let’s modify the cursor state to indicate a movement option for when we have a Unit selected. Before we can implement something specific for our Unit, we need to add in some general handling of a mouse hover. We start by adding this method to UserInput

private void MouseHover() {
	if(player.hud.MouseInBounds()) {
		GameObject hoverObject = FindHitObject();
		if(hoverObject) {
			if(player.SelectedObject) player.SelectedObject.SetHoverState(hoverObject);
			else if(hoverObject.name != "Ground") {
				Player owner = hoverObject.transform.root.GetComponent< Player >();
				if(owner) {
					Unit unit = hoverObject.transform.parent.GetComponent< Unit >();
					Building building = hoverObject.transform.parent.GetComponent< Building >();
					if(owner.username == player.username && (unit || building)) player.hud.SetCursorState(CursorState.Select);
				}
			}
		}
	}
}

and call it from the end of MouseActivity() in UserInput. Now we need to implement the default behaviour for SetHoverState in WorldObject.

public virtual void SetHoverState(GameObject hoverObject) {
	//only handle input if owned by a human player and currently selected
	if(player && player.human && currentlySelected) {
		if(hoverObject.name != "Ground") player.hud.SetCursorState(CursorState.Select);
	}
}

With the default behaviour in place we can now add some specific behaviour for our Unit with the following.

public override void SetHoverState(GameObject hoverObject) {
	base.SetHoverState(hoverObject);
	//only handle input if owned by a human player and currently selected
	if(player && player.human && currentlySelected) {
		if(hoverObject.name == "Ground") player.hud.SetCursorState(CursorState.Move);
	}
}

If you run this from Unity now you will notice that no move cursor shows up if the unit is selected. This is because the Unit does not actually belong to a player at the moment. To fix this, drag your unit onto your player, making it a child of the player. Unfortunately, you will now no longer be able to select the Unit, since we accidentally introduced a bug in an earlier post. Thankfully this is an easy bug to fix. The problem is that when we are determining which object was selected we are using

hitObject.transform.root.GetComponent< WorldObject >()

to gain a reference to the WorldObject script (or a subclass of that). Unfortunately, when we add the object to a player this reference no longer works. We actually need to use

hitObject.transform.parent.GetComponent< WorldObject >()

instead. To fix our code we need to make this change in MouseClick() in WorldObject and LeftMouseClick() in UserInput. Now if you run from within Unity things should behave as expected. We can still select both MyBuilding and MyUnit. If we have the building selected we are only ever shown the select cursor. But if we have the unit selected we are shown the select cursor if we are over an object and the move cursor if we are hovering over the ground – complete with animation.

Movement Input

Now it is time to handle user input for movement. To initiate movement for a Unit we need to extend the functionality of our mouse click logic for a world object. Add the following code to MouseClick inside Unit.cs.

public override void MouseClick(GameObject hitObject, Vector3 hitPoint, Player controller) {
	base.MouseClick(hitObject, hitPoint, controller);
	//only handle input if owned by a human player and currently selected
	if(player && player.human && currentlySelected) {
		if(hitObject.name == "Ground" && hitPoint != ResourceManager.InvalidPosition) {
			float x = hitPoint.x;
			//makes sure that the unit stays on top of the surface it is on
			float y = hitPoint.y + player.SelectedObject.transform.position.y;
			float z = hitPoint.z;
			Vector3 destination = new Vector3(x, y, z);
			StartMove(destination);
		}
	}
}

We start off here by making sure that the default implementation for handling a mouse click is handled. Then, if the player clicked on the ground, we want to start a move towards that position. To handle that we need to implement StartMove.

public void StartMove(Vector3 destination) {
	this.destination = destination;
	targetRotation = Quaternion.LookRotation (destination - transform.position);
	rotating = true;
	moving = false;
}

This methods sets the state for our object in preparation for moving. We need the destination that our Unit is to move towards and the rotation that Unit needs to rotate towards the destination. This rotation is given to us by the Unity method Quaternion.LookRotation. It also appears that Unity is using the z-axis as the forward direction (which is why we constructed our Unit the way we did earlier). We then specify that the Unit is ready to rotate in preparation for moving. To allow our code to compile we need to add these global variables to the top of Unit.

protected bool moving, rotating;

private Vector3 destination;
private Quaternion targetRotation;

Unit Movement

With the ability for players to give destinations to units, it is time to implement some basic movement for a Unit. This will be telling the Unit how to get from it’s current location to the destination that has been set. For now we will go with a very simple algorithm.

• Rotate so that the “front” of the Unit is pointing directly at the destination
• Move in a straight line towards the destination, ignoring everything in it’s path
• Stop when the destination is reached

At a later date you will want to implement some form of pathfinding and collision avoidance so that your Unit does not run into anything along the way. But for now it is enough to be able to move around. Remember that at the end of StartMove() we introduced two state variables – rotating and moving. We will use these to determine what the Unit should currently be doing. Modify the Update method for Unit to be the following.

protected override void Update () {
	base.Update();
	if(rotating) TurnToTarget();
	else if(moving) MakeMove();
}

This implements all of the logic for our algorithm above, leaving it up to the individual methods to fill in the blanks for how each part is to be implemented. Let’s handle turning towards our destination first.

private void TurnToTarget() {
	transform.rotation = Quaternion.RotateTowards(transform.rotation, targetRotation, rotateSpeed);
	//sometimes it gets stuck exactly 180 degrees out in the calculation and does nothing, this check fixes that
	Quaternion inverseTargetRotation = new Quaternion(-targetRotation.x, -targetRotation.y, -targetRotation.z, -targetRotation.w);
	if(transform.rotation == targetRotation || transform.rotation == inverseTargetRotation) {
		rotating = false;
		moving = true;
	}
}

The Unity method Quaternion.RotateTowards provides a smooth rotation between the current rotation of the Unit and the desired rotation. The variable rotateSpeed is used to determine how quickly we want to get between those two rotation values. A numerical issue can cause the Unit to be stuck facing the wrong way, which we fix with the check against inverseTargetRotation. Once the current rotation of the Unit matches the desired (or inverse desired) rotation we stop rotating and declare that the Unit is now ready to move. Before we go any further let’s declare a movement speed and a rotation speed at the top of Unit.cs, making them public so that we can tweak their values inside Unity.

public float moveSpeed, rotateSpeed;

Now we need to provide the basic movement for our Unit.

private void MakeMove() {
	transform.position = Vector3.MoveTowards(transform.position, destination, Time.deltaTime * moveSpeed);
	if(transform.position == destination) moving = false;
}

Once again we make use of a Unity method to give us smooth movement to our destination, this time by using Vector3.MoveTowards. And once again we have moveSpeed to help us determine how quickly that will happen. If we now set moveSpeed and rotateSpeed for the Unit to 1 you should be able to direct it around the map (taking care not to run into any other objects). Feel free to play around with these values until they match a speed that you are comfortable with.

You will notice an annoying fact when you move your unit: the selection box remains where the Unit was first located, which is no use at all. What we want is for the selection box to remain around the Unit at all times. The selection box is based on the Bounds for the Unit – these are never being updated, which is why the selection box does not move. We may want these bounds to remain up-to-date for other checks against the Unit, so let’s make sure they stay current by adding

CalculateBounds();

to the end of TurnToTarget() and MakeMove(). This guarantees that whenever the position of the Unit has changed (whether through movement or rotation) it’s Bounds remain correct.

And that brings us to the end of this part. We are now informing the user that they can select a position to move the currently selected Unit to and allowing them to move that Unit there in a very basic fashion. We have also structured the code in such a way that we should be able to update the movement process reasonably easily without breaking the rest of our code. As usual, the code can be found on github under the post for Part 8.