3D Free Grounder
Raycast-based grounder for standard 3D locomotion — detects ground contact with coyote time, applies manual gravity when airborne, switches to Slide mode on steep slopes.
Tag: Docs
3D Free Mover
Standard 3D locomotion — camera-relative movement and rotation driven by spring-damped physics, with optional slope slowdown.
Categories:
Action
The base class for triggerable actions — channel-based firing, completion broadcasting, and action chaining for lightweight behavior sequencing.
Categories:
Audio Manager
Master audio controller – engine initialization, mixing bus routing, event library loading, and score playback coordination.
Categories:
Change Logs
Version changelogs for all GS_Play gems and documentation.
Categories:
Common Enums
Shared enumeration types used across the GS_Play framework — CurveType for easing curve selection and BooleanConditions for condition evaluation.
Categories:
Dialogue Manager
Full API reference for GS_DialogueManagerComponent — dialogue database management, performer marker registration, and the DialoguePerformerMarkerComponent.
Categories:
Game Manager
The top-level game lifecycle controller — startup sequencing, systemic navigation, standby mode, and debug support.
Categories:
List of Savers
Pre-built saver components included in GS_Core — ready-to-use entity persistence without writing code.
Categories:
GS_MotionTrack
Abstract base class for all animation tracks — fields, lifecycle, and virtual methods for domain extension.
Movement
The complete movement subsystem — movers, grounders, movement influence, and the movement profile asset for configuring unit locomotion.
Categories:
Mover Context
The central movement hub — transforms raw input into camera-relative and ground-projected vectors, manages mode switching, context states, and movement profiles.
Categories:
Options Manager
The singleton options controller — holds the active Input Profile and provides runtime configuration data to game systems.
Categories:
Performer Manager & Skin Slots
Performer manager lifecycle, skin slot system for modular character appearance, and config profile assets.
Categories:
Pulse Types
Built-in pulse types for the Pulsor interaction system.
Categories:
Pulsors
Physics-based pulse emitter and reactor system — extensible typed interactions via polymorphic PulseType and ReactorType classes.
Categories:
Save Manager
The central save/load controller — manages save files, triggers global persistence events, and provides data access for all savers.
Categories:
Stage Manager
The singleton level controller — manages a list of stages, handles level loading/unloading, and coordinates staged startup with the Stage Data component.
Categories:
Targeting Handler
Central targeting processor — receives target registrations from sensory fields, selects best interact target, and manages cursor feedback.
Categories:
Time Manager
World clock management, time-of-day control, day/night cycle detection, and per-tick time notifications.
Categories:
Trigger Sensors
Trigger sensor component and sensor types — condition evaluation objects for physics, interact, and record-based world trigger activation.
Categories:
Typewriter
Full API reference for the TypewriterComponent — character-by-character text reveal with configurable speed, force-complete, and notification events.
Categories:
UI Manager
The singleton manager that owns all loaded UI canvases, maintains a global focus stack, and drives the startup focus sequence.
Categories:
Understanding GS_Play
What is GS_Play and what does it do?
Categories:
Unit Manager
The central manager for unit lifecycle — spawning, registration, standby coordination, and unit tracking across the game session.
Categories:
Environment System
Runtime system component that drives the world clock tick and handles GS_EnvironmentRequestBus queries.
Categories:
Input Reactor
Base and concrete reactor components — convert unit input state into pressed/held/released events or axis changes for movement and actions.
Categories:
Movers
Mover base class and concrete mover components — translate MoverContext input into physics-based unit motion via named mode activation.
Categories:
SensorType_Record
Record-based sensor type — fires when a named RecordKeeper entry reaches a configured value.
Categories:
Savers
The base class for entity-level save handlers — override BuildSaveData() and ProcessLoad() to persist any component data automatically.
Categories:
Slide Mover
Slope-sliding locomotion — automatically activated when slope exceeds maxWalkAngle, drives the unit down the slope via spring-damped physics with optional input resistance and automatic recovery.
Categories:
Stage Data
The per-level anchor component — holds stage configuration, NavMesh references, and runs the level’s staged activation sequence.
Categories:
Unit Controllers
The controller-unit possession model — base controller, player controller, and AI controller components for driving unit behavior.
Categories:
Grounders
Grounder base class and concrete grounder components — detect ground contact, compute ground normals and slope data, and drive mode switching on the MoverContext.
Categories:
Input Data
The decoupled input pipeline — reading hardware events on the controller, storing state on the unit, and reacting to state changes through reactor components.
Categories:
Record Keeper
Lightweight key-value progression tracking — store and retrieve named integer records without writing a custom saver.
Categories:
Targeting
Target detection, selection, and cursor management — scanning, filtering, and selecting entities based on proximity and sensory fields.
Categories:
Senses & Targeting Fields
Physics-based detection volumes for the targeting system — interaction fields and sensory detection.
Categories:
Input Profiles
Data assets for input binding configuration — map key bindings to named events, organized into toggleable groups for advanced runtime input control.
Categories:
Page Navigation
The core single-tier navigation component – root canvas registration, nested child page management, focus push/pop stacks, and show/hide transitions.
Categories:
Player Input Reader
Controller-side component that reads hardware input events and routes them to the possessed unit’s input data component.
Categories:
Units
What makes an entity a unit — the GS_UnitComponent, entity configuration, collision setup, and links to movement subsystems.
Categories:
Buttons
Enhanced button component with motion-driven hover and select animations, built on top of LyShine interactable notifications.
Categories:
GS_InputOptions
The input subsystem — Input Profiles for grouped event-to-binding mappings and Input Readers for processing input in gameplay.
Categories:
Locomotion
Velocity-driven animation hooks and prefab animation asset reloading for performer entities.
Categories:
Reactor Types
Built-in reactor types for the Pulsor interaction system.
Categories:
Targets
Target component types — base target markers and specialized interact targets that make entities detectable by the targeting system.
Categories:
World Triggers
Trigger sensor and world trigger system — event-driven world state changes via composable polymorphic type objects on two container components.
Categories:
World Triggers
World trigger component and trigger types — response execution objects that change world state when a trigger sensor fires.
Categories:
Cinematics Manager
Full API reference for GS_CinematicsManagerComponent — cinematic lifecycle control, stage marker registration, and the CinematicStageMarkerComponent.
Categories:
UI Animation
GS_Motion extension with eight LyShine-specific animation tracks, data-driven .uiam assets, and a standalone playback component.
Categories:
UI Interaction
Button animations and input interception — motion-driven hover/select states and input channel management for focused UI canvases.
Categories:
Interact Input Reader
Categories:
UI Input
Input interception for UI canvases – captures and redirects input events to prevent gameplay propagation while a UI is focused.
Categories:
Widgets
Standalone UI widget components — load screens, pause menus, and other self-contained UI elements that operate outside the page navigation model.
Categories:
Audio Change Log
GS_Audio version changelog.
Categories:
Audio Events
Event-based sound playback – audio event definitions, clip pool selection, spatialization, and event library assets.
Categories:
Audio Manager
How to work with the GS_Play Audio Manager — engine initialization, bus routing, and master control.
Categories:
Cam Manager
How to work with the GS_PhantomCam manager — enabling and disabling the camera system, and responding to active camera changes.
Categories:
Cinematics Manager
How to coordinate cinematic sequences in GS_Play — beginning and ending cutscenes, registering stage markers, and reacting to cinematic events from scripts.
Categories:
GS_Core
The foundation gem for the GS_Play framework — game lifecycle, save system, stage management, input, actions, and utility libraries.
Categories:
GS_Core
The foundation gem for the GS_Play framework — game lifecycle, save system, stage management, input, actions, motion animation system, and utility libraries.
Categories:
Feature List
Quick index of all GS_Play Features.
Categories:
Feedback System
Feedback motion tracks, FeedbackEmitter component, and FeedbackMotionAsset reference.
Feedback System
How to work with GS_Play feedback motions — transform and material animation effects for game feel.
GS_Managers
The game lifecycle management system — startup sequencing, systemic navigation, and the extensible manager pattern.
Categories:
Managers System
How to work with the GS_Play manager system — startup events, game navigation, and standby mode from scripts.
Categories:
Head Tracking
Procedural head look-at targeting — drives bone orientation toward a world-space target with configurable angle limits and damping.
Categories:
Input Reader
Component that reads input through the active profile and fires named gameplay events, with runtime group toggling and input claiming.
Categories:
Inventory
How to work with GS_Play inventory — container-based item storage with slots and stacking.
Categories:
Manager
The base class for all game system managers — automatic two-stage initialization and lifecycle integration with the Game Manager.
Categories:
GS_Motion
The playback engine — ticks through tracks, computes per-track progress windows, and manages motion lifecycle.
Performer Manager
How to work with the GS_Play Performer Manager — performer registration and lifecycle.
Categories:
Project Quick Start
Easy set up to get started.
Categories:
Pulsors
How to work with the GS_Interaction Pulsor system — emitting typed physics-based pulse events and reacting to them from scripts.
Categories:
Simple Project Setup
Easy set up to get started.
Categories:
Status Effects
How to work with GS_Play status effects — timed modifiers that alter entity stats or behavior.
Categories:
Time Manager
How to work with the GS_Play Time Manager — world time, day/night cycles, and time passage control.
Categories:
UI Manager
How to work with the GS_Play UI Manager — canvas lifecycle, focus stack, and cross-canvas navigation.
Categories:
Unit Manager
How to work with the GS_Unit manager — spawning units, registering player controllers, and coordinating standby across all controlled characters.
Avatar Performer
How to work with GS_Play avatar performers.
Avatar Performer
How to work with GS_Play avatar performers — 3D pipeline, animation, equipment.
Babble
Audio babble synchronized to dialogue typewriter output — procedural vocalization tones keyed to speaker identity.
Categories:
Cinematics Change Log
GS_Cinematics version changelog.
Categories:
Serialization Helpers
Three reflection helpers — single-include headers for common and asset serialization, and a generic asset handler template for custom asset types.
Categories:
GS_AI
Foundation scaffold for AI-driven entity behavior in the GS_Play framework.
Categories:
GS_AI
Foundation scaffold for AI controller integration in GS_Play projects. Provides the system component and extension point for custom AI controller gems.
Categories:
Audio Events
How to work with GS_Play audio events — data-driven sound playback with pooling, spatialization, and concurrency control.
Categories:
Controllers
How to work with GS_Unit controllers — the possession model, player and AI controller setup, and switching control at runtime.
Categories:
Curves
40+ easing curve functions for smooth animation and interpolation — organized by family with a CurveType enum for data-driven selection.
Categories:
Dialogue System
How to author and play back branching dialogue in GS_Play — dialogue databases, node types, conditions, effects, and the runtime sequencer.
Categories:
Environment Change Log
GS_Environment version changelog.
Categories:
Equipment
How to work with GS_Play equipment — typed equipment slots with visual integration via GS_Performer skin slots.
GS_Save
The persistence system — save files, load data, and track progression with managers, savers, and record keepers.
Categories:
Save System
How to work with the GS_Play save system — saving game state, loading saves, and tracking progression with the Record Keeper.
Mixing & Effects
Named audio mixing buses with configurable effects chains, environmental influence, and 9 built-in audio filter types.
Categories:
GS_MotionComposite
Runtime deep-copy motion instance with proxy entity overrides — created from GS_MotionAsset for per-entity playback.
Mover Context
Movement state coordinator for GS_Unit — manages movement modes, context states, input axis transformation, and movement profile priority.
Page Navigation
How to work with GS_Play page navigation — single-tier page hierarchy, focus management, and transitions.
Categories:
Patterns
Patterns associated with the GS_Play featuresets.
Phantom Cameras
How to configure and use GS_PhantomCameraComponent — priority, targets, data fields, and the available camera behavior types.
Categories:
Skin Slots
How to work with GS_Play skin slots — modular character appearance with swappable actor meshes and materials.
Sky Configuration
How to work with GS_Play sky configuration — data-driven sky color settings for time-of-day transitions.
Categories:
Targeting
How to work with the GS_Interaction Targeting system — selecting interactable entities, managing cursor display, and handling interaction input from scripts.
Categories:
Templates List
All ClassWizard templates for GS_Play gems — one-stop reference for generating extension classes across every gem.
GS_Audio
Audio management, event-based sound, music scoring, mixing, and Klatt voice synthesis for the GS_Play framework.
Categories:
GS_Audio
Audio management, event-based sound playback, multi-layer music scoring, mixing buses with effects, and Klatt formant voice synthesis with 3D spatial audio.
Categories:
Best Practices
Conventions and habits that make working with GS_Play faster and less frustrating.
Categories:
Core Change Log
Changelog.
Categories:
Dialogue Data Structure
Full reference for the DialogueDatabase asset, dialogue sequences, node types, conditions, effects, localization types, and the extension guide for custom polymorphic types.
Categories:
Dialogue System
Architecture overview of the GS_Cinematics dialogue system — sequencing, data structures, UI display, actors, and extensible conditions, effects, and performances.
Categories:
Performers
Billboard and 3D character entity types — PaperFacingHandlerComponent for 2.5D rendering and the Avatar pipeline for rigged EMotionFX characters.
Springs
Spring-damper functions for physically-grounded value interpolation — smooth following, overshoot, and settling for floats, vectors, and quaternions.
Categories:
Buttons
Redirected — button documentation is now part of UI Interaction.
Categories:
Cam Core
How to work with GS_CamCoreComponent — the rendering bridge that reads the dominant Phantom Camera each frame and drives the real camera entity.
Categories:
GS_Cinematics
Node-graph dialogue sequences, cinematic stage management, polymorphic performances, and world-space UI with typewriter and audio babble.
Categories:
GS_Cinematics
Dialogue graphs, cinematic staging, UI display, localization, and extensible condition/effect/performance systems for authored narrative experiences.
Categories:
Dialogue UI
How to display dialogue text, player choices, and typewriter effects in GS_Play — screen-space and world-space UI components and the bridge that connects them to the sequencer.
Categories:
Gradients
Multi-stop gradient types for sampling color, float, and vector values over a normalized range — used by motion tracks and feedback effects.
Categories:
GS_StageManager
The level navigation system — handles loading, unloading, and staged startup of game levels with exit point traversal.
Categories:
Stage Management
How to work with the GS_Play stage management system — level loading, stage transitions, exit points, and stage data.
Input Data
How to work with the GS_Unit input pipeline — reading player input, converting keyboard and joystick signals into movement vectors, and chaining input reactors.
Interaction Change Log
GS_Interaction version changelog.
Categories:
Mixing & Effects
How to work with GS_Play audio mixing — named buses, effects chains, and environmental audio influence.
Categories:
GS_MotionAsset
Abstract base for motion data assets — holds track definitions and creates runtime composites.
Paper Performer
Billboard-based character rendering — paper facing handlers that orient sprite quads toward the camera.
Categories:
Paper Performer
How to work with GS_Play paper performers — billboard-style 2.5D character rendering with camera-aware facing.
Performers
The character rendering entity types in GS_Performer — billboard 2.5D paper performers and fully-rigged 3D avatar performers.
Score Arrangement
Multi-layer musical score system for dynamic music – tempo, time signatures, fade control, and layer selection.
Categories:
UI Interaction
How to work with GS_Play UI interaction — motion-based button animations and input interception for focused canvases.
Categories:
World Triggers
How to work with the GS_Interaction World Trigger system — configuring sensor types and trigger types to create event-driven world responses without scripting.
Categories:
Juice Change Log
GS_Juice version changelog.
Categories:
Blend Profiles
How to create and use GS_PhantomCamBlendProfile assets to control transition timing, easing, and interpolation between Phantom Cameras.
Categories:
Entity Helpers
Utility functions for finding entities in the scene by name — runtime entity lookup without maintaining manual references.
Categories:
GS_Environment
World time and environmental systems for GS_Play — time-of-day progression, day/night cycle management, and data-driven sky configuration.
Categories:
GS_Environment
Time of day progression, day/night cycle management, and sky colour configuration for GS_Play projects.
Categories:
GS_Motion
Track-based animation and tween system — abstract base classes for motions, tracks, composites, assets, and proxies with a domain extension pattern.
Options & Input
How to work with the GS_Play options system — input profiles, input groups, and runtime binding management.
Klatt Voice Synthesis
Custom text-to-speech via Klatt formant synthesis with 3D spatial audio, phoneme mapping, and voice profiling.
Categories:
Locomotion
How to work with GS_Play velocity locomotion — automatic animation parameter driving from entity velocity.
GS_MotionProxy
Serialized struct for track-to-entity redirection — allows designers to target named tracks at different entities.
Movement
How to work with GS_Unit movement — mover types, mover context, grounders, movement profiles, and influence fields.
Performances
How to move and reposition actors during dialogue in GS_Play — the polymorphic performance system, built-in movement types, and async completion.
Categories:
Performer Change Log
GS_Performer version changelog.
Categories:
Score Arrangement
How to work with GS_Play score arrangements — multi-layer dynamic music with configurable time signatures and layer control.
UI Animation
How to work with GS_Play UI animations — motion-based LyShine property animation for pages, buttons, and standalone components.
Units
What makes an entity a unit — the GS_UnitComponent, entity configuration, collision setup, possession, standby, and movement.
PhantomCam Change Log
GS_PhantomCam version changelog.
Categories:
Widgets
How to work with GS_Play UI widgets — load screens, pause menus, and other standalone UI components.
Categories:
Angle Helpers
Angle and orientation math — sector mapping, yaw extraction, quaternion conversion, and hysteresis for directional classification.
Categories:
Actions System
How to work with the GS_Play action system — triggerable, composable behaviors that fire from scripts, triggers, or code.
GS_Options
The configuration system — input profiles, input readers, and runtime settings management for gameplay and accessibility.
Categories:
Influence Fields
How to use GlobalCameraInfluenceComponent and CameraInfluenceFieldComponent to apply dynamic camera modifications globally or within spatial zones.
Categories:
GS_Interaction
Physics-based pulse events, proximity targeting with cursors, and data-driven world trigger zones.
Categories:
GS_Interaction
Entity interaction systems — physics-based pulse events, targeting and cursor management, and extensible world trigger actions.
Categories:
Klatt Voice Synthesis
How to work with GS_Play Klatt voice synthesis — text-to-speech with 3D spatial audio, voice profiles, and inline parameter control.
Lessons
Index of Lesson Guides
Performer Features
Universal capabilities for any performer entity — procedural head tracking, typewriter-synchronized babble, and mesh swapping.
Powerful Utilities
Powerful Utilities associated with the GS_Play featuresets.
Systems
Core framework systems — the GS_Motion track-based animation engine and the GS_Actions triggerable behavior system.
Categories:
Systems
Core framework systems — the GS_Actions triggerable behavior system and the GS_Motion track-based animation engine.
Categories:
UI Change Log
GS_UI version changelog.
Categories:
Motion System
How to work with GS_Motion — the track-based animation and tween system that powers UI transitions, feedback effects, and custom animations.
GS_Juice
Game feel and feedback motion system — screen shake, bounce, flash, and material effects driven by the GS_Motion engine.
GS_Juice
Game feel and feedback motion system — GS_Motion extension with transform and material tracks for visual feedback effects.
Spline Helpers
Utility functions for O3DE spline queries — closest point, fraction, and local/world space conversion by entity ID.
Categories:
Unit Change Log
GS_Unit version changelog.
Categories:
GS_Item
Inventory and equipment systems for GS_Play — container-based item storage, slot management, stacking, and visual equipment integration with GS_Performer.
Categories:
GS_Item
Data-driven inventory containers and equipment slot management for collectible, usable, and equippable items in GS_Play projects.
Categories:
Performer Features
Universal capabilities that extend any performer type — modular equipment via skin slots, and velocity-driven animation via locomotion.
Physics Trigger Volume
Base class and component for physics trigger and collision handling — inherit to create interactive volumes with enter, exit, and hold callbacks.
Categories:
Utilities
General-purpose components and math helpers — physics triggers, easing curves, spring dampers, gradients, splines, and more.
GS_Performer
Character rendering and animation for GS_Play — modular skin slots, billboard 2.5D rendering, and velocity-driven locomotion parameters.
GS_Performer
Modular character rendering via skin slots, paper billboard performers, velocity-driven locomotion, head tracking, and audio babble integration.
Categories:
Dialogue Sequencer
Full API reference for the DialogueSequencerComponent and DialogueUIBridgeComponent — runtime dialogue graph traversal, node processing, and UI routing.
Categories:
GS_PhantomCam
Priority-based virtual camera management with blend profiles, multiple behavior types, and spatial influence fields.
Categories:
GS_PhantomCam
Priority-based virtual camera management — phantom cameras, blend profiles, and spatial camera influence fields.
Categories:
GS_Stats
RPG stat definitions, stat containers, and a polymorphic status effect system for character and entity attribute management.
Categories:
GS_Stats
RPG statistics and status effect systems for GS_Play — timed and permanent modifiers that alter entity stats and drive reactive gameplay behavior.
GS_Complete
Cross-gem integration layer — reference components that combine multiple GS_Play gems for camera-aware performers, cinematic controllers, and dialogue UI selection.
Categories:
Dialogue UI
Full API reference for all dialogue UI components — screen-space and world-space dialogue display, selection menus, typewriter text reveal, and babble audio.
Categories:
GS_UI
The complete UI framework for GS_Play — canvas lifecycle management, single-tier page navigation, enhanced buttons, data-driven animation, and input interception.
Categories:
GS_UI
The complete UI framework — single-tier page navigation, motion-based animations, enhanced buttons, input interception, load screens, and pause menus.
Categories:
Utilities
A collection of utility libraries — easing curves, spring dampers, physics trigger volumes, gradients, and entity helpers.
Categories:
Weighted Random
Weighted random selection — pick a key from a weighted map with probability proportional to each entry’s float weight.
Categories:
GS_Unit
The character and entity control system — unit registration, player and AI controllers, input processing, and modular movement.
GS_Unit
Character and entity control — unit lifecycle, player and AI controllers, input processing, movement, and grounding.
GS_Actions
A utility system for triggerable single-purpose actions — fire discrete behaviors from any system without recoding logic for each component.
Categories:
Dialogue Actors
Full API reference for DialoguePerformerMarkerComponent, ActorDefinition data model, and the performer registration and lookup system.
Categories:
Effects
Full API reference for the DialogueEffect base class and built-in effect types — SetRecords and ToggleEntitiesActive.
Categories:
Performances
Full API reference for the DialoguePerformance base class and built-in performance types — MoveTo, PathTo, and RepositionPerformer.
Categories:
Learn
Lessons for quick, or extended learning.
Categories:
Glossary
Descriptions and resources around common terminology used in the documentation.
Categories:
Third Party Implementations
Integration guides for third-party audio systems with GS_Audio.
Categories:
Third Party Implementations
Integration guides for third-party cross-gem components with GS_Complete.
Categories:
Third Party Implementations
Integration guides for third-party feedback systems with GS_Juice.
Categories:
3rd Party API
API for 3rd party support.
Categories:
Templates
ClassWizard templates for GS_Cinematics — dialogue conditions, effects, and performance objects for the dialogue sequencer.
Categories:
Templates
ClassWizard templates for GS_Core — manager components, save system savers, input readers, and physics trigger volumes.
Categories:
Templates
ClassWizard templates for GS_Interaction — Pulsor pulses, reactors, world triggers, and trigger sensors.
Categories:
Templates
ClassWizard templates for GS_Juice — custom feedback motion tracks for world-space game-feel effects.
Categories:
Templates
ClassWizard templates for GS_PhantomCam — custom phantom camera behaviour components.
Categories:
Templates
ClassWizard templates for GS_UI — custom UI animation motion tracks.
Categories:
Templates
ClassWizard templates for GS_Unit — unit controllers, input reactors, mover components, and grounder components.
Categories:
Links
Useful links.
Categories:
Video Tutorials
Index of Video based tutorials.
Agentic Guidelines
Agent bootstrap document for GS_Play framework contextualization. Optimized for LLM parsing, not human reading.
Docs Change Log
Updated changelog.
Categories:
Core Actions
Pre-built actions included in GS_Core — ready-to-use triggerable behaviors for common game functionality.
Categories:
Equipment
Categories:
Inventory
Categories:
Status Effect
The core gem for the GS_Play framework.