Game feel through touch

Give each effect a job

Separate three jobs before building a library: confirming an input, reporting an outcome and conveying a changing state. A menu selection, damage event and accelerating engine need different lifetimes and different priorities.

Write a short intent for each effect. “The landing should feel heavier than a footstep” is useful. “Add rumble” leaves timing, strength and meaning undecided.

Build a family of impacts

Take one collision and test it at low, medium and high game speeds. Keep the timing tied to the actual collision. Adjust the haptic’s strength and character so the three outcomes are distinguishable without making the largest one uncomfortable.

Apple’s HapticBounce sample derives intensity and sharpness from impact velocity. Treat its mapping as an example: choose the range for your game and test it. Your physics units are not a physical calibration of the haptic actuator. Collision-based patterns

For material differences, start with a hypothesis such as a short, crisp contact for a hard surface and a softer, longer response for a yielding one. Compare the candidates with the animation and sound present. Avoid shipping a table that claims one sharpness value universally represents wood or metal.

Protect the important cue

A busy scene may contain footsteps, a vehicle, weapon impacts and a damage warning. If every event owns an independent maximum-strength effect, the player cannot easily tell which one matters.

Choose a priority policy alongside the patterns. For example, a damage cue could briefly reduce the vehicle texture, and repeated minor debris impacts could be coalesced. These are game-design choices to evaluate, not a promise that the framework mixes effects that way for you.

Listen to each layer alone, then together. Keep a way to disable ambient effects during testing so an important cue’s identity does not get hidden by the scene.

Query the controller itself

A controller’s haptics are exposed through GCDeviceHaptics. Its supported localities describe available actuator locations. The host device’s supportsHaptics result is not a controller-capability check: an iPad or Mac can have a controller with haptics even when its built-in device output cannot play your pattern. Controller haptics

import GameController
import CoreHaptics

func makeControllerEngine(for controller: GCController) -> CHHapticEngine? {
    guard let haptics = controller.haptics,
          !haptics.supportedLocalities.isEmpty else {
        return nil
    }
    return haptics.createEngine(withLocality: .default)
}

Pass the controller assigned to the player, not an arbitrary connected controller. The factory can return nil; the game must still run. Retain the engine, install its lifecycle handlers and start it before playback. Apple’s default locality chooses the expected actuator arrangement; request other localities only when supported and useful to your design. Creating a controller engine

Test the actual controller and connection you intend to support. Successful pattern parsing is not a promise that every controller has the same actuator behaviour or player capabilities. Handle player-creation and playback errors rather than discarding them.

Design sustained effects with an exit

For an engine or charge-up, decide what begins the effect, what controls its intensity and what stops it. Releasing a control, losing focus, pausing the game and disconnecting a controller all need an answer.

Prefer a changing effect that communicates state over a flat vibration left running by default. Core Haptics continuous haptic events have a maximum duration of 30 seconds; do not use that ceiling as a target duration. Continuous haptic events

Review with players

Play a whole level, including a failure and a retry. Ask which cues people can identify and which they would reduce. Give players control over haptic feedback, and keep critical information visible or otherwise accessible when it is disabled.

A practical test matrix includes touch-only iPhone play, each supported controller, no haptic device, disconnection during an effect, and the game’s pause menu. Record the hardware and route with the result.

Use Haptrix’s editing workflow to prototype a pattern before integrating it. Then use the synchronization guide to connect it to the game’s timeline, and the accessibility guide to check what remains when touch is unavailable.