[Unity] Game Creator 2 Characters — Player/NPC Movement, Animation, IK & Ragdoll

Thank you for visiting this site.

In this article, we will provide a detailed explanation of “Characters” (the Character System), one of the core features of Game Creator 2.

Characters is the system that governs every “moving entity” in a scene — players, NPCs, and more. A single Character component encompasses nearly everything a character needs: movement, jumping, animation, IK, footsteps, and ragdoll.

Official documentation: Game Creator 2 Documentation

You can find a list of all articles in this series below.

Complete Article List — Game Creator 2 Complete Guide Series Indexen.senkohome.com/gamecreator2-series-index/

---

What Are Characters?

Simply attaching a Character component to any GameObject gives it movement, rotation, IK, jumping, falling, footsteps, and animation capabilities.

The main features are:

• Player Input: Switchable control schemes — directional input, point & click, tank controls, etc.
• Rotation Modes: Multiple rotation options — face camera direction, movement direction, specific target, etc.
• World Navigation: Choose from Character Controller / NavMesh Agent / Rigidbody drivers
• Gestures & States: A lightweight animation system built on Mecanim
• Inverse Kinematics: Automates foot grounding and head orientation toward gaze targets
• Footstep Sounds: Multi-layer mixed footstep sounds based on ground texture
• Dynamic Ragdoll: Ragdoll activation and recovery without additional setup

Player Character

A Character with the Is Player checkbox ON processes input through the Player unit.

Only one Player can exist in a scene at a time. Switch with the Change Player Instruction. Creating a “Player” from the Hierarchy menu or Toolbar automatically sets Is Player to ON.

---

Character Component Overview

The Character component is divided into the following blocks in the Inspector.

General Settings

• Is Player: Whether to treat as a player character
• Update Time: Game Time (follows time scale) / Unscaled Time (real-time)
• Mannequin icon: Displays debug information at runtime
  • Green = normal / Red = that limb is Busy / Red skull = dead

Kernel Settings

The core group of 5 Units that drive character behavior. A Unit is a Game Creator concept — a swappable module that constitutes character behavior (also called “Control Unit” in official docs).

Extra Settings

• Inverse Kinematics (IK rig management)
• Footsteps (footstep system)
• Ragdoll

---

Kernel (5 Units)

The Kernel splits character behavior into 5 types of “Units”, each independently swappable. Switch implementations via the icon at the right edge of the Inspector.

Player Unit Options

• Directional: Camera-relative WASD / left stick input. The most common option, suitable for 3D action, RPG, and adventure games in general
• Point & Click: Move to mouse click location. With NavMesh Agent driver, navigates around obstacles. Ideal for classic RPGs, strategy games, and CRPGs
• Tank: Forward key moves in the local forward direction. Requires Tank rotation. Used in fixed-camera horror games, etc.

Motion Unit Main Parameters

• Speed / Rotation / Mass / Height / Radius / Gravity / Terminal Velocity
• Use Acceleration: Whether to use acceleration/deceleration. Without it, moves at max speed instantly
  • Acceleration / Deceleration: Speed of startup / slowdown
• Can Jump / Air Jumps / Jump Force / Jump Cooldown: Jump behavior
• An Interaction section at the bottom (detailed later)

Driver Unit

• Character Controller: Standard. Appropriate for almost all cases
• Navmesh Agent: Obstacle avoidance capable but cannot jump
• Rigidbody: Behavior driven by Unity’s physics engine

Drivers have an Axonometry field (v2.9.36+) that constrains movement.

Rotation Unit (Facing)

• Pivot: Faces the most recent movement direction
• Pivot Delayed: Rotates with delay (for slow movement like sneaking)
• Look at Target: Always faces a specific object, with lateral movement becoming strafing
• Object Direction: Aligns with the direction another object is facing (for TPS/FPS)
• Towards Direction: Always faces a single world-space direction (for on-rails, etc.)
• Tank: Rotates in place with specified keys
• Runtime switching is supported: Can be dynamically swapped based on context (e.g., Pivot normally, Look at Target when engaging enemies)

Rotation also has Axonometry — matching values with the Driver ensures consistency. Rotation constraints per mode:

Animation Unit (Kinematic)

• Position / Rotation / Scale: Mannequin’s local Transform
• Smooth Time: Seconds for most animation transitions. Larger = smoother/slower, smaller = snappy
• Mannequin: Intermediate object between the Character and the 3D model
• Animator: The model’s Animator. Default uses GC’s Locomotion Runtime Animator Controller
• Start State: Initial State (layer = -1)
• Reaction: Default hit reaction for Shooter/Melee

The still pose (1-frame idle) is designed to look alive with overlapping Breathing and Twitching.

---

Extra Settings Detail

Inverse Kinematics

IK uses a stack-based system. Add rigs via the Add IK Rig Layer button — they are applied from top to bottom.

Standard rigs included:

• Look at Target: Rotates head, neck, chest, and spine toward a gaze point (works with Hotspots). Humanoid only
• Align Feet with Ground: Foot grounding and slope following. On steep slopes, lowers the hips to keep both feet grounded

Footsteps

• Register foot bones in an array (defaults to 2 human feet, extensible with Add Foot)
• Link a Footstep Sounds (Material Sounds asset) to the Sound Asset
• Sound pitch/speed is automatically varied, and on blended-texture ground, volume is also blended

Ragdoll

Ragdoll state can be transitioned to without additional setup. A Skeleton asset is required.

Parameters:

• Transition Duration: Blend time from ragdoll → recovery animation. 0.5 seconds or more recommended (to avoid snap)
• Recover Face Down / Recover Face Up: Get-up animations for face-down / face-up orientations

---

Animation (Gestures and States)

A custom layer built on Unity Mecanim that lets you dynamically play animations without pre-registering them in an Animator Controller.

Gestures (One-Shot Playback)

Single-shot animations that automatically return to the previous animation when done (punch, vault, wave, etc.). Play with the Play Gesture Instruction.

Main parameters:

• Character / Animation Clip: Target character and clip (required)
• Avatar Mask: Body parts to apply to
• Blend Mode: Blend (override) / Additive (additive)
• Delay / Speed
• Root Motion: Ignores input when using root motion
• Transition In / Out: Fade in/out seconds
• Wait to Complete: Whether to wait for completion before the next Instruction

Gestures always have higher priority than any State — this is an important point.

States (Loop Playback)

• Animation State: Loops a single clip. Can set up Entry/Exit Gestures. Since v2.5.20, On Refresh Instructions at the bottom is called in order from lower to upper layers whenever a State is added/removed
• Locomotion State: Blends clips based on speed, direction, and fall speed
  • Basic State: Idle + 8-directional movement clips
  • Complete State: Idle + 16-directional (8 half-speed + 8 full-speed). Use this for analog stick input
  • Airborne Mode: Single / Circular 8 Point / Circular 16 Point
• Properties (v2.9.34+): States can hold override values for speed, rotation speed, jump, gravity, etc. Applied in ascending layer order — higher layers override

Layers (Layer Priority)

Same concept as Photoshop layers — higher numbers take priority.

For example, if States exist on Layers 1, 2, and 10, Layer 10 plays. Removing Layer 10 switches to Layer 2.

Setting a Transition when adding/removing provides smooth blending.

Gestures always take priority over all States.

Full priority overview:

[Highest] Gesture (always plays on top)
  ↑
[High]    State Layer 10
  ↑
[Middle]  State Layer 2
  ↑
[Low]     State Layer 1
  ↑
[Base]    Locomotion Controller (base animation)

Weights

Adding a State is not an all-or-nothing replacement — you can blend by percentage (e.g., run + crouch-run at 50/50). At runtime, change with Change State Weight.

Starting / Stopping States

• Enter State Instruction: Select AnimationClip / State asset / Runtime Animator Controller via State Type
• Parameters: Layer / Blend Mode / Delay / Speed / Weight / Transition
• Stop State Instruction: Smoothly stops the State on a specified Layer. Delay / Transition can be specified

Custom Model

Simply drag & drop a character prefab into the Character’s Animation section to swap models. Runtime swapping uses the Change Model Instruction.

To replace the Locomotion Controller with a custom one, you need a custom unit implementing the IAnimim interface.

---

Inverse Kinematics Detail

Rig Management

Add from “Add IK Rig” at the bottom of the Character component. Executed from top to bottom — subsequent rigs touching the same bone chain override previous ones.

Standard Rigs

Feet Align (Humanoid only)

• Grounds and rotates feet to match terrain irregularities
• Foot Offset: Vertical offset to correct the gap between skin mesh and bone tip
• Foot Mask: Collider layers for ground detection (e.g., exclude water surfaces)

Look at Target (Humanoid only)

• Rotates head, neck, chest, and spine toward a Hotspot’s gaze point
• Track Speed (deg/s) / Max Angle (peripheral vision) / Head / Neck / Chest / Spine Weight

Custom Rig (Custom IK)

Characters have a layered IK system that can stack multiple rigs. Beyond Feet IK (foot grounding) and Look At (gaze), you can add custom IK logic.

Accessing Rigs

Get rigs from the Character component’s IK property. Returns null if the rig doesn’t exist.

// Example: disable foot grounding IK
character.IK.GetRig<RigFeetPlant>().IsActive = false;

Creating Custom Rigs

Game Creator provides two IK wrappers:

Inherit from one and override the following methods:

public class MyCustomRig : TRigAnimationRigging
{
    protected override bool DoStartup(Character character)  { /* init */ }
    protected override bool DoEnable(Character character)   { /* enable */ }
    protected override bool DoDisable(Character character)  { /* disable */ }
    protected override bool DoUpdate(Character character)   { /* per-frame update */ }
}

---

Footstep Sounds Detail

Phases (Foot Contact Detection)

• Phase curves (animation curves) detect foot contact (Phase-0 through Phase-3, up to 4)
• Humanoid defaults: Phase-0 = left leg, Phase-1 = right leg
• Value 0 = airborne / Value 1 = grounded
• Custom animations require manually adding Phase curves (automatable with the official Footsteps Generator extension)

Material Sounds

• Create via Create > Game Creator > Common > Material Sounds
• Multiple SFX can be defined per texture. Randomly selected on playback, but the same sound never plays consecutively
• Can also spawn particle Prefabs from the pool at the impact point
• Pitch/speed is slightly varied each time to reduce repetitiveness
• On blended-texture terrain, volume/pitch is proportionally mixed
• Link to the Character’s Sound Asset field via drag & drop

On Step Trigger

The On Step event enables executing Instructions in sync with footsteps (e.g., leaving footprints).

---

Ragdoll and Skeleton

Activation / Recovery

• Start with the Start Ragdoll Instruction
• However, input remains active, so these two Instructions are typically used instead:
  • Kill Character: Disables interaction and automatically activates ragdoll
  • Revive Character: Automatically selects a get-up animation and restores control
• Recover Face Down / Up plays based on body orientation

Skeleton Asset

A foundational asset used not only for Ragdoll but also for Melee/Shooter hit detection.

Create via Create > Game Creator > Characters > Skeleton and drag & drop to the Character’s Animation tab.

Skeleton Structure

• Skeleton Configuration Mode: Displays the character in a dedicated scene. Drag & drop a prefab model to the bottom field and click Change Character to swap the preview model
• Physical Material / Collision Detection mode
• Volume (volume bones):
  • Box: For chest / flat areas
  • Sphere: For hands / head
  • Capsule: For most limbs
• Each volume consists of Bone Type (Humanoid dropdown or Root/Spine/... path), volume definition, and Joint
• Create Humanoid button: Automatically estimates the Skeleton when dropping a Humanoid model

---

Markers (Movement Destinations)

A component representing the destination a Character moves toward. Includes a yellow arrow gizmo indicating direction.

• Stop Distance: Tolerance for arrival detection. Prevents jostling in crowded situations
• Type:
  • Directional: Stops at the arrow’s position and rotation
  • Inwards: Moves to the nearest point on the circumference and faces the center (convenient for item pickup, etc.)

---

Interaction (Interaction System)

Character-Side Settings (Inside Motion Unit)

• Radius: Minimum distance to recognize a target of interest
• Mode: Prioritization of targets
  • Near Character: Selects the closest target to the Character’s interaction center. Center position adjustable via offset (controller-oriented)
  • Screen Center: Closest to screen center (FPS-oriented)
  • Screen Cursor: Closest to cursor (point & click-oriented)
• Use the Interact Instruction to interact with the currently focused object
• Note that a Busy character cannot Interact

Interactive Object-Side Settings

• Simply placing an On Interact event on a Trigger component makes an object interactive
• On Focus / On Blur events detect focus start/end as well
• Combining with Hotspots enables text display or Prefab activation on focus

---

Busy (Body Part In-Use Status)

A mechanism for querying whether specific body parts are “in use”. The Mannequin icon toggles green ↔ red at runtime, visualizing each limb’s Busy state.

Accessible and settable from Instructions / Conditions.

Script API

IsArmLeftBusy : bool
IsArmRightBusy : bool
IsLegLeftBusy : bool
IsLegRightBusy : bool
AreArmsBusy : bool
AreLegsBusy : bool
IsBusy : bool

Set each limb to Busy with MakeLimbXXX() (e.g., MakeLegLeftBusy()). See the scripts under Plugins/GameCreator/Packages/Core/Runtime/Characters/Busy for detailed methods.

---

Handles (Prop Attachment Points)

An asset that determines which bone, at what position and rotation, a prop (such as a weapon) is attached to.

Evaluates Conditions from top to bottom and uses the matching Handle information. For example, for Humanoid — sword in right hand; for non-Humanoid — attached to beast’s mouth.

The same position information can be reused across multiple weapons, making this useful for games with many items.

---

Scripting / Extension

Frame Update Order

1. Player.Update() → Interprets input, calls Motion’s MoveToDirection / MoveToPosition
2. Motion.Update() → Calculates external forces (gravity, slope sliding, dash, jump)
3. Driver.Update() → Updates Transform
4. Facing.Update() → Calculates body orientation
5. Animim.Update() → Feeds Animator parameters

Each Unit can reference the others (mutual read access).

Extension Points (Interfaces)

Motion Move Methods

• MoveToDirection / StopToDirection
• MoveToLocation(Location) / MoveToTransform(Transform) / MoveToMarker(Marker)
• StartFollowingTarget(target, min, max) / StopFollowingTarget()
• Jump(): Jumps / air jumps when conditions are met

Facing Layer API

int SetLayerDirection(int key, Vector3 direction, bool autoDestroyOnReach);
int SetLayerTarget(int key, Transform target);
void DeleteLayer(int key);

• First call returns a new key. Use the same key for subsequent updates
• autoDestroyOnReach = true auto-removes on arrival
• Deleting a non-existent key does not throw an exception

// Continuously look at a target (3rd arg false → don't auto-remove on reach)
IUnitFacing face = character.Facing.Current;
key = face.SetLayerTarget(key, lookAtTransform, false);

// Remove (no exception for non-existent keys)
face.DeleteLayer(key);

Model Change (Script)

GameObject instance = character.ChangeModel(prefab, default);

The second argument ChangeOptions struct can also specify footsteps, Skeleton, Animator Controller, and offset.

IK Rig Access

character.IK.GetRig<RigFeetPlant>().IsActive = false;

Returns null if the rig doesn’t exist.

Breathing / Twitching

Default characters overlay procedural animation for breathing and micro-movements on all animations. Intensity can be dynamically changed via HeartRate / Exertion / Twitching properties.

---

Getting Started Mini-Guide

1. Right-click in Hierarchy → Game Creator > Characters > Player to create a Player (ensure camera and lights exist in the scene)
2. Verify Speed / Rotation in the Character’s Motion, Character Controller in Driver, and Pivot in Rotation
3. Create a Camera Shot and set Look Target / Orbit Target to the Player
4. The Locomotion Animator Controller is set by default on the Animator, so just drag & drop a model into the Character’s Animation section for running/jumping to work
5. Create Material Sounds and drop them into the Character’s Sound Asset for footsteps
6. If you need a death mechanic, create a Skeleton and use Create Humanoid for ragdoll preparation
7. When enemies or interactions are needed, set up On Interact Triggers

---

Visual Scripting Reference (Full Instruction / Condition / Event List)

A comprehensive quick-reference table of all Instructions, Conditions, and Events callable from Visual Scripting under the Characters category. Use as a search aid when adding nodes.

Instructions

Instructions addable to Visual Scripting’s Actions component. Category path: Characters > <subcategory>.

Animation

Busy (Body Part Management)

Combat > Invincibility

Combat > Poise

Combat > Targeting

Footsteps

IK (Inverse Kinematics)

Interaction

Navigation

Player

Properties (Character Properties)

Ragdoll

Visuals (Appearance / Equipment)

Conditions

Conditions usable in Conditions component Branches and Condition-type nodes.

Animation

Busy

Combat

Interaction

Navigation

Properties

Visuals

Events

Add to Trigger components to fire Instructions when the event occurs.

Characters (Root Level)

Combat

Navigation

Ragdoll

Note: Beyond what’s listed here, there are Character-related events in other categories such as Interaction (On Interact / On Focus / On Blur), Audio, and Input.

---

Practical Usage — Configuration Guide by Use Case

Summary of which Units and Instructions to use for “I want to achieve this character behavior”.

Standard 3D Action / RPG Player Controls

Configuration where the character moves with WASD / left stick relative to camera direction.

The most versatile configuration, suitable for most 3D games.

Classic RPG / Strategy Point & Click Movement

Configuration where the character walks to the clicked point while avoiding obstacles.

Fixed Camera Horror (Resident Evil Style) Tank Controls

Configuration where the character moves in its local forward direction with the forward key, regardless of camera orientation, and rotates in place with left/right keys.

Strafing When Facing an Enemy

Normally faces movement direction, but when entering combat, always faces the enemy while moving laterally.

Seamlessly switches at runtime based on context.

TPS/FPS — Aligning Character Body to Camera Direction

Configuration where the character faces the same direction as the camera when aiming, with the weapon direction matching the camera’s line of sight.

Side-Scroll / Isometric Game Movement Constraints

Configuration that uses 3D space while constraining movement to specific axes or directions.

Available from v2.9.36. Set the same Axonometry on both Driver and Rotation for consistency.

Playing One-Shot Animations (Punch, Wave, etc.)

Plays once and automatically returns to the previous animation.

Gestures always take priority over all States.

Switching State Animations (Crouch, Swim, etc.)

Dynamically start and stop looping posture animations (crouch, sit, swim, etc.).

Layer usage example:

• Layer 1: Running State (Speed = 10)
• Layer 2: Crouch-running State (Speed = 5)
• Adding Layer 2 plays the higher-layer State and changes movement speed to 5
• Stopping Layer 2 returns to Layer 1 and speed reverts to 10

States with Entry/Exit Animations

Like playing a “draw sword” animation → “guard stance loop” → “sheathe sword” animation on exit.

Moving an NPC to a Position Before Acting

Configuration where an NPC walks to a door, stops in the correct orientation, then opens it.

Flow example: Move To (door Marker) → Wait to Complete → Play Gesture (door opening animation)

For crowds, slightly increasing Stop Distance allows NPCs to process as “approximately arrived” without jostling.

Creating a Marker That Allows Item Pickup from Any Angle

Makes item pickup feel natural regardless of approach direction.

Death → Ragdoll → Revival Flow

Enemy goes ragdoll on death, automatically gets up on revival event.

Using Start Ragdoll directly leaves input active, so the Kill/Revive pair is typically recommended.

Disabling Player Controls During Cutscenes

Prevents the player from moving during events.

Matching Interaction Priority to Control Type

Set in the Mode field of the Interaction section inside the Character’s Motion Unit.

Making an NPC Follow a Specific Character

Making an escort NPC follow the player.

Stops when within Min Distance, starts chasing when beyond Max Distance. With NavMesh Agent driver, follows while avoiding obstacles.

Implementing an Action Game Dodge Dash

A quick evasive dash in a specified direction on button input.

Use Cancel Dash to interrupt mid-dash.

Attaching Weapon and Item Props to Characters

Configurations like holding a sword or attaching a shield to the back.

Conditional branching for Humanoid/non-Humanoid attachment points can be configured within the Handles asset.

Grounding Feet to Terrain (IK)

Makes character feet naturally contact the ground on slopes and steps.

Making Characters Naturally Look at Nearby Points of Interest

When the player approaches a Hotspot, their head, neck, and chest turn toward it.

Works in conjunction with the Hotspot component.

---

Official Links

• Game Creator 2 Official Documentation
• Game Creator 2 — Unity Asset Store

---

Summary

In this article, we covered the Characters system of Game Creator 2.

Characters is a system that achieves character control for any game genre by combining 5 Units (Player, Motion, Driver, Rotation, and Animation).

It offers broad support from no-code configuration changes to C# script extension, with the flexibility to handle everything from prototypes to full production.

Complete Article List — Game Creator 2 Complete Guide Series Indexen.senkohome.com/gamecreator2-series-index/

We hope you’ll check out our other articles as well.