VIDEOGICIELS.FR, le site qui critique très dur les jeux vidéo

This blog post is intended for developers ; it’s a way for me to describe what I think should be the gold, simple standard for any video game that expects the user to look around or aim using a thumbstick on a controller. I love indie FPSs, TPSs and first person horror and adventure, and sadly, more often than not, they offer an implementation for the camera stick that I find severely lacking in precision, comfort and smoothness.

I’m writing this after having researched the subject extensively ; read veteran developer Josh Sutphin’s great blog post about deadzones ; watched many deadzone analysises on Eternal Dahaka’s YouTube video channel and read many of his numerous documented feedbacks on Steam and Reddit ; and of course after having myself experimented and tested a large number of games with various implementations of stick aiming.

Without further ado, here are the basic features I think we should have in any first or third person game where looking/aiming is involved :

• a scaled radial deadzone for the look stick
• a deadzone slider for the look stick (ranges from 0% to 30%, increments of 1%)
• an acceleration exponant slider for the look stick (ranges from 0.1 to 5, increments of 0.1)
• options to separately invert X and Y axises for the look stick
• a sensitivity slider for the look stick

The last two items seem pretty popular or self-explanatory already – but important nonetheless. Let me instead elaborate on the first three items.

What is a scaled radial deadzone ? As Josh Sutphin defines it, it’s an implementation of thumbstick aiming that verifies two things. Let’s look at the picture below (credits Josh Sutphin) :

Where it’s pitch black near the center, game will nullify any input : that’s the deadzone. The gradient indicates the strength of the resulting input. As you move away from the center (as you push your stick in any direction), the input will smoothly ramp from 0 to +1 whatever the size of the deadzone. This is the result we want, this is what the scaled in scaled radial deadzone is about.

So the two things that are of extreme importance are these : 1) the deadzone should be radial and 2) the input should be scaled to ramp smoothly from 0 to +1 from the moment the stick escapes the deadzone and no matter the actual size of the deadzone. This is how you will provide gamers with precise, smooth, full diagonal camera movement that is both immersive and effective.

We also want the user to be able to freely set the deadzone size with a slider ; ranging from zero to 30%, in order to cover a wide range of potential wear for the thumbstick.

Finally, the acceleration exponant slider. A good scaled radial deadzone is mandatory, but it is not sufficient to provide ease of aiming for the user. You need to also implement a stick response curve, and you need to let the user adjust the curve to their liking. Basically, a response curve makes more or less stick input range for fine, slow controls.

With no response curve, if you push the stick at 50% of the available range of input (the « livezone »), the camera speed in-game will be 50% of its maximum speed. But this is not necessarily what we want. We may want to reach 50% speed only when the stick is near fully tilted. This is where the response curve finds its purpose.

See the examples below (credits Eternal Dahaka for his interactive demo where you can fiddle with deadzone size, acceleration exponant and stick position) :

Now that we explained all the items, let’s see how you can implement the scaled radial deadzone and the response curve in the code. Here’s an example where I borrow heavily from Josh Sutphin :

float deadzone = 0.20f;

float exponent = 3.00f;

Vector2 stickInput = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));

if (stickInput.magnitude < deadzone)

    {

    stickInput = Vector2.zero;

    }

else

    {

    stickInput = stickInput.normalized * pow(((stickInput.magnitude - deadzone)/(1 - deadzone)), exponent);

    }

This last expression

pow(((stickInput.magnitude - deadzone)/(1 - deadzone)), exponent)

is a power function that can be written like this :

Where « x » is the stick input magnitude, « d » is the deadzone size and « a » is the acceleration exponant ; the latter two which you should provide sliders for in your game settings.

You can see this power function in action in another interactive demo made by Eternal Dahaka (that I’ve slighly modified to provide a wider range of values).

So this is it. I think we’ve covered everything you need to know to implement a great aiming system in your game. Let me know what you think in the comments.

One last thing though. Take the time to test camera movement at least once with your deadzone set to zero. This will let you check if another built-in-engine deadzone isn’t creeping up on your input – in which case please make sure to disable it.

Update : How can I check if my deadzone is scaled and radial ?

Try to perform a really soft acceleration. Is the transition from stillness to movement sudden or smooth? If it is sudden, then the deadzone is not scaled.

Try to perform a really soft diagonal acceleration. Is the direction diagonal from the start, or does it begin purely cardinal (horizontal or vertical) ? If the direction is purely cardinal at the start, then the deadzone is not radial.

Alternatively, if you see the right stick as a clock, try fully tilting the stick towards 7:00 and rotating it to 5:00, and back, while still fully tilted. As you approach 6:00, does the camera stop rotating horizontally ? If it does, then the deadzone is axial. On the contrary, if the camera never really stops its horizontal rotation until it swaps direction, then there is no axial deadzone (which is great).

Credits this website for the idea and some of the phrasing of these tests.

Update 2 : video example in Unity

I’ve just found this video that shows in Unity how to disable the default axis deadzones and set up a radial deadzone. There is no scaling and no acceleration curve but still, a nice illustration I think !