API Reference

Complete API Reference

Also available in short form inside the Editor itself:

Asset Constructors

Constructors create the main asset types used by the editor. When you assign one to a variable, the editor recognizes it and lets you open the matching asset editor with Ctrl+Click.

List Methods

Create lists with [] or [value1, value2, ...]. Read and overwrite entries with list[index], and iterate with for (var i = 0; i < list.length(); i = i + 1).

Operators

Operators are small symbols that perform common calculations. The modulo operator is especially useful for wrapping timers, indexes, animation steps, or repeating patterns.

Object Properties

Objects are the things your script usually moves and changes during the game. These functions read or update an object's position, sprite, collision behavior, layer, and visual tint.

Sprite Functions

Sprite functions let code inspect or modify sprite pixel data and animation speed. Most games draw sprites in the editor, but these functions are useful for procedural effects, debugging, or simple runtime changes.

Animation Functions

Animation functions work on objects that use sprites with multiple frames. Use them when you want code to inspect or force the current animation frame.

Transform Functions (Flip/Rotation)

Transform functions change how an object's sprite is drawn without editing the sprite itself. They are good for reusing one sprite in multiple directions.

Note: These transforms are applied at render time only. They do not affect collision boxes or actual sprite pixel data.

Collision Types

Collision types decide how an object participates in collision checks. Pick the type based on the role of the object: walls are usually static, players are usually dynamic, and pickups are often triggers.

Scene Functions

Scene functions control which scene is active, which objects are inside it, and scene-wide settings like background color and gravity. They also provide search helpers for finding objects at positions or by name.

Audio Playback

Audio playback functions start and stop audio assets from script. playAudio() returns a handle so you can later stop or check that specific playback instance.

Screen Functions

Screen functions help when you need to know the window size or convert between screen pixels and world positions. This is useful for mouse aiming, click detection, and camera-aware UI.

Window Mode

Control the window mode for exported games. These functions have no effect when playing in the editor (the editor has higher authority over window state).

Example:

func start() {
    // Set window mode (WINDOW_MAXIMIZED is the default for exported games)
    setWindowMode(WINDOW_MAXIMIZED())
}

Note: If setWindowMode() is never called in an exported game, the default is WINDOW_MAXIMIZED.

UI Functions

UI uses a virtual screen-space resolution. The default UI space is 100 x 100. Font size can be pushed for subsequent text widgets with uiPushFontSize(size) and restored with uiPopFontSize(). Font colors can be stacked with uiPushFontColor(r, g, b[, a]), and UI element fills can be stacked with uiPushElementColor(r, g, b[, a]). Like the rest of the immediate-mode UI, these overrides apply while building the current frame's UI. If the pushed size is 0 or less, the engine uses automatic sizing.

UI State Constants

UI functions return state constants so your script can tell whether a widget is idle, hovered, held, or clicked. Usually UI_CLICKED() is the value you check for button actions.

Camera Functions

The camera position represents the center of the view. The zoom maintains consistent vertical world view regardless of screen size.

Zoom behavior: The zoom maintains consistent vertical world view regardless of window size or aspect ratio. Wider screens show more horizontally but the same amount vertically.

Input Functions

Input functions let the game react to keyboard and mouse state. Use Pressed for one-frame actions, Held for continuous movement, and Released for actions that happen when a button is let go.

Mouse Button Constants

Mouse button constants are passed into the mouse input functions. They make code easier to read than raw numbers.

Key Constants

Key constants are passed into keyboard input functions. The engine exposes letters, numbers, function keys, arrows, and a small set of common special keys.

Letters: KEY_A() through KEY_Z()

Numbers: KEY_0() through KEY_9()

Function keys: KEY_F1() through KEY_F12()

Special keys: | Constant | Key | |----------|-----| | KEY_SPACE() | Spacebar | | KEY_ENTER() | Enter/Return | | KEY_ESCAPE() | Escape | | KEY_TAB() | Tab | | KEY_BACKSPACE() | Backspace | | KEY_DELETE() | Delete | | KEY_SHIFT() | Shift | | KEY_CTRL() | Control | | KEY_ALT() | Alt | | KEY_LEFT() | Left arrow | | KEY_RIGHT() | Right arrow | | KEY_UP() | Up arrow | | KEY_DOWN() | Down arrow | | KEY_HOME() | Home | | KEY_END() | End |

Math Functions

Math helpers cover common calculations used in movement, animation, randomness, and value limits. They keep scripts shorter and easier to read.

Utility Functions

Utility functions are general helpers that do not belong to a specific asset type. print() is especially useful while learning because it shows what your script is doing.

String Functions

String functions work with text values. For now, this section is intentionally small.

Storage Functions

Save and load game data to files. Supports numbers, strings, booleans, and lists (including nested lists). Does NOT support Sprite, Scene, Object, or Audio values.

Example: Saving and Loading Player Progress

// Save player data
var playerData = [100, "Player1", true, [1, 2, 3]]
var savePath = getAppDataPath() + "/MyGame/save.dat"
if (save(savePath, playerData)) {
    print("Game saved!")
}

// Load player data
if (fileExists(savePath)) {
    var loaded = load(savePath)
    if (loaded != null) {
        var health = loaded[0]
        var name = loaded[1]
        var hasKey = loaded[2]
        var inventory = loaded[3]
    }
}

// Encrypted save (for hiding data from casual inspection)
var secretData = ["secret", 12345]
save(getAppDataPath() + "/MyGame/config.dat", secretData, "binary", "mySecretKey")
var decrypted = load(getAppDataPath() + "/MyGame/config.dat", "mySecretKey")

// Text format (human-readable, useful for debugging)
save(getAppDataPath() + "/MyGame/debug.txt", playerData, "text")

Notes:

• Binary format (default) is compact and faster
• Text format is human-readable, useful for debugging
• Wrong encryption key returns null (data will be garbage)
• Directories are created automatically when saving