just_game_engine library

Just Game Engine: a 2D game engine for Flutter.

This library is the engine and what hosts it in an app: Engine with its subsystems and EngineContext; the ECS (World, Entity, Component, System) with the engine's own components and systems; scene loading (SceneLoader); level maps, sprites and animator graphs, timelines, virtual cameras, physics, particles, effects, audio, input, localization, dialogue and subtitles; and GameWidget, which shows a game in a Flutter app, with GameLayers for widgets drawn over it.

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  final engine = Engine(
    config: const EngineConfig(defaultSystems: DefaultSystems.all),
  );
  await engine.initialize(); // before the first frame
  engine.world.createEntityWithComponents([
    TransformComponent(),
    CircleComponent(radius: 32),
  ]);
  engine.start();
  runApp(MaterialApp(home: GameWidget(engine: engine)));
}

Not in this library:

Ready-made screen widgets — dialogue boxes, subtitles, localized text, camera zoom controls, on-screen touch controls, rebinding lists — are in package:just_game_engine/widgets.dart.
Of the packages the engine is built on, only what a game uses through the engine is re-exported: the run-time input API of just_inputs, the math types of just_dart, the memory diagnostics of just_memory, the audio types of just_audio_engine, the physics types of just_physics_engine, the saved formats of just_game_engine_formats and the Signal and Computed of just_signals. For anything else, import the package.
Achievements, sign-in, leaderboards, currency, inventory and ads are in the package just_game_services, as opt-in EngineServices.

Classes

Aabb3: A mutable axis-aligned box [min, max].
ActivationTrack: The bound entity is active inside the blocks and inactive outside them.
ActiveCameraBlend: A blend in progress.
AnimatedSpriteParticleRenderer: Renders particles as animated sprites, advancing through frames over the particle's lifetime.
AnimationEvent: A named time marker within an animation.
AnimationTarget: Something an AnimatorSystem plays a graph's states on: a 3-D model's skeleton, or a kit's own kind of animation.
AnimationTargets: The AnimationTargets of one engine context, tried in the order they were registered. Register a package's own from its ContextExtension.
AnimatorBindings: The sources a graph's parameter can be bound to, by id.
AnimatorBlendMotion: One clip of a blend tree, and where it sits.
AnimatorBlendTree: A state that plays several clips at once, weighted by parameters: walk to run by speed (1-D), or strafing in eight directions (2-D). A target that can't blend (a sprite) plays the heaviest motion.
AnimatorComponent: Runs an animation state machine on this entity: the graph decides which clip the entity's SpriteAnimationComponent plays.
AnimatorCondition: One test a transition makes: speed > 10, grounded == true. For a trigger the op and value are ignored — it holds while the trigger is set.
AnimatorGraph: A whole state machine. Immutable: an editor replaces it.
AnimatorParameter: A named value transitions are conditioned on.
AnimatorState: A state: one clip, playing.
AnimatorStateChange: A state change, for whoever wants to react: sound, particles, a debugger.
AnimatorSystem: Runs every AnimatorComponent: fills its bound parameters, takes the transition that should fire, and tells the entity's SpriteAnimationComponent which clip to play — or, for an entity without one, the first of the context's AnimationTargets that drives it (a 3-D model's skeleton).
AnimatorTransition: A way from one state to another, taken when every condition holds.
Archetype: An Archetype groups all entities that share the exact same set of component types. Components of each type are stored in contiguous lists (one "column" per type), giving systems cache-friendly iteration.
ArenaStats
AsepriteAtlasParser: Parses Aseprite's JSON export format (both array and hash frames).
Asset: Base class for all assets
AssetLoader: Base asset loader interface
AssetManager: Main asset manager class
AssetRefFieldType: A path into the asset bundle. Stored as text; the editor offers a picker.
AssetScope: A scoped handle for reference-counted asset management.
AtlasAnimationClip: A named, reusable sequence of AtlasFrames that forms one animation (e.g. "run", "idle", "jump_rise").
AtlasAsset: An Asset wrapping a fully-parsed and texture-loaded SpriteAtlas.
AtlasAssetLoader: AssetLoader that creates AtlasAsset instances.
AtlasFrame: A single frame within an AtlasAnimationClip, pairing a SpriteRegion name with how long that frame is displayed.
AtlasParser: Common interface for all sprite atlas parsers.
AtlasRegionSprite: A Sprite showing one SpriteRegion of an atlas the way its exporter packed it.
AttractorForce: Point attractor — pulls particles toward center.
Audio3DListener: Where the listener is and which way it faces: its position, the direction it looks in, and its up.
Audio3DPosition: A point, or a direction, in world space, for spatial audio.
AudioAsset: Audio asset (placeholder for audio data)
AudioAssetLoader: Audio asset loader
AudioBackend: Abstract contract every platform backend must implement.
AudioBus: A named mixer bus that aggregates voices from a logical channel.
AudioBusGraph: Owns all AudioBus instances and resolves effective volume for a channel.
AudioClip: A single audio asset that can be loaded, played, paused, and stopped.
AudioEffect: Parameter bag for a single DSP effect.
AudioEngine: Central audio facade for just_game_engine.
AudioListenerComponent: Marks the entity that hears: 3-D sounds are panned and faded for where it is and which way it faces.
AudioSourceComponent: Component describing an audio source attached to an entity.
AudioSpatial: How a 3-D sound is heard from the listener: how it fades with distance, how much moving changes its pitch, and how far it is muffled.
AudioSpatialMix: What one 3-D sound sounds like from the listener, as AudioSpatial.mix works it out.
AudioStream: Streams a large audio file without loading the whole buffer into memory.
AudioStreamComponent: Component that streams a large audio file without buffering it entirely.
AudioSystem: System that drives audio playback from ECS entities.
AudioTrack: Starts sounds: TimelineBlock.value is the file, TimelineBlock.amount the volume. A sound starts when time passes the block's start going forwards; scrubbing in an editor stays quiet.
AutoSyncSystem: A system that automatically syncs signals after each frame.
BatchableSprite: Marker interface for renderables that can be GPU-batched.
BinaryAsset: Binary asset
BinaryAssetLoader: Binary asset loader
BindingDisplay: Turns bindings into what a player reads: Space, W/A/S/D, Shift + E, Ⓐ.
BindingOverrides: A player's own bindings: binding (or part) id → control path. Stored apart from the asset, so the game's defaults are never touched.
BlendListManager: Plays its children as a sequence of held shots.
BlockTrack: A track of TimelineBlocks.
BodyPair: Pair of physics bodies for collision checking.
BooleanFieldType: A bool, saved as JSON true / false and read back as it is.
BoundaryForce: Restricts particles to an axis-aligned rectangle.
BoundarySystem: Boundary system - Keeps entities within bounds
Box2DJoint: Wraps a native Box2D joint and implements JointConstraint as a no-op (Box2D solves the constraint internally each step).
Box2DPhysicsEngine: Box2D v3.2 physics engine adapter exposing the same duck-typed API as the pure-Dart PhysicsEngine.
BuiltInTilesets: The tilesets that come with the engine, by their builtin: path.
BundleSpriteAssetLoader: Loads through an asset manager — the engine's (context.assets) — which caches by path. With none given it keeps an AssetManager of its own.
CacheBudgetStats
CacheInputOverrideStore: Players' own bindings, kept beside the engine's cache — a file on desktop and mobile, local storage on the web.
CacheManager: Manages caching of various game resources.
Camera: The output camera: a view of the world and the maths to draw through it.
CameraBlend: How long a change of shot takes, and how it eases.
CameraBlendListComponent: Manager: plays its children as a sequence of shots — a cutscene.
CameraBlendRule: A blend for one pair of cameras, by entity name. '*' matches any.
CameraBlendStep: One shot of a blend list.
CameraBlendTable: Per-pair blends, over the brain's default.
CameraBoundsComponent: A rectangle a camera can be confined to, centred on its entity.
CameraBoundsSource: Something that can say where a camera is allowed to look.
CameraBrain: Decides what the camera shows.
CameraBrainSystem: Evaluates the camera brain once per ECS update — or, with the brain's updateMode set to CameraUpdateMode.frame, once per rendered frame (it is a FrameSystem), following targets between updates.
CameraChildBlender: Blends from whichever child a manager was showing to the one it shows now. Kept in the manager's memory, so it starts fresh when the manager does.
CameraConfinerComponent: Keeps a virtual camera's view — not just its centre — inside the bounds of the entity called boundsName.
CameraDefinitions: Definitions for the camera components: a virtual camera and the stages that shape its shot. One per component, so each is saved, inspected and added from the picker like any other.
CameraDollyComponent: Body: a camera that rides a path.
CameraEffect: Abstract base class for camera visual effects.
CameraEffectManager: Owns a list of CameraEffect instances and routes rendering calls each frame.
CameraFramingComponent: Frames a virtual camera's target on screen.
CameraGroupFramingComponent: Body: sets the lens so a followed target group fits the view.
CameraGroupMember: Who a target group keeps in shot: one entity, or every entity with a tag.
CameraImpulse: Something that happened in the world that a camera should feel.
CameraImpulseBus: The impulses in the air. Owned by the camera brain, which ages them once a frame; cameras with a listener read from it.
CameraImpulseListenerComponent: Makes a virtual camera feel the impulses emitted near it.
CameraImpulseSourceComponent: An authored impulse: what CameraBrain.emitImpulseFrom sends for this entity — a landing, an explosion, a door slamming.
CameraLens: A camera's lens: its projection and what it can see.
CameraManager<T extends Component>: Turns one component type into a camera made of child cameras.
CameraManagerContext: Everything a manager may look at while choosing among its children.
CameraManagerRegistry: Which manager runs for which component.
CameraMixerComponent: Manager: a weighted mix of its children, all at once.
CameraNoiseComponent: Continuous procedural motion on a virtual camera: the difference between a locked-off shot and one that feels held.
CameraNoiseProfile: A recipe for continuous camera motion, as layers of smooth noise.
CameraRegistries: The camera stages and managers an engine's brains run: one set per EngineContext (of), so a kit's ContextExtension can register its own once for every brain.
CameraRigMemory: What one virtual camera remembers between frames.
CameraShotTrack: Gives the shot to a virtual camera for a while: TimelineBlock.value is the camera entity's name, and its priority is raised by TimelineBlock.amount for the block's length. The camera brain blends to it and back as it does for any change of priority.
CameraStage<T extends Component>: One step of a virtual camera's pipeline, driven by one component type.
CameraStageContext: Everything a stage may look at while shaping one camera's state.
CameraStageRegistry: Which stage runs for which component.
CameraState: Where a camera is, how far it is zoomed, how it is turned and through what lens it looks.
CameraStateComponent: A named state a state-driven camera can read: 'grounded', 'falling', 'boss'. The game writes it; the camera follows it.
CameraStateDrivenComponent: Manager: shows the child mapped to the current state of another entity.
CameraSystem: Owns the output mainCamera and the brain that drives it.
CameraTargetGroupComponent: Turns its entity into the weighted centre of several others.
CameraTargetGroupSystem: Moves each target group's entity to the weighted centre of its members.
CameraTargetResolver: Resolves the EntityTargets cameras name to entities, once a frame.
CameraTriggerComponent: A rectangle, centred on its entity, that switches a virtual camera by whether a target is inside it.
CameraTriggerSystem: Switches virtual cameras by whether a target is inside a trigger.
CapsuleComponent: Capsule shape component.
CapsuleShape: A capsule collision shape — the Minkowski sum of a line segment and a circle.
ChainShape: A chain of connected line segments for complex terrain and loop-the-loops.
CharacterBody2D: A character gameplay moves rather than the simulation: it walks slopes up to maxSlopeAngle, climbs steps up to stepHeight, keeps to the floor going down, rides moving platforms, stands on one-way platforms and jumps up through them, and pushes dynamic bodies — like the 3-D CharacterBody3D, field for field. It needs no RigidBody2D or Collider2D: its shape is its own, centred on the entity (plus offset).
CheckpointActivatedEvent: Fired when a player entity touches and activates a checkpoint for the first time.
CheckpointComponent: Marks an entity as a checkpoint / respawn point.
CheckpointSystem: Checkpoint / respawn system.
ChildrenComponent: Children component - Tracks child entities
ChoiceOption: One option inside a ChoiceSetStatement.
ChoiceSetStatement: A set of player-selectable options at the same indentation level.
CircleComponent: Circle shape component.
CircleParticleRenderer: Renders each particle as a filled circle.
CircleRenderable: A circle of radius centred on the renderable's position, filled with fillColor and outlined in strokeColor when that is set; both colours are faded by opacity.
CircleShape: A circular collision shape.
Collider2D: The shape of its entity's RigidBody2D — or, without one, of a static body made for it. It follows the entity's scale. Set to ColliderShape2D.matchShape it takes the shape its entity is drawn as.
ColliderDebuggerSystem: Outlines every physics body (PhysicsBodyRefComponent) and every RaycastColliderComponent in color, above everything else (SystemPriorities.debug).
ColliderGeometry: The collider a Collider2D stands for, in its body's own space: what PhysicsSystem gives the simulation, what the debug outline draws, what an editor puts handles on.
CollisionDetector: Utility for manual broad-phase collision queries outside PhysicsEngine.
CollisionEnter2DEvent: Two bodies have begun touching.
CollisionExit2DEvent: Two bodies have stopped touching.
CollisionManifold: Contains information about a collision between two bodies.
CollisionShape: Base class for collision shapes.
CollisionStay2DEvent: Two bodies are still touching, each step after CollisionEnter2DEvent — only when PhysicsSystem.reportContactStay is on.
ColorFieldType: A Color, saved as its 32-bit ARGB value as a JSON int (0xAARRGGBB).
ColorTintEffect: Animates the Renderable.tint colour of an entity's RenderableComponent from a starting colour to to over durationTicks ticks.
CommandBuffer: A buffer that collects structural mutations (create, destroy, add/remove component) during system updates and applies them in a batch after iteration is complete — in the order they were queued, so removeComponent<Sprite>(e) then addComponent(e, newSprite) ends with the new sprite.
CommandStatement: A generic <<commandName arg1 arg2 …>> statement.
Component: Base class for all components
ComponentCodec<T extends Component>: Converts one component type to and from JSON.
ComponentDefinition<T extends Component>: Everything the engine and editor need to know about one component type, in one place: how to build it, what it persists, how it looks in an inspector, how big it is, and how it draws.
ComponentDefinitionRegistry: Every component the engine can save, load, inspect, size and draw, keyed by type name, alias and Dart type.
ComponentExtent: The size a component implies, and how to change it.
ComponentHints: How a component appears in an inspector and component picker.
ComponentPainter<T extends Component>: Draws a component that is not a RenderableComponent — text, a button, a progress bar, anything that renders itself from its own fields.
ComponentPainterPass: Draws every component whose ComponentDefinition carries a ComponentPainter, entity transform applied, ordered by ComponentPainter.layerOf.
ComponentSchema<T extends Component>: A component described as data: a type name, a factory, and its fields.
ComponentSignal<C extends Component, T>: A signal that wraps a component's property for reactive updates.
Computed<T>: A computed signal that derives its value from other signals.
ConditionalBranch: One arm of a ConditionalStatement.
ConditionalStatement: An <<if>> … <<elseif>> … <<else>> … <<endif>> block.
ConfinerStage: Finalize: keeps the whole view inside the named bounds.
ContextExtension: What a package teaches an engine: its component definitions, migrations, animator bindings, timeline track kinds, collision kinds and easings.
ContextResource: State a package keeps per context (see EngineContext.slot) that must be released with it.
CoreComponentSchemas: Schemas for the core components the editor has always saved in its descriptor shape ({type, customComponentId, fields}).
CoreDefinitions: Definitions for the core components whose save format predates definitions, one per built-in component.
CullStateComponent: Opt-in view-culling state, maintained each frame by ViewCullingSystem.
CustomPathParticleRenderer: Renders each particle as an arbitrary developer-provided Path.
CustomRenderable: A custom renderable that uses a callback for rendering
DecimalFieldType: A double, saved as a JSON number. Reading takes any number as a double and clamps it to the constraints' min and max.
DefaultSystems: Sets of DefaultSystems.
DelayEffect: A no-op effect that occupies durationTicks ticks without mutating any component. Use it as a spacer inside SequenceEffect.
DeterministicEffect: Abstract base for all deterministic tick-driven effects.
DialogueChoice: A single player choice after localization and condition evaluation have been applied.
DialogueCommandContext: Context passed to every DialogueCommandHandler.
DialogueCommandRegistry: Registry for named DialogueCommandHandlers.
DialogueComponent: Marks an entity (typically an NPC) as having associated dialogue.
DialogueConditionRegistry: Registry for named DialoguePredicates.
DialogueEvent: Structured event describing something that happened in a dialogue, for a game to put on its own event bus. The engine does not emit these itself.
DialogueGraph: A collection of DialogueNodes that together form a complete dialogue.
DialogueLine: A single dialogue line after localization and variable substitution have been applied.
DialogueLocalizer: Resolves localized dialogue strings at runtime.
DialogueManager: Central service for the Narrative/Dialogue System.
DialogueNode: An individual narrative unit inside a DialogueGraph.
DialogueRunner: Executes a DialogueGraph step-by-step and exposes the current state through reactive signals.
DialogueStatement: Base class for every statement in a parsed dialogue node.
DialogueSystem: ECS system that drives DialogueComponent and DialogueTriggerComponent entities.
DialogueTriggerComponent: Trigger zone that automatically starts dialogue when a player enters.
DialogueVariableStore: Stores named dialogue variables used by <<set>> and <<if>> statements.
DistanceJoint: Keeps two bodies' centres minLength to maxLength apart.
DistanceJoint2D: Keeps two bodies a set distance apart, springily.
DollyPath: A polyline measured by length, so 0.5 is halfway along it however its points are spaced. Shared with the editor, which draws the same track.
DollyStage: Body: puts the camera on its track — at the point nearest the target, or wherever pathPosition says.
DragForce: Velocity-proportional drag (air resistance).
Easings: The engine's easing functions — the single table behind the effects' EasingType and the timelines' KeyEasings.
EdgeInsetsFieldType: Space around something: {l, t, r, b}.
EffectBinaryCodec: Compact binary codec for EffectSnapshot.
EffectComponent: ECS component that attaches an EffectPlayer to an entity.
EffectContext: Per-tick execution context for DeterministicEffect.applyTick.
EffectHandle: A cancellable reference to a scheduled DeterministicEffect.
EffectPlayer: Per-entity deterministic effect queue.
EffectRuntime: Pluggable multiplayer coordination interface for deterministic effects.
EffectSerializer: JSON serialiser for DeterministicEffect instances.
EffectSnapshot: A serialisable point-in-time snapshot of all active effects across all entities.
EffectSystemECS: ECS system that drives all EffectComponents each fixed-timestep tick.
EffectTypes: The effect types that can be read back, keyed by DeterministicEffect.effectType. The engine's eleven are always there; a game registers its own into an engine's (engine.context.effectTypes). builtIn holds only the engine's and cannot be changed.
Engine: Main game engine class that orchestrates all subsystems
EngineConfig: Choices made once, when an Engine is made: what it is taught (extensions), what it runs beside the game (services), and how some subsystems are built.
EngineContext: Everything one engine knows that is not a subsystem: the component definitions and field types scenes are read with, and the per-package state packages hang on it.
EnginePlugin: Something that attaches to a running Engine to observe or extend it — a debug editor, a profiler, a replay recorder.
EngineService: Something a game adds to its engine that lives as long as the engine does — achievements, a wallet, sign-in, ads (package just_game_services), or a game's own.
EngineTags: Tags the engine's own code looks for.
Entity: Entity - A lightweight handle for components stored in an Archetype.
EntityPrefab: A reusable entity blueprint that can be instantiated many times.
EntityRefFieldType: The name of another entity. Stored as text: an entity is referred to by what the author called it, which survives a reload and a respawn where an id would not.
EntitySignal: A signal that tracks entity-level events like component changes.
EntitySpatialGrid: A uniform grid for fast "which entities are roughly near this rect" broad-phase queries — the same technique just_physics_engine's SpatialGrid uses for collision broad-phase, generalized here to any ECS Entity instead of a physics body.
EntityTarget: Who a component means — the entity a camera follows, what sets a trigger off — named rather than referenced, and looked up when it is needed.
EntityTargetFieldType: Who a component means: an EntityTarget — the entity itself, one by name, or entities by tag. Saved as 'self', {'name': …}, {'tag': …} or null for nobody.
EnumerationFieldType: An enum stored by name and parsed back with FieldConstraints.enumParser.
EnumFieldType<E extends Enum>: An enum that knows its own values, so it needs no parser and the editor can list its options without being told them separately.
EulerFieldType: A rotation as three Euler angles in radians, {x, y, z} — the engine's one convention, q = qY · qX · qZ (see Quaternion). The value is a Vector3 of angles. A 2-D scene shows only z, the angle in the plane.
EulerRotation: A rotation held as Euler angles in radians — the engine's one convention, q = qY(y) · qX(x) · qZ(z) (see Quaternion).
EventBus: A lightweight event bus for decoupled inter-system communication.
EventSubscription: Handle returned by EventBus.on to cancel a subscription.
EventTrack: A track of TimelineEvents, fired as the playhead crosses them and told to the playback's listener. The binding is not used: an event comes from the entity playing the timeline.
ExpressionEvaluator: Evaluates Yarn Spinner condition and assignment expressions at runtime.
FadeEffect: Animates the Renderable.opacity of an entity's RenderableComponent from a starting alpha to to over durationTicks ticks.
FieldConstraints: Bounds and parsers a field applies while decoding.
FieldHint: How one field appears in an inspector. Presentation only — the field's name, kind, limits and read/write come from its SchemaField.
FieldRowHint: Several numeric fields of a component on one inspector row, as a vector's axes are: Dead zone W [0.10] H [0.10].
FieldType<T>: How one kind of field value is written to and read from JSON.
FieldTypeRegistry: Field types by FieldType.id.
FieldTypes: The field types the engine ships with.
FieldValueCodec: Converts one field value to and from its JSON form.
FirstPersonComponent: Body stage: the camera at its target's eyes, turned by yaw and pitch — a first-person view.
FirstPersonStage: Body: at the target's eyes, looking where the component's yaw and pitch say.
FixedJoint2D: Holds two bodies rigidly together (Box2D calls it a weld).
FlowFieldSystem: Grid-based "flow field" pathfinding toward a named target entity (the player, by default), routing around any entity carrying a NavigationObstacleComponent.
ForceManager: Applies global forces (gravity, wind, etc.) to a set of PhysicsBodys.
FrameSystem: A System that also runs once per rendered frame, after the frame's fixed updates and before it is drawn — for what must move at the display's rate rather than the simulation's: a camera following a body between physics steps, a look that reads this frame's mouse movement.
FrameView: The camera of one frame, in the forms a renderer needs — reused frame to frame, so reading it allocates nothing.
FramingStage: Body: keeps the target inside its dead zone, easing when it leaves and never letting it out of the soft zone.
Frustum: The six planes bounding what a camera sees, each facing inwards.
FrustumViewVolume: What a camera in space sees: its frustum.
GameAssetBundle: A named group of assets that load and unload together.
GameCamera: Minimal camera interface consumed by ECS render systems.
GameEvent: Base class for all events dispatched through the EventBus.
GameLayer: Something drawn over the game as real Flutter widgets.
GameLayerController: One view's instance of a GameLayer.
GameLayers: The layers registered on an engine, and which are switched off.
GameLoop: Main game loop implementation
GamepadControls: The controls of a standard gamepad, named by position — the button at the bottom of the face is buttonSouth whether it says A or ✕ — and tied to the W3C standard layout just_gamepads reports every pad in.
GamepadDevice: One pad. Two pads are two devices — which is what lets two players each have their own.
GamepadSource: Where gamepads come from. JustGamepadsSource in a game; a fake in tests.
GameTerminal: Manages all in-game terminal state: visibility, text input, scrollback history, and the command registry.
GameWidget: Main game widget that renders the game
GeneratedEntityComponent: Tags an entity that a system made from other data while the game runs — the static bodies a tile map's collision is built from, say.
GravityForce: Constant gravitational acceleration.
GridSheetAtlasParser: Parses the engine's older "grid sheet" animation JSON, so files written for the retired AnimatedSpriteComponent still play:
GroupFramingStage: Body, ahead of framing: sets the lens so a followed target group fits.
HealthComponent: Health component - HP system
HealthSignals: A collection of signals for health component.
HealthSystem: Health system - Handles death and health regeneration
HierarchySystem: Former home of parent → child transform propagation.
IEnableable: Interface for systems that can be enabled/disabled
ILifecycle: Interface for objects with lifecycle management
ImageAsset: Image/Texture asset
ImageAssetLoader: Image asset loader
ImpulseListenerStage: Noise: what the impulses in the air do to this shot.
InputAction: A live action: what its bindings say now, and what just happened.
InputActionAsset: Everything a game's input is: its action maps, the control schemes, the on-screen controls and the player rules. Saved as a .input.json file.
InputActionMap: A group of actions switched on and off together.
InputActions: The asset, live, for one set of devices: its maps and actions, read from those devices only. The service has a shared one for all devices; each player has their own.
InputComponent: One player's input, copied onto the entity they control each step by the input system, by action name — so gameplay reads input.isDown('jump') and never asks which device or which player.
InputControl: One thing on a device a binding can name.
InputDevice: One source of input — the keyboard, the mouse, a gamepad, the on-screen controls.
InputEvent<T>: Something that happens to players — one joined, one's pad went — that any number of listeners hear.
InputOverrideStore: Where players' overrides are kept. The engine keeps them in its cache; tests keep them in memory.
InputService: A game's input: its devices, the asset, and every live copy of the asset (a shared one, and one per player).
InputSubscription: A way to stop listening.
InputSystem: Reads each InputComponent's player from the InputService and writes every action of maps into it by its short name — jump, move — so gameplay code reads names, not devices.
IntegerFieldType: An int, saved as a JSON number. Reading truncates any number to an int and clamps it to the constraints' min (rounded up) and max (rounded down).
IPausable: Interface for systems that can be paused
IRenderable: Interface for systems that can be rendered
IUpdatable: Interface for systems that can be updated every frame
Joint2D: What a joint holds its entity's body to — in step with the 3-D Joint3D. The joint is on one entity (A, which has a body: a RigidBody2D and a Collider2D) and names the other (connectedBody, B). PhysicsJointBindingSystem makes it once both bodies exist, and again when a setting changes.
JointConstraint: Base class for all joint constraints.
JsonAsset: JSON asset
JsonAssetLoader: JSON asset loader
JumpStatement: <<jump NodeTitle>> — unconditionally jumps to another node.
JustGamepadsSource: The real pads, through just_gamepads. Shares the manager with anything else that uses it, and never disposes it.
KeyboardDevice: The keyboard. Keys are by position; see KeyboardKeys.
KeyboardKeys: Every key a binding can name.
KeyCurve: Keys in time order, and the value between them.
KeyEasings: Easing functions by name, so a key in a file can ask for one: shapes a single bezier cannot make, like a bounce. A key saves the name, so the names never change.
KeyTangent: A bezier handle, as an offset from its key: dt seconds, dv value.
LayerComponent: Draw order and editor grouping for an entity.
LetterboxEffect: Animated cinematic letterbox — solid bars at the top and bottom of the screen.
LevelLayers: Conventional LayerComponent.layer values.
LevelMapComponent: Puts a map in the level — its tile layers — at its entity's position. A scene has one: its Level Map. What is placed on a layer of it is a child of its entity naming the layer (LayerComponent.mapLayer).
LevelMapData: A level map.
LevelMapDefinitions: The level-map subsystem's component definitions: one, for LevelMapComponent.
LevelMapFiles: The names of map files.
LevelMapHandle: Reading and changing a map while the game runs.
LevelMapLoadFailure: A map LevelMaps.preload could not load.
LevelMapRuntime: What the running game made of one map: the document it reads, its own changes on top, the tilesets and images it loaded, and its drawing.
LevelMaps: Finding maps in a world.
LevelMapSystem: Brings every LevelMapComponent to life: loads its map (from the scene or a file) and tilesets, and gives its entity one render item per layer, so each layer sorts among the level's drawing on its own.
LifetimeComponent: Lifetime component - Entity that expires after time
LifetimeSystem: Lifetime system - Destroys expired entities
Light2D: Lights a 2-D scene that has Lighting2D on: sprites, shapes and tile layers are shaded by it — by the bumps their materials' normal maps draw — and, where castsShadows, darkened behind what casts shadows.
Lighting2D: Turns 2-D lighting on for the scene it is in: the frame is drawn, then lit by every Light2D near the view over ambient light. A scene without one — or with it off — is drawn as it is, and pays nothing for lighting.
Lighting2DPass: Lights the frame when the world has a Lighting2D on: the frame and its normals (RenderSystem.renderNormals) drawn through shaders/lighting_2d.frag, lit by up to maxLights Light2Ds — those reaching the view, the nearest its middle first — over the ambient light. Lights that cast shadows are stopped by what casts them (ShadowCaster2D, Level Map layers that cast them): their shapes drawn into a mask (RenderSystem.renderOccluders), how far each light reaches every way found from it (shaders/shadow_map_2d.frag). What the engine puts first in RenderingEngine.screenPasses.
LineComponent: Line shape component.
LineParticleRenderer: Renders each particle as a line from Particle.previousPosition to Particle.position, creating a motion-blur streak effect.
LineRenderable: A renderable line
LineStatement: A single spoken line, optionally attributed to a character.
ListFieldType: A list of plain JSON values, saved and read back as it is — no element is converted.
LoaderOverride: What EngineContext.overrideLoaders changed, and how to put it back.
LocaleStringTable: An immutable flat mapping from string key → localized string for one Locale.
LocalizationManager: Engine-wide localization service.
LocalizationScope: Provides a LocalizationManager to the widget subtree via LocalizationScope.of.
LookActions: Ready-made look actions for a camera that turns, in the shape LookInput reads. Look comes as two actions because it comes two ways:
LookAtComponent: Aim stage: points the camera at its target, wherever the body put it.
LookAtStage: Aim: turns the camera, wherever its body put it, to look at its target.
LookInput: A camera's look, read once per rendered frame from the two look actions (LookActions):
LookSettings: How look input becomes a turn. Immutable; a settings screen makes a new one with copyWith and gives it to LookInput.settings.
MapBodyComponent: On each body a map's collision is built from: which map and layer it came from, what kind of collision, and which cells.
MapBodySpec: One static body a layer's collision is made of, from its tiles.
MapCollisionKind: What a tile's collision kind means at runtime.
MapCollisionKinds: The collision kinds tiles can use.
MapCollisionSystem: Gives every map layer marked collides the static bodies its tiles' collision shapes describe.
MapFieldType: A map of plain JSON values, saved and read back as it is — no entry is converted.
MapGeometry: The geometry of a map's grid, in map-local pixels (world units, with the map's entity at the origin).
MapLayerData: One layer of a map: its tiles. What else is on it — the entities placed there — are children of the map's entity that name the layer.
MapLayerPainter: Draws a map's layers.
MapLayerRenderItem: One map layer's tiles, as one of the level's things to draw: it sorts among sprites and shapes by the layer's own sort layer and z-order, and the entities on the layer draw just after it.
Material2D: Draws an entity's sprite through a 2-D material file (*.material2d.json): an outline, a flash, a dissolve, a wave — the effects the file switches on (Material2DEffects).
Material2DBatch: Sprites drawn with one 2-D material from one sheet, queued to be drawn together: one drawVertices call through the material's shader, each sprite a quad, with what differs per sprite — its frame, tint, place and overridden values — in a small params image made at flush.
Material2DEffect: A switch in a 2-D material: off unless the file turns it on.
Material2DEffects: Every effect a 2-D material can switch on, in the order a material applies them (and a file saves them).
Material2DFile: A 2-D material saved in its own file (*.material2d.json): effects for sprites, shapes and tile layers (Material2DKind.sprite), or for the whole frame from a camera (Material2DKind.screen).
Material2DLibrary: The 2-D material files (*.material2d.json) an engine's entities are drawn with (Material2D), and the shader that draws them.
Material2DParam: One value of a Material2DEffect.
Material2DShader: The layout shaders/material_2d.frag reads. Change one, change both.
MaterialChain: Walks a variant's parents and lays each file over the one before.
MaterialOverridesFieldType: An entity's own values for its material — Material2D.overrides, ScreenMaterial.overrides, MaterialOverrides3D.values — saved as a map by key, whose channels are the numbers in it a timeline can key: each animatable number, a pair as key#0 and key#1. (A colour is changed from code: keyed as one number it would not blend as a colour.)
Matrix4: 4D Matrix. Values are stored in column major order.
MemoryCleanupResult
MemoryInputOverrideStore
MemoryProfiler
MemoryProfileSnapshot
MemoryScope
MemoryStats
MigrationHooks: The rules a package adds to the scene and timeline migrations, on top of the engine's own — its old component shapes brought forward.
MigrationNote: Something one migration step noticed that a person may want to know.
MigrationResult: A scene brought up to the current format, and what was found on the way.
MigrationRun: One migration in progress: the hooks it runs with and what it finds. Handed to every step, so two migrations never share what they found.
MixerManager: Shows every weighted child at once.
ModelAsset: A 3-D model, as the engine sees one: its bounds and, for picking and mesh colliders, its triangles. Drawing it is someone else's business.
ModelGeometry: Triangles on the CPU: three indices per triangle into positions.
MotionBlurEffect: Directional motion blur driven by camera velocity.
MouseControls: The mouse's controls.
MouseDevice: The mouse. MouseControls.delta and MouseControls.scroll add up what happened since the last update and start again from zero at each; their running totals (InputControl.readTotal) never start again, for reading once per rendered frame instead.
MouseJoint: Pulls a body toward a target point using a spring force.
MoveEffect: Translates an entity's position from its captured start to to over durationTicks ticks.
MovementSystem: Movement system - Applies velocity to transform
MoverShape: The shape a character moves as, centred on its position: a capsule standing upright, or a box with slightly rounded corners.
MusicManager: Convenience wrapper around AudioEngine for background music.
NarrativeSignals: All reactive state exposed by a running DialogueRunner.
NavigationObstacleComponent: Marks an entity as a static obstacle for FlowFieldSystem pathfinding — rasterized into the walkability grid as a circle of radius centered on the entity's TransformComponent.position.
NestedTimelineTrack: Runs other timelines inside this one: TimelineBlock.value is the timeline's path, played for the bound entity as its "self".
NineSliceSprite: Nine-slice sprite for UI elements
NoiseForce: Noise-based perturbation using 2-D value noise.
NoiseOctave: One layer of noise: how fast and how far.
NoiseStage: Noise: continuous handheld motion over the settled shot.
OffsetFieldType: An Offset, saved as {dx, dy}; a missing or non-numeric part reads as 0.
OffsetListFieldType: A list of Offsets — a polygon's points, say — saved as a list of {dx, dy} maps. Reading skips entries that are not maps.
OnScreenDevice: The controls a game draws on a touch screen, as a device: the widget that draws them sets them, and bindings read them like any other button or stick — <OnScreen>/jump.
OrbitFollowComponent: Body stage: a third-person camera circling its target at distance, turned by yaw and pitch.
OrbitFollowStage: Body: circles the target at a distance, turned by the component's yaw and pitch, the pivot easing after the target.
ParallaxBackground: A multi-layer parallax background.
ParallaxComponent: Parallax component — a ParallaxBackground drawn behind the world.
ParallaxLayer: A single layer in a parallax background.
ParallaxRenderSystem: Scrolls and draws every entity's ParallaxComponent.
ParallaxSystem: Parallax subsystem that manages multiple ParallaxBackground instances.
ParallelEffect: Runs all child effects simultaneously.
ParentComponent: Hangs an entity under a parent: it moves, turns and scales with it.
Particle: An individual particle managed by a ParticleEmitter.
ParticleEffect: Base class for custom particle behaviors.
ParticleEffects: Ready-made particle effect factories.
ParticleEmitter: Particle emitter — the core class of the advanced particle system.
ParticleEmitterComponent: ECS component that attaches a ParticleEmitter to an entity.
ParticleForce: A force that mutates a Particle's Particle.velocity each tick.
ParticleRenderer: Base class for all particle renderers.
ParticleSystemECS: ECS system that drives ParticleEmitterComponent entities every frame.
PathEffect: Moves an entity along a path defined by waypoints over durationTicks.
Physics2DQueries: Rays, sweeps and overlaps against the bodies system keeps in physics. Each takes the layers it sees (layerMask, bit n for layer n), an entity to look through (ignore, the asker itself, say), and whether sensors count.
PhysicsBody: Physics body — the core simulation object in the physics engine.
PhysicsBodyRefComponent: Links an entity to a subsystem PhysicsBody for automatic position sync.
PhysicsCharacters2D: The CharacterBody2D side of PhysicsSystem, which owns one and runs it each update before stepping — as the 3-D PhysicsSystem3D moves its characters.
PhysicsDefinitions2D: The definitions of RigidBody2D, Collider2D, CharacterBody2D and the 2-D joints. Each is Dimensions.twoD, in the Physics group.
PhysicsEngine: Main physics engine class
PhysicsHit2D: What a 2-D query hit.
PhysicsJointBindingSystem: Makes the 2-D joints (DistanceJoint2D, FixedJoint2D, SliderJoint2D, WheelJoint2D) in the physics engine, between the body of the entity a joint is on and the body of its Joint2D.connectedBody.
PhysicsLayerFieldType: A collision layer, 0 to 15, saved as its number. Reading clamps it into range.
PhysicsLayerMaskFieldType: A set of collision layers as a 16-bit mask, saved as its number — or null, saved as null, for "as the project's grid says".
PhysicsLayers: What collides with what, by layer: up to count layers, each with a name, and a grid saying which pairs of them collide.
PhysicsShapeFieldType: A physics CollisionShape, stored as {kind, ...dimensions}.
PhysicsSystem: Physics system — the ECS front end for PhysicsEngine, in step with the 3-D PhysicsSystem3D.
PlanarSpatialIndex: A SpatialIndex over the x/y footprint of everything — an EntitySpatialGrid — ignoring depth, as 2-D does.
PlanarViewVolume: What a 2-D camera sees: a rectangle of the world, at every depth.
Plane: The plane of points p with normal · p + constant = 0.
PlayerInput: One player: their devices, their scheme, and their own live copy of the asset, reading only their devices.
PlayerInputManager: Local multiplayer: who is playing, with what, and who joins next.
PlayerRespawnEvent: Fired by CheckpointSystem.respawn to request the player be moved to their last saved respawn position.
PluginHost: The plugins attached to one engine.
PointerLock: Locks the mouse pointer to the game window, for mouse look.
PolygonComponent: Polygon shape component.
PolygonDecompose: Convex decomposition for collision shapes.
PolygonShape: A convex polygonal collision shape using SAT (Separating Axis Theorem).
PoolManager
PoolStats
PostProcessPass: A single fullscreen post-process shader pass.
PostProcessSystem: Manages fullscreen post-process shader passes on behalf of the ECS world.
PredictionEffectRuntime: EffectRuntime for client-side prediction with rollback.
PrefabApply: Writes what an instance changes into its prefab, so that every instance has it: an editor's Apply.
PrefabCollapse: Works out what an instance changes, from its entities as they are now against what its prefab makes on its own: what an editor saves.
PrefabEntity: One entity of a PrefabFile.
PrefabExpander: Turns prefab instances into the entities they make: the prefab's own, each nested instance in it made in turn, and the instance's changes applied. Plain JSON in, plain JSON out — the engine, the editor and the command line expand the same way.
PrefabFile: A prefab saved in its own file (*.prefab.json): entities — one at the top, the rest under it — that scenes and other prefabs place as an instance, changing what they need to (PrefabInstance).
PrefabInstance: An instance of a prefab — in a scene, or in another prefab — and what it changes: fields (overrides), names and switches of the entities in it, entities removed, components added and removed. Everything else is the prefab's, so an edit to the prefab reaches every instance.
PrefabInstanceComponent: On the top entity of a prefab instance: which prefab file it is (path) and what this instance changed when it was loaded (block).
PrefabLibrary: The prefab files (*.prefab.json) one engine has read, by path: what scenes holding instances of them and spawners placing them make their entities from.
PrefabLink: On every entity a prefab instance made (its top one too): the instance's top entity (instance) and where in the prefab it is (path, a path of the prefab's ids).
PrefabNode: One entity a prefab instance makes: where it is in the prefab (path, a path of ids), its name and switch, the entity it is under (parent, a path too; null at the top) and its components as saved — copies, to change freely.
PrefabOverride: One field of a component changed in an instance: on the entity at target (a path of ids, c3/x9 for x9 inside the instance c3), component's field is value (as saved).
PropertyAccess: A field, reached through its component's definition in the field's saved (JSON) form. That form is the same for every field type — a number, a bool, a string, an ARGB int, or a map of numbers like {x, y} — which is why one track kind animates them all, a package's own types included.
PropertyTrack: Animates one field of one component on the bound entity along a curve of keys. The field is named by saved names — component, field, and channel for one number of a map-valued field — so the track fits any entity that has it.
PropertyTrackRunner: The running half of a PropertyTrack: finds the field on the bound entity — again when the entity or its components change — and writes the curve's value there on every apply.
Quaternion: A mutable rotation quaternion (x, y, z, w), Hamilton convention.
Ray: A ray in 2-D world space with an origin, normalised direction, and maximum travel distance.
Ray3: A half-line from origin along direction.
RayBodyHit: The result of a ray cast against a PhysicsBody.
RaycastColliderComponent: Marks an entity as participating in ray-cast queries and defines its circular collision shape.
RaycastHit: The result of a single ray–entity intersection.
RaycastSystem: ECS system that provides ray-vs-collider intersection tests against every entity that has a TransformComponent and a RaycastColliderComponent.
RayRenderable: Draws a glowing line from start to end that fades to transparent over lifetime seconds.
RayTrace: Complete result of a RayTracer.trace call.
RayTracer: Performs multi-bounce ray tracing against RaycastColliderComponent entities that have RaycastColliderComponent.isReflective set to true.
RayTraceSegment: A single path segment of a multi-bounce ray trace.
ReactiveSystem: A system that only processes entities with dirty (changed) components.
RebindCanceled
RebindCompleted
RebindingOperation: Listens for the next control pressed, to bind it.
RebindResult: How a rebind ended.
RectangleComponent: Rectangle shape component.
RectangleRenderable: A renderable rectangle shape
RectangleShape: A rectangular collision shape (simplified Polygon).
RefreshableExtension: A ContextExtension that can put its definitions in place again, as the code now makes them, after a hot reload — so an editor shows a field just added to one of its components. See EngineContext.refreshDefinitions.
Renderable: Base class for all renderable objects
RenderableComponent: Renderable component - Links to a Renderable object
RenderContext: What a ComponentPainter is given per frame.
RenderHookChain: Several render callbacks called in order.
RenderingEngine: Main rendering engine class responsible for graphics rendering
RenderItem: One drawable an entity owns, sorted into the same draw order as every renderable in the world.
RenderItemsComponent: The RenderItems an entity draws. Runtime only: whatever creates the items (a loading system, usually) attaches this, and nothing saves it.
RenderPass: One stage of RenderSystem's frame, run inside the camera transform.
RenderStatsSink: Something that adds up what a frame's drawing cost: RenderingEngine, whose stats then count the ECS world's drawing along with its own.
RenderSystem: Render system - Renders ECS world-space renderables and UI components.
RepeatEffect: Repeats a single child effect a fixed number of times.
RepellerForce: Point repeller — pushes particles away from center.
ResolvedMaterial<T>: A material file with every parent laid under it, and what went wrong on the way.
RevoluteJoint: A hinge: the two bodies turn about a shared anchor.
RigidBody: Represents a rigid body with 2D force accumulation (convenience wrapper).
RigidBody2D: Makes its entity a body that PhysicsSystem simulates: how it moves, how heavy it is, what it is made of. It needs a Collider2D on the same entity for its shape; a collider without one is a static body.
RotateEffect: Animates an entity's TransformComponent.angle from its captured start to to (radians) over durationTicks ticks.
RoundedPolygonShape: A convex polygon with rounded corners.
ScaleEffect: Animates an entity's TransformComponent.scale from its captured start to to over durationTicks ticks.
SceneAssets: Where scenes live in a game's assets, and how to find them.
SceneFormat: The saved scene format's version, and how older files are brought up to date.
SceneLoader: Loads levels saved by the editor into a World, with no editor present.
SceneManifest: assets/scenes/scenes.json: the scenes the game plays, in order.
SceneMigration: One step of the scene-format migration chain: from version from to from + 1.
SceneMigrations: Every migration, in order.
SceneNames: The rules for a scene's name: a Dart identifier that is not a keyword, unique ignoring case.
SceneRenderer: Draws the world from a FrameView — the slot a 3-D rendering backend fills.
SceneStarters: The scene a new level starts from, as its file holds it.
SchemaField: One persisted property of a component.
ScreenFadeEffect: Full-screen colour overlay with animated alpha.
ScreenMaterial: Draws the whole view through a 2-D material of the screen kind (*.material2d.json): a vignette, a colour grade, scanlines, a CRT bulge, big pixels — the effects the file switches on.
ScreenMaterialPass: Draws the frame through the world's ScreenMaterial: of those enabled on active entities, the one with the highest order. What the engine installs as its RenderingEngine.screenPass.
ScreenPass: Drawn over the whole frame from an image of it — a screen material's vignette, colour grade or pixelation, say — by RenderingEngine: when active, the frame is drawn into an image (everything up to the overlay hooks of order RenderingEngine.screenPassOrder, an editor's own drawing left out), which paint then draws over the view.
ScreenPassPlan: How a frame is drawn through its ScreenPasses.
ScrubHint: Drag-to-scrub feel for a numeric field in an inspector. Limits are not here: they come from SchemaField.min/SchemaField.max, so what the inspector allows and what a load accepts cannot drift apart.
SegmentShape: A line-segment collision shape for static terrain and one-way platforms.
SensorEnter2DEvent: Something has entered a sensor (a body with RigidBody2D.isSensor).
SensorExit2DEvent: Something has left a sensor.
SequenceEffect: Runs a list of child effects one after another in order.
ServiceContext: What a started EngineService gets from its engine.
ServiceHost: The EngineServices of one engine (engine.services), in start order.
SetStatement: <<set $variable = expression>> (or to for =) — assigns a value to a Yarn variable; <<declare $variable = expression>> — gives it a first value, only when it has none yet.
ShaderComponent: Attaches a custom GLSL ui.FragmentShader to an ECS entity.
ShaderFilterSupport: Guards every ImageFilter.shader the engine makes.
ShadowCaster2D: Makes its entity's sprite or shape cast shadows from the Light2Ds that cast them, in a scene with Lighting2D on: light stops at its shape, and what is behind it from the light is in shadow.
ShakeEffect: Applies a damped oscillating positional shake to TransformComponent.
ShapeCastResult: The result of a circle shape cast against a PhysicsBody.
ShapeGradient: Serializable-style gradient config used by shape components.
ShapePaintCache: One shape's fill and stroke paints, brought up to date only when what they are made from changes.
ShapePainting: Draws rectangles, circles and polygons the way the shape components do: filled (when asked) in ShapePaintStyle fill, then outlined in the stroke style.
ShapePaintStyle: Unified shape paint style that combines color tint and optional gradient.
ShapePaintStyleFieldType: A ShapePaintStyle: colour, blend mode and optional gradient.
ShapeSheet: What a shape drawn through a 2-D material is drawn from: the shape drawn into an image in its own space, its box (bounds) and how many image pixels a unit of that space is (resolution).
ShapeSheets: Each entity's shape drawn into an image, kept while it looks the same.
Signal<T>: A reactive primitive that holds a value and notifies listeners when it changes.
SimpleMovementComponent: Moves an entity straight from a vector action — no physics. For top-down games, cursors and quick tests.
SimpleMovementSystem: Applies a vector action straight to TransformComponent.
SliderJoint2D: Lets two bodies slide along one axis: a drawer, a piston, a lift (Box2D calls it prismatic).
SolidBox: A box, axis-aligned in its entity's space.
SolidCapsule: A capsule standing along Y: a cylinder halfHeight × 2 tall with a half-sphere on each end.
SolidCylinder: A cylinder standing along Y.
SolidHeightField: Ground as a grid of heights — a terrain: sampleCount by sampleCount samples cellSize apart, row by row along Z, each along X, its first at (x, y, z). Each height is how far up the ground is there (+Y is down: it is subtracted). holeHeight or more marks a hole: nothing there.
SolidHull: The convex hull of a set of points: a cone, a wedge, one piece of an arch.
SolidMesh: A surface of triangles — a road swept along a path, a bridge — for what stands still or is moved by hand (static and kinematic bodies): one thrown about by forces needs convex parts.
SolidPart: One convex part of a SolidShapeSource's shape.
SolidShapeSource: A component whose look is a solid of known shape — a 3-D primitive such as a box, a sphere or a staircase — so that a collider can take the same shape without being told it twice.
SolidSphere: A sphere.
SoundEffectManager: Convenience wrapper around AudioEngine for one-shot & looping SFX.
SpatialGrid: A uniform grid for broad-phase collision detection.
SpatialIndex: An index of entities by their bounds in the world, in 3-D.
SpawnComponent: Marks an entity as a spawn point: where the app creates something when the level starts. What is created is up to the app — the spawner names one of its Spawners.
Spawner: Something a spawn point can create, as the app registers it.
SpawnerRefFieldType: The id of a spawner the game registers, as a spawn point names it. Stored as text; the editor offers the spawners it was given.
SpawnPoints: Finding spawn points, the same way everywhere.
Sprite: A sprite that can be rendered
SpriteAnimationComponent: Plays a clip from a sprite atlas on this entity.
SpriteAnimationSignal: Something a playing sprite said: a frame event the artist placed, or SpriteAnimationSignal.completed when a clip that does not loop ends.
SpriteAnimationSystem: Plays SpriteAnimationComponents: loads the atlas, advances the clip by each frame's own duration, shows the frame, and reports events.
SpriteAssetLoader: Where sprite images and atlases come from.
SpriteAtlas: A parsed sprite atlas containing one or more SpriteAtlasPages plus a registry of named SpriteRegions and AtlasAnimationClips.
SpriteAtlasPage: A single texture page belonging to a SpriteAtlas.
SpriteBatch: A batched sprite renderer that issues a single Canvas.drawRawAtlas call.
SpriteBatchRenderer: Abstract contract for a sprite-batch renderer.
SpriteClipTrack: Plays clips on the bound entity's SpriteAnimationComponent. Between blocks the sprite goes back to the clip it was playing before — what was authored, unless something (an animator) had switched it. It sets what the sprite plays at run time, never what it saves.
SpriteComponent: A still image on this entity: a whole image file, or one region of a sprite atlas. SpriteLoadSystem loads it and keeps it showing.
SpriteLoadSystem: Shows a SpriteComponent: loads its image — or its region of an atlas — into a RenderableComponent, and keeps flip, tint and filtering current.
SpriteParticleRenderer: Renders each particle using a ui.Image, batched via Canvas.drawAtlas.
SpriteRegion: A named region within a SpriteAtlas — describes one sprite or animation frame packed onto an atlas page.
SpriteSheet: Sprite sheet for managing multiple sprites from one image
SquareParticleRenderer: Renders each particle as a filled square (axis-aligned, rotatable).
StampCell: One cell of a stamp: where it goes relative to the brush, and what.
StarParticleRenderer: Renders each particle as a 5-pointed star.
StateDrivenManager: Shows the child mapped to another entity's CameraStateComponent.state.
StopStatement: <<stop>> — immediately ends the dialogue session.
StringInterpolator: Performs {variable} substitution and ICU-lite plural selection on a localized string template.
SubEmitterConfig: Describes a child particle emitter that is spawned by a parent emitter's particles.
SubtitleController: Drives subtitle playback from a SubtitleTrack.
SubtitleCue: A single timed subtitle entry.
SubtitleTrack: An ordered list of SubtitleCue entries that make up a subtitle sequence.
System: Base class for all systems
SystemManager: System manager for coordinating engine subsystems
SystemMemorySnapshot
SystemPriorities: Named priority constants for System.priority.
TagComponent: The labels an entity carries — player, enemy, boss — for systems, cameras and triggers to find it by.
TagDefinition: One tag a project knows: its name, and how an editor shows it.
TagLibrary: The project's tags, in the order they are listed. Immutable: every change returns a new library.
TagListFieldType: Several tags: a list of names, blanks and repeats dropped. What a TagComponent saves.
TagNames: What makes a good tag name, and what is probably a typo of one.
TagRefFieldType: A tag, from the project's tag list. Stored as text; the editor offers the tags the project knows and a way to make a new one.
TextAsset: Text asset
TextAssetLoader: Text asset loader
TextFieldType: A String, saved as a JSON string and read back as it is.
TextParticleRenderer: Renders each particle as a text glyph (e.g. an emoji).
TextRenderable: A renderable text label
TexturePackerAtlasParser: Parses the three TexturePacker JSON export variants into a SpriteAtlas.
TileAssets: Loads tilesets (.tileset.json) and map files (.map.json or .tilemap.json, and Tiled's .tmx / .tmj), and keeps what it loaded.
TileCell: The value of one cell: which tile of which tileset, and how it is turned.
TileChangedEvent: Fired when the running game changes a tile.
TileChunkData: Sixteen by sixteen cells of one layer.
TileChunkStore: A layer's cells: any number of them, in any direction, only where something is painted.
TileCollision: What a tile does when something runs into it.
TileCollisionBuilder: Builds a layer's collision from what its tiles' tilesets say.
TileCoord: A cell's position on a map layer, in tiles.
TileDef: What a tileset says about one of its tiles. Only tiles that say something have one.
TiledImageRecord: An image layer from a Tiled map, placed in map-local pixels.
TiledImport: What an import made of a Tiled map.
TiledInterop: Conversions between just_tiled's models of TMX/TSX (and TMJ/TSJ) files and the engine's LevelMapData and TilesetData.
TiledObjectRecord: An object from one of a Tiled map's object layers, with what the groups it sat in did to it.
TileEllipseShape: An ellipse inscribed in bounds.
TileFrame: One frame of an animated tile: which tile of the same tileset to show, and for how long.
TileInfo: A tile, with what its tileset says about it.
TilePolygonShape: A polygon, convex or not; the collision builder splits it as needed.
TileProperties: Named, typed values a designer attaches to a tile or a layer and a game reads: a tile's damage, a layer's ambient sound.
TileRange: A rectangle of cells: x0 to x1 and y0 to y1, the far edges exclusive.
TileRectShape: An axis-aligned box.
TilesetData: A .tileset.json: an image cut into a grid of tiles, and what the tiles mean — collision, animation, terrain, properties.
TileShape: One shape of a tile's collision, in the tile image's own pixels (0,0 is the image's top-left).
TileStamp: A brush's contents.
TileTransformations: Which ways a terrain brush may turn this tileset's tiles to find a match — Tiled's tileset transformations.
TimelineAsset: Tracks on one clock: what a .timeline.json holds, or what a Timeline Player keeps inline. Immutable — an editor makes a new one with copyWith — so one asset can be shared by every player of it.
TimelineAudio: How an audio track makes a sound: through its world's context (context.timelineAudio), which a game with its own audio replaces. The default, viaAudioSystem, asks the world's AudioSystem for a one-shot.
TimelineBlock: A stretch of a block track. Every kind reads the same few fields its own way, which is what lets one editor draw, move and trim them all.
TimelineContext: What a running track can reach: the world, who is playing the timeline, the entities bindings mean, and a way to say an event happened.
TimelineDefinitions: Definitions for the timeline components that need more than a plain schema: TimelineTriggerComponent, whose rectangle the editor sizes and scales.
TimelineEvent: Something that happens at a time.
TimelineEventFired: An event a timeline fired.
TimelineFormat: The timeline file format: its current version, and bringing an older file up to it.
TimelineKey: A value at a time.
TimelineMarker: A named time: somewhere to play from, something to snap to.
TimelineMigration: One step of the timeline-format migration chain: from version from to from + 1.
TimelinePlayback: One timeline being played by one entity. The ECS system drives one per player component; an editor drives its own to preview, and a game can make one with no component at all.
TimelinePlayerComponent: Plays a timeline. The timeline is a .timeline.json asset at timelinePath, shared by every player that names it — or, with no path, the inline one that belongs to this entity alone.
TimelineSignals: A bus of names, one per engine (engine.context.signals), shared by every world on that engine — the level's and the interface's screens', so a button on a screen can start a timeline in the level. A TimelinePlayerComponent whose listenSignal is a name plays when that name is emitted; a timeline event marked as a signal emits one.
TimelineSystem: Runs every TimelinePlayerComponent: loads its timeline, plays it, and says which events fired.
TimelineTrack: One row of a timeline. Immutable: an editor replaces a track to change it, which is what makes undo a list of assets.
TimelineTrackKinds: The kinds of track a timeline can hold. The engine's own are always there; a package registers more into an engine's (engine.context.trackKinds), and a timeline asset that uses them loads, plays and saves like any other:
TimelineTrackOffer: How an editor offers a kind of track for adding: what it is called, and an empty one of it.
TimelineTriggerComponent: A rectangle that starts a timeline when a target walks in — and may do something else when it walks out. Centred on the entity's transform.
TimelineTriggerSystem: Runs every TimelineTriggerComponent: watches its target cross the rectangle's edge and tells the player what to do.
TimelineV1ToV2: v1 → v2: rotation became three angles.
TimeManager: Time management system for the game engine
TouchscreenControls: The first finger on a touch screen. Several fingers at once are for the on-screen controls, each of which follows its own.
TouchscreenDevice: A touch screen: the first finger as TouchscreenControls, and every finger in touches for game code that wants them.
TrackBinding: Who a track acts on, looked up when the timeline plays — never an id, so a timeline asset fits any scene that has the names it asks for.
TrackRunner: The running half of a track, made fresh for every playback.
TransformComponent: Transform component — where an entity is in the world: position, rotation and scale, in 3-D.
TransformHierarchy: Keeps every child's world transform in step with its parent's.
TransformSignals: A collection of signals for all properties of a transform component.
TriangleParticleRenderer: Renders each particle as a filled triangle.
UnknownFieldType: Raw JSON, kept exactly as found.
UnknownTrack: A track of a kind nobody registered — a package that is not installed — or of a known kind whose reader could not read it (error says why). Kept as it was read so saving the timeline does not lose it.
V0ToV1: v0 → v1: every component becomes {type, fields}.
V1ToV2: v1 → v2: the camera becomes virtual cameras.
V2ToV3: v2 → v3: sprites play from an atlas.
V3ToV4: v3 → v4: timelines.
V4ToV5: v4 → v5: UI that keeps its look.
V5ToV6: v5 → v6: every entity is 3-D.
V6ToV7: v6 → v7: tags and targets.
V7ToV8: v7 → v8: physics bodies.
V8ToV9: v8 → v9: one physics model for 2-D and 3-D.
V9ToV10: v9 → v10: a scene entry may be an instance of a prefab file — a prefab block (path, and what it changes) in place of components — and an entry may name an entity inside such an instance as its parent (parentTarget, a path of the prefab's ids, beside parentName).
Vector2: A mutable 2-D vector.
Vector2FieldType: A Vector2, saved as {x, y}; a missing or non-numeric part reads as 0.
Vector3: A mutable 3-D vector.
Vector3FieldType: A Vector3, saved as {x, y, z}; a missing or non-numeric part reads as 0.
VelocityComponent: Velocity component — linear velocity in 3-D world space.
VelocitySignals: A collection of signals for velocity component.
ViewCullingSystem: Opt-in view culling — tracks which entities are near the camera and marks them accordingly on their CullStateComponent.
ViewVolume: The region of the world a camera sees.
VirtualCameraComponent: Makes its entity a virtual camera.
VortexForce: Rotational vortex force around center.
WangColorData: One terrain: grass, water, a road.
WangFiller: Paints terrains with one Wang set of one tileset, the way Tiled's terrain brush does.
WangResult: The result of a terrain stroke.
WangSetData: A set of terrains, and which corners or edges of which tiles are which.
WangTarget: One place a terrain brush paints, on the map's lattice (see MapGeometry.toLattice).
WeldJoint: Holds bodyB where it was against bodyA when the joint was made, turning with bodyA, at the same angle to it.
WheelJoint2D: A wheel on a suspension along axis.
WindForce: Continuously varying directional wind with optional turbulence.
World: ECS World - Manages all entities and systems
WorldAxes: Which way is which in the engine's world — for 2-D and 3-D alike.
WorldSignal: A signal that tracks world-level events like entity and system changes.
YarnParser: Parses Yarn Spinner 2.x dialogue source into a DialogueGraph.
YarnToken: A single logical line from a Yarn Spinner source file.
YarnTokenizer: Converts a Yarn Spinner source string into a flat YarnToken list.

Enums

ActionValueType: What an action reads out.
AngleUnit: How an angle is shown; the value itself is always radians.
AnimatorBlendType: How a blend tree places its motions.
AnimatorOp: How a condition compares its parameter with its value.
AnimatorParameterType: What kind of value a parameter holds.
AssetType: Asset types supported by the engine
AudioChannel: Audio channel identifiers — used to route clips to named mixer buses.
AudioEffectType: DSP effect types that can be applied per-voice or per-bus.
AudioFormat: Audio format types
AudioRequest: What a game asks of a playing sound; see AudioRequests.
AudioRolloff: How a 3-D sound gets quieter with distance from the listener.
AudioState: Playback lifecycle state of an AudioClip.
BodyType: How a body participates in the simulation.
BoundaryBehavior: Boundary behavior options
CameraNoisePreset: The noise recipes a CameraNoiseProfile can be picked from by name.
CameraProjection: Straight on, or with perspective.
CameraStagePhase: Where in the pipeline a stage runs. Within a phase, by CameraStage.order.
CameraStandbyUpdate: When a camera that is not live keeps evaluating its pipeline.
CameraTriggerMode: What a trigger does to its camera while the target is inside.
CameraUpdateMode: When the brain thinks.
CharacterShape2D: The shape a CharacterBody2D moves as.
ColliderShape2D: The shapes a Collider2D can be.
DefaultSystem: One of the engine's standard sets of systems; see registerDefaultSystems.
DeviceChange: Whether a device came or went.
DialogueEventType: Types of events produced by the dialogue system.
Dimensions: Which scene modes something belongs in — a component, a field, a prefab, a tool. An editor offers it only where it belongs.
EasingType: Easing curve selector for DeterministicEffect.
EngineState: Where an Engine is in its life.
EntityTargetKind: How an EntityTarget picks its entity.
GroundState2D: What a character stands on after a move.
InputActionPhase: Where an action is in its life.
JoinBehavior: How players come into a game.
JointType: Enumeration of joint types.
KeyInterpolation: How a key reaches the next one.
Light2DKind: What kind of light a Light2D is.
MapOrientation: The shape and layout of a map's cells — Tiled's four orientations.
Material2DKind: What a 2-D material is put on.
Material2DValue: What kind of value a Material2DParam holds, and how a file saves it.
OneWayDirection: Which side a one-way platform is solid from.
ParticleBoundaryBehavior: What happens when a particle hits a BoundaryForce rect.
PropertyTrackMode: How a property track's keys are read.
RebindState
SceneMode: How a scene is authored.
ShapeGradientKind: Engine-specific gradient descriptor for shape paints.
SubEmitterTrigger: When a sub-emitter should be spawned.
TangentMode: How an editor keeps a key's two handles in step. The runtime ignores it.
TileMergeMode: How a kind's tiles join up into bodies.
TilePropertyType: The kinds of value a property can hold — Tiled's.
TileRenderOrder: The order Tiled draws an orthogonal layer's tiles in. Kept for export; the engine draws every orientation back to front by screen position.
TileStaggerAxis: Which axis a staggered or hexagonal map staggers along.
TileStaggerIndex: Whether the odd or the even rows (or columns) are the shifted ones.
TimelineTriggerAction: What a TimelineTriggerComponent does to its player.
TimelineWrap: What happens when time reaches the end.
TimelineWrapChoice: Which wrap a player uses.
TokenType: Classifies the role of a single Yarn Spinner source line.
WangFeatureKind: What a terrain brush stroke touches: a corner, an edge, or a whole cell.
WangTemplate: A standard arrangement of terrain tiles in a tileset image, and the Wang ids that arrangement means.
WangType: What a terrain set matches tiles by — Tiled's Wang set types.

Mixins

AudioRequests: Play, pause, resume and stop for a component that plays a sound — AudioSourceComponent and AudioStreamComponent.
LifecycleStateMixin: Mixin for adding lifecycle state tracking
ReactiveComponent: A mixin for components that want built-in change notification.
SignalSyncMixin: A system that syncs component changes to signals after processing.

Extensions

EntityTags on Entity: Tagging straight from an entity.
JustMatrix4 on Matrix4: Engine-side operations on Matrix4.
ReactiveEntityExtension on Entity: Extension on Entity to create reactive wrappers.
ReactiveWorldExtension on World: Extension on World to create reactive wrappers.

Functions

cameraAnglesOf(Vector3 direction) → (double, double): The pitch and yaw that look along direction.
cameraForward(double pitch, double yaw) → Vector3: The way a camera with pitch and yaw looks (unit length): +Z when both are zero. A pitch below zero looks down (+Y is down).
offload<M, R>(ComputeCallback<M, R> work, M message) → Future<R>: Run a pure function work on a background isolate, passing message as input and returning the result.
offloadUnit<R>(ComputeCallback<void, R> work) → Future<R>: Variant of offload for functions that take no meaningful input.
rebindPlayer(PlayerInput player, String bindingId, {bool swap = true, KeyboardCaptureHook? keyboardHook, void onStart(RebindingOperation operation)?}) → Future<RebindResult>: Rebinds one of player's bindings: listens, keeps the result, saves.
refreshCoreCodecs(ComponentDefinitionRegistry registry) → void: Puts the engine's own definitions in registry again as the code now makes them, leaving a project's replacements alone — see ComponentDefinitionRegistry.refresh. For a hot reload; a game never needs it.
registerCameraSystems(World world, CameraSystem cameraSystem) → void: Adds every system the camera needs to world. Call it from boot, where the game registers its other systems.
registerCoreCodecs(ComponentDefinitionRegistry registry) → void: Registers every component the engine itself defines into registry, one definition each. The definition is the wire codec: what it encodes is scene format v1, and a v0 file is migrated on load.
registerDefaultSystems(World world, Engine engine, {Set<DefaultSystem> include = DefaultSystems.all, GameCamera? camera, List<String> inputMaps = const ['player']}) → void: Adds the engine's standard systems in include to world — the engine's world, normally, or another world run with engine's subsystems.
registerLevelMapSystems(World world, {bool collision = true}) → void: Adds what level maps need to world: the system that loads and draws them and the one that builds their collision. Skips any already there, so calling it twice is harmless.
registerSpriteSystems(World world, {SpriteAssetLoader? loader, Future<AnimatorGraph> graphLoader(String path)?, Future<TimelineAsset> timelineLoader(String path)?}) → void: Registers what shows and animates sprites: still sprites, the animator state machine, clip playback and timelines. A game that places sprites calls this once at boot; without it a sprite component is only data. Systems already in world are left alone.

Typedefs

AnimatorBinding = Object? Function(Entity entity): Reads an entity's own state into an animator parameter, every frame. Returns a num or a bool, or null to leave the parameter alone.
AnimatorGraphLoader = Future<AnimatorGraph> Function(String path): Loads an animator graph by path.
ComponentFactory = Component Function(): A factory function that creates a fresh Component instance.
ComponentMigration = Map<String, dynamic> Function(Map<String, dynamic> component): Rewrites one component's v0 JSON to its v1 shape. Receives the component map with type already read; must return {type, fields}.
DeviceListener = void Function(InputDevice device, DeviceChange change)
DialogueCommandHandler = Future<void> Function(DialogueCommandContext ctx): Handler invoked when a <<commandName args>> statement is executed.
DialoguePredicate = bool Function(DialogueVariableStore variables): A Dart function used as a named dialogue condition in Yarn <<if>> blocks.
DisposeCallback = FutureOr<void> Function()
EasingFunction = double Function(double t): An easing curve: normalised progress t ∈ [0, 1] to eased progress.
EffectDecoder = DeterministicEffect Function(Map<String, dynamic> json, EffectSerializer serializer): Reads one effect from its saved form; serializer reads any effects nested in it.
EntityId = int: Unique identifier for an entity
EntityMigration = void Function(Map<String, dynamic> entity, Map<String, dynamic> scene): Rewrites one entity in place. scene is the whole file, for a migration that has to look at — or add — other entities.
EventCallback<T extends GameEvent> = void Function(T event): Typed callback for event subscriptions.
FieldMigration = void Function(Map<String, dynamic> fields): Rewrites a component's fields map in place.
FrameCallback = void Function(double deltaTime, double alpha): Called once per rendered frame, after its fixed updates: deltaTime is the frame's length in seconds — at most TimeManager.maxDeltaTime, then scaled by the time scale — alpha how far the frame lies between the last two fixed updates (0..1).
FrameTask = void Function(double deltaTime, double alpha): Callback used by the frame scheduler for per-frame tasks: deltaTime is the frame's length, alpha how far it lies between the last two fixed updates.
InputActionCallback = void Function(InputAction action)
PrefabLoader = Future<PrefabFile> Function(String path): Loads a prefab file by path.
RawInputListener = void Function(InputControl control, double magnitude): Called for every control whose value changes, the moment it changes — before any update, and while the game is paused.
RenderCallback = void Function(): Type definition for render callback
RenderHook = void Function(Canvas canvas, Size size): A render callback in screen or world space.
RenderPassFilter = bool Function(Entity entity): Whether an entity should be drawn this frame.
SpawnFunction = Entity Function(World world, Entity spawnPoint): Creates the entity for a spawn point: the player, an enemy wave, a pickup.
SpriteBatchFactory = SpriteBatchRenderer Function(Image atlas): Factory function type for creating SpriteBatchRenderer instances.
TerminalCommandHandler = String? Function(List<String> args): Signature for a registered terminal command handler.
TextReader = Future<String> Function(String path): Reads a text file by path.
TimelineAudioPlayer = void Function(TimelineContext context, Entity at, TimelineBlock cue): Makes the sound an audio track's cue asks for, at entity at.
TimelineLoader = Future<TimelineAsset> Function(String path): Loads a timeline by path.
TimelineTrackReader = TimelineTrack Function(Map<String, dynamic> json): Reads a track of one kind from its saved form.
TrackBindingKind = EntityTargetKind: Who a track acts on: EntityTargetKind, by its timeline name.
TrackMigration = Map<String, dynamic>? Function(Map<String, dynamic> track): Rewrites one track of a version-1 timeline for version 2. Returns the track, changed or not, or null to drop it.
UpdateCallback = void Function(double deltaTime): Type definition for update callback
UpdateTask = void Function(double deltaTime): Callback used by the frame scheduler for update tasks.

Exceptions / Errors

AssetLoadException: Asset loading exception
EngineInitException: Why Engine.initialize failed: the stage that threw, and what it threw.
EngineNotReadyError: An engine subsystem was asked for when there is none: before Engine.initialize has built it, or after Engine.dispose.
UnknownComponentTypeException: Thrown when a level contains a component no registered codec understands.
UnsupportedFormatVersionException: A saved file declares a format version newer than this engine reads.
YarnParseException: Thrown when a Yarn Spinner source string cannot be parsed.

just_game_engine library

Classes

Enums

Mixins

Extensions

Functions

Typedefs

Exceptions / Errors

just_game_engine package

just_game_engine library