7 Building Blocks for Better Controls

0 Views 0

SaveSavedRemoved 0

Every established gamer has their own set of building blocks that they’ve become comfortable using to control games. These building blocks are the control elements that players have learned to use in other games and expect to use when they pick up a new game. When designing controls, we want players to learn our game’s controls quickly. We want players to be thinking about what their character can do, not thinking about how to use their controller/keyboard/touchscreen/mouse to make the character do it. So when designing the controls for a new game, we tend to reuse building blocks from other games. We ask questions like: What are we doing similar to other games? How will our target audience expect to be able to do this?

Consider, for example, using WASD to move with a keyboard. Using these keys in particular on a keyboard is by no means natural – it took a long time and many games for this convention to become established. But now it is used ubiquitously in PC games today. It’s so common that we have keyboards that highlight those keys in particular, and streaming overlays that only show the left half of the keyboard.

On gamepads we have other building blocks, and they determine how we steer vehicles, how we select items or weapons, and how we control the camera in 3D space. But we limit ourselves by leaning too much on these conventions – by using these building blocks and only these building blocks. Consider the following three truths:

First-time gamers begin with no building blocks of their own. Their first game experience is not benefited by whether or not its controls rely on common conventions. Sometimes alternative building blocks are easier to learn.
Disabilities (whether temporary or permanent) can make it difficult or impossible for players to enjoy playing with more conventional building blocks. Sometimes alternative building blocks are the only way one can enjoy a game.
Common building blocks can constrain the player in undesirable ways. They can slow the player down or increase the amount of conscious effort required to use the game’s systems effectively or naturally. Sometimes alternative building blocks are even better suited for skillful play.

Therefore, offering players alternative control schemes may benefit newcomers, players with disabilities, and enthusiasts looking to maximise their skill in a game. Some unconventional options can even benefit all three types of player at once!

As an input specialist, my job is to design and often implement control schemes in games. I’m best known for my work on Fortnite, implementing unconventional controls that give players a nearly mouse-like experience on a controller without any aim assist. Fortnite players are still able to enjoy the game as they’re used to with the default controls, but for those who are willing to play with these less conventional building blocks, Fortnite offers precision and agility that is peerless in the console space (for now), and goes a long way towards letting mouse and controller players play with each other without feeling significantly advantaged or disadvantaged.

We’ll get into that stuff towards the end of this article.

But while gyro controls are a specialty of mine, most of my professional work is not on those kinds of controls specifically. There are plenty of other ways to improve upon conventional controls, so let’s start elsewhere as we look at seven building blocks for better controls:

2D Steering
Winding Stick Steering
Motion Steering
Chorded Item Selection
Motion/Gyro Pointing
Motion/Gyro Aiming
Flick Stick

Sometimes I’ll draw from real examples already found in a few games. When I can’t, I’ll have examples that I’ve forced into games using JoyShockMapper (an open source input remapper I created but now in the capable hands of Electronicks) and my controller overlay JoyShockOverlay (which will be publicly available later this year, hopefully).

Real-time controller overlay including gyro in action! pic.twitter.com/KItWyu2YI8

— Jibb Smart 🎮 (@JibbSmart) September 13, 2019

This means that even if I haven’t found an example of a game doing exactly what I’m talking about, I can still use these tools to demonstrate it in real games. And for those features that are already in a number of games, they’re still woefully underused. If they are relevant to your game, I urge you to future-proof your game by adding these options to it.

Oh, and the point of this article is that I’d like to see these options (and other alternative ways to play) in your games. You hopefully already know that copying simple game mechanics isn’t plagiarism. It isn’t theft. It isn’t like selling someone else’s story, copying someone else’s photo, uploading someone else’s video and claiming it as your own. There are no protections here. You just get to use whatever you want. And games are all the better for it. In that spirit, I want to make it clear that any code examples I’m including here are specifically for you to use how you please, credit or no credit. They’re all very simple ideas, and you probably won’t use my code verbatim. And if you do, that’s cool, too.

With that out of the way, let’s get started.

1. 2D Steering

Rotate the stick for more precise steering with no deadzone in the middle.

Traditional steering on a gamepad just uses the horizontal axis of one of the analog sticks. While this gives more flexibility to gently turn than, say, steering with a keyboard, here are a couple observations:

Even modern games and controllers have a noticeable deadzone in the middle, which makes it harder to make very small left-right steering adjustments;
The thumbstick is a 2D input, but driving games tend to treat it as a 1D input.

We can consider a thumbstick input as having two components: direction and magnitude. All the fine adjustments that traditional stick steering offers require us to carefully change the magnitude of the stick position. Due to the very small distance between the stick’s neutral position and a full deflection, magnitude is already a thumbstick’s least precise component. This is exacerbated quite a bit by having to deal with the deadzone in the middle.

Stick direction, on the other hand, gives players significantly more distance and resolution between a full-left turn and a full-right turn, without a deadzone in the middle. This is 2D steering. We still use a deadzone to tell whether the player has engaged the stick, but it’s a circular deadzone that the stick sits in when it’s untouched. This means the player can push the stick forward to get out of the deadzone and make the slightest left and right adjustments and see immediate effects in-game. A full-tilt left is still a hard left turn, full-tilt right is still a hard right turn. 45 degrees to the left or right is a half-strength turn in that direction. We linearly map the angle of the stick to the strength of the turn in that direction.

Of course, we’re still using stick magnitude! If the player only half-tilts the stick, we can simply multiply that with our angular steering strength. If your game has a non-linear stick response with steering, you can apply that same nonlinear response to the magnitude component here as well.

When your stick angle is 90 degrees to the left or right, the angular or directional component of 2D steering is +-1. Here, steering strength is entirely dictated by the magnitude of the stick input. This means that if the player chooses to use the stick only in the horizontal axis just as they are used to with traditional stick steering, it’ll behave identically to traditional stick steering. Since players are used to staying in the horizontal axis for steering in games like these anyway, this means you don’t even have to create a new setting in your game for 2D steering – just replace your traditional steering with 2D steering and tell players they can rotate the stick if they want to. If they don’t want to, nothing changes for them.

Now, it’s a big ask to have players tilt the stick exactly horizontally for their hardest turns, so I do recommend a small angular outer deadzone. This is much less intrusive than an inner deadzone, because players are not trying to move from one side of it to the other.

Here’s some code that applies all of the above. Note that for the sake of having no discontinuities, the lower half of the stick mirrors the upper half – tilting the stick straight down is the same as tilting it straight up.

// +- angular range from horizontal that'll be treated as a horizontal input
float OuterDeadzone = 10.0;
 
// this will return a value between -1 and 1, inclusive, for how hard the vehicle is turning.
// assume circular deadzone is already applied
float StickToSteeringStrength(Vec2 stick) {
   if (stick.X == 0.0 && stick.y == 0.0) {
      return 0.0;
   }
 
   float absY = abs(stick.Y);
   // using absolute Y means the back half of the stick mirrors the front
   float stickAngle = atan2(stick.X, absY);
   // convert to degrees because our outer deadzone is in degrees
   float absAngle = abs(stickAngle * 180.0f / PI);
   // remap to [-1, 1] range without the deadzone
   float angularStickStrength = sign(stickAngle) *
      clamp(absAngle / (90.f - OuterDeadzone), 0.f, 1.f);
   // some games apply a power curve on their traditional steering.
   // here, you would apply that to the magnitude
   float magnitudeStickStrength = stick.Magnitude();
 
   return angularStickStrength * magnitudeStickStrength;
}

JoyShockMapper has the option to add 2D steering to games by taking the stick angle and remapping it to a horizontal-only position on a virtual controller. Using JoyShockMapper, I play with 2D steering in any game that offers simple stick steering, such asTrackmania (as demonstrated above) and even Spyro (with 2D steering active only while holding the “charge” button). I’d like to play Rocket League this way, but because JoyShockMapper can’t tell when the vehicle is airborne I lose control of my vehicle’s pitch while jumping or boosting through the air. This would not be a problem with a native implementation.

In summary, 2D steering:

Offers players more steering precision, more naturally mapping your controls to what the player character is able to do;
Is incredibly simple to implement and simple to test;
Is a generalisation of the controls you already offer the player, so you can make it part of the default experience without messing with what the player’s used to.

Drop it into any game that uses traditional stick steering. The only game I’m aware of that has the option natively is Fortnite (since its 20.30 update this month), but it’s generally easy to check in any game by rotating the stick and seeing its effect on the vehicle’s steering.

2. Winding Stick Steering

When it comes to driving sims, players want far more precision with their steering input. Don’t get me wrong, 2D steering is hugely valuable in these kinds of games, too. Every driving sim should have 2D steering, just like how every driving sim will let you steer with traditional stick steering if you want.

But for an even more sim-like experience, with far more range of movement and precision, how about letting the player wind the stick left and right just like a steering wheel? Where 2D steering took the absolute direction of the stick and mapped it to a steering wheel position, winding stick steering takes relative changes in the stick direction, allowing you to make 360 rotations of the stick (or more!) and turn them into meaningful changes in steering direction in game. Just like how many cars will let you rotate the steering wheel 450 degrees or more left and right, winding stick steering lets the player do that with the left thumbstick.

Of course, this should all be configurable. Some players might like 1080 degrees of rotation, while others might be comfortable with 360 or even less. And letting players control the response/linearity of their steering will be of huge benefit as well, letting them get more resolution for the finer adjustments while letting them quickly flick into a drift and counter-steer with bigger turns.

Here’s some code for you:

// total angular range the stick can be rotated from full left to full right
float WindingRange = 900.0;
// how far we let the stick rotate beyond a full turn before we start ignoring further rotation
float WindingStickOverRotationBuffer = 90.0;
// power curve, if you want
float WindingPowerCurve = 1.0;
 
// track the current virtual stick range
float CurrentWindingStickAngle = 0.0;
 
// this will return a value between -1 and 1, inclusive, for how hard the vehicle is turning.
// assume circular deadzone is already applied
float WindingStickToSteeringStrength(Vec2 stick, Vec2 previousStick, float deltaTime) {
   float stickMagnitude = stick.Magnitude();
 
   if (!stick.IsZero() && !previousStick.IsZero()) {
      float stickAngle = atan2(-stick.X, stick.Y) * 180.0 / PI;
      float lastStickAngle = atan2(-previousStick.X, previousStick.Y) * 180.0 / PI;
      // the angle change might cross a threshold, such as going from a small number to just below 360.
      // Wrap around and find the angle difference in the +-180 degree range
      float angleChange = wrap(stickAngle - lastStickAngle, -180.0, 180.0);
      // multiply by stick magnitude in case player hasn't fully tilted the stick
      CurrentWindingStickAngle += angleChange * stickMagnitude;
   }
 
   // let the player release the stick gently to release the wheel gently
   if (stickMagnitude < 1) {
      // some magic here depending on the game: given the game state and physics, how fast would the wheel try
      // to return to neutral? In JoyShockMapper we just have a constant unwind rate set by the user
      float unwindRate = CalculateUnwindRate();
      // fully released stick means full unwind rate is used. partially released stick = partial unwind rate
      unwindRate *= 1.0 - stickMagnitude;
      float unwindAngle = unwindeRate * deltaTime;
      if (abs(unwindAngle) >= abs(CurrentWindingStickAngle)) {
         CurrentWindingStickAngle = 0.0;
      } else {
         CurrentWindingStickAngle -= unwindAngle * sign(CurrentWindingStickAngle);
      }
   }
 
   // finally, clamp the steering angle
   CurrentWindingStickAngle = clamp(CurrentWindingStickAngle,
      -WindingRange * 0.5 - WindingStuckOverRotationBuffer,
      WindingRange * 0.5 + WindingStuckOverRotationBuffer);
   // and return the steering strength in [-1, 1] interval
   float remappedWindingAngle = clamp(CurrentWindingStickAngle * 2.0 / WindingRange, -1.0, 1.0);
   // ...with power curve applied
   return sign(remappedWindingAngle) * pow(abs(remappedWindingAngle), WindingPowerCurve);
}

The left stick becomes a steering wheel. Engaging the stick is like grabbing the steering wheel, and releasing the stick is like letting go of the steering wheel. In my implementation, partially releasing the stick will let the steering wheel slip through my virtual hands more slowly. JoyShockMapper lets you configure a fixed rate that the virtual steering wheel moves back to its neutral position as you release the stick, but your driving sim can take into account the vehicle’s velocity and pull the virtual wheel back to the neutral position at a much more realistic rate.

Now, a simulation wheel will stop rotating when it reaches its limit – it will “lock”. We can’t stop the player from rotating their stick further. But giving the player feedback about their current virtual stick position is extremely important to this being an enjoyable experience.

If you’re using JoyShockMapper to force these controls into games, you’re probably best off staying in the cockpit view where you can see the game’s virtual steering wheel. For me, with my not-yet-released JoyShockOverlay, I’ve added the option for the kind of visual feedback I’d like every sim with these kinds of controls to offer. You can see it and how it responds to controller input in the clip above. Here’s a close-up:

This HUD element shows:

How hard I’m steering and in which direction;
How far I am between the neutral position and steering wheel lock;
A bright, eye-catching indicator of when my steering is locked;
How far past lock I have continued to rotate my stick.

That last part is more important than it might appear. It’s important to let me rotate past the lock position and keep track of that over-rotation internally. Otherwise, stick noise or small adjustments in my stick position would have me drift out of steering lock. As the player gets better at these controls, they’ll feel more and more comfortable only slightly going past the lock position. Until then, the player should be able to see how far they’re over-rotating. In my code example, I also limit how far the over-rotation is tracked to limit delays as the virtual steering wheel pulls back to its neutral position when the stick is released.

In my experimenting with visual feedback, I found it helpful to be able to put this HUD element front-and-centre. This example, in which I’m using JoyShockMapper and JoyShockOverlay with Assetto Corsa, might look intrusive. But in practice it obscures very little, and I found it very useful to be able to see my virtual steering position without taking my eyes far off the road. I also played with it at the bottom of the screen. Wherever it is vertically, I found it best suited to being centred horizontally. Letting the player customise the position of HUD elements is a great option to offer.

Your HUD element could look exactly like mine if you want, or it could look drastically different. But please make sure it provides the same info to the player. Admittedly, in a sim the player spends very little time with locked steering (unless perhaps they’re drifting in some genres of sim). But I still felt being able to see my full range of movement helpful when I am going slow enough to use the steering wheel’s full range. And even at full speed where most turning is very slight, the HUD element is useful for seeing the state of a virtual steering wheel that I can’t feel.

Finally, it is helpful to offer some physical feedback. I’ve set it up here to lightly rumble the controller when my steering is locked. I found that hugely helpful for feeling my steering range, and letting me ease out of a hard turn. Sims are usually offering plenty of other rumble feedback which may interfere. But combining both and letting the player independently configure the strength of steering feedback and environmental vibration would be great.

In summary, winding stick steering:

Maps more naturally to the range of a real steering wheel;
Is not very easy to learn, but has a very high skill ceiling for controller players who want a more realistic experience;
Lets players enjoy a more simulation-like experience where wheels aren’t affordable or aren’t viable (on the go with a Switch or Steam Deck);
Needs additional feedback (HUD, vibration) so players can feel and/or see when the steering locks and see the direction they’re steering.

Best for driving sims, and probably any other game that benefits from a steering wheel (if such games exist outside of sims). Let your players dip their toe into more realistic simulations on the go or if they’re undecided on whether to buy a wheel. I have not seen this in the wild, but this idea was inspired by a comment on Reddit 3 years ago (“I am still waiting for racing games using the left stick angle instead of X axis.”), and others have been floating the idea around for even longer.

3. Motion Steering

I don’t want to go into great detail about motion steering, except to say this: good player feedback is the difference between gimmicky and great motion steering.

So simply take what I wrote about visual and rumble/haptic feedback in the previous section, and apply it to motion steering with just about the exact same HUD element, showing players:

Their current steering strength/direction;
Whether they’ve “locked” the steering wheel (reached max rotation);
How far they’ve rotated beyond max rotation;
And since motion steering may have a deadzone in the middle (player configurable, please), show that on the HUD element, too.

The same physical feedback advice applies, too: even a simple constant rumbling while steering is locked goes a long way to letting the player feel the range of movement available to them.

Without good feedback, players drastically over-rotate their controller just to make sure they’re turning as hard as they can. This is perhaps less of an issue with (non-drifting) sims, where players are very rarely actually using the virtual steering wheel’s full range available to them. But this feedback is essential in non-sims, where players tend to spend a lot of time trying to turn as hard as they can as fast as they can. When you’re trying to hit that hard-as-you-can full-speed turn, it makes a world of difference to actually know how far you need to tilt.

Speaking of sims as compared with non-sims, because tilting the controller offers much more precision than even 2D steering, it’s relatively well-suited to both arcadey steering (where the game limits your turning range as you go faster) and simulation-style steering (leaving it up to the player not to turn so hard that they lose traction). But because the range of motion with motion steering is still much less than a real steering wheel, a player-configurable non-linear response is very helpful for bridging that gap in sims.

All that said, my main point with motion steering is that visual and/or physical feedback is so helpful I’d call it crucial to a good implementation. It’s a simple way to move motion steering from gimmicky to genuinely great.

Using JoyShockMapper for the steering control and vibration and JoyShockOverlay for the HUD element, let’s shove these controls into Trackmania:

I personally prefer 2D steering in arcadey games like Trackmania. But good visual feedback makes motion steering a close second for me, then traditional stick steering in third place followed by motion steering without good feedback in last place.

In summary, motion steering:

Provides more range of movement and precision than traditional stick or even 2D steering;
Has enough range and precision that it can reasonably be used with zero speed sensitivity in sims (no scaling back the steering range as the car gets faster);
Needs additional feedback (HUD, vibration) since players can’t feel when the steering locks or feel the direction they’re steering.

I don’t have a lot of experience with games that offer motion steering, but here’s a shout-out to Gran Turismo 7’s red dot showing the player’s current motion steering and the full range available:

4. Chorded Item Selection

Besides aiming, the other big advantage mouse and keyboard players have over gamepad players is with item selection. Keyboard players are used to having an array of keys dedicated to selecting specific weapons, letting them access every weapon in a near-instant, and often being able to access their favourites without interfering with their movement or other keyboard actions at all.

While keyboard players have dozens of unique inputs available to them, gamepads have very few. When designing for gamepads, fitting all the things we want to do on the few buttons available is often a great challenge.

Radial menus / weapon wheels have become a fairly common solution. They essentially mean all of your weapon / item selection only takes up one button: the button you hold to bring up the radial menu. Players then make their selection on that radial menu using one of the sticks – usually the right stick, so the player’s movement isn’t interrupted while selecting items/weapons.

The nice thing about this is you can offer the player just about any number of options, but the more options you offer them, the more precision is required with the stick to equip the item the player intends. This can be somewhat mitigated with a spiraling radial menu – rotating through multiple layers of possible selections by winding the stick as in Beyond Good and Evil’s text input interface – or by letting the player cycle through distinct wheels with no more than 8 or so options on each (see Ratchet and Clank: Rift Apart).

Either way, we’re changing the functionality of one input (one of the thumbsticks, in this case) while another input is held. This is called a “chorded input”. Like playing a chord on a piano, it’s the combination of multiple inputs that gives the desired result.

But instead of having a button change the stick behaviour, it can often be better to change the behaviour of other buttons. See Crysis Remastered, and how it gave players the option to select nano suit mode by chording the face buttons instead of an analog stick. The suit mode layout shown on screen spatially maps to the controller in an intuitive way – just like a weapon wheel – but executing a chorded button press is simpler (both for the developer and for the player) than repurposing one of the sticks. Digital Foundry called this suit selection “really nice” and “pretty much as quick as it is on PC”.

This is something JoyShockMapper users have been doing for a long time – in Fortnite, in Crysis well before Crysis Remastered was released, and even for choosing between the 8 weapons in DOOM Eternal (which conveniently fit into 4 simple categories – shotguns, buttets, energy, and big-bang) — see what DualShock 4 user SmvR can pull off using JoyShockMapper for chorded weapon selection:

What is it that makes using face buttons preferable over using a stick?

For one thing, an analog input isn’t well-suited to digital selections – just as a keyboard shortcut is quicker than using the mouse to press an on-screen button, using a physical button is quicker than using an analog stick to select an on-screen item.

In addition, I personally find that I can more easily learn mappings to specific buttons than to specific directions of the stick. Stick selection layout is certainly easier to memorise in a game like Deathloop, where each item wheel only uses the cardinal directions anyway. But having so few items to choose from also makes it ideal for selection with face buttons or d-pad.

Chorded item selection also gives us a new way to explore older means of item management. While games have long used the d-pad for secondary functions like weapon or item selection, letting go of the left stick (typically the move stick) in order to use the d-pad slows down the pace of the game. We could use modern remapping tools to play with Jak 3’s 4-category, 12-weapon d-pad system and remap it to, say, a shoulder button + the face buttons. This lets us easily access every weapon while on the move, and the game’s HUD already communicates how to access each weapon very clearly (see top-right):

Consider also that we often have the weapon-wheel button double as a previous-weapon or weapon-cycling action on a short press. The radial menu only appears when the button has been held too long to be considered a “short press”. It makes logical sense and it’s easy to learn, but:

Selecting other weapons is now even slower, since the player always has to wait for the radial menu to appear if they have a specific weapon or item in mind;
This creates uncertainty as to when the stick will change from controlling the camera to selecting a weapon, making weapon selection even clunkier than it was without the delay.

Using chorded button presses fixes both of these issues! Pressing the weapon button + a face button unambiguously communicates the player’s intent: R1 + Triangle means “give me my shotgun, please!” regardless of whether the radial menu has appeared on screen yet. And a press and release of the weapon button without pressing one of those other face buttons can unambiguously be considered a short press – or at least can allow a more generous timing window without slowing the player’s weapon selection down.

And it may be possible to layer these shortcuts on-top of your existing analog-selection system (as long as you’re not already using weapon button + face button to do something else, like holstering your item in Deathloop).

Of course, not all games will be well-suited to this kind of change. With very many items or weapons, it may be difficult to group them into categories that map well to only 4 button inputs. Maybe you can explore using more than just the face buttons for your chorded mappings? In the past I have used all of the face buttons and d-pad for weapon shortcuts in Quake, but I ended up preferring to put two weapons on each face button like I do in DOOM so I never had to use the d-pad while moving.

In the end, I’m not saying all games should do this, but many certainly could, and it’s a great tool for you to have in your toolbelt when designing controls.

In summary, chorded item selection:

Multiplies your controller button real-estate;
Is often quicker, simpler, and communicates player intent more clearly than analog item selection;
Can often be layered on top of a current analog stick radial menu seamlessly.

Nearly keyboard-fast item selection! Try it out in Crysis Remastered.

5. Motion Pointing

/ Gyro Pointing

Controlling an on-screen cursor is a well-known weakness for legacy controllers. The stick can only tilt so far, and is much easier to use by going full-tilt in a direction than a careful and gentle half-deflection (as I mentioned before: sticks are more useful for inputting direction than magnitude).

How fast should an on-screen cursor move when the user is giving their maximum stick input? Fast enough to move between items of interest quickly, but slow enough to not overshoot them. And since for most users these are two very different speeds, we tend to accelerate over time (to differentiate between small corrections and big movements), slow the cursor as it passes over items of interest, and give the cursor a larger hit-box (effectively giving all the on-screen items over-sized collision shapes).

Contrast that with a mouse. A mouse can move a cursor pretty much as quickly or slowly as the user likes. With low enough input latency, the cursor can move practically simultaneously with the physical mouse, giving the user a far more direct connection between their input and the game’s response.

It can be very simple to turn motion sensor input into a precise, responsive, mouse-like cursor control. It’s actually trivial to implement.

Here’s mouse control:

float Sensitivity;
 
// look, I know you're probably using the system cursor...
// but if you weren't, it'd look something like this, right?
void MoveMouseCursor(Vec2 mouseInput) {
   Cursor.Location += mouseInput * Sensitivity;
}

Here’s just using gyroscope input as a mouse:

float Sensitivity;
 
// move the cursor
void MoveGyroCursor(Vec3 gyroInput, float deltaTime) {
   Cursor.Location.X += gyroInput.Y * deltaTime * Sensitivity;
   Cursor.Location.Y += gyroInput.X * deltaTime * Sensitivity;
}

That’s not bad, hey? I mean, depending on the coordinate space of your inputs and what you’re doing with screen space, you might have to change the axes or a sign or something. But it’s still essentially this simple. The main difference is that while a mouse is reporting a change in position, the gyro is reporting a velocity (change in angular position over time), so we need to take time into account.

No need for acceleration over time or slowing over targets (in fact it’s preferable that you don’t do these as it makes the cursor movement feel less connected to the player’s input). Big cursor collision can’t hurt but it isn’t necessary. And since you can lift your mouse off the mousepad to reposition it without moving the on-screen cursor, the best motion pointing implementations will give you a button to do the same.

You can certainly provide more options. Separate X and Y sensitivity is common, for example. The point of the snippets above is to show you how simple it is. You don’t have to deal with 3D orientations. You don’t have to do any difficult transformations. The platform you’re developing on probably already deals with calibration for you (chat to me about that, as there are platform specifics I can’t get into here). The gyro really is a mouse.

For simple menu navigation where appropriate without having to train the user or have them go into their settings, try:

Motion/gyro on or off by default – up to you;
On-screen prompt “(□) disable/enable gyro mouse”, depending on whether it’s currently enabled;
Short-press (□) to toggle gyro mouse enabled or disabled, hold (□) to temporarily disable or enable gyro mouse while pressed.

Given how much Nintendo likes to use motion controls, I was disappointed that Super Smash Bros. Ultimate didn’t let me move the fighter-select cursor around the screen with this kind of motion pointing. Play the game now and consider how much nicer it would be to select your fighter with a mouse instead of pushing the cursor around with a stick. A simple motion pointing solution like that shown above feels almost exactly the same as using a mouse.

But there are some pretty good implementations out in the wild! Check out the Switch version of World of Goo, even allowing two players playing together to each hold a Joy-Con and control separate cursors on-screen. Their motion pointing is more complex than the example above, but it’s still robust and easy to pick up.

It should go without saying that any motion-related feature on the Switch is equally useful on other platforms with similar sensors – I’m thinking in particular of the PS4 and PS5. But too many games lack useful motion controls in their PlayStation and PC versions even though they offer them in their Switch versions (Xbox game devs get a pass because Xbox doesn’t have the hardware to offer these features). To me, this points to either:

Developers over-valuing thumbsticks as a cursor- or aim- controlling input device. “Joy-Con thumbsticks aren’t as good as PlayStation ones, so Switch needs an alternative but PlayStation doesn’t.”
OR developers under-valuing motion/gyro as a mouse-like input. “It’s a gimmick, but Switch players expect the feature, so here is an implementation they’ll probably like.”

Both of those views are incorrect. PlayStation does benefit from gyro pointing – the built-in motion keyboard on both the PS4 and PS5 are examples of this. And gyro pointing doesn’t sit in the small gap between Joy-Con sticks and larger PlayStation thumbsticks, but instead it sits at the far end of the much larger gap between standard thumbsticks and a gaming mouse (no scale, this is just illustrative):

Please reconsider the weaknesses and strengths of stick controls and mouse controls and realise that the gyro is a mouse. Whether for fighter selection in a game with a large roster, interacting with an in-game-world touch screen, placing pins on a map, or the cursor-based menu navigation found in games like Destiny and Deathloop, the controller’s gyroscope is the best option available to the player for controlling an on-screen cursor.

Finally, consider how this mouse-like input in the controller can be used to bring genres to consoles that have just not been considered viable with a legacy controller, such as rail shooters like The House of the Dead: Remake. Using JoyShockMapper, I can force controls like these into just about any PC game, and while I’m not particularly good at the excellent pointer rhythm game osu!, compare that to its reputation for being unplayable with a controller.

In summary, motion pointing:

Almost effortlessly provides mouse-like cursor control on most modern consoles;
Works very naturally in games that already have the player control a cursor in their menus (Super Smash Bros, Deathloop, Destiny);
Makes formerly PC-only genres more viable on consoles.

Especially natural with a Joy-Con on Switch, if your implementation is decent. Test your implementation with an expert to see if it is. For real examples, check out World of Goo on Switch and House of the Dead: Remake.

PS: I tend to say “gyro” rather than “motion” because motion controls of other kinds (shakes and waggles) have soured some players on the idea of any kind of motion-related input, regardless of how precise and responsive it is. This is very much like dismissing mouse aiming because you didn’t like having to use the mouse for gestures in Black & White.

6. Motion Aiming

/ Gyro Aiming

Don’t scroll past just because you saw “motion” or “gyro”. Watch this 31 second clip first:

The gyro is the mouse of the controller. And not just for moving a cursor around the screen. For any game where the player takes direct control of the camera, gyro controls offer precision and quickness that thumbsticks are not well-suited for. Turn off aim assist and let players acquire targets, pull off flick shots, and track weaving enemies with their own hands.

The main weakness of gyro aiming is the player’s limited range of movement — no one wants to have to spin around in their chair as the game forces them to turn around over and over to track enemies or navigate winding paths. This is what the sticks are good at, and so we have a naturally complementary combination of sticks for broad turns and gyro for precision.

Traditional stick-only camera controls give the player the impossible task of fine-tuning their settings to allow for precise adjustments and quick 180s at the same time. A stick cannot do both well. And in fact even if you don’t need to turn around in a game – even if all of your targets are on-screen at once – a stick will still be out-performed by a mouse. Consider that turning the camera to point at targets that are all near each other is essentially the same task as moving a cursor around a screen:

So sticks are bad at precision aiming. Why don’t we offer better options? Because stick-only is what we’re used to. We’re so used to that being the only option on the gamepad that we’ve forgotten how difficult it was to learn in the first place even with aim assist helping out. This is probably the biggest reason for gyro aiming’s relatively slow adoption. But there are millions of new gamers every year, and there’s no need for them to endure the same challenges to enjoy modern games.

In comparison, gyro aiming is very easy for new players to pick up. It doesn’t really have to be explained to them in depth. They’ll usually have little trouble figuring out how to aim at a target and shoot it, because there is such a natural connection between the real life movement and the in-game action.

And it’s super simple. Start with something like this:

float Sensitivity;
 
// move the cursor
void ApplyGyroCamera(Vec3 gyroInput, float deltaTime) {
   Camera.AddYaw(gyroInput.Y * deltaTime * Sensitivity);
   Camera.AddPitch(gyroInput.X * deltaTime * Sensitivity);
}

How easy is that? It’s basically the same as mouse controls. Compare that to your stick aiming implementation that has deadzones, maybe some directional warping, response curve, boosting/acceleration… And then aim assist is an even bigger beast that has no business being involved in mouse aiming or gyro aiming.

Now, you can certainly add more to this snippet. But whatever else you add to it, make sure it’s all optional. You must let players disable all the other stuff you’re gonna do to their controls. Because that’s where so many games stumble. They add acceleration or deadzones or smoothing or a combination of the above that make gyro aiming less precise, less responsive, and less useful to skilled players. Those things are great options, and some of them can even be useful defaults. But they must be disablable. That’s totally a word.

Two other ways a lot of games stumble:

The sensitivity slider doesn’t go high enough. The above snippet assumes you’re getting degrees per second in and the camera Euler angles are in degrees. If that’s not the case (some platforms provide radians per second, others rotations per second), convert. And then you’re on the natural sensitivity scale, where ‘1’ means in game rotations are the same as real world rotations. That’s the scale all games should use for gyro controls. Now, how high does your sensitivity slider go? Many games top out at 1 or 2. For a long time I’ve recommended 10 to comfortably fit what experienced gyro players use (anything from 1-8, in my experience). That’s what I put in Fortnite. Then those with ridiculously steady hands chimed in and I bumped it up to 20.
There’s no way to disable the gyro. This is much less of an issue for games where you only ever shoot while holding a dedicated aim button. In fact, these happen to be really common (think of just about every PlayStation blockbuster in the last two generations). Such games are actually ideal for learning gyro controls, because you don’t need to pay attention to how you’re holding the controller unless you’re getting ready to shoot. Zelda: Breath of the Wild proved this in spite of limited options and a low framerate. But there are also many “always aiming” games: DOOM, Overwatch, Quake, Counter-Strike, Valorant, just about every indie boomer shooter. These are great with gyro, too! But just like a mouse player lifts their mouse off the mousepad to reposition it without moving the camera, these games must offer a way to disable the gyro so the player can reposition their controller.

That last one is the single hardest thing for implementing good gyro controls. But in my experience there are always some actions that can double as a gyro-off button on a long press. Before this turns into a complete gyro controls tutorial of its own, just check out the front page of GyroWiki. It has something of a curriculum for developers looking to do this stuff properly, from the absolute basics that most games miss to the advanced stuff that’ll make your good gyro controls great.

Compare what you read there with what you can do in the games that offer the best controls:

Fortnite
Counter-Strike: Global Offensive
Boomerang X (especially on PC)

If you’re one of the lucky few to already have a Steam Deck, play the free Aperture Desk Job. Between that, CS:GO, and Steam’s built-in controller configurator, it’s plain to see that Valve also considers gyro aiming an important building block in modern games:

#GameDev on all platforms, please listen to Valve. This is what I mean when I say “the gyro is a mouse”, and “if it plays better with mouse, it plays better with gyro” https://t.co/oVMF0AlAdd pic.twitter.com/Ybl2SIu5sJ

— Jibb Smart 🎮 (@JibbSmart) November 30, 2021

Now, you may have picked up on some bias here. I speak very highly of Fortnite’s gyro controls, but I worked on them, so how can I be objective here? Well, I do a lot of non-gyro input design and gameplay programming, but I’m something of a gyro specialist. I made all the learning resources on GyroWiki, created JoyShockMapper, and have established simple standards and novel techniques that have been proven by countless player-hours. I’m well-connected with the gyro gaming community. And I’ve used tools like JoyShockMapper to play games with gyro controls almost exclusively for the last 4 years.

It was because of all this experience that I got to be involved with Fortnite. So yes, I’m probably biased when it comes to my assessment of Fortnite‘s gyro controls. But since the other front-runners are either not on console (CS:GO) or not on a high-performance console (Boomerang X), I say with confidence that Fortnite‘s gyro controls are peerless in the console space.

So when you read the advice on GyroWiki, you can be sure that all of it works. And if you want to be really sure, see for yourself: you can use JoyShockMapper with almost any PC game, or you can scroll through the settings in Fortnite and see how they compare.

And then, with a little work, you can offer your players the option of mouse-like precision and directness control that cannot be achieved with sticks alone. There’s no reason not to offer these options on every platform except Xbox. And as more and more players get into gyro controls, there are also more people for whom these options are make-or-break. See this thread of choice quotes from players lamenting the lack of gyro aiming options on PS5 so far. And I’m the same. This is why I own two PS4 controllers but never bought a PS4.

In summary, gyro aiming:

Turns the whole controller into a frictionless mouse;
Offers aiming precision so good that you should have aim assist disabled when gyro aiming is active;
Sets your game distinctively apart from stick-only aiming games;
Is a make-or-break feature for increasing numbers of players.

Forgive me getting a little over-excited on this one. Gyro aiming can add so much to a game, and it’s really hard to go back. It’s frustrating to see otherwise great console-exclusives with such stiff, slow, limited controls. Not because the developers have done a poor job with the thumbstick aiming, but because thumbsticks are bad aiming devices. And we all know that. And we have better options now. I’d put up with stick aiming if it was the best we had, but it’s not.

Oh, and now that we have two inputs controlling our aim — the gyro for precision and the thumbstick for coarse camera movements — let’s explore unlocking the aimer from the center of the screen:

7. Flick Stick

We’ve established that with gyro controls, the right stick can be relegated to macro-scale camera turns, pointing in the general direction of interest rather than honing in on a target. But what if we could make that macro-scale control even faster and more direct?

You see, Splatoon, which really innovated by going all-in on gyro aiming, made some other really bold moves that are almost unheard of elsewhere. When gyro aiming, they ignore the vertical axis of the right stick. Tilting the right stick up and down does nothing. And this is, of course, great for new players. Because if you’ve ever put a controller in the hands of a non-gamer for the first time and asked them to control the camera while moving their character around, I’m sure you’ve seen them get stuck staring at their feet or the sky and wondering why.

Another thing they did to help with this was have a reset camera button. Press the button, and the camera will centre itself vertically. Press the button while moving in any direction with the left stick, and the camera will even flick around to face that direction while centering itself vertically.

Splatoon illuminated for me that gyro aiming is more than sufficient for all your vertical aiming. That and the camera reset function inspired me to create the flick stick control scheme:

1 minute video introducing flick stick for the first time

When using flick stick, the right stick no longer turns the camera gradually in two axes. Instead, the whole 2D range of the stick is used to control the camera in one axis:

Move the stick from neutral to the edge of its range in any direction to trigger a flick – the camera will quickly turn to face that direction relative to where you’re already facing. For example, if you’re getting shot at from your back left, you can tilt the stick to the back left to turn to face that direction.
When the stick is already tilted, rotate the stick to rotate the camera. This is generally one-to-one. Rotating the stick 73 degrees to the right will rotate the camera 73 degrees to the right as you’re doing that motion.

Players have compared it to a top-down twin-stick shooter translated to 3D, or how some driving games point the camera in the same direction as your right stick relative to the car.

This gives the player faster and more direct control over their bearing than traditional stick controls. But of course, it offers no way to aim up and down. That’s why flick stick requires gyro controls. The gyro isn’t only handling vertical aiming. It also offers horizontal control with precision that isn’t practical with flick stick. This combination of gyro aiming and flick stick takes Splatoon’s gyro controls, constrained stick aiming, and camera reset button to their logical conclusion.

Check out my original flick stick tutorial for more details on implementing this feature well. There are other ways to do it which I’ll get into another time, but it’s worth checking out the original article because it explains some important nuances, such as when to apply smoothing, or why a good implementation will not block other inputs from adjusting the camera during the flick.

Flick stick started with JoyShockMapper, which was first publicly available early 2019, but now it’s an option in most popular input remappers, including Steam Input, DS4Windows, and reWASD. In July 2021 Boomerang X launched as the first commercial game to include flick stick as a feature (and the first game I’ve played to reach the gyro control standards set in the Absolute Basics of Good Gyro Controls).

Since then, Valve made it a native feature in CS:GO, and I had the pleasure of implementing it myself in Fortnite.

In a comment on one of my YouTube videos, Valve’s Aubrey Hesselgren said: “flick stick and gyro are like peanut butter and jelly; anyone who spends a bit of time to get used to it seems to prefer it to the console standard. We want other developers to know that it’s a fantastic option, whilst knowing it’s an uphill struggle to make it ubiquitous (not least because not all major platforms have gyros built in).”

Flick stick is new enough that the feature alone is a significant draw for players who already like to use it. Though at time of writing I only know of 3 games that offer the feature natively (with more on the way), I use JoyShockMapper to play almost every 3D game with flick stick, whether fast-paced or slow and careful, first person or third person, shooters or platformers or even God of War.

Anecdotally, it appears to me that experienced traditional stick players have a harder time picking up flick stick while mouse players pick it up more easily. The established stick player has a lot of muscle memory to fight against. But mouse- and even non-gamers are often able to find it useful with relatively little practice. I’d say the jury’s still out on what’s generally easier to pick up, but let’s not assume traditional stick controls are the best option for new players just because that’s what experienced players are used to.

For now, I’d just love to see it as an option I can choose in more games.

In summary, flick stick:

Offers unparalleled speed and range of yaw motion;
Requires gyro aiming for a complete aiming experience;
Doesn’t require gyro aiming if you don’t need a “complete aiming experience” (many platformers and 3D action games, for example).

Quick and direct control over the player’s bearing, already available in Fortnite, Counter-Strike: Global Offensive, and Boomerang X.

Conclusion

It is great that we’re able to benefit from well-established conventions. These conventions are really helpful for experienced gamers even when they’re not the best option for first-timers. So I’m not saying we need to throw out those conventions. But let’s explore powerful alternatives. Let’s offer the best experience we can to new players, disabled players, and expert players, by offering them alternative building blocks that better suit their experiences and their ambitions.

I’d love to see these used in more games!

2D steering can pretty much be dropped into any game that offers simple stick steering, from the most arcadey to the most exacting sims.
Winding stick steering can offer controller players precise control and immersion that’s hard to come by in other games, if they’re willing to learn to use it.
Good visual and physical feedback can really elevate motion steering by addressing its major shortcomings so players can benefit from the precision offered by its wide range of movement.
Chorded item selection, in the right games, can go a long way to closing the gap between keyboard item selection and slow and clunky weapon wheels.
Gyro pointing brings the mouse into the console space with no extra hardware required in an intuitive way.
Gyro aiming goes a long way to close the gap between mouse aim and stick aim, while making hugely popular genres of games easier to learn, more accessible, and have more room for mastery.
Flick stick offers players more direct control over their bearing without having to deal with new players staring at their feet. While it feels unusual for established stick players, it’s a simple and powerful control scheme that suits a wide variety of games (often with the help of gyro aiming).

These are pretty basic. They just slide almost seamlessly into the space between the player and the in-game character, not actually changing the mechanics of the game itself. There is so much more we can explore by expanding our set of basic building blocks. Those listed here are low-hanging fruit for offering distinctively good controls. Let’s offer more approachable, more accessible, and more empowering controls to players. Let’s change how games are played.

Source link