just_game_engine library

Just Game Engine for Flutter

A comprehensive game engine package for Flutter providing core game development features.

This is the main entry point for the Just Game Engine. Import this library to access all engine functionality.

Example usage:

import 'package:just_game_engine/just_game_engine.dart';

void main() async {
  final engine = Engine();
  await engine.initialize();
  engine.start();
}

Classes

Achievement: A single achievement definition with mutable runtime state.
AchievementManager: Manages achievement definitions, tracks progress, persists state, and delegates to a platform AchievementProvider.
AchievementProgressUpdatedEvent: Fired on the ECS event bus when a progress achievement advances.
AchievementProvider: Contract for platform achievement backends (Play Games, Game Center, Steam, etc.).
AchievementUnlockedEvent: Fired on the ECS event bus when an achievement is first unlocked.
AdConsentStatusChangedEvent: Fired when the UMP consent status changes.
AdDismissedEvent: Fired when an ad overlay is dismissed by the user.
AdFailedToLoadEvent: Fired when an ad fails to load.
AdLoadedEvent: Fired when an ad has finished loading.
AdRewardedEvent: Fired when a rewarded ad grants its reward.
AdShownEvent: Fired when an ad is displayed to the user.
AdsManager: Engine-level façade for the ads subsystem.
AdsProvider: Abstract contract for ad backends.
AnimatedSpriteParticleRenderer: Renders particles as animated sprites, advancing through frames over the particle's lifetime.
Animation: Base class for all animations.
AnimationGroup: Parallel animations
AnimationSequence: Sequence of animations
AnimationStateComponent: Animation state component - Tracks current animation
AnimationSystem: Main animation system class
AnimationSystemECS: Animation system — advances animation time and updates sprite frames.
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
AssetBundle: Asset bundle for grouped loading
AssetLoader: Base asset loader interface
AssetManager: Main asset manager class
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.
AtlasSpriteAnimation: An Animation that drives a Sprite through the frames of an AtlasAnimationClip.
AttractorForce: Point attractor — pulls particles toward center.
Audio3DListener: Full listener orientation: position, look-at direction, and up vector.
Audio3DPosition: 3-dimensional position in world space used 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 an entity as the audio listener (typically the camera or player).
AudioPauseComponent: Trigger component: add this to an entity to pause its active AudioSourceComponent playback. Removed by AudioSystem after processing.
AudioPlayComponent: Trigger component: add this to an entity to request one-shot playback.
AudioResumeComponent: Trigger component: add this to an entity to resume its paused AudioSourceComponent playback. Removed by AudioSystem after processing.
AudioSourceComponent: Component describing an audio source attached to an entity.
AudioStopComponent: Trigger component: add this to an entity to stop its active AudioSourceComponent playback. Removed by AudioSystem after processing.
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.
AuthManager: Manages platform authentication and exposes the signed-in AuthUser.
AuthProvider: Contract for platform authentication backends (Play Games, Game Center, Steam, Epic Games, etc.).
AuthSignedInEvent: Fired when a player successfully signs in via any AuthProvider.
AuthSignedOutEvent: Fired when the current player signs out.
AuthUser: A signed-in player returned by an AuthProvider.
AutoSyncSystem: A system that automatically syncs signals after each frame.
BannerAdConfig: Configuration for creating a banner ad.
BannerAdInstance: A loaded, renderable banner ad handle.
BatchableSprite: Marker interface for renderables that can be GPU-batched.
BinaryAsset: Binary asset
BinaryAssetLoader: Binary asset loader
BodyPair: Pair of physics bodies for collision checking.
BoundaryForce: Restricts particles to an axis-aligned rectangle.
BoundarySystem: Boundary system - Keeps entities within bounds
Box2DJoint
Box2DPhysicsEngine
BudgetedCache<K, V>
ButtonComponent: UI button component data.
CacheBudgetStats
CacheManager: Manages caching of various game resources.
Camera: Camera — viewport control, coordinate transforms, trauma shake, spring motion and visual effects.
CameraBehavior: Abstract base for pluggable camera behaviors.
CameraEffect: Abstract base class for camera visual effects.
CameraEffectManager: Owns a list of CameraEffect instances and routes rendering calls each frame.
CameraFollowComponent: Marks an entity as a camera follow target.
CameraFollowSystem: ECS system that drives the camera based on entities carrying a CameraFollowComponent.
CameraKeyframe: A single keyframe on a CameraPath.
CameraPath: An ordered sequence of CameraKeyframe values.
CameraRoom: A bounded rectangular room definition for RoomBehavior.
CameraSystem: Manages the mainCamera and drives the pluggable behavior stack each frame.
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.
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.
CinematicBehavior: Plays back a CinematicSequence, interpolating camera values between keyframes and firing CinematicKeyframe.onArrive callbacks exactly once.
CinematicKeyframe: A keyframe in a CinematicSequence.
CinematicSequence: An ordered sequence of CinematicKeyframe values.
CircleComponent: Circle shape component.
CircleParticleRenderer: Renders each particle as a filled circle.
CircleRenderable
CircleShape: A circular collision shape.
CircularProgressComponent: Circular UI progress bar component data.
CollisionDetector: Utility for manual broad-phase collision queries outside PhysicsEngine.
CollisionEvent: Fired when two physics entities collide.
CollisionManifold: Contains information about a collision between two bodies.
CollisionShape: Base class for collision shapes.
ColorTintEffect: Animates the Renderable.tint colour of an entity's RenderableComponent from a starting colour to to over durationTicks ticks.
ColorTween: Color tween for color transitions
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.
CommandStatement: A generic <<commandName arg1 arg2 …>> statement.
Component: Base class for all components
ComponentSignal<C extends Component, T>: A signal that wraps a component's property for reactive updates.
ConditionalBranch: One arm of a ConditionalStatement.
ConditionalStatement: An <<if>> … <<elseif>> … <<else>> … <<endif>> block.
ConsentConfig: Configuration for the UMP consent flow passed to AdsProvider.initialize.
ContactExitEvent: Fired when two physics entities that were colliding stop overlapping.
ControllerInput: Handles game controller/gamepad input
CurrencyChangedEvent
CurrencyManager
CustomPathParticleRenderer: Renders each particle as an arbitrary developer-provided Path.
CustomRenderable: A custom renderable that uses a callback for rendering
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.
DialogueBoxWidget: A ready-to-use dialogue box that renders the current DialogueLine from a DialogueRunner with an optional typewriter animation.
DialogueChoice: A single player choice after localization and condition evaluation have been applied.
DialogueChoicesWidget: Displays the current set of DialogueChoices and calls DialogueRunner.selectChoice when the player taps one.
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 emitted by DialogueManager to an optional event bus.
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: Maintains a target distance (range minLength, maxLength) between two bodies.
DragForce: Velocity-proportional drag (air resistance).
Easings: Common easing functions
EffectBinaryCodec: Compact binary codec for EffectSnapshot.
EffectComponent: ECS component that attaches an EffectPlayer to an entity.
EffectContext: Per-tick execution context for DeterministicEffect.applyTick.
EffectEasings: Self-contained easing math for the effects system.
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.
Engine: Main game engine class that orchestrates all subsystems
Entity: Entity - A lightweight handle for components stored in an Archetype.
EntityPrefab: A reusable entity blueprint that can be instantiated many times.
EntitySignal: A signal that tracks entity-level events like component changes.
EpicGamesAuthProvider: AuthProvider stub for Epic Games Online Services.
EpicGamesLeaderboardProvider: LeaderboardProvider stub for Epic Online Services.
EventBus: A lightweight event bus for decoupled inter-system communication.
EventSubscription: Handle returned by EventBus.on to cancel a subscription.
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.
ForceManager: Applies global forces (gravity, wind, etc.) to a set of PhysicsBodys.
GameCamera: Minimal camera interface consumed by ECS render systems.
GameCameraControls: A widget that wraps child with scroll-wheel and on-screen +/− zoom controls that operate a Camera without rebuilding the child.
GameEvent: Base class for all events dispatched through the EventBus.
GameLoop: Main game loop implementation
GameObject: Base class for game objects in a scene
GamepadAxis: Gamepad axis identifiers
GamepadButton: Gamepad button identifiers
GameTerminal: Manages all in-game terminal state: visibility, text input, scrollback history, and the command registry.
GameWidget: Main game widget that renders the game
GravityForce: Constant gravitational acceleration.
HealthComponent: Health component - HP system
HealthSignals: A collection of signals for health component.
HealthSystem: Health system - Handles death and health regeneration
HierarchySystem: Parent-child system - Updates child transforms based on parents.
IEnableable: Interface for systems that can be enabled/disabled
ILifecycle: Interface for objects with lifecycle management
ImageAsset: Image/Texture asset
ImageAssetLoader: Image asset loader
InputComponent: Input component - Tracks input state for an entity
InputManager: Main input manager class
InputSystem: System that reads InputManager state and writes it into ECS components.
InventoryItem
InventoryItemChangedEvent
InventoryManager
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
JointConstraint: Base class for all Dart-fallback joint constraints.
JoystickInputComponent: Joystick input component for ECS-driven touch controls.
JsonAsset: JSON asset
JsonAssetLoader: JSON asset loader
JumpStatement: <<jump NodeTitle>> — unconditionally jumps to another node.
JustAdSize: Named ad size constants that mirror google_mobile_ads without importing it.
JustRewardItem: A reward item granted after a completed rewarded ad view.
KeyboardInput: Handles keyboard input
LeaderboardDefinition: Defines a leaderboard with its platform-specific IDs.
LeaderboardEntry: A single entry returned from a leaderboard query.
LeaderboardManager: Manages leaderboard definitions, submission, and platform delegation.
LeaderboardProvider: Contract for platform leaderboard backends (Play Games, Game Center, Steam, Epic Games, etc.).
LeaderboardScoreSubmittedEvent: Fired on the ECS event bus after a score is successfully submitted.
LeakTracker
LetterboxEffect: Animated cinematic letterbox — solid bars at the top and bottom of the screen.
LifetimeComponent: Lifetime component - Entity that expires after time
LifetimeSystem: Lifetime system - Destroys expired entities
LinearProgressComponent: Linear UI progress bar component data.
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.
LocaleSelector: A widget that renders a locale switcher from a list of supported locales.
LocaleStringTable: An immutable flat mapping from string key → localized string for one Locale.
LocalizationBuilder: Rebuilds its subtree whenever the active locale changes.
LocalizationManager: Engine-wide localization service.
LocalizationScope: Provides a LocalizationManager to the widget subtree via LocalizationScope.of.
LocalizedText: A Text widget that displays a localized string and automatically rebuilds when the locale changes.
LookaheadBehavior: Follow behavior that anticipates movement by offsetting the target in the direction of travel.
MemoryArena
MemoryCleanupResult
MemoryProfiler
MemoryProfileSnapshot
MemoryScope
MemoryStats
MotionBlurEffect: Directional motion blur driven by camera velocity.
MouseButton: Mouse button constants
MouseInput: Handles mouse input
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
MultiTargetBehavior: Keeps multiple world-space positions simultaneously visible by computing their bounding box and auto-adjusting camera position and zoom.
MusicManager: Convenience wrapper around AudioEngine for background music.
NarrativeSignals: All reactive state exposed by a running DialogueRunner.
NetworkClient: Handles client-side networking
NetworkManager: Main networking class
NetworkProtocol: Handles network protocols
NetworkServer: Handles server-side networking
NetworkSync: Manages network synchronization
NineSliceSprite: Nine-slice sprite for UI elements
NoiseForce: Noise-based perturbation using 2-D value noise.
NoOpAchievementProvider: Default provider — persists achievements locally only, no platform calls.
NoOpAdsProvider: Default no-op provider — all methods silently succeed, no ads are shown.
NoOpAuthProvider: Default provider — no platform calls, always reports signed out.
NoOpLeaderboardProvider: Default provider — no platform calls, all operations are no-ops.
ObjectPool<T>
OpacityTween: Opacity tween for fading objects
ParallaxBackground: A multi-layer parallax background.
ParallaxComponent: Parallax component — attaches a ParallaxBackground to an entity.
ParallaxLayer: A single layer in a parallax background.
ParallaxSystem: Parallax subsystem that manages multiple ParallaxBackground instances.
ParallelEffect: Runs all child effects simultaneously.
ParentComponent: Parent-child component - Hierarchy relationships
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.
PathBehavior: Drives the camera along a CameraPath over time.
PathEffect: Moves an entity along a path defined by waypoints over durationTicks.
PhysicsBody: Physics body — the core simulation object in the physics engine.
PhysicsBodyComponent: Physics body component - Collision and physics properties
PhysicsBodyRefComponent: Links an entity to a subsystem PhysicsBody for automatic position sync.
PhysicsBridgeSystem: Syncs subsystem PhysicsBody → ECS TransformComponent each frame.
PhysicsEngine: Main physics engine class
PhysicsSystem: Physics system - Handles physics simulation for ECS entities
PlayerRespawnEvent: Fired by CheckpointSystem.respawn to request the player be moved to their last saved respawn position.
PolygonComponent: Polygon shape component.
PolygonShape: A convex polygonal collision shape using SAT (Separating Axis Theorem).
PoolManager
PoolStats
PositionTween: Position tween for moving objects
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.
PriorityPool<T>
Quadtree<T>: A spatial quadtree that indexes items by their bounding rectangle.
Ray: A ray in 2-D world space with an origin, normalised direction, and maximum travel distance.
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.
ReactiveHealthComponent: A reactive health component with built-in signals.
ReactiveSystem: A system that only processes entities with dirty (changed) components.
ReactiveTransformComponent: A reactive transform component with built-in signals.
ReactiveVelocityComponent: A reactive velocity component with built-in signals.
RectangleComponent: Rectangle shape component.
RectangleRenderable: A renderable rectangle shape
RectangleShape: A rectangular collision shape (simplified Polygon).
Recyclable: Interface for objects that can clear their mutable state before reuse.
RefCountedRegistry<K, V>
Renderable: Base class for all renderable objects
RenderableComponent: Renderable component - Links to a Renderable object
RenderingEngine: Main rendering engine class responsible for graphics rendering
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.
ResourceHandle<K, V>
RevoluteJoint: Constrains two bodies to rotate around a shared world-space anchor point.
RigidBody: Represents a rigid body with 2D force accumulation (convenience wrapper).
RoomBehavior: Snaps and transitions the camera between defined rooms, then clamps camera movement within the active room's bounds.
RotateEffect: Animates an entity's TransformComponent.rotation from its captured start to to (radians) over durationTicks ticks.
RotationTween: Rotation tween for rotating objects
RoundedPolygonShape: A convex polygon with rounded corners.
RoundRobinPool<T>
ScaleEffect: Animates an entity's TransformComponent.scale from its captured start to to over durationTicks ticks.
ScaleTween: Scale tween for scaling objects
Scene: Represents a scene/level in the game
SceneEditor: Main scene editor class
SceneGraph: Manages object hierarchy and transforms
SceneNode: Node in the scene graph (hierarchical)
ScreenFadeEffect: Full-screen colour overlay with animated alpha.
SegmentShape: A line-segment collision shape for static terrain and one-way platforms.
SensorEnterEvent: Fired when a non-sensor body begins overlapping a sensor body.
SensorExitEvent: Fired when a non-sensor body stops overlapping a sensor body.
SequenceEffect: Runs a list of child effects one after another in order.
SessionManager: Manages player sessions
SetStatement: <<set $variable = expression>> — assigns a value to a Yarn variable.
ShaderComponent: Attaches a custom GLSL ui.FragmentShader to an ECS entity.
ShakeEffect: Applies a damped oscillating positional shake to TransformComponent.
ShapeCastResult: The result of a circle shape cast against a PhysicsBody.
SoundEffectManager: Convenience wrapper around AudioEngine for one-shot & looping SFX.
SpatialGrid: A uniform grid for broad-phase collision detection.
SpringFollowBehavior: Continuously follows a target position using the camera's spring smoothing.
Sprite: A sprite that can be rendered
SpriteAnimation: Sprite animation for frame-based animations
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.drawAtlas call.
SpriteBatchRenderer: Abstract contract for a sprite-batch renderer.
SpriteComponent: Sprite component - Sprite rendering data
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).
StarParticleRenderer: Renders each particle as a 5-pointed star.
SteamAuthProvider: AuthProvider stub for Steam (Windows / Linux).
SteamLeaderboardProvider: LeaderboardProvider stub for Steam (Windows / Linux).
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.
SubtitleOverlay: Wraps child and overlays a subtitle panel driven by controller.
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: Tag component - Simple marker component
TextAsset: Text asset
TextAssetLoader: Text asset loader
TextComponent: UI text component data.
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.
TiledCollisionSystem: System that loads TMX collision objects into the physics engine.
TiledMapFactory: Factory that spawns ECS entities from a parsed TiledMap.
TiledObjectComponent: Component for entities representing a Tiled map object.
TileMapLayerComponent: Component for entities representing an entire tile layer.
TileMapRenderSystem: System that renders tile map layers within the ECS world.
TimeManager: Time management system for the game engine
TouchInput: Handles touchscreen input
TouchPoint: Touch point information
TransformComponent: Transform component — position, rotation, and scale in 3-D world space.
TransformSignals: A collection of signals for all properties of a transform component.
TriangleParticleRenderer: Renders each particle as a filled triangle.
TweenAnimation<T>: Tween animation for interpolating values.
TypedBuffer<T extends num>
TypedTransform
TypedVec2
UIComponent: Base UI component for ECS-driven interface elements.
Vector2: A mutable 2-D vector.
Vector3: A mutable 3-D vector.
VelocityComponent: Velocity component — linear velocity in 3-D world space.
VelocitySignals: A collection of signals for velocity component.
VirtualJoystick: A reusable virtual joystick widget for touch controls.
VortexForce: Rotational vortex force around center.
WeldJoint: Rigidly locks two bodies together by strongly correcting their relative position and velocity each step.
WindForce: Continuously varying directional wind with optional turbulence.
World: ECS World - Manages all entities and systems
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

AchievementType: Whether an achievement requires a single action or cumulative progress.
AdType: Distinguishes ad formats in events.
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
AudioState: Playback lifecycle state of an AudioClip.
AuthPlatform: The platform that authenticated the current user.
BoundaryBehavior: Boundary behavior options
ConsentStatus: GDPR/UMP consent status.
DialogueEventType: Types of events produced by the dialogue system.
EasingType: Easing curve selector for DeterministicEffect.
EngineState: Engine state enumeration
JointType: Enumeration of joint types.
JoystickAxis: Axis constraint mode.
JoystickInputAxis: Axis lock mode for joystick input.
JoystickInputLayout: Joystick placement behavior for input components.
JoystickVariant: Joystick placement behavior.
ParticleBoundaryBehavior: What happens when a particle hits a BoundaryForce rect.
ParticleShape: Shape enum — kept for backward compatibility.
SubEmitterTrigger: When a sub-emitter should be spawned.
TokenType: Classifies the role of a single Yarn Spinner source line.

Mixins

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

L10nContext on BuildContext: Convenience extension on BuildContext for quick string lookups.
ParticleShapeRenderer on ParticleShape: Converts a ParticleShape enum value to the corresponding ParticleRenderer.
ReactiveEntityExtension on Entity: Extension on Entity to create reactive wrappers.
ReactiveWorldExtension on World: Extension on World to create reactive wrappers.

Properties

easeInCubic → Easing: final
easeInOutCubic → Easing: final
easeInOutQuad → Easing: final
easeInQuad → Easing: final
easeOutCubic → Easing: final
easeOutQuad → Easing: final
linear → Easing: final

Functions

createAudioBackend() → AudioBackend: Returns the correct AudioBackend for the current platform.
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.

Typedefs

ButtonMapping = Map<String, LogicalKeyboardKey>: Maps for translating InputComponent.buttons string keys to keyboard keys.
ComponentFactory = Component Function(): A factory function that creates a fresh Component instance.
ComponentMapper = Component? Function(String className, TiledProperties properties): Callback for mapping Tiled custom properties to engine components.
CostEstimator<K, V> = int Function(K key, V value)
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()
Easing = double Function(double t): Easing functions for smooth animations
EntityId = int: Unique identifier for an entity
EventCallback<T extends GameEvent> = void Function(T event): Typed callback for event subscriptions.
EvictionCallback<K, V> = void Function(K key, V value)
RenderCallback = void Function(): Type definition for render callback
ResourceDisposer<V> = FutureOr<void> Function(V value)
ResourceLoader<K, V> = FutureOr<V> Function(K key)
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.
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
YarnParseException: Thrown when a Yarn Spinner source string cannot be parsed.

just_game_engine library

Classes

Enums

Mixins

Extensions

Properties

Functions

Typedefs

Exceptions / Errors

just_game_engine package

just_game_engine library