# How can I map thumbsticks to cardinal directions?

I've got a tile based game that has notions of moving up, down, left, right and the diagonals (by alternating horizontal/vertical movement).

I've found that if I use the default ThumbStick<Direction> buttons that XNA provides I'm often moving diagonally instead of in a straight line. E.g. moving the thumbstick left, often just triggers 'down' too (but only just).

How can I map moving a thumbstick to the 8 discrete directions so this accidental diagonal movement doesn't occur?

I'm starting to think about favouring up/down/left/right over diagonals (as you more frequently move straight in my game), however, I'm not sure how do put this into code.

• that's because you're probably taking any value != 0 as a "direction trigger" for example, if the thumbstick is 99% to the left and 1% to the bottom, it will trigger both. Try to use a 15% threshold. (or some other value that you feel good with) Jan 23 '12 at 21:40
• The XNA does use a threshold, although I've added my own (higher) threshold on top and it seems to be doing the trick. If you post as an answer I'll accept. Jan 23 '12 at 21:58
• -1: For accepting the wrong answer. That'll teach you to wait more than a few minutes before clicking the "accept" tick. Jan 24 '12 at 1:02
• @NicolBolas: I don't see anything wrong with accepting an answer that is posted that solves my problem. I can always change that if I feel a subsequent answer is better. Jan 24 '12 at 7:55
• @NicolBolas: But Gtoknu's answer is more useful to me. Possibly next time I might wait a little longer, but I'd probably go for the same answer as although detailed, Jonathan's one in my case would be overkill. Jan 24 '12 at 8:34

That's because you're probably taking any value != 0 as a "direction trigger". For example, if the thumbstick is 99% to the left and 1% to the bottom, it will trigger both.

Try to use a 15% (or some other value that you feel good with) as a threshold.

## Distance-Based

You will basically need to take two things into consideration: a threshold (inversely a deadzone) and the dominant vector. Given an enum like the following:

public enum Direction { None, Up, Down, Left, Right }


You would find the dominant direction (if the deadzone isn't in play) and use that.

// You could make this user-configurable.
const float DiagonalAvoidance = 0.2f;

{
// Get the length and prevent something from happening
// if it's in our deadzone.
return Direction.None;

var absDiff = Math.Abs(absX - absY);

// We don't like values that are too close to each other
// i.e. borderline diagonal.
if (absDiff < length * DiagonalAvoidance)
return Direction.None;

if (absX > absY)
{
return Direction.Right;
else
return Direction.Left;
}
else
{
return Direction.Down;
else
return Direction.Up;
}
}


## Angle-Based

With this one you basically ensure that, once again, we don't fall within a deadzone - but also that the angle is within certain ranges.

const float PI = (float)Math.PI;

// You could make this user-configurable.
const float AliveAngle = PI / 4 - (PI / 16);

// Remember PI = 180 degrees
const float AliveAngle1Start = PI * 0;
const float AliveAngle1End = PI * 0.5f - AliveAngle;

const float AliveAngle2Start = PI * 0.5f + AliveAngle;
const float AliveAngle2End = PI * 1f - AliveAngle;

const float AliveAngle3Start = PI * 1f + AliveAngle;
const float AliveAngle3End = PI * 1.5f - AliveAngle;

const float AliveAngle4Start = PI * 1.5f + AliveAngle;
const float AliveAngle4End = PI * 2f - AliveAngle;

{
// Get the length and prevent something from happening
// if it's in our deadzone.
return Direction.None;

// Find the angle that the stick is at. see: http://en.wikipedia.org/wiki/File:Atan2_60.svg
if (angle < 0)
angle += PI * 2; // Simpify our checks.

if (angle > AliveAngle4End)
return Direction.Right;
if (angle > AliveAngle4Start)
return Direction.None;
if (angle > AliveAngle3End)
return Direction.Up;
if (angle > AliveAngle3Start)
return Direction.None;
if (angle > AliveAngle2End)
return Direction.Left;
if (angle > AliveAngle2Start)
return Direction.None;
if (angle > AliveAngle1End)
return Direction.Down;
if (angle > AliveAngle1Start)
return Direction.None;
return Direction.Right;
}

// Inlined in release so don't worry about it.
private static bool IsBetween(float value, float start, float end)
{
return value > start && value < end;
}


## Remarks

The way I did the distance-based one would likely emulate the (possibly more expensive) angle-based one - this is because of the absDiff < length * DiagonalAvoidance. Either way experiment with them and see which you like best.

• Thanks for going into more detail and posting after an accepted answer. In my case the first one is simple and works, so I'll keep that accepted. +1 Jan 24 '12 at 7:56
• @GeorgeDuckett that's fine, just sticky this answer for when you get bug reports because of the missing dead angle. Jan 24 '12 at 10:29
• @JonathanDickinson Using your angle-based method. I have noticed that when I press up on the left thumbstick, it returns Direction.Down and when I press down, it returns Direction.Up. This is an easy fix, I just want to let you know so you can make the changes yourself. Aug 17 '12 at 3:22
• @KyleUithoven oops, I will make a fix ASAP. Thanks for the feedback ;). Aug 17 '12 at 14:59