# Flow Character Level: Intermediate ## Goal Use Flow Character to drive player and NPC movement, animation layers, State assets, Gesture assets, Marker events, and character-facing Flow logic from one authoring model. ## What It Is Flow Character is the gameplay-facing character layer in FlowCore. It gives designers a configured Character object, movement controls, animation State assets, one-shot Gesture assets, Marker events, and Flow instructions/conditions that can be used from graphs. It is not a full character game. It does not decide combat rules, inventory rules, dialogue rules, networking, or save policy. It gives those systems a stable character surface to call. ## Setup Use the GameObject menu for the first object: * `GameObject/Flow Core/Flow Player` creates a player-ready Flow Character. * `GameObject/Flow Core/Flow NPC` creates an NPC-ready Flow Character. Use the asset menu for animation assets: * `Flow Core/Character/Locomotion State` for idle, directional movement, and jump-phase clips. * `Flow Core/Character/Clip State` for a single active State clip. * `Flow Core/Character/Gesture` for a one-shot or layered action such as pickup, attack, wave, use, or cast. Expected result: * The scene has a Flow Character component. * The Character can receive movement and facing instructions. * State and Gesture assets can be triggered from Flow Graphs. * Marker events can start chains from animation timing. ## How It Feels A Flow Character has long-running state and short-running actions. State is the persistent layer. A locomotion State can keep the character walking, idling, turning, and reacting to jump phases. A clip State can place a character into a pose or continuous animation layer. Gesture is the temporary layer. It can play an entry segment, a main segment, and an exit segment. It can use a tag, priority, AvatarMask, conflict policy, and motor overrides so short actions can coexist with the base State. Marker is the animation-timed signal layer. A Marker fires when clip playback crosses its normalized time. It can identify a limb such as `LeftFoot` or `RightHand`, or use a custom Id. That event can trigger graph logic at the authored moment instead of relying on approximate timers. ## State, Gesture, And Marker State is best for sustained identity: * Locomotion sets the default movement animation surface. * Clip State sets a continuous animation layer. * State Enter and Exit tracks let you add transition clips. * State motor overrides can change movement speed, rotation speed, gravity, jump force, and movement permissions while the State is active. Gesture is best for temporary intent: * Entry starts the action. * Main holds the primary animation. * Exit resolves the action when stopped or completed. * Tags group related Gestures. * Priority decides which active Gesture wins when motor overrides conflict. * AvatarMask limits a Gesture to part of the body. Marker is best for precise gameplay moments: * Foot contact can spawn dust, play audio, or drive camera feedback. * Hand contact can attach an item, apply damage, or open a container. * A custom Id can distinguish `pickup`, `release`, `hit`, `cast`, or `reload`. * Marker conditions can filter by limb and Id before a chain continues. ## State Asset Settings Every State shares the same main animation settings: * AvatarMask limits which bones the State affects. Leave it empty when the State should drive the whole body. * Blend Mode decides whether the State replaces lower animation data or adds on top of it. * Delay waits before the State starts contributing weight. * Speed changes the authored playback rate for the State layer. * Weight decides how visible the State is after blending finishes. * Blend In and Blend Out decide how quickly the State appears and disappears. * Root Motion lets the animation feed motion back into the Character driver when the Character animation units allow it. Clip State is the simplest State asset: * Clip is the main animation track. * Lifecycle Enter and Exit are optional one-shot tracks for transitions. * Motor Overrides are fixed movement and control values applied while the State is active. * Event Graph receives Enter, Marker, ExitBegin, ExitEnd, and Interrupted events. Locomotion State is for directional movement: * Idle is used when local planar movement is low. * Forward, Backward, Left, and Right are the cardinal movement tracks. * Forward Left, Forward Right, Backward Left, and Backward Right are optional diagonal tracks. * Use Diagonal Clips lets diagonal clips contribute to locomotion blending. * Full Speed defines the local planar speed that counts as full locomotion weight. * Jump Enter, Air Jump Enter, Jump, and Jump Exit are overlay tracks for jump phases. * Lifecycle Enter and Exit are optional one-shot transition tracks. * Motor Overrides are fixed movement and control values applied while the locomotion State is active. Use asset-level Motor Overrides when the whole State owns a rule. A crawl State can lower Move Speed for the entire crawl. A ladder State can disable jumping for the entire ladder mode. A knocked-down State can disable Can Move until it exits. ## Gesture Asset Settings Gesture assets use the same animation settings, but they apply to the Gesture's Entry, Main, and Exit segments as one layer. Gesture Rules: * Tag groups related Gestures for conflict and stop rules. * Priority sorts active Gestures. Higher priority is layered later and wins later in motor override resolution. Segments: * Entry is the optional wind-up. * Main is the primary action. * Exit is the optional recovery. * Empty segments are skipped. * Each segment is a Clip Track, so it has Clip, Loop, Speed Curve, Markers, and Clip Motor Overrides. Motor Overrides on a Gesture are fixed while that Gesture is active. Use them when the whole action owns the rule: an interact Gesture can disable jumping, a reload Gesture can reduce movement, and a heavy attack Gesture can lock Can Move. Use Clip Motor Overrides inside a segment when the rule changes during the action. For example, allow movement during the first half of an attack, lock movement at the hit frame, then restore movement during recovery. ## Clip Track Settings A Clip Track is the reusable track shape used by Clip State clips, Locomotion clips, State Enter/Exit tracks, and Gesture Entry/Main/Exit segments. * Clip is the animation clip to play. If it is empty, that track is skipped. * Loop keeps the clip repeating while the track remains active. * Use Speed Curve enables per-normalized-time playback speed. * Speed Curve is only used when Use Speed Curve is enabled. * Markers fire semantic events at normalized clip times. * Clip Motor Overrides apply movement and control values while this track contributes animation. Clip Track settings are where animation timing becomes gameplay timing. The same clip can slow down before contact, fire a Marker at contact, and apply Clip Motor Overrides only during the part of the motion that should affect movement. ## Speed Curve Practical Guide Speed Curve controls playback speed over normalized clip progress. * X is normalized time from 0 to 1. * Y is playback speed multiplier. * The default curve is flat: 1 at the start and 1 at the end. * When Use Speed Curve is off, the track plays with a multiplier of 1. * Very low Y values are clamped by the Flow Core Settings minimum multiplier so playback does not stall completely. Speed Curve changes the animation clock. It does not directly change Character Move Speed. If the character should physically move slower, faster, jump higher, or stop moving, use Motor Overrides or Clip Motor Overrides. Useful patterns: * Slow wind-up: start below 1, then rise toward 1 before the action releases. * Impact hold: dip the curve around the hit moment to make contact feel heavier. * Quick release: rise above 1 after a Marker so the recovery does not feel sluggish. * Landing recovery: slow the first part of the landing, then return to 1. * Charge release: keep the charge readable, then speed up the release segment. Markers are placed by normalized time. Speed Curve changes when that normalized time is reached in real seconds, but it does not move the Marker's normalized position. ## Clip Motor Overrides Practical Guide Clip Motor Overrides are track-level movement and control overrides. They are useful when a movement rule should happen only during a specific part of a clip. To make a Clip Motor Override active: * Enable the Clip Motor Overrides section. * Enable the specific field's Override toggle. * Set the field value. * For float fields, adjust the Multiplier Curve when the value should change over normalized time. Float fields use `Value * Multiplier Curve` at the current normalized time: * Move Speed changes traversal speed. * Rotation Speed changes turning speed. * Acceleration changes how quickly movement reaches speed. * Deceleration changes how quickly movement stops. * Air Drag changes airborne damping. * Gravity changes fall pull. * Jump Force changes jump impulse. Bool fields use the configured value while the override participates: * Can Move allows or blocks movement. * Can Jump allows or blocks jump requests. Use Clip Motor Overrides when timing matters inside a clip: lock Can Move during a hit frame, increase Gravity during a fall pose, reduce Move Speed during a reload step, or add a short speed burst after a dodge release. Asset-level Motor Overrides are for the whole State or Gesture. Clip Motor Overrides are for a specific clip track and can change over normalized time. ## Why Marker Matters Marker is useful because it treats animation timing as authored gameplay data. The animation clip owns when something should happen, while Flow owns what happens. This separation keeps graph logic reusable. A footstep graph can react to `LeftFoot` and `RightFoot` across different clips. A pickup graph can react to a custom `grab` Marker on many Gestures. A combat graph can react to a `hit` Marker without hardcoding frame numbers into the graph. Marker also remains stable during blending. A Marker can use Disabled, Default, or Custom cooldown behavior. Default cooldown uses the project setting. Custom cooldown uses the marker's own seconds value. The cooldown key follows marker meaning: non-Custom limbs are keyed by limb, and Custom markers are keyed by Id. ## Practical Scenarios Footstep effects: * Add `LeftFoot` and `RightFoot` Markers to locomotion clips. * Route Marker events to a graph that checks the limb and plays surface feedback. * Use Default cooldown when blended clips can cross foot contact timing close together. Pickup action: * Create a `Gesture` with a hand AvatarMask or full-body mask. * Add a custom Marker Id such as `grab`. * In the Marker event graph, attach or show the object when the hand reaches it. Attack window: * Add a custom Marker Id such as `hit`. * Use a Gesture tag such as `Attack`. * Use conflict policy to stop or keep overlapping attack Gestures according to the design. Movement lock: * Use State or Gesture motor overrides to disable movement or jump during a controlled animation. * Release the lock through Exit or completion rather than a guessed timer. ## Design Levers Movement: * Move speed changes traversal feel. * Acceleration changes responsiveness. * Deceleration changes stopping behavior. * Air drag and gravity change fall readability. * Can Move and Can Jump decide whether animation should temporarily lock input or instructions. Animation: * Blend In softens entry. * Blend Out softens exit. * Weight changes visibility of a layer. * Speed Curve changes timing over normalized clip progress. * AvatarMask limits which bones a State or Gesture affects. Gesture conflict: * Stop None allows overlap. * Stop Same Tag keeps only one action from a group. * Stop Same Mask avoids two actions fighting over the same body region. * Stop All makes the new Gesture exclusive. Marker: * Normalized Time defines when the event fires. * Limb gives common body semantics. * Custom Id gives designer-defined semantics. * Cooldown avoids duplicate semantic events during blending. ## Development Tips * Use State for what the character is doing over time. Use Gesture for what the character does briefly. * Put gameplay timing into Markers when the timing belongs to animation. * Use custom Marker Ids for design concepts, not clip names. * Use Gesture tags for conflict groups such as `Attack`, `Interact`, or `Emote`. * Keep marker Id spelling consistent. A whitelist in settings makes authoring safer. * Prefer motor overrides on the State or Gesture that owns the restriction. * Use Speed Curve for animation timing. Use Motor Overrides when movement values must change. * Use Clip Motor Overrides when the movement rule belongs to one segment or one normalized-time window. * Test Marker chains with slow animation speed when debugging timing. ## Common Mistakes * Using a Wait node instead of a Marker for hand or foot timing. This drifts when animation speed changes. * Treating Speed Curve as Character Move Speed. It changes playback timing, not the movement value. * Editing Speed Curve but leaving Use Speed Curve disabled. * Enabling Clip Motor Overrides but not enabling any specific Override row. * Using asset-level Motor Overrides when the rule needs to change inside a clip. * Putting every short action into State. This makes layers harder to stop and reason about. * Putting every sustained pose into Gesture. This can leave the base State unclear. * Expecting the Alive flag to run death logic by itself. It is a state flag; graph logic decides consequences. * Expecting one Marker Id to mean different things in different assets. Reused Ids should mean the same design event. * Leaving cooldown disabled on blended footstep clips that can emit the same semantic contact close together. ## Related * [Flow Interaction](/flow-core-docs/documentation/gameplay-modules/flow-interaction.md) * [Character Interaction Catalog](/flow-core-docs/documentation/reference/character-interaction-catalog.md) * [Character and Interaction Runtime](/flow-core-docs/documentation/runtime-guide/character-interaction-runtime.md) * [Terminology](/flow-core-docs/documentation/reference/terminology.md) --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://flow-core.gitbook.io/flow-core-docs/documentation/gameplay-modules/flow-character.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.