API Reference

Custom error class for Glyft with fix instructions.

Tween manager with object pooling.

Named animation definition for override animations

Texture atlas

Atlas frame data

Camera

Collision action

Options for floating text

Main Glyft engine interface

A Glyft addon extends the engine with new capabilities via `game.use()`. Lifecycle: 1. Factory function creates addon config → GlyftAddon object 2. `game.use(addon)` calls `init()` with the game instance 3. Each frame, hooks are called in order: - `preUpdate(dt)` → before user `onUpdate` callbacks - `postUpdate(dt)` → after user callbacks, before collision detection - `postPhysics(dt)` → after collisions + reactive sounds 4. `destroy()` called on addon removal

Main configuration object for a Glyft game. Glyft is config-driven: game rules are defined as data, not scattered code. This enables hot-reload, easy serialization, and cleaner game logic.

Core engine settings - required for every Glyft game.

Input manager

Network adapter interface

Network adapter interface. Implement this for your transport layer (WebSocket, socket.io, WebRTC, etc.)

Network configuration

Network configuration for GlyftConfig.

Particle emitter definition

Declarative sound effect definition. Each SfxDef describes a procedurally-generated sound using Web Audio oscillators. All fields are serializable JSON — no callbacks, no audio files needed.

Compiled shader program

Sound rule options

A game sprite with GPU-driven animation. Sprites use velocity-driven animation: set `vx` and `vy`, and the GPU shader automatically selects the correct direction and walk/idle frames.

Pointer event fired on interactive sprites or the game canvas.

Stat definition

Stats manager

Tilemap

Tween handle for cancellation

Tween configuration options

Properties that can be tweened

Any object with numeric properties that can be tweened

Direction (for 4dir mode)

Direction (for 8dir mode)

Easing function type

Easing name (matches helpers.ts)

Config for floatText in collision actions: true = auto, or override options

Float text display style

Game event for network sync

Game events sent between client and server.

Custom handler function

Label visibility mode

Sprite animation mode - determines how velocity maps to sprite directions. The mode you choose affects how your spritesheet should be organized: | Mode | Rows | Description | |------|------|-------------| | `'4dir'` | 4 | Down, Right, Up, Left (RPG-style) | | `'8dir'` | 8 | 8 compass directions | | `'2dir-side'` | 1 | Left/Right, GPU flips for left (platformer) | | `'2dir-top'` | 2 | Down, Up only | | `'1dir'` | 1 | Single direction, use rotation for facing | | `'iso4'` | 4 | Isometric SE, SW, NW, NE | | `'iso8'` | 8 | 8 isometric directions |

Get the angle from one point to another (in radians).

Apply collision action for pattern [A]:[B] — "A encounters B". Effects (damage, heal, knockback, flash) target A (the subject). Removal (destroy, collect) targets B (the thing encountered). Float text appears above A.

Clamp a value between min and max.

Compile a shader program from vertex and fragment source.

Create a vertex buffer.

Create collision system.

Initialize WebGL2 context with optimal settings.

Create a data texture (for tilemap storage).

Create the music manager.

Create the sound manager.

Create a VAO for instanced rendering.

Calculate Euclidean distance between two points.

Calculate squared distance (faster than distance, good for comparisons).

Find the best matching rule for a collision/event. More specific patterns take priority.

Calculate direction index from velocity (for 4-direction sprites).

Calculate direction index from velocity (for 8-direction sprites).

Linear interpolation between two values.

Load an image and create a WebGL texture.

Pattern matching for reactive sounds. Patterns: - `[tag]` - sprite has tag - `name*` - wildcard - `[t1,t2]` - multiple tags (AND) - `a:b` - a collides with b - `a:moving` - a has velocity - `a:destroyed` - a was destroyed

Move a value toward a target at a constant speed.

Normalize a 2D vector (make it unit length).

Check if a point is inside a rectangle.

Generate a random number between min and max (inclusive).

Generate a random integer between min and max (inclusive).

Pick a random element from an array.

Check if two rectangles overlap.

Set canvas size to virtual viewport (pixel-perfect). CSS handles scaling - canvas stays at exact viewport size.

Shuffle an array in place (Fisher-Yates algorithm).

Smoothly damp a value toward a target (spring-like smoothing).

Convert radians to degrees.

Convert degrees to radians.

Update a region of a data texture.

Wrap a value around a range (useful for seamless map scrolling).

Easing functions for smooth animations. All functions take t in range [0, 1] and return value in range [0, 1].