Generic

Generic plays a character animation through the standard ability system without requiring a new ability class. Use it for an emote, gesture, pose, short interaction animation, or other self-contained clip that only needs input, Animator parameters, ability settings, and a reliable completion point.

Before you begin

• Import the animation clip and confirm it previews correctly on the character’s Avatar.
• Use an Animator Controller with the UCC AbilityIndex, AbilityChange, and AbilityIntData parameters.
• Decide whether the animation is presentation-only. Generic does not apply damage, choose a target, spawn an object, or run custom gameplay logic. Use a purpose-built or custom ability when the animation must coordinate those results.
• Choose a project-unique Ability Index Parameter. Generic defaults to 10000; the worked example below uses 10100.

The numeric Ability Index selects an Animator branch. It does not set ability-list priority; the Generic entry’s position in Abilities controls priority.

Add a no-code animation

1. Select the character GameObject.
2. In Ultimate Character Locomotion, expand Abilities, select the plus button, and add Generic.
3. Keep Enabled selected and set Ability Index Parameter to the unique value reserved for this animation. This example uses 10100.
4. Leave Ability Int Data Value at -1 when the transition needs only the Ability Index. Assign a deliberate integer when several animation variants share one index.
5. Choose how the ability starts. The default is Start Type: Button Down with Input Names: Action. Change the input name or use another standard start type when the animation needs a different control.
6. Keep Stop Type set to Manual so Generic’s Stop Event owns completion.
7. Place Generic at the desired priority. Keep critical interruptions such as death above it. Place it below actions that should block the gesture, or above lower-priority actions it is allowed to interrupt.
8. Configure movement, root motion, items, and an optional State as described below.

Generic allows duplicate entries. Add one entry per independently configured animation, give each a clear Inspector Description, and use distinct inputs or start conditions so several entries do not compete for the same press.

Add the Animator state

1. Open Window > Animation > Animator and select the character’s Animator Controller.
2. In Full Body Layer, create or open a sub-state machine for the project’s Generic animations.
3. Create a state for the clip. The legacy example uses a PutGlassesOn state.
4. Follow the controller’s existing ability-transition pattern: enter the branch when AbilityChange is triggered and AbilityIndex equals the Generic entry’s Ability Index Parameter. Add an AbilityIntData condition when that value selects a variant.
5. Add the return transition used by the controller when the active Ability Index no longer selects this state. Do not rely on the clip reaching its final frame to stop the UCC ability; Stop Event controls the ability lifetime.

The example value 10100 is not required. The Inspector value and Animator condition only need to match and remain distinct from other ability branches in the project.

Choose the completion timing

Expand Stop Event and choose one mode.

Stop after a duration

Disable Wait For Animation Event and set Duration to the number of seconds after the ability starts. A new Generic entry defaults to duration mode with 0.5 seconds.

Use duration mode for a quick prototype or a clip whose timing and playback speed are fixed. Retune the duration whenever the clip, transition, or Animator speed changes.

Stop on the animation frame

Enable Wait For Animation Event when the ability should finish at a frame authored in the clip:

1. Open Window > Animation > Animation and select the clip.
2. Add an Animation Event at the intended completion frame.
3. Set Function to ExecuteEvent.
4. Set the String value to OnAnimatorGenericAbilityComplete exactly. Event names are case-sensitive.
5. Add the event to every first-person or third-person clip that can drive this same Generic animation.

Animation-event mode follows the meaningful frame when playback speed changes. It has no duration fallback: if the active clip never sends the event, Generic remains active.

Choose movement and presentation

In-place gesture

For a wave, salute, or other animation that should hold the character in place:

• Disable Allow Positional Input and Allow Rotational Input when the player must not steer during the gesture.
• Prefer an in-place clip. Leave Use Root Motion Position and Use Root Motion Rotation at No Override when the character’s existing settings already suppress unwanted motion; set both overrides to False when this ability must force an in-place result.
• Use Allow Equipped Items or Item Equip Verifier settings when the gesture is incompatible with equipped items.

Clip-authored movement

Set Use Root Motion Position or Use Root Motion Rotation to True when the clip itself should move or turn the character. Test collision, slopes, and the return to locomotion over the entire clip. Generic supplies no destination or obstacle planning beyond the standard locomotion settings.

Temporary character configuration

Assign State when the animation needs an existing State System preset while it is active, such as a camera, movement, or presentation adjustment. The state activates when Generic starts and clears when it stops. Use a specialized ability when the scenario needs logic beyond property changes.

Use several Generic animations

Generic can be added more than once:

• Use a different Ability Index Parameter for completely separate Animator branches.
• Reuse one Ability Index and assign different Ability Int Data Value values when several variants belong inside the same Generic branch.
• Give each entry a distinct Input Name, custom starter, or manual caller. If duplicate non-concurrent entries respond to the same input, the higher-priority entry starts first and prevents the lower entry from starting.
• Test a direct transition between variants. AbilityChange is raised when the Ability Index changes; an Animator that switches variants under the same index must also respond correctly to AbilityIntData.

How it runs

When its configured start condition succeeds, Generic enters the active ability list and exposes its Ability Index Parameter and Ability Int Data Value to Animator Monitor. The highest-priority active ability that supplies those parameters controls the Animator values. Generic also applies its standard input, root-motion, item, attribute, and State settings.

Generic is non-concurrent. A higher-priority active non-concurrent ability can block it, while a newly started higher-priority ability can interrupt it according to the normal ability rules.

As soon as Generic starts, Stop Event begins waiting. Duration mode schedules completion after Duration. Animation-event mode waits for OnAnimatorGenericAbilityComplete. Completion stops Generic, clears its State and overrides, and allows the Animator parameters to return to the next active ability or their neutral values.

Verify in Play Mode

1. Keep Ultimate Character Locomotion and the Animator window visible, then activate the configured input.
2. Confirm Generic shows (Active) and the Animator reports the intended AbilityIndex and AbilityIntData values.
3. Confirm the correct clip plays once and the character retains or loses movement input according to Allow Positional Input and Allow Rotational Input.
4. For root-motion animation, confirm the character moves or rotates with the clip and does not pass through the tested scene geometry.
5. In duration mode, confirm Generic stops after Duration. In animation-event mode, enable Animator Monitor > Editor > Log Events and confirm OnAnimatorGenericAbilityComplete executes at the authored frame.
6. Confirm Generic is no longer active, its optional State is cleared, locomotion and items return to their expected behavior, and the Animator exits the Generic state.
7. Repeat with every supported perspective, equipped-item combination, and higher-priority interruption.
8. If duplicate Generic entries exist, trigger each one separately and confirm its input, index, data value, clip, and completion timing are independent.

Troubleshoot Generic

Symptom	Check	Fix
The input does nothing.	Check Enabled, Start Type, Input Names, and whether a higher-priority non-concurrent ability is active.	Correct the input setting, release or reorder the blocking ability, and test the live input value.
Generic becomes active but the animation does not play.	Compare Ability Index Parameter with the Animator’s AbilityIndex condition and confirm the transition uses AbilityChange.	Make the values match and restore the standard ability entry condition.
The wrong Generic variant plays.	Compare Ability Int Data Value with the Animator’s AbilityIntData conditions.	Give each variant a unique value and make its transition conditions mutually exclusive.
Generic never stops in animation-event mode.	Check the active clip for Function: ExecuteEvent and the exact String OnAnimatorGenericAbilityComplete.	Add or correct the event on every clip that can play, or deliberately use duration mode.
The animation ends before or after Generic stops.	Check the Duration, event-frame position, transitions, and playback speed.	Retune Duration or move the animation event to the intended completion frame.
The character can move during an in-place gesture.	Check Allow Positional Input, Allow Rotational Input, the clip, and root-motion overrides.	Use an in-place clip, disable unwanted input, and set both root-motion overrides to False when the ability must force an in-place result.
Root motion in the clip has no gameplay effect.	Check Use Root Motion Position, Use Root Motion Rotation, and the clip’s imported root-motion data.	Set the required override to True and correct the clip import or Animator setup.
A duplicate Generic entry never starts.	Check whether another entry uses the same input and has higher list priority.	Give the entries distinct controls or start conditions, or invoke the intended entry manually.
The animation plays, but its intended gameplay effect never occurs.	Check whether the scenario requires behavior beyond Animator parameters and standard ability settings.	Use the appropriate included ability or create a custom ability that performs the gameplay action at a defined event.

Related tasks

• Animation Event Trigger explains duration and exact-frame completion.
• Animator Controller explains organizing ability states and transitions.
• Animator Parameters explains AbilityIndex, AbilityChange, and AbilityIntData.
• Abilities explains start types, list priority, input permissions, root motion, items, and States.
• State System explains property presets activated through State.
• New Ability is the next step when the animation requires custom gameplay behavior.

Developer reference

Generic allows duplicate ability types. Its defaults are Ability Index Parameter 10000, Ability Int Data Value -1, Start Type: Button Down, Input Names: Action, and a Stop Event in duration mode at 0.5 seconds. It inherits non-concurrent behavior and the base Stop Type: Manual.

On Awake, Generic registers OnAnimatorGenericAbilityComplete. AbilityStarted calls StopEvent.WaitForEvent; the completion callback cancels the pending wait and calls StopAbility. Changing the public AbilityIntData property while Generic is active immediately updates the Animator integer parameter.

Generic contains no custom movement, targeting, collision, or gameplay-effect callbacks. Code can retrieve a particular duplicate with the normal Ultimate Character Locomotion ability APIs and start it manually, but a reusable scenario with its own validation or runtime work should derive a dedicated ability instead.