Game Maker: Gradually rotating an object towards a target

You can get the GML script here. This post will explain the code.

When I was developing enemies in Yxi, I was trying to get turrets to aim at you, but I didn’t want them  to possess “instant aim”. I wanted them to rotate towards you given a maximum rotation speed. If you move too fast, it should turn towards you gradually, not instantly.

It seems that it wasn’t as simple as I thought it was. I had the basic algorithm down, but because of the way Game Maker handled angles, the turrets would behave strangely when you would hover around the 0°/360° point with respect to the turret.

I figured a tutorial would be necessary for something that isn’t so obvious to implement. This only pertains to Game Maker and thus uses the GML language.

There are three steps involved when gradually rotating an object (let’s call it a turret for now) towards a target object:

1. Calculate the target’s direction with respect to the turret’s position.
2. Calculate the angle difference between the direction derived from step 1 (let’s call “target direction”) and the turret’s facing direction.
3. Apply angular rotation towards the target so that the target direction is the facing direction.

Calculating Target Direction

This step is relatively easy if you know Game Maker’s point_direction() function. It takes in the object’s position and the target’s position and returns the direction pointing from the object to target (which we already dubbed “target direction”).

var targetDir = point_direction(objToTurn.x, objToTurn.y, target.x, target.y);

Here’s a picture to visualize (turret is objToTurn):

Calculating the Difference between Target and Facing Direction

This part was personally the hardest for me.  The problem is that Game Maker changes angles from 359° to 0° (assuming you’re incrementing the angle) and that throws off calculations.

The angle difference is usually the facing direction subtracted by the target direction:

var facingMinusTarget = facingDir - targetDir;
var angleDiff = facingMinusTarget;

It’s more complicated when the difference involves one of the direction being  near 360° and the other direction being near 0°.  The angleDiff is way off and would cause the turret to spin all the other way around in order to aim at you. You can see that would make the turret look pretty dumb.

The solution is to adjust the angleDiff if the difference between the facing and target directions are greater than 180°. If the angleDiff is greater than 180°, the adjustment is different depending on whether the facing direction has the greater angle value or if the target direction does.

Basically, you have to measure the shortest angle between the facing direction and 360º, then the shortest angle between the target direction and 360º, and add those two differences together. This is best explained the the diagram below:

The result has to be negated if the facing direction is greater than the target direction because we want the angle difference as defined by facing - target. In that particular situation, the difference is negative, but is not factored into the algorithm explained above.

Here’s that whole explanation in code:

if(abs(facingMinusTarget) > 180)
{
    if(facingDir > targetDir)
    {
        angleDiff = -1 * ((360 - facingDir) + targetDir);
    }
    else
    {
        angleDiff = (360 - targetDir) + facingDir;
    }
}

Applying Angular Rotation towards the Target

Now that we have the proper angle difference (whose absolute value should be less than 180º), we can apply a change in rotation to the turret’s direction (its facing direction). My code considers accuracy, so I’ll explain that now.

We could always compare if the angleDiff is greater or less than 0, but sometimes you don’t want the turret to have deadly precision. That’s why the script I linked above allows you to adjust the accuracy. What “accuracy” means here actually defines the angular range the turret considers being locked onto its target. If the target is in this angular range, the turret will stop rotating.

This accuracy range is defined as the least accurate aiming angle multiplied by an accuracy percentage (in the code, a number between 0 and 1). At 100% accuracy, the range would be very slim, giving the turret high precision. At 0% accuracy, the range would be as wide as the defined worst accurate aiming angle. By default, it’s 30º in my script. You give an accuracy of 1.0 (most accurate) to 0.0 (least accurate) and the script inverses them (0 becomes 1 and 1 becomes 0) so it can define the accuracy range.

If the angle difference is greater than the accuracy range, rotate clockwise. Otherwise, if the angle difference is less than the accuracy range, rotate counterclockwise. Not that the accuracy range will always be a positive number, while the angle difference can be either positive or negative.

var leastAccurateAim = 30;
if(angleDiff > leastAccurateAim * accuracy)
{
    objToTurn.direction -= turnSpeed * delta_time;
}
else if(angleDiff < leastAccurateAim * accuracy)
{
    objToTurn.direction += turnSpeed * delta_time;
}

And here’s a diagram:

Using the Script

Using the script itself is pretty easy. Assuming the object you want to gradually rotate is a turret, you put the script in the turret object’s step event. Here’s how the script should be invoked:

if(instance_exists(target_obj))
{
    // FORMAT:
    // gradually_turn(objToTurn, target, turnSpeed, accuracy);
    gradually_turn(self.id, target_obj, 5, 1.0);
}

You should always check if the target object exists, otherwise Game Maker will signal a runtime error. The first parameter is the object you want to rotate. The second parameter is the target object. The third parameter is the turn speed; adjust this number to your liking. And the fourth number is the accuracy ratio; it has to be a decimal number between 0.0 and 1.0.

Hopefully that explains how to gradually rotate an object towards a target in Game Maker. Feel free to use the code I linked above.