Gameplay Systems — Horizon Engine Documentation

Jolt-powered

Physics

Physics runs on Jolt, stepped at a fixed timestep during play mode. Give an entity a Rigid Body (Static, Dynamic or Kinematic — with mass, friction and restitution) and optionally a Collider (Box, Sphere or Capsule; without one, a box is derived from the transform scale). A 2D-physics toggle routes bodies to a planar solver.

Triggers — a collider marked Is Trigger generates events without a collision response.
Character Controller — slope limit, step height, skin width, mass and gravity; scripts drive it with setVelocity and query isGrounded.
Raycasts — raycast(origin, direction, maxDistance) returns the closest hit with entity, point, normal and distance, from Lua, Python, HorizonCode and C++.
Collision callbacks — scripts receive onCollisionEnter / onCollisionExit (Lua) or on_collision_enter / on_collision_exit (Python) with the other entity's id, for solid contacts and triggers alike.

Listen

Audio

An Audio Source component references an audio asset and plays it with volume, pitch, loop and Play on Start. Enabling Spatial gives it 3D positioning with linear attenuation between an inner (full-volume) and outer (silence) range. The first Audio Listener in the scene — typically on the camera or player — receives the mix and sets the master volume.

Mixer buses — sources route to named buses (music, sfx, …); scripts set bus volumes at runtime (audio.setBusVolume).
Script playback — audio.play, audio.playAt (3D position), audio.stop / stopAll / isPlaying / setSoundPosition.
Formats — WAV import today, stored as PCM inside the asset.

Move

Animation

Skeletal meshes are skinned on the GPU (up to 128 joints, four weighted influences per vertex) and posed by a family of animator components — from a single looping clip to a full state machine. All animation systems tick in the editor too, so previews work without pressing Play.

Tool	Use it for
Animator	Playing one clip — speed, time, looping.
Animator Blend	Mixing two clips with a blend alpha (e.g. walk ↔ run).
Animator State Machine	Full character logic — see below.
Property Animator	Keyframed transform and material properties — cutscenes, moving platforms, pulsing materials.

Animator State Machine

A standalone asset edited on the shared graph canvas: states are nodes (each with an animation clip and a looping flag), transitions are links with a condition — a named float parameter compared against a threshold (greater / less / equal) — and a crossfade duration. The component on the entity references the asset and holds the live parameter values; gameplay code drives the parameters and the machine blends states automatically. One asset can drive any number of characters.

Skeletal Mesh editor

Double-click a skeletal mesh asset for a dedicated tab: the joint hierarchy as a tree, an orbit-camera preview with a Show Skeleton bone overlay, and an optional clip slot with play/pause and time scrubbing — inspect a rig without touching any scene.

Pathfinding

Navigation

Navigation is built on Recast/Detour. Add a Nav Mesh component, feed it the walkable geometry, tune the agent parameters (cell size/height, walkable height, climb, radius, max slope) and press Bake. A Show NavMesh toggle draws the baked mesh as a wireframe overlay in the viewport.

A Nav Agent component paths across the baked mesh: set its Target, Speed and Stop Distance — from the editor (Go/Stop buttons) or from gameplay code by writing the target position. The navigation system computes and follows the path automatically every frame.

Sparks

Particles

Particle systems are graph assets: create a Particle System in the Content Browser and double-click it for a node-graph editor with a live simulated preview. A fixed Emitter Output node collects the emitter parameters; value nodes (Const Float/Vec3/Color, Random Range, Add, Multiply, Lerp) feed its pins.

Emitter parameters	Meaning
Emit Rate · Max Particles · Looping	Spawn rate and pool size.
Lifetime Min/Max	Per-particle lifetime range.
Start/End Size · Start/End Color · Start/End Alpha	Interpolated over each particle's life.
Initial Velocity · Velocity Spread · Gravity	Motion model.
Collision · Restitution · Kill on Collision	Optional per-particle world collision (raycast-based bounce or despawn).
Mesh · Material	Optional mesh/material slots on the Output node for custom particle looks.

Attach the asset to an entity with the Particle System component. Rendering is GPU instanced — one batch per emitter — and on export the colour/alpha-over-life curves are baked into small per-backend shader snippets so packaged games evaluate them on the GPU.

Weather rain and snow use a separate camera-following simulation that runs fully on the GPU on capable backends — see Weather.

Control

Input

Input is asset-driven: instead of hard-coding key codes, you declare logical Input Actions and bind them in an Input Mapping Context.

Input Action — a named action with a value type: Button (pressed/released) or Axis (−1…1). The asset name is the action name (e.g. IA_Jump).
Input Mapping Context — binds keys to actions and key pairs (with scales) to axes.

In HorizonCode projects, Player Controller and Player Character classes are spawned automatically when play begins; each mapped action arrives as graph events — Input.<Action>.Pressed, Input.<Action>.Released and Input.<Action>.Axis — alongside BeginPlay and a per-frame Tick.

Scripts can also poll input directly: input.keyDown("Space"), input.mouseButton, input.mousePosition, input.mouseDelta, input.scrollDelta.