prog

Docs
Interact
2026-06-18 20:25:54 -05:00 · 2026-06-18 14:59:21 -05:00 · 2026-06-18 13:34:36 -05:00 · 2026-06-18 13:03:57 -05:00 · 2026-06-18 12:44:23 -05:00 · 2026-06-18 10:24:45 -05:00
420 changed files with 9156 additions and 11171 deletions
@@ -0,0 +1,74 @@
 # Animation System
 Source: `src/dusk/animation/`
 Lightweight keyframe-based value interpolation using fixed-point math throughout.
 ---
 ## Easing (`animation/easing.h`)
 `easingApply(type, t)` applies an easing function to a normalized time value `t ∈ [0, FIXED_ONE]` and returns the eased value in the same range.
 All functions are also callable directly:
 ```c
 fixed_t t = FIXED(0.5f);
 fixed_t out = easingApply(EASING_IN_OUT_CUBIC, t);
 ```
 Available easing types (all in `easingtype_t`):
 | Enum value | Curve |
 |---|---|
 | `EASING_LINEAR` | straight line |
 | `EASING_IN_SINE` / `OUT` / `IN_OUT` | sinusoidal |
 | `EASING_IN_QUAD` / `OUT` / `IN_OUT` | quadratic |
 | `EASING_IN_CUBIC` / `OUT` / `IN_OUT` | cubic |
 | `EASING_IN_QUART` / `OUT` / `IN_OUT` | quartic |
 | `EASING_IN_BACK` / `OUT` / `IN_OUT` | overshoots slightly |
 `EASING_FUNCTIONS[EASING_COUNT]` is a table of `easingfn_t` function pointers for when you need to pick an easing at runtime without a switch.
 ---
 ## Keyframes (`animation/keyframe.h`)
 ```c
 typedef struct {
  fixed_t time;          // time point this keyframe is at
  fixed_t value;         // output value at this time
  easingtype_t easing;   // easing to apply when interpolating toward the NEXT keyframe
 } keyframe_t;
 ```
 Keyframe arrays should be sorted ascending by `time`.
 ---
 ## Animation (`animation/animation.h`)
 `animation_t` wraps a keyframe array and provides value lookup:
 ```c
 keyframe_t frames[] = {
  { FIXED(0.0f), FIXED(0.0f), EASING_LINEAR },
  { FIXED(1.0f), FIXED(1.0f), EASING_IN_OUT_CUBIC },
  { FIXED(2.0f), FIXED(0.0f), EASING_LINEAR },
 };
 animation_t anim;
 animationInit(&anim, frames, 3);
 fixed_t value = animationGetValue(&anim, FIXED(0.75f));   // interpolated
 ```
 `animationGetValue` finds the surrounding keyframes for the given `time`, computes the local `t` within that segment, applies the keyframe's easing, and linearly interpolates between the two keyframe values.
 The animation does not own the keyframe array — it holds a pointer. Pass a static or long-lived array.
 ---
 ## Usage in the engine
 Entity animations (`entityanim_t`) do NOT use this system — they use a simple countdown timer (`animTime`) and a state enum. The `animation_t` system is intended for property animation: UI transitions, camera easing, visual effects, anything that needs a time → value curve.
@@ -0,0 +1,81 @@
 # Architecture
 ## Platform abstraction
 Every subsystem that differs across platforms (display, input, asset loading, save, time, network, log) follows the same pattern:
 1. `src/dusk/<subsystem>/<subsystem>platform.h` — included by the public header. Contains `#include "path/to/platform-specific-header.h"` resolved by the build system include path.
 2. `src/dusk{platform}/<subsystem>/<subsystem>platform.h` — the actual platform-specific header included above (e.g. `src/duskgl/display/framebuffer/framebufferplatform.h`).
 3. The shared header (`src/dusk/<subsystem>/<subsystem>.h`) `#error`s at compile time if the platform doesn't define the expected macros/types.
 The active platform backends are selected by `DUSK_TARGET_SYSTEM` in CMake, which includes `cmake/targets/<system>.cmake`. That file sets compile definitions (`DUSK_LINUX`, `DUSK_SDL2`, `DUSK_OPENGL`, …) and links platform libraries.
 Platform source directories:
 - `src/duskgl/` — OpenGL rendering (used on Linux and as the GL layer for SDL2)
 - `src/dusksdl2/` — SDL2 window/input/time (Linux desktop)
 - `src/dusklinux/` — Linux filesystem/save/network
 - `src/duskdolphin/` — GameCube & Wii (GX renderer, libogc)
 - `src/duskpsp/` — PSP (GU renderer, PSPSDK)
 - `src/duskvita/` — PS Vita
 ## Subsystem lifecycle
 All subsystems follow `init → update (per frame) → dispose`. Engine initialization order matters and is centralized in `engine.c`:
 ```
 systemInit → timeInit → consoleInit → inputInit → assetInit →
 localeManagerInit → displayInit → uiInit → uiTextboxInit →
 cutsceneInit → rpgInit → networkInit → sceneInit
 ```
 Dispose runs in reverse. Each call uses `errorChain()` to propagate failures.
 ## Error handling
 Functions that can fail return `errorret_t` (a code + pointer to thread-local error state). Three core macros:
 ```c
 errorThrow("message %s", arg);        // sets error, returns from current function
 errorChain(someCall());               // if someCall() fails, propagates and returns
 errorOk();                            // returns success
 ```
 Check with `errorIsOk(ret)` / `errorIsNotOk(ret)`. The error state carries file/function/line info for a stack-like trace.
 ## Fixed-point math
 `fixed_t` is `int32_t` with Q24.8 format (8 fractional bits, ~0.004 resolution). Use it for all world/game values:
 ```c
 fixed_t x = FIXED(1.5);              // compile-time literal
 fixed_t y = fixedFromI32(3);         // runtime conversion
 fixed_t z = fixedMul(x, y);          // arithmetic
 float_t f = fixedToFloat(z);         // only where float is needed (e.g. GL uniforms)
 ```
 ## Code generation from CSV
 Several subsystems define their data in CSV files and have corresponding Python tools that generate C headers at build time (via CMake `add_custom_command`):
 | CSV | Tool | Output |
 |-----|------|--------|
 | `src/dusk/input/input.csv` | `tools/input/csv/` | input action enum + names |
 | `src/dusk/display/color.csv` | `tools/color/csv/` | color constants |
 | `src/dusk/rpg/item/item.csv` | `tools/item/csv/` | item enum + metadata |
 | `src/dusk/rpg/story/storyflag.csv` | `tools/story/csv/` | story flag enum + initial values |
 Generated headers are written to `build-<target>/generated/` and included via `target_include_directories`.
 ## Asset system
 Assets are packed into `dusk.dsk` (a zip archive) at build time from the `assets/` directory. At runtime `asset.c` opens the archive and serves files from it.
 Loading is asynchronous: `assetLock()` registers a load request; the background thread calls the appropriate loader; call `assetRequireLoaded()` to block until ready. `assetUnlock()` / `assetUnlockEntry()` releases the entry so it can be reclaimed.
 Loaders are registered per type (`assetloadertype_t`) and live under `src/dusk/asset/loader/`. Platform-specific asset init (finding the .dsk file) is in `src/dusk{platform}/asset/`.
 ## Display subsystem
 The display system is currently organized around immediate GPU-style rendering: `mesh_t` (vertex buffers), `shader_t` (GLSL on GL / TEV state on Dolphin), `texture_t`, and `framebuffer_t`. See [display-refactor.md](display-refactor.md) for the planned move to a render-queue model (needed for a future Saturn port).
 The `spritebatch_t` (`display/spritebatch/`) accumulates 2D quads and flushes in batches — the primary 2D drawing primitive used by the RPG layer.
@@ -0,0 +1,115 @@
 # Asset System
 Source: `src/dusk/asset/`
 All game assets are packed into `dusk.dsk` (a zip archive) at build time and served from it at runtime. The asset system manages async loading, reference counting, and platform-specific archive location.
 See [architecture.md](architecture.md#asset-system) for the high-level overview.
 ---
 ## Asset archive
 The archive is opened at `assetInit()`. `assetFileExists(filename)` checks for a file without loading it. The file path format inside the archive matches the layout of the `assets/` source directory.
 On each platform, `assetInitPlatform()` locates the `.dsk` file (e.g. adjacent to the binary on Linux, on the SD card on PSP).
 ---
 ## Entry lifecycle
 An `assetentry_t` represents one file being managed by the system. States:
 ```
 NOT_STARTED → PENDING_ASYNC → LOADING_ASYNC → PENDING_SYNC → LOADING_SYNC → LOADED
                                                                           └→ ERROR
 ```
 - **PENDING_ASYNC / LOADING_ASYNC**: the background thread is handling I/O (file reads, decompression).
 - **PENDING_SYNC / LOADING_SYNC**: the main thread needs to finish loading (e.g. uploading to GPU), triggered during `assetUpdate()`.
 The async/sync split exists because GPU operations must happen on the main thread.
 ---
 ## Using assets
 ```c
 // Acquire a loaded entry (blocks until loaded):
 assetentry_t *entry = assetLock(filename, ASSET_LOADER_TYPE_TEXTURE, &input);
 errorChain(assetRequireLoaded(entry));
 // Use the loaded data:
 texture_t *tex = &entry->data.texture.texture;
 // Release when done:
 assetUnlockEntry(entry);
 ```
 `assetLock` finds-or-creates an entry and increments its reference count. `assetUnlock` / `assetUnlockEntry` decrements it; when it reaches zero the entry is reclaimed at the next `assetUpdate()`.
 To subscribe to async completion instead of blocking:
 ```c
 eventSubscribe(&entry->onLoaded, myCallback, myUser);
 ```
 ---
 ## Loader types
 | Type constant | File | Output struct accessed via |
 |---|---|---|
 | `ASSET_LOADER_TYPE_TEXTURE` | `.png` etc. | `entry->data.texture.texture` |
 | `ASSET_LOADER_TYPE_TILESET` | tileset descriptor | `entry->data.tileset.tileset` |
 | `ASSET_LOADER_TYPE_MESH` | mesh data | `entry->data.mesh.mesh` |
 | `ASSET_LOADER_TYPE_LOCALE` | `.po` file | internal to locale manager |
 | `ASSET_LOADER_TYPE_JSON` | `.json` | `entry->data.json.*` |
 Each loader type registers `loadAsync`, `loadSync`, and `dispose` callbacks in `ASSET_LOADER_CALLBACKS[]`.
 The async callback runs on the loader thread; the sync callback runs on the main thread during `assetUpdate()`. Most loaders do file I/O async and GPU upload sync.
 ### Error handling inside loaders
 Use these macros instead of `errorThrow` / `errorChain` inside loader callbacks — they also set the entry state to ERROR:
 ```c
 assetLoaderErrorChain(loading, someCall());
 assetLoaderErrorThrow(loading, "Descriptive message");
 ```
 ---
 ## Low-level file I/O (`asset/assetfile.h`)
 `assetfile_t` wraps a `zip_file_t` handle and provides streaming reads:
 ```c
 assetFileInit(&file, "textures/player.png", NULL, NULL);
 assetFileOpen(&file);
 assetFileRead(&file, buffer, size);
 assetFileClose(&file);
 assetFileDispose(&file);
 // Read entire file into a malloc'd buffer:
 uint8_t *buf; size_t size;
 assetFileReadEntire(&file, &buf, &size);   // caller frees buf
 ```
 For line-by-line text parsing (`assetfilelinereader_t`):
 ```c
 assetFileLineReaderInit(&reader, &file, readBuf, readBufSize, outBuf, outBufSize);
 while(!reader.eof) {
  errorChain(assetFileLineReaderNext(&reader));
  // reader.outBuffer contains the line, reader.lineLength its length
 }
 ```
 ---
 ## Background loader thread
 `assetUpdateAsync(thread)` is the thread entry point. It calls `assetUpdate()` in a loop, sleeping briefly between iterations, until `threadShouldStop()` returns true. The main thread also calls `assetUpdate()` once per frame to process the sync phase.
 Up to `ASSET_LOADING_COUNT_MAX` (4) entries can be loading concurrently.
 Up to `ASSET_ENTRY_COUNT_MAX` (128) entries can exist at once.
@@ -0,0 +1,92 @@
 # Display Refactor Progress
 ## Immediate Goal
 Render a 32x32 white square through the new render opcode stack on Linux.
 ## Architecture (summary)
 See `.claude/display-refactor.md` for the full design.
 - `src/dusk/render/` -- opcode format + buffer + submission API (the *contract*).
 - Platform backends (e.g. `src/duskgl/`) consume the buffer and translate to native API calls.
 - `src/dusk/display/` -- orchestration shell only: `displayInit`, `displayUpdate`, `displayDispose`.
 - Scenes call `renderSprite(...)`, `renderClear(...)`. The backend executes the intent.
 ## Opcode format (32 bytes)
 Every command starts with a 4-byte `ropheader_t` (opcode, flags, depth). Two commands defined:
 - `ROP_CLEAR` (32 bytes) -- clear with a color.
 - `ROP_DRAW_SPRITE` (32 bytes) -- screen-space int16 x/y/w/h + tint color.
 ## Milestone 1 -- Archive + strip existing display deps ✓
 - [x] Old `src/dusk/display/` archived (now deleted from working tree via git).
 - [x] Old `src/duskgl/display/` removed (new GL renderer replaces it).
 - [x] `engine.c` stripped to minimal subsystems, set to `SCENE_TYPE_TEST`.
 - [x] `scene.c` stripped of old display/shader/screen references.
 - [x] `console.c` stripped of display deps.
 - [x] `ui/CMakeLists.txt` gutted (re-implementation deferred).
 - [x] `asset/loader/CMakeLists.txt` -- display loaders disabled.
 - [x] `asset/loader/assetloader.h` -- display loader types removed.
 - [x] `rpg/overworld/chunk.h` -- mesh_t / meshvertex_t removed.
 - [x] `rpg/overworld/map.c` -- mesh/spritebatch calls removed.
 - [x] `scene/overworld/sceneoverworld.c` -- stubbed to empty callbacks.
 - [x] Test suite display tests disabled.
 ## Milestone 2 -- Render opcode system ✓
 - [x] `src/dusk/render/rop.h` -- `ropheader_t`, `ropclear_t`, `ropsprite_t`.
 - [x] `src/dusk/render/ropbuffer.h/.c` -- `ROPBUFFER` global, reset, alloc.
 - [x] `src/dusk/render/render.h/.c` -- `renderClear()`, `renderSprite()`.
 - [x] `src/dusk/render/CMakeLists.txt`.
 ## Milestone 3 -- New minimal display shell ✓
 - [x] `src/dusk/display/display.h/.c` -- init/update/dispose, calls platform hooks.
 - [x] `src/dusk/display/displaystate.h` -- cull/depth/blend flags.
 - [x] `src/dusk/display/color.csv` + `CMakeLists.txt` -- color generation kept.
 ## Milestone 4 -- GL backend ✓
 - [x] `src/duskgl/render/rendergl.h/.c`:
  - GL 3.3 core shader (ortho projection, solid color, no texture yet).
  - `renderGLInit` -- creates VAO/VBO/shader.
  - `renderGLFlush(buf, w, h)` -- walks ROPBUFFER, GL calls per opcode.
  - `ROP_CLEAR` → `glClearColor` + `glClear`.
  - `ROP_DRAW_SPRITE` → 6-vertex quad, `glDrawArrays`.
 - [x] `src/duskgl/error/errorgl.h/.c` -- `errorGLCheck`.
 - [x] `src/duskgl/CMakeLists.txt`.
 - [x] `src/dusksdl2/display/displaysdl2.h/.c` updated:
  - `displaySDL2Init` -- SDL2 window + GL 3.3 context + `renderGLInit`.
  - `displaySDL2Flush(ropbuffer_t *)` -- MakeCurrent + `renderGLFlush`.
  - `displaySDL2Swap` -- SDL_GL_SwapWindow.
 - [x] `src/dusklinux/display/displayplatform.h` updated with new macros.
 ## Milestone 5 -- Test scene ✓
 - [x] `SCENE_TYPE_TEST` added to `scenetype.h/.c`.
 - [x] `src/dusk/scene/test/scenetest.h/.c`:
  - `renderClear(color(32, 32, 48, 255))` -- dark blue-grey background.
  - `renderSprite(100, 100, 32, 32, COLOR_WHITE)` -- 32x32 white square.
 - [x] `engine.c` starts with `SCENE_TYPE_TEST`.
 ## Milestone 6 -- Verified ✓
 - [x] Build succeeds with no errors (2026-06-18).
 - [x] Engine initializes: SDL window + GL context + shader + test scene.
 - [x] No crashes running for 5+ seconds.
 - [ ] 32x32 white square visually confirmed on screen.
 ---
 ## Status: BUILD PASSING -- awaiting visual confirmation
 ---
 ## Decisions log
 **2026-06-18** -- `color_t = color4b_t` (from generated `display/color.h`). The color generation pipeline (color.csv + Python tool) is kept in the new minimal `src/dusk/display/CMakeLists.txt`.
 **2026-06-18** -- `ROP_SIZE = 32`. All opcodes fixed 32 bytes. 3D quads will be 64 bytes when added later.
 **2026-06-18** -- Depth sort deferred. Buffer stores unsorted commands; painter platforms sort on flush. GL uses Z-buffer.
 **2026-06-18** -- Texture system not yet wired into the opcode pipeline. `ROP_DRAW_SPRITE` with `texture=0` uses solid tint color only (no sampler). Texture handle system comes next.
 **2026-06-18** -- GL backend uses GL 3.3 Core profile. Shader takes screen-space pixel coordinates and converts to clip space using window size queried from SDL each frame.
 **2026-06-18** -- `ROPBUFFER` is a global (4096 slots × 32 bytes = 128 KB). Reset at start of each frame in `displayUpdate`.
 **2026-06-18** -- `ui/`, `rpg/overworld` display code, asset display loaders all temporarily stubbed/disabled. Will be rewritten against the new render API.
@@ -0,0 +1,215 @@
 # Display System
 Source: `src/dusk/display/`
 The display system is the rendering pipeline. It is abstracted across platforms via `displayplatform.h` — see [architecture.md](architecture.md) for the abstraction pattern. The current concrete backends are OpenGL (`src/duskgl/`) and GX/Dolphin (`src/duskdolphin/`).
 For the planned render-queue refactor (required for Saturn), see [display-refactor.md](display-refactor.md).
 ---
 ## Initialization order
 Within the display system, init must follow this order (enforced in `engine.c`):
 ```
 displayInit → uiInit → uiTextboxInit
 ```
 Within `displayInit`, the platform typically initialises: framebuffer → screen → shader list → textures → spritebatch → text system.
 ---
 ## `display_t` / `displaystate_t`
 `display_t DISPLAY` is the global display instance (type alias for `displayplatform_t`).
 `displaystate_t` carries per-draw-call render state flags:
 ```c
 DISPLAY_STATE_FLAG_CULL       // face culling
 DISPLAY_STATE_FLAG_DEPTH_TEST // depth testing
 DISPLAY_STATE_FLAG_BLEND      // alpha blending
 ```
 Set state before drawing with `displaySetState(state)`.
 ---
 ## Screen (`display/screen/`)
 `screen_t SCREEN` manages the logical viewport that game content renders into. On dynamic-size platforms (Linux/SDL2) the screen can differ from the native window/framebuffer resolution.
 Screen modes:
 ```
 SCREEN_MODE_BACKBUFFER           — maps 1:1 to backbuffer
 SCREEN_MODE_FIXED_SIZE           — fixed pixel dimensions
 SCREEN_MODE_ASPECT_RATIO         — fixed aspect, scale to fit
 SCREEN_MODE_FIXED_HEIGHT         — fixed height, width scales
 SCREEN_MODE_FIXED_WIDTH          — fixed width, height scales
 SCREEN_MODE_FIXED_VIEWPORT_HEIGHT — fixed viewport height
 ```
 The linux target defines `DUSK_DISPLAY_SCREEN_HEIGHT=240`, producing a 240p fixed-height viewport.
 Render loop usage:
 ```c
 screenBind();       // set up viewport, projection
 // ... draw game content ...
 screenUnbind();
 screenRender();     // blit to backbuffer / current framebuffer
 ```
 `SCREEN.width` / `SCREEN.height` are the logical dimensions used for world-to-screen math — always prefer these over the framebuffer dimensions.
 ---
 ## Framebuffer (`display/framebuffer/`)
 `framebuffer_t FRAMEBUFFER_BACKBUFFER` is the platform backbuffer. `FRAMEBUFFER_BOUND` points to the currently-bound framebuffer (or `NULL` for backbuffer).
 ```c
 frameBufferInitBackBuffer();                        // called once at startup
 frameBufferBind(fb);                                // NULL → backbuffer
 frameBufferClear(FRAMEBUFFER_CLEAR_COLOR | FRAMEBUFFER_CLEAR_DEPTH, COLOR_BLACK);
 frameBufferGetWidth(fb) / frameBufferGetHeight(fb) / frameBufferGetAspect(fb);
 ```
 On platforms with `DUSK_DISPLAY_SIZE_DYNAMIC`, off-screen framebuffers can be created with `frameBufferInit(fb, w, h)` and disposed with `frameBufferDispose(fb)`. Fixed-resolution platforms (PSP, GameCube) only ever use the backbuffer.
 ---
 ## Mesh (`display/mesh/`)
 `mesh_t` is a vertex buffer. The type is `meshplatform_t` (e.g. a VAO+VBO on GL, a GX display list on Dolphin).
 ```c
 meshInit(&mesh, MESH_PRIMITIVE_TYPE_TRIANGLES, vertexCount, verticesPtr);
 meshFlush(&mesh, offset, count);  // upload CPU vertices → GPU
 meshDraw(&mesh, offset, count);   // draw; pass -1 for count to draw all
 meshDispose(&mesh);
 ```
 **Key distinction**: `meshFlush` uploads data to GPU memory; `meshDraw` issues the draw call. For static geometry (chunk meshes) you call `meshFlush` once on load, then `meshDraw` every frame. For dynamic geometry (spritebatch) you `meshFlush` + `meshDraw` each frame.
 `meshvertex_t` (`display/mesh/meshvertex.h`) contains:
 - `float_t uv[2]` — texture coordinates
 - `float_t pos[3]` — position
 - Optionally `color_t color` if `MESH_ENABLE_COLOR` is defined (off by default)
 Primitive mesh generators live alongside `mesh.h`: `quad.h`, `plane.h`, `cube.h`, `sphere.h`, `capsule.h`, `triprism.h`.
 ---
 ## Shader (`display/shader/`)
 `shader_t` is `shaderplatform_t` (GLSL program on GL, TEV state block on Dolphin).
 ```c
 shaderInit(&shader, &definition);
 shaderBind(&shader);
 shaderSetMatrix(&shader, "uModel", modelMat);
 shaderSetTexture(&shader, "uTexture", &texture);
 shaderSetColor(&shader, "uColor", COLOR_WHITE);
 shaderSetMaterial(&shader, &material);
 shaderDispose(&shader);
 ```
 ### Shader list (`display/shader/shaderlist.h`)
 The engine maintains a small set of built-in shaders in `SHADER_LIST_DEFS[]`. Currently only one is defined:
 - `SHADER_LIST_SHADER_UNLIT` → `SHADER_UNLIT` — unlit textured/colored rendering, used for all world and entity drawing.
 `shaderListInit()` compiles/uploads all built-in shaders and sets shared projection/view matrices. Call once after display init.
 ### Materials (`display/shader/shadermaterial.h`)
 `shadermaterial_t` is a union of all shader-specific material structs. Currently only `shaderunlitmaterial_t`:
 ```c
 shadermaterial_t mat = {
  .unlit = {
    .color = COLOR_WHITE,
    .texture = &myTexture,   // NULL for solid color
  }
 };
 shaderSetMaterial(&SHADER_UNLIT, &mat);
 ```
 ---
 ## Texture (`display/texture/`)
 ```c
 textureInit(&texture, width, height, format, data);
 textureDispose(&texture);
 ```
 Width and height **must be powers of two** (asserted at init time).
 `textureformat_t` is `textureformatplatform_t`. Supported formats vary by platform; the common ones are `TEXTURE_FORMAT_RGBA` and `TEXTURE_FORMAT_PALETTE`.
 `texturedata_t` is a union:
 ```c
 // RGBA:
 data.rgbaColors = colorArray;
 // Paletted:
 data.paletted.indices = indexArray;
 data.paletted.palette = &palette;   // palette color count must be power of two
 ```
 **Built-in textures** (defined in `texture.c`, no asset loading needed):
 - `TEXTURE_WHITE` — 4×4 solid white
 - `TEXTURE_TEST` — 4×4 black/magenta checkerboard
 ### Palette (`display/texture/palette.h`)
 Up to `PALETTE_COUNT` (6) global palettes in `PALETTES[]`, each holding up to `PALETTE_COLOR_COUNT` (255) `color_t` entries.
 ### Tileset (`display/texture/tileset.h`)
 A tileset slices a texture into a grid of equal-sized tiles. Used by fonts and UI frames. The tileset does not own the texture — it references a `texture_t *`.
 ---
 ## SpriteBatch (`display/spritebatch/`)
 The primary 2D/billboard drawing primitive. Accumulates `spritebatchsprite_t` quads and flushes them in batches of `SPRITEBATCH_FLUSH_COUNT` (16) sprites at a time.
 ```c
 // Per frame:
 spriteBatchClear();
 spriteBatchBuffer(sprites, count, &SHADER_UNLIT, material);  // auto-flushes when batch full
 spriteBatchFlush();  // flush remaining
 // Low-level: write directly to an external mesh (for baking static geometry):
 spriteBatchBufferToMesh(sprites, count, vertices, verticesSize);
 ```
 `spritebatchsprite_t`:
 ```c
 typedef struct {
  vec3 min, max;     // 3D bounding box
  vec2 uvMin, uvMax; // texture region
 } spritebatchsprite_t;
 ```
 The global `SPRITEBATCH` and its vertex backing array `SPRITEBATCH_VERTICES[]` are defined externally to the struct to satisfy alignment requirements on certain platforms.
 ---
 ## Text (`display/text/`)
 Text rendering uses `FONT_DEFAULT` (loaded during `textInit()`), which references a texture and a tileset. Characters start at ASCII `!` (`TEXT_CHAR_START`).
 ```c
 textDraw(x, y, "Hello", COLOR_WHITE, &FONT_DEFAULT);
 textMeasure("Hello", &FONT_DEFAULT, &outWidth, &outHeight);
 // Single-char sprite for manual layout:
 spritebatchsprite_t s = textGetSprite(pos, 'A', &FONT_DEFAULT);
 ```
 `font_t` holds a `texture_t *` and a `tileset_t *` — both are owned by the asset system, not the font struct.
@@ -0,0 +1,93 @@
 # Input System
 Source: `src/dusk/input/`
 The input system decouples physical hardware buttons from logical game actions via a binding layer. Actions are defined in `src/dusk/input/input.csv` and code-generated into `inputaction_t` enum values — see [architecture.md](architecture.md#code-generation-from-csv).
 ---
 ## Concepts
 **Button** (`inputbutton_t`) — a physical input source: a keyboard scancode, gamepad button, gamepad axis, or pointer axis. The available button types depend on which `DUSK_INPUT_*` defines are active for the target platform.
 **Action** (`inputaction_t`) — a logical game input (e.g. `INPUT_ACTION_UP`, `INPUT_ACTION_CONFIRM`, `INPUT_ACTION_RAGEQUIT`). Each action accumulates a float value `[0.0, 1.0]` from all buttons bound to it.
 **Binding** — a many-to-one mapping from buttons to actions. Bindings are registered at runtime with `inputBind(button, action)`.
 ---
 ## Querying actions
 ```c
 // Boolean helpers (current frame):
 inputIsDown(action)        // value > 0 this frame
 inputPressed(action)       // down this frame but not last
 inputReleased(action)      // down last frame but not this
 // Last frame state:
 inputWasDown(action)
 // Raw float value:
 inputGetCurrentValue(action)   // [0.0, 1.0]
 inputGetLastValue(action)
 // Axis helpers — combine two opposing actions into a signed float:
 float_t h = inputAxis(INPUT_ACTION_LEFT, INPUT_ACTION_RIGHT);  // -1.0 to 1.0
 inputAxis2D(negX, posX, negY, posY, result);   // fills vec2
 inputAngle2D(negX, posX, negY, posY, result);  // atan2-based normalized direction
 // Deadzone:
 float_t clean = inputDeadzone(rawValue, 0.1f);
 ```
 ---
 ## Dynamic values (`DUSK_TIME_DYNAMIC`)
 On platforms with variable frame rates, each action also tracks `dynamicDelta`-scaled values:
 ```c
 inputGetCurrentValueDynamic(action)
 inputGetLastValueDynamic(action)
 ```
 These account for the actual time elapsed since the last frame, so movement calculated from them is frame-rate independent.
 ---
 ## Events on actions
 Each `inputactiondata_t` exposes `onPressed` and `onReleased` events:
 ```c
 eventSubscribe(&INPUT.actions[INPUT_ACTION_CONFIRM].onPressed, myCallback, myUser);
 ```
 The callback signature is `void cb(void *params, void *user)`. `params` is always `NULL` for input events.
 ---
 ## Buttons and bindings
 Physical buttons are typed via `inputbuttontype_t`:
 | Constant | When available | Payload |
 |---|---|---|
 | `INPUT_BUTTON_TYPE_KEYBOARD` | `DUSK_INPUT_KEYBOARD` | `inputscancode_t` |
 | `INPUT_BUTTON_TYPE_GAMEPAD` | `DUSK_INPUT_GAMEPAD` | `inputgamepadbutton_t` |
 | `INPUT_BUTTON_TYPE_GAMEPAD_AXIS` | `DUSK_INPUT_GAMEPAD` | axis + positive direction flag |
 | `INPUT_BUTTON_TYPE_POINTER` | `DUSK_INPUT_POINTER` | `inputpointeraxis_t` |
 Button names and default bindings are defined in `input.csv`. Look up a button by name:
 ```c
 inputbutton_t btn = inputButtonGetByName("keyboard_w");
 inputBind(btn, INPUT_ACTION_UP);
 ```
 `INPUT_BUTTON_DATA[]` holds runtime state (current/last raw values) for every physical button.
 ---
 ## Platform platform-specific reads
 `inputButtonGetValuePlatform(button)` is the one required platform function — it returns the current raw `[0.0, 1.0]` value for a button. The platform implementations live in `src/dusk{platform}/input/`.
@@ -0,0 +1,149 @@
 # Cutscenes
 Two distinct layers: a low-level engine sequencer (`src/dusk/cutscene/`) and a higher-level RPG wrapper (`src/dusk/rpg/cutscene/`). Almost all game code works with the RPG layer.
 ---
 ## Engine sequencer (`src/dusk/cutscene/`)
 `cutscene_t CUTSCENE` is a minimal event runner with up to `CUTSCENE_EVENT_COUNT_MAX` (16) `cutsceneevent_t` slots. Each event has three callbacks:
 ```c
 typedef struct {
  errorret_t (*onStart)(void);
  errorret_t (*onUpdate)(void);
  errorret_t (*onEnd)(void);
 } cutsceneevent_t;
 ```
 API:
 ```c
 cutscenePlay(events, count);   // copy events array and start from index 0
 cutsceneAdvance();             // end current event, start next (deactivates after last)
 cutsceneStop();                // abort immediately
 cutsceneIsActive();            // bool
 ```
 This layer is primarily used by the RPG cutscene system — game code doesn't normally touch it directly.
 ---
 ## RPG cutscene layer (`src/dusk/rpg/cutscene/`)
 ### Data structures
 A `cutscene_t` is just a pointer to an item array and a count:
 ```c
 typedef struct cutscene_s {
  const cutsceneitem_t *items;
  uint8_t itemCount;
 } cutscene_t;
 ```
 A `cutsceneitem_t` is a tagged union of all item types:
 ```c
 typedef struct cutsceneitem_s {
  cutsceneitemtype_t type;
  union {
    cutscenetext_t    text;      // display text in textbox
    cutscenecallback_t callback; // call a void(*)(void) function
    cutscenewait_t    wait;      // pause for a fixed_t duration (seconds)
    const cutscene_t *cutscene;  // nest another cutscene
  };
 } cutsceneitem_t;
 ```
 ### Item types
 | Type constant | Payload | Behaviour |
 |---|---|---|
 | `CUTSCENE_ITEM_TYPE_TEXT` | `cutscenetext_t` — `text[256]` + `rpgtextboxpos_t position` | Shows textbox; advances on player confirm input |
 | `CUTSCENE_ITEM_TYPE_CALLBACK` | `cutscenecallback_t` (function pointer) | Calls the function once, then immediately advances |
 | `CUTSCENE_ITEM_TYPE_WAIT` | `cutscenewait_t` (a `fixed_t` in seconds) | Counts down `animTime` each frame, then advances |
 | `CUTSCENE_ITEM_TYPE_CUTSCENE` | `const cutscene_t *` | Plays the nested cutscene before continuing |
 ### Runtime state
 `cutscenesystem_t CUTSCENE_SYSTEM` tracks:
 - `scene` — pointer to the active `cutscene_t`
 - `currentItem` — index into `scene->items[]`
 - `data` — per-item runtime data (`cutsceneitemdata_t`, currently just `cutscenewaitdata_t`)
 - `mode` — the current `cutscenemode_t`
 API:
 ```c
 cutsceneSystemStartCutscene(cutscene);   // begin playing a cutscene
 cutsceneSystemNext();                    // advance to next item
 cutsceneSystemUpdate();                  // called each frame from rpgUpdate
 cutsceneSystemGetCurrentItem();          // inspect active item
 ```
 ### Cutscene mode (`cutscenemode.h`)
 Each item can run in one of three modes:
 ```c
 CUTSCENE_MODE_NONE           // no cutscene active
 CUTSCENE_MODE_FULL_FREEZE    // pause everything (not yet used)
 CUTSCENE_MODE_INPUT_FREEZE   // player input blocked (default: CUTSCENE_MODE_INITIAL)
 CUTSCENE_MODE_GAMEPLAY       // player can still move during cutscene
 ```
 `cutsceneModeIsInputAllowed()` is checked by `entityUpdate()` before invoking the movement callback — the player cannot walk when in INPUT_FREEZE mode.
 ### Defining a cutscene
 Cutscenes are defined as `static const` arrays in header files under `rpg/cutscene/scene/`. Example (`testcutscene.h`):
 ```c
 static const cutsceneitem_t MY_CUTSCENE_ITEMS[] = {
  {
    .type = CUTSCENE_ITEM_TYPE_TEXT,
    .text = { .text = "Hello!", .position = RPG_TEXTBOX_POS_BOTTOM }
  },
  {
    .type = CUTSCENE_ITEM_TYPE_WAIT,
    .wait = FIXED(1.5f)
  },
  {
    .type = CUTSCENE_ITEM_TYPE_CUTSCENE,
    .cutscene = &ANOTHER_CUTSCENE
  },
 };
 static const cutscene_t MY_CUTSCENE = {
  .items = MY_CUTSCENE_ITEMS,
  .itemCount = sizeof(MY_CUTSCENE_ITEMS) / sizeof(cutsceneitem_t)
 };
 ```
 Attach to an NPC via its interact component:
 ```c
 entity->interact.type = ENTITY_INTERACT_CUTSCENE;
 entity->interact.data.cutscene = &MY_CUTSCENE;
 ```
 ---
 ## Textbox (`src/dusk/rpg/rpgtextbox.h`)
 `rpgtextbox_t RPG_TEXTBOX` is the global textbox state:
 ```c
 typedef struct {
  rpgtextboxpos_t position;      // RPG_TEXTBOX_POS_TOP or RPG_TEXTBOX_POS_BOTTOM
  bool_t visible;
  char_t text[RPG_TEXTBOX_MAX_CHARS];   // 256 chars
 } rpgtextbox_t;
 ```
 API:
 ```c
 rpgTextboxShow(position, text);   // copies text, sets visible = true
 rpgTextboxHide();                 // sets visible = false
 rpgTextboxIsVisible();            // bool
 ```
 The textbox state is read by `ui/uitextbox.c` during the UI render pass to draw the dialogue box on screen. `rpgtextbox.c` itself does no rendering.
@@ -0,0 +1,140 @@
 # Entities
 Source: `src/dusk/rpg/entity/`
 ---
 ## Storage
 Entities live in a single fixed global array:
 ```c
 entity_t ENTITIES[ENTITY_COUNT];   // ENTITY_COUNT = 64
 ```
 A slot is "empty" when `entity->type == ENTITY_TYPE_NULL`. Never allocate entity memory dynamically — always find a free slot with `entityGetAvailable()`, which returns its index (`0xFF` if none free).
 ---
 ## `entity_t` structure
 ```c
 typedef struct entity_s {
  uint8_t id;                  // index in ENTITIES[]
  entitytype_t type;           // ENTITY_TYPE_NULL / PLAYER / NPC
  entitytypedata_t data;       // union: player_t | npc_t
  entitydir_t direction;       // facing direction (N/S/E/W)
  fixed_t position[3];         // current sub-tile position (x, y, z)
  fixed_t lastPosition[3];     // position before last move (for interpolation)
  entityanim_t animation;      // IDLE / TURN / WALK
  fixed_t animTime;            // countdown timer for current animation
  entityinteract_t interact;   // optional interact component
 } entity_t;
 ```
 ---
 ## Type system
 Entity types are defined in `entitytype.h` using the enum+integer-typedef pattern:
 ```c
 typedef enum { ENTITY_TYPE_NULL, ENTITY_TYPE_PLAYER, ENTITY_TYPE_NPC, ENTITY_TYPE_COUNT } entitytype_enum_t;
 typedef uint8_t entitytype_t;
 ```
 Each type has a `entitycallback_t` entry in the `ENTITY_CALLBACKS[ENTITY_TYPE_COUNT]` static table:
 ```c
 typedef struct {
  void (*init)(entity_t *entity);
  void (*movement)(entity_t *entity);
  bool_t (*interact)(entity_t *player, entity_t *entity);
 } entitycallback_t;
 ```
 Callbacks not applicable to a type are `NULL`; `entityUpdate()` guards against this before calling.
 Type-specific data sits in `entitytypedata_t` (a union of `player_t` and `npc_t`). Currently both are stubs (`void *nothing`).
 ---
 ## Direction (`entitydir.h`)
 ```c
 ENTITY_DIR_NORTH / EAST / SOUTH / WEST
 ```
 Aliases: `UP = NORTH`, `DOWN = SOUTH`, `LEFT = WEST`, `RIGHT = EAST`.
 Utilities:
 - `entityDirGetOpposite(dir)` — returns the opposite direction.
 - `entityDirGetRelative(dir, &relX, &relY)` — fills in the ±1 XY delta for that direction.
 - `assertValidEntityDir(dir, msg)` — assertion macro.
 ---
 ## Animation (`entityanim.h`)
 ```c
 ENTITY_ANIM_IDLE   // standing still
 ENTITY_ANIM_TURN   // turning to a new direction (ENTITY_ANIM_TURN_DURATION = FIXED(0.06))
 ENTITY_ANIM_WALK   // mid-step (ENTITY_ANIM_WALK_DURATION = FIXED(0.1))
 ```
 `entityAnimUpdate(entity)` decrements `animTime` each frame and transitions back to `IDLE` when it reaches zero.
 `entityCanWalk(entity)` / `entityCanTurn(entity)` both return true only when `animation == ENTITY_ANIM_IDLE`.
 The renderer interpolates between `lastPosition` and `position` using `animTime / WALK_DURATION` to produce smooth motion even at low frame rates.
 ---
 ## Movement
 `entityWalk(entity, direction)`:
 1. Converts `entity->position` to a `worldpos_t` (truncates fractional part).
 2. Applies the directional delta to get `newPos`.
 3. Checks the current and target tiles for ramp raise/fall logic (see [world.md](world.md)).
 4. Checks `ENTITIES[]` for another entity occupying `newPos` — blocks if found.
 5. On success: copies `position` to `lastPosition`, updates `position` to `newPos` (via `worldPosToFixed`), sets `animation = ENTITY_ANIM_WALK`.
 `entityTurn(entity, direction)`: sets `direction` and starts a brief turn animation.
 ---
 ## Interaction (`entityinteract.h`)
 The `entityinteract_t` component is embedded in every entity. It is optional — set `type = ENTITY_INTERACT_NULL` for non-interactable entities.
 ```c
 typedef enum {
  ENTITY_INTERACT_NULL,
  ENTITY_INTERACT_CUTSCENE,   // plays a cutscene_t *
  ENTITY_INTERACT_PRINT,      // prints a short message[32]
 } entityinteracttype_t;
 ```
 `entityInteractWith(player, target)` dispatches:
 1. If the interact component's `type != NULL`, handles it (starts the cutscene or prints the message).
 2. Otherwise falls back to `ENTITY_CALLBACKS[type].interact` if set.
 ---
 ## Player (`player.h` / `player.c`)
 `playerInit()` is called via `ENTITY_CALLBACKS[ENTITY_TYPE_PLAYER].init`.
 `playerInput(entity)` is the movement callback. It reads `PLAYER_INPUT_DIR_MAP[]` — a static table mapping input actions (`INPUT_ACTION_UP/DOWN/LEFT/RIGHT`) to entity directions — and calls `entityWalk` or `entityTurn` accordingly.
 The player entity is normally `ENTITIES[0]` but there is no hardcoded assumption about its index beyond being initialized with `ENTITY_TYPE_PLAYER`.
 ---
 ## NPC (`npc.h` / `npc.c`)
 `npcInit()`, `npcMovement()`, and `npcInteract()` provide the NPC type callbacks. Currently stubs; movement does nothing, interact returns false.
@@ -0,0 +1,18 @@
 # RPG Layer
 The RPG layer lives in `src/dusk/rpg/` and is the game-logic tier above the engine. It is initialized and ticked by `engine.c` via `rpgInit` / `rpgUpdate` / `rpgDispose`. The `rpg_t` struct is currently a stub; all meaningful state lives in the subsystems below.
 ## Contents
 - [world.md](world.md) — scene manager, overworld map, chunks, tiles, coordinate system, camera
 - [entity.md](entity.md) — entity pool, types, direction, animation, interaction, player, NPC
 - [cutscene.md](cutscene.md) — cutscene system, item types, mode control, textbox
 - [story.md](story.md) — story flags, items, inventory, backpack, save system
 ## Scene system
 The scene manager (`src/dusk/scene/`) sits above the RPG layer and owns the single active scene. Scenes are identified by `scenetype_t` and registered in `SCENE_TYPES[]` (`scene/scenetype.c`) as `scenecallbacks_t` (init / update / render / dispose).
 `scenedata_t` is a union so all scene structs share memory. `sceneSet(type)` defers the transition — the old scene disposes before the new one inits.
 Currently the only scene is `SCENE_TYPE_OVERWORLD` → `src/dusk/scene/overworld/sceneoverworld.c`.
@@ -0,0 +1,124 @@
 # Story, Items & Save
 ---
 ## Story flags (`src/dusk/rpg/story/`)
 Story flags are the primary mechanism for tracking game-world state (quest progress, one-time events, unlocks). Each flag is a `uint8_t` value (`storyflagvalue_t`), so they can hold booleans or small counts.
 ### Defining flags
 Flags are defined in `src/dusk/rpg/story/storyflag.csv`:
 ```
 id,description,initial
 test,"Test flag for debugging purposes",1
 ```
 The build tool generates:
 - A `storyflag_t` enum (e.g. `STORY_FLAG_TEST`) in the generated header.
 - `STORY_FLAG_VALUES[]` — the runtime array, pre-populated with the `initial` column values.
 To add a flag: add a row to the CSV. The build re-runs the Python tool automatically on the next CMake build.
 ### Access
 ```c
 storyflagvalue_t v = storyFlagGet(STORY_FLAG_TEST);   // macro: array read
 storyFlagSet(STORY_FLAG_TEST, 1);                      // function: also marks save dirty
 ```
 `storyFlagGet` is a macro that directly indexes `STORY_FLAG_VALUES[]` — no function call overhead.
 ---
 ## Items (`src/dusk/rpg/item/`)
 ### Item definitions
 Items are defined in `src/dusk/rpg/item/item.csv`. The build tool generates `itemid_t` enum values and item metadata. `itemid_t` is a generated `uint8_t` typedef.
 ### Inventory (`inventory.h`)
 `inventory_t` is a generic container backed by a caller-supplied `inventorystack_t` array:
 ```c
 typedef struct {
  itemid_t item;
  uint8_t quantity;        // max ITEM_STACK_QUANTITY_MAX (255)
 } inventorystack_t;
 typedef struct {
  inventorystack_t *storage;
  uint8_t storageSize;
 } inventory_t;
 ```
 Key operations:
 ```c
 inventoryInit(&inv, storageArray, size);
 inventoryAdd(&inv, ITEM_POTION, 3);
 inventoryRemove(&inv, ITEM_POTION);
 inventorySet(&inv, ITEM_POTION, 10);
 inventoryGetCount(&inv, ITEM_POTION);   // returns 0 if not present
 inventoryItemExists(&inv, ITEM_POTION);
 inventoryIsFull(&inv);
 inventorySort(&inv, INVENTORY_SORT_BY_ID, false);
 ```
 `inventory_t` itself holds no data — the backing array is always external. This avoids fixed-size struct limits and lets different inventories (backpack, shop, chest) share the same logic.
 ### Backpack (`backpack.h`)
 The player's inventory is the global `BACKPACK` instance:
 ```c
 extern inventorystack_t BACKPACK_STORAGE[BACKPACK_STORAGE_SIZE_MAX];  // 20 slots
 extern inventory_t BACKPACK;
 backpackInit();   // wires BACKPACK_STORAGE into BACKPACK
 ```
 ---
 ## Save system (`src/dusk/save/`)
 The save system is stubbed out — it exists and compiles but is commented out of engine init (`engine.c`). What follows describes the design as implemented.
 ### Slots
 `save_t SAVE` holds `SAVE_FILE_COUNT_MAX` slots:
 ```c
 typedef struct {
  savefile_t files[SAVE_FILE_COUNT_MAX];
  saveplatform_t platform;   // platform-specific state (paths, card handles)
 } save_t;
 ```
 ### Streams
 `savestream_t` (`save/savestream.h`) is a raw byte cursor used to serialize/deserialize `savefile_t`. Platform backends in `src/dusk{platform}/save/` implement the actual I/O:
 - Linux: filesystem files in a save directory.
 - GameCube/Wii: memory card via libogc.
 ### API
 ```c
 saveInit();
 saveLoad(slot);     // reads platform storage → savefile_t
 saveWrite(slot);    // writes savefile_t → platform storage
 saveDelete(slot);
 saveExists(slot);   // bool
 saveGet(slot);      // returns savefile_t *
 saveDispose();
 ```
 ---
 ## Locale / i18n (`src/dusk/locale/`)
 Translations are loaded from `.po` files in `assets/locale/` (e.g. `en_US.po`). `localemanager.c` manages the active locale and exposes a key→string lookup. `assetlocaleloader.c` parses the PO format via the asset system.
 All player-visible strings must go through the locale system rather than being hardcoded. The locale is loaded asynchronously via the asset system so it is available before the first scene renders.
@@ -0,0 +1,114 @@
 # World
 Source: `src/dusk/rpg/overworld/`
 ---
 ## Coordinate system
 Three nested coordinate spaces, each defined in `worldpos.h`:
 | Type | Description | Unit |
 |---|---|---|
 | `worldpos_t` | Tile-level absolute position `{x, y, z}` | `worldunit_t` (int16) |
 | `chunkpos_t` | Chunk-grid position `{x, y, z}` | `chunkunit_t` (int16) |
 | `fixed_t[3]` | Smooth sub-tile position used by entities | Q24.8 fixed-point |
 One chunk = `CHUNK_WIDTH × CHUNK_HEIGHT × CHUNK_DEPTH` tiles (16 × 16 × 8).
 The loaded world window = `MAP_CHUNK_WIDTH × MAP_CHUNK_HEIGHT × MAP_CHUNK_DEPTH` chunks (5 × 5 × 3).
 Conversion helpers (all in `worldpos.c`):
 ```c
 worldPosToChunkPos(&worldPos, &chunkPos);   // tile → chunk grid
 chunkPosToWorldPos(&chunkPos, &worldPos);   // chunk grid → tile origin
 worldPosToChunkTileIndex(&worldPos);        // tile → index within its chunk
 chunkPosToIndex(&chunkPos);                 // chunk grid → linear index in MAP.chunks[]
 worldPosToFixed(&worldPos, fixedOut);       // tile → entity fixed position
 fixedToWorldPos(fixedPos);                  // entity fixed → tile (truncates frac)
 ```
 ---
 ## Tiles
 Defined in `tile.h` as a plain `tile_t` enum:
 ```
 TILE_SHAPE_NULL    — empty / unloaded
 TILE_SHAPE_GROUND  — solid flat tile
 TILE_SHAPE_RAMP_*  — directional ramps (N/S/E/W + diagonals NE/NW/SE/SW)
 ```
 Key predicates:
 - `tileIsWalkable(tile)` — true for GROUND and all ramp shapes.
 - `tileIsRamp(tile)` — true only for ramp shapes.
 Entity walk code (`entity.c`) checks both the current tile and the target tile to decide whether the entity steps forward flat, raises one Z level (walking up a ramp), or falls one Z level (stepping onto a downward ramp from above).
 ---
 ## Chunks
 `chunk_t` (`chunk.h`) holds:
 - `position` — its `chunkpos_t` in the world grid
 - `tiles[CHUNK_TILE_COUNT]` — flat array of `tile_t`, indexed by `chunkGetTileIndex()`
 - `vertices[CHUNK_VERTEX_COUNT]` / `mesh` — pre-baked mesh uploaded to GPU on load
 - `entities[CHUNK_ENTITY_COUNT_MAX]` — indices into `ENTITIES[]` currently in this chunk (sentinel `0xFF`)
 - `testColor` — temporary debug color (checkerboard), will be replaced by real tileset data
 Tile layout within a chunk is `z * W*H + y * W + x` (Z-major, row-major in XY).
 ---
 ## Map
 `map_t MAP` (`map.h`) is the single global map instance.
 ```c
 chunk_t chunks[MAP_CHUNK_COUNT];         // flat storage — index is NOT world position
 chunk_t *chunkOrder[MAP_CHUNK_COUNT];    // draw-order sorted pointers into chunks[]
 chunkpos_t chunkPosition;               // world-grid origin of the loaded window
 bool_t loaded;
 ```
 ### Load / unload
 `mapInit()` allocates chunk meshes and performs the initial load of all chunks in the starting window.
 `mapPositionSet(newPos)` shifts the window:
 1. Determines which of the `MAP_CHUNK_COUNT` slots remain within the new window vs. fall outside it.
 2. Calls `mapChunkUnload()` on every chunk that falls outside (nulls its entity slots, zeroes `vertCount`).
 3. Reuses freed slots for newly-in-range chunks; calls `mapChunkLoad()` on each.
 4. Rebuilds `chunkOrder[]` in XYZ order for the new position.
 ### Chunk load (current stub)
 `mapChunkLoad()` currently:
 - Fills all tiles with `TILE_SHAPE_GROUND`
 - Assigns a checkerboard debug color based on chunk XY parity
 - Bakes a flat sprite-batch quad mesh for the z=0 layer and uploads it via `meshFlush()`
 - Skips mesh generation for z > 0 chunks (they're empty)
 ### Tile lookup
 ```c
 tile_t mapGetTile(const worldpos_t position);
 ```
 Converts `position` to its chunk, looks up the chunk in `chunkOrder`, then indexes into `chunk->tiles[]`. Returns `TILE_SHAPE_NULL` for any out-of-bounds position or when the map is not loaded.
 ---
 ## Camera
 `rpgcamera_t RPG_CAMERA` (`rpgcamera.h`) has two modes:
 ```c
 RPG_CAMERA_MODE_FREE            // free worldpos; camera.free holds the position
 RPG_CAMERA_MODE_FOLLOW_ENTITY   // tracks ENTITIES[followEntityId]
 ```
 `rpgCameraGetPosition()` returns the active world tile position in either mode.
 The scene renderer (`sceneoverworld.c`) uses `rpgCameraGetPosition()` to build the `glm_lookat` view matrix. When following an entity, it sub-tile interpolates between `entity->lastPosition` and `entity->position` using `entity->animTime / ENTITY_ANIM_WALK_DURATION` to smooth movement.
@@ -0,0 +1,96 @@
 # Save & Locale
 ---
 ## Save system (`src/dusk/save/`)
 Slot-based persistent storage. Currently disabled in engine init (commented out in `engine.c`) — the system is fully implemented but not yet wired up.
 ### Slots
 Up to `SAVE_FILE_COUNT_MAX` (3) save slots. The global `SAVE` holds all slots:
 ```c
 saveInit();
 saveExists(slot);          // bool_t — check before load
 saveLoad(slot);            // read from platform storage → SAVE.files[slot]
 saveWrite(slot);           // write SAVE.files[slot] → platform storage
 saveDelete(slot);
 savefile_t *f = saveGet(slot);
 saveDispose();
 ```
 ### Save file format
 `savefile_t` is the serialized struct stored per slot. Currently minimal:
 ```c
 typedef struct {
  char_t header[3];    // "DSK"
  uint32_t version;    // SAVE_FILE_VERSION = 1
  bool_t exists;
 } savefile_t;
 ```
 Extend this struct to add game-specific save data (player position, story flags, etc.).
 ### Stream serialization (`save/savestream.h`)
 `savestream_t` is a cursor used to read/write a save slot's bytes. It CRC32-checksums all data written through it and verifies the checksum on read.
 Write a save:
 ```c
 savestream_t stream;
 // (platform opens stream for slot)
 saveFileWriteHeader(&stream, SAVE_FILE_HEADER);
 saveFileWriteVersion(&stream, SAVE_FILE_VERSION);
 saveFileWriteBool(&stream, myFlag);
 saveFileWriteInt32(&stream, myInt);
 saveFileWriteString(&stream, myString, sizeof(myString));
 saveStreamFinalizeWriteImpl(&stream);   // writes CRC
 ```
 Read a save:
 ```c
 saveFileReadHeader(&stream, headerBuf);
 saveFileReadVersion(&stream, &version);
 saveFileReadBool(&stream, &myFlag);
 saveFileReadInt32(&stream, &myInt);
 saveFileReadString(&stream, myString, sizeof(myString));
 saveStreamVerifyChecksumImpl(&stream, slot);   // returns error if CRC mismatch
 ```
 All multi-byte values are stored in little-endian byte order. The `saveFile*` macros are thin wrappers over the `*Impl` functions that integrate `errorChain` — always use the macros.
 ### Platform backends
 Each `src/dusk{platform}/save/` provides `saveplatform_t` (e.g. a file path on Linux, a memory-card handle on GameCube). The stream implementations (`savestream{platform}.c`) do the actual I/O.
 ---
 ## Locale / i18n (`src/dusk/locale/`)
 Translations are stored as GNU `.po` files in `assets/locale/`. Only `en_US.po` currently exists.
 ### Loading
 `localemanager_t LOCALE` tracks the active locale and its in-progress asset entry:
 ```c
 localeManagerInit();                         // loads en_US by default
 localeManagerSetLocale(&LOCALE_EN_US);       // switch locale (async load)
 localeManagerDispose();
 ```
 `LOCALE_EN_US` is a predefined `localeinfo_t` constant (`name = "en-US"`, `file = "locale/en_US.po"`).
 ### Looking up strings
 ```c
 char_t buf[128];
 localeManagerGetText("my.key", buf, sizeof(buf), 1, /* format args */ );
 ```
 The macro handles plural forms and `printf`-style format arguments. Pass plural `1` for singular, any other value for plural.
 `assetlocaleloader.c` parses the `.po` format (msgid / msgstr pairs) into a key→string table during the async asset load phase.
@@ -0,0 +1,382 @@
 # Coding Style
 All source is C11. Everything below is derived from the existing codebase — match it exactly.
 ---
 ## File structure
 ### Headers (`.h`)
 ```c
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "direct/dependency.h"
 ```
 - `#pragma once` always, never `#ifndef` guards.
 - No blank line between the license block and `#pragma once`.
 - One blank line between `#pragma once` and the first `#include`.
 ### Sources (`.c`)
 ```c
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "thisfile.h"
 #include "assert/assert.h"
 #include "util/memory.h"
 ```
 - First include is always the matching `.h` for this `.c` file.
 - Remaining includes follow with no separator unless logically grouped (then one blank line between groups — see [Include order](#include-order)).
 ---
 ## Include order
 In `.c` files, include in this order with a blank line between each group:
 1. The matching header (e.g. `#include "entity.h"`)
 2. Core utilities (`assert/assert.h`, `util/memory.h`, `util/math.h`, etc.)
 3. Engine subsystems (`display/...`, `input/...`, etc.)
 4. Domain subsystems (`rpg/...`, `scene/...`, etc.)
 In `.h` files, only include what the header directly requires. Never include more than necessary to make the type definitions in that header compile.
 All include paths are relative to `src/dusk/` (the root include directory). Use the full path:
 ```c
 #include "rpg/overworld/map.h"   // correct
 #include "map.h"                  // wrong
 ```
 ---
 ## Line length
 80-character limit. Break before it, not after.
 Multi-parameter function signatures break one param per line, with 2-space indent, closing `)` on its own line before `{`:
 ```c
 errorret_t textureInit(
  texture_t *texture,
  const int32_t width,
  const int32_t height,
  const textureformat_t format,
  const texturedata_t data
 ) {
 ```
 Same rule for calls that don't fit on one line:
 ```c
 assertTrue(
  data.paletted.palette->count ==
  mathNextPowTwo(data.paletted.palette->count),
  "Palette color count must be a power of 2"
 );
 ```
 ---
 ## Indentation and spacing
 - **2 spaces** per indent level. No tabs.
 - No space between a control keyword and its `(`:
  ```c
  if(x) {        // correct
  if (x) {       // wrong
  ```
 - No space between a function name and its `(` in either declarations or calls.
 - Opening brace on the same line:
  ```c
  void entityUpdate(entity_t *entity) {
  if(x) {
  for(int i = 0; i < n; i++) {
  ```
 - Closing brace always on its own line, except `} else {` and `} while(...)`.
 - One blank line between function definitions in `.c` files.
 - No trailing whitespace.
 ---
 ## Naming
 | Kind | Convention | Example |
 |---|---|---|
 | Types (struct/union/typedef) | `snake_case_t` | `entity_t`, `worldpos_t` |
 | Struct tags | `struct name_s` | `struct entity_s` |
 | Union tags | `union name_u` | `union texturedata_u` |
 | Enum tags (when typedef'd separately) | `name_enum_t` | `entitytype_enum_t` |
 | Functions | `subsystemVerb` (camelCase, noun-first) | `entityInit`, `mapGetTile` |
 | Macro constants | `UPPER_SNAKE_CASE` | `CHUNK_WIDTH`, `FIXED_ONE` |
 | Function-like macros | `camelCase` (same as functions) | `errorThrow`, `assertNotNull` |
 | Global subsystem instances | `UPPER_SNAKE_CASE` | `ENGINE`, `MAP`, `ENTITIES` |
 | Local variables | `camelCase` | `tileNew`, `spriteCount` |
 | Parameters | `camelCase` | `texture`, `worldPos` |
 Subsystem prefix always comes first in function names: `textureInit`, `shaderBind`, `spriteBatchFlush`. The verb describes the action: `Init`, `Update`, `Dispose`, `Get`, `Set`, `Is`, etc.
 ---
 ## Typedefs
 ### Structs
 ```c
 typedef struct {
  uint8_t id;
  entitytype_t type;
 } entity_t;
 ```
 Use a named tag (`struct entity_s`) only when forward declaration is required:
 ```c
 typedef struct entity_s {
  // ...
 } entity_t;
 ```
 ### Unions
 ```c
 typedef union texturedata_u {
  struct {
    uint8_t *indices;
    palette_t *palette;
  } paletted;
  color_t *rgbaColors;
 } texturedata_t;
 ```
 ### Enums
 When the enum values need to be a compact integer (common for arrays and flags), declare the enum separately and typedef an integer type:
 ```c
 typedef enum {
  ENTITY_TYPE_NULL,
  ENTITY_TYPE_PLAYER,
  ENTITY_TYPE_NPC,
  ENTITY_TYPE_COUNT
 } entitytype_enum_t;
 typedef uint8_t entitytype_t;  // actual type used everywhere
 ```
 Always include `_NULL` as the first value (zero) and `_COUNT` as the last value.
 ---
 ## `#define` constants
 All-caps, underscores. Wrap multi-token expressions in parentheses:
 ```c
 #define CHUNK_WIDTH 16
 #define CHUNK_HEIGHT CHUNK_WIDTH
 #define CHUNK_TILE_COUNT (CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH)
 ```
 Multi-line macros: backslash continuation, body indented 2 spaces, closing line has no backslash:
 ```c
 #define errorThrow(message, ...) \
  return errorThrowImpl(\
    &ERROR_STATE, ERROR_NOT_OK, __FILE__, __func__, __LINE__, (message), \
    ##__VA_ARGS__ \
  )
 ```
 ---
 ## `const` usage
 Mark every pointer and value parameter `const` unless the function modifies it:
 ```c
 void entityTurn(entity_t *entity, const entitydir_t direction);
 errorret_t textureInit(texture_t *texture, const int32_t width, ...);
 ```
 `entity_t *entity` is non-const because the function writes to it; `direction` is const because it is read-only.
 ---
 ## `void` in no-argument functions
 Use `(void)` in definitions and declarations of zero-parameter functions:
 ```c
 errorret_t engineUpdate(void);
 errorret_t spriteBatchFlush(void);
 ```
 ---
 ## Global subsystem state
 Each subsystem exposes a single global instance declared `extern` in the header and defined (once) in the `.c` file:
 ```c
 // entity.h
 extern entity_t ENTITIES[ENTITY_COUNT];
 // entity.c
 entity_t ENTITIES[ENTITY_COUNT];
 ```
 Never define a subsystem global as `static` in a header.
 ---
 ## Assertions
 Place assertions at the very top of a function, before any logic:
 ```c
 void entityInit(entity_t *entity, const entitytype_t type) {
  assertNotNull(entity, "Entity pointer cannot be NULL");
  assertTrue(type < ENTITY_TYPE_COUNT, "Invalid entity type");
  // ... actual logic
 }
 ```
 Available assertion macros (from `assert/assert.h`):
 - `assertNotNull(ptr, msg)`
 - `assertNull(ptr, msg)`
 - `assertTrue(expr, msg)`
 - `assertFalse(expr, msg)`
 - `assertUnreachable(msg)`
 - `assertStringEqual(a, b, msg)`
 - `assertIsMainThread(msg)` / `assertNotMainThread(msg)`
 ---
 ## Error handling style
 Functions that can fail return `errorret_t`. Three patterns:
 ```c
 // Propagate a child call's failure and return from this function:
 errorChain(someCall());
 // Return success:
 errorOk();
 // Return failure:
 errorThrow("Descriptive message %s", variable);
 ```
 `errorChain` is used inline — do not capture the result first:
 ```c
 errorChain(textureInitPlatform(texture, width, height, format, data));  // correct
 errorret_t r = textureInitPlatform(...); errorChain(r);                 // wrong
 ```
 ---
 ## Struct initialization
 Use C99 designated initializers for any struct literal with more than one field:
 ```c
 static const entitycallback_t ENTITY_CALLBACKS[ENTITY_TYPE_COUNT] = {
  [ENTITY_TYPE_NULL] = { NULL },
  [ENTITY_TYPE_PLAYER] = {
    .init = playerInit,
    .movement = playerInput
  },
 };
 ```
 ```c
 shadermaterial_t material = {
  .unlit = {
    .color = COLOR_WHITE,
    .texture = NULL
  }
 };
 ```
 ---
 ## Fixed-size array iteration
 Prefer pointer arithmetic with `do/while` over index loops for iterating through fixed global arrays:
 ```c
 entity_t *ent = ENTITIES;
 do {
  if(ent->type == ENTITY_TYPE_NULL) continue;
  // ...
 } while(++ent, ent < &ENTITIES[ENTITY_COUNT]);
 ```
 Use `for` loops when an index variable is actually needed.
 ---
 ## Comments
 Comments explain *why*, not *what*. One short inline comment is fine; multi-line block comments for non-obvious invariants only.
 ```c
 // Walking up a ramp — only the direction the ramp faces is valid.
 if(tileIsRamp(tileCurrent) && ...) {
 ```
 Section labels inside long functions are acceptable:
 ```c
 // Chunks
 {
  ...
 }
 // Entities
 {
  ...
 }
 ```
 Doc comments on public functions use Javadoc style with `@param` / `@return`:
 ```c
 /**
 * Gets the tile at the given world position.
 *
 * @param position The world position.
 * @return The tile at that position, or TILE_NULL if the chunk is unloaded.
 */
 tile_t mapGetTile(const worldpos_t position);
 ```
 ---
 ## Platform-conditional code
 Use the `DUSK_*` compile-definition macros set by `cmake/targets/<target>.cmake`:
 ```c
 #ifdef DUSK_THREAD_PTHREAD
  #include "thread/thread.h"
  extern pthread_t ASSERT_MAIN_THREAD_ID;
 #endif
 ```
 Never use `#ifdef __linux__`, `#ifdef _WIN32`, etc. directly — go through the engine macros.
@@ -0,0 +1,177 @@
 # Engine Systems
 Smaller systems that support the engine but don't warrant their own file each.
 ---
 ## Time (`src/dusk/time/`)
 `dusktime_t TIME` tracks fixed and dynamic delta time.
 ```c
 TIME.delta         // fixed_t: always DUSK_TIME_STEP (16ms default) on fixed-rate platforms
 TIME.time          // fixed_t: total elapsed time in seconds
 ```
 On platforms with `DUSK_TIME_DYNAMIC` (Linux/SDL2):
 ```c
 TIME.dynamicDelta  // fixed_t: actual time since last frame
 TIME.dynamicTime   // fixed_t: total elapsed (dynamic)
 TIME.dynamicUpdate // bool_t: true when a real tick occurred
 ```
 Call `timeUpdate()` once per frame (before input/logic). `timeGetEpoch()` returns the current wall-clock time as a `dusktimeepoch_t`.
 ### Epoch time (`time/timeepoch.h`)
 `dusktimeepoch_t` stores a Unix timestamp (double) with timezone offset. Utilities:
 ```c
 dusktimeepoch_t e = timeGetEpoch();
 timeEpochGetHours(e)      // 0–23
 timeEpochGetMinutes(e)    // 0–59
 timeEpochGetSeconds(e)    // 0–59
 timeEpochGetDayOfMonth(e) // 0–30
 timeEpochGetMonth(e)      // 0–11
 timeEpochGetYear(e)
 // Format: %Y year, %m month, %d day, %H hour, %M minute, %S second
 timeEpochFormat(e, "%Y-%m-%d %H:%M:%S", buf, sizeof(buf));
 // Compare: returns -1, 0, 1
 timeEpochCompare(a, b);
 // Timezone shift:
 dusktimeepoch_t local = timeEpochSwitchTimeZone(e, offsetHours);
 ```
 ---
 ## Thread (`src/dusk/thread/`)
 Currently only the pthread backend (`DUSK_THREAD_PTHREAD`) exists. Thread objects are `thread_t` — used primarily by the asset loader.
 ```c
 threadInit(&thread, myCallback);   // myCallback: void (*)(thread_t *)
 threadStart(&thread);              // blocks until thread is RUNNING
 threadStop(&thread);               // requests stop, blocks until STOPPED
 // Inside the thread callback:
 while(!threadShouldStop(&thread)) { /* work */ }
 ```
 State flow: `STOPPED → STARTING → RUNNING → (STOP_REQUESTED) → STOPPED`.
 ### Mutex (`thread/threadmutex.h`)
 ```c
 threadMutexInit(&lock);
 threadMutexLock(&lock);
 threadMutexUnlock(&lock);
 threadMutexTryLock(&lock);       // non-blocking; returns false if already held
 threadMutexWaitLock(&lock);      // release lock and sleep until signalled
 threadMutexSignal(&lock);        // wake a thread waiting on this mutex
 threadMutexDispose(&lock);
 ```
 ### Thread-local storage
 `THREAD_LOCAL` expands to `__thread` (GCC) on pthread platforms. Used for the per-thread error state (`ERROR_STATE` in `error/error.h`).
 ---
 ## Event (`src/dusk/event/`)
 A fixed-capacity multicast callback list.
 ```c
 // Declare backing arrays (choose a size):
 eventcallback_t cbs[4];
 void *users[4];
 event_t myEvent;
 eventInit(&myEvent, cbs, users, 4);
 eventSubscribe(&myEvent, myCallback, myUser);
 eventUnsubscribe(&myEvent, myCallback);
 eventInvoke(&myEvent, params);   // calls all subscribers; params passed as-is
 ```
 Callback signature: `void cb(void *params, void *user)`.
 `event_t` does not own its callback/user arrays. Always declare them alongside the event in the same struct or as static arrays.
 ---
 ## Console (`src/dusk/console/`)
 `CONSOLE` is a scrolling in-game terminal for debug output. On POSIX platforms (`DUSK_CONSOLE_POSIX`) it also polls stdin in a thread so commands can be typed during a running session.
 ```c
 consolePrint("Value is %d", x);   // printf-style; thread-safe
 consoleDraw();                     // renders visible history lines to screen
 ```
 Configuration constants (`consoledefs.h`):
 - `CONSOLE_LINE_MAX` — 512 chars per line
 - `CONSOLE_HISTORY_MAX` — 16 lines of scrollback
 - `CONSOLE_EXEC_BUFFER_MAX` — 32 pending exec commands
 `CONSOLE.visible` controls whether `consoleDraw()` actually renders anything.
 ---
 ## Log (`src/dusk/log/`)
 Two simple output functions, implemented per-platform:
 ```c
 logDebug("format %s", arg);   // debug output (stdout on Linux, debug channel on consoles)
 logError("format %s", arg);   // error output; may pause execution on some platforms
 ```
 These go directly to the platform's native output and are not buffered by the console history.
 ---
 ## System / Platform (`src/dusk/system/`)
 `systemInit()` runs platform-specific startup (e.g. Wii PAD init, PSP kernel setup). Must be the first call in `engineInit()`.
 ```c
 systemplatform_t p = systemGetPlatform();   // SYSTEM_PLATFORM_LINUX, _PSP, etc.
 systemdialogtype_t d = systemGetActiveDialogType();
 // SYSTEM_DIALOG_TYPE_NONE / RENDER_BLOCKING / TICK_BLOCKING
 ```
 The full platform list is defined via X-macro in `system/systemplatformlist.h`:
 | Constant | Value |
 |---|---|
 | `SYSTEM_PLATFORM_LINUX` | 0 |
 | `SYSTEM_PLATFORM_KNULLI` | 1 |
 | `SYSTEM_PLATFORM_PSP` | 2 |
 | `SYSTEM_PLATFORM_GAMECUBE` | 3 |
 | `SYSTEM_PLATFORM_WII` | 4 |
 ---
 ## Network (`src/dusk/network/`)
 `network_t NETWORK` manages platform connection state. The engine calls `networkInit` / `networkUpdate` / `networkDispose`; game code uses the request API:
 ```c
 networkRequestConnection(onConnected, onFailed, onDisconnect, user);
 networkRequestDisconnection(onComplete, user);
 networkIsConnected();   // bool_t
 ```
 State machine: `DISCONNECTED → CONNECTING → CONNECTED → DISCONNECTING → DISCONNECTED`.
 Network address info (after connection):
 ```c
 networkinfo_t info = networkGetInfo();
 // info.type = NETWORK_TYPE_IPV4 / IPV6
 // info.ipv4.ip[4] or info.ipv6.ip[16]
 ```
 Platform backends implement `networkPlatformInit/Update/Dispose/IsConnected`. Currently only Linux (socket-based) and PSP/Vita are implemented.
@@ -0,0 +1,123 @@
 # UI System
 Source: `src/dusk/ui/`
 The UI system is an immediate-mode layer drawn on top of the game scene each frame. Elements register themselves; `uiUpdate()` ticks all elements and `uiRender()` draws them. All coordinates are in screen pixels.
 ---
 ## Lifecycle
 ```
 uiInit() → uiTextboxInit()   // init order matters — textbox depends on display being ready
 uiUpdate()                   // each frame, before rendering
 uiRender()                   // each frame, after scene render
 uiDispose()
 uiTextboxDispose()
 ```
 ---
 ## Element registration (`ui/uielement.h`)
 Elements are stored in `UI_ELEMENTS[]`. Each has a type and a `draw` callback:
 ```c
 typedef struct {
  uielementtype_t type;
  errorret_t (*draw)();
 } uielement_t;
 ```
 Currently `UI_ELEMENT_TYPE_NATIVE` elements call their `draw` function directly. New debug/HUD elements are registered by adding to this array.
 ---
 ## Textbox (`ui/uitextbox.h`)
 `UI_TEXTBOX` is the global dialogue box. It word-wraps text, paginates it, and plays a typewriter scroll effect.
 ```c
 uiTextboxSetText("Long dialogue string...");  // wraps to charsPerLine, paginates
 uiTextboxUpdate();                            // each frame: advance scroll, check input
 uiTextboxDraw();                              // draw box + text
 // Pagination:
 uiTextboxPageIsComplete()   // true when all chars of current page are visible
 uiTextboxHasNextPage()
 uiTextboxNextPage()
 // Subscibe to page events:
 eventSubscribe(&UI_TEXTBOX.onPageComplete, cb, user);
 eventSubscribe(&UI_TEXTBOX.onLastPage, cb, user);
 ```
 `UI_TEXTBOX.advanceAction` defaults to the input action that advances dialogue — set it before calling `uiTextboxInit()` if the default doesn't suit.
 Layout constants:
 - `UI_TEXTBOX_TEXT_MAX` — 1024 chars
 - `UI_TEXTBOX_LINES_MAX` — 64 lines
 - `UI_TEXTBOX_LINES_PER_PAGE_MAX` — 3 lines visible at once
 - `UI_TEXTBOX_SCROLL_CHARS_PER_TICK` — 1 char per tick (typewriter speed)
 The textbox uses `UI_TEXTBOX.frame` (a `uiframe_t`) for its border rendering and `UI_TEXTBOX.font` for text.
 ---
 ## UI Frame (`ui/uiframe.h`)
 9-slice bordered box rendered with a tileset:
 ```c
 uiFrameInit(&frame);
 uiFrameDraw(&frame, x, y, width, height);
 uiFrameDispose(&frame);
 ```
 The tileset is loaded from the asset system during `uiFrameInit()`. The 9 slices are arranged in the tileset grid as: top-left corner, top edge, top-right corner, left edge, fill, right edge, bottom-left, bottom edge, bottom-right.
 ---
 ## Loading overlay (`ui/uiloading.h`)
 `UI_LOADING` is a full-screen loading indicator with fade-in/fade-out transitions:
 ```c
 uiLoadingShow(onShownCallback, user);   // fade in; calls callback when fully opaque
 uiLoadingHide(onHiddenCallback, user);  // fade out; calls callback when fully transparent
 uiLoadingUpdate(delta);                 // each frame
 uiLoadingDraw();                        // each frame, over everything
 ```
 `UI_LOADING_FADE_DURATION` is `FIXED(0.5f)` seconds. Subscribe to `UI_LOADING.onTransitionEnd` for completion events.
 ---
 ## Full-box overlay (`ui/uifullbox.h`)
 Two global full-screen color overlays: `UI_FULLBOX_UNDER` (drawn before game content) and `UI_FULLBOX_OVER` (drawn after). Used for scene transitions (fade to black, etc.):
 ```c
 uiFullboxTransition(
  &UI_FULLBOX_OVER,
  COLOR_TRANSPARENT, COLOR_BLACK,
  FIXED(0.5f),
  EASING_IN_OUT_CUBIC
 );
 eventSubscribe(&UI_FULLBOX_OVER.onTransitionEnd, myCallback, NULL);
 uiFullboxUnderDraw();   // draw under layer
 uiFullboxOverDraw();    // draw over layer
 ```
 ---
 ## FPS counter (`ui/uifps.h`)
 `UIFPS` tracks a rolling average FPS. `uiFPSDraw()` renders it in the corner. Currently drawn as part of the debug HUD (not wired to an element slot).
 ---
 ## Player position HUD (`ui/uiplayerpos.h`)
 `uiplayerpos.c` draws the player's current world tile coordinates. Debug overlay, currently drawn directly in the scene render.
@@ -0,0 +1,162 @@
 # Utilities
 Source: `src/dusk/util/`
 ---
 ## String (`util/string.h`)
 **Always use these instead of stdlib equivalents** (`strcmp`, `strcpy`, `sprintf`, etc.).
 ```c
 stringCopy(dest, src, destSize);           // safe strncpy; always null-terminates
 stringCompare(a, b);                       // -1 / 0 / 1
 stringEquals(a, b);                        // bool_t
 stringCompareInsensitive(a, b);            // case-insensitive -1 / 0 / 1
 stringTrim(str);                           // in-place strip leading/trailing whitespace
 stringFindLastChar(str, c);                // last occurrence pointer or NULL
 stringFormat(dest, destSize, fmt, ...);    // snprintf wrapper; pass NULL dest to get length
 stringFormatVA(dest, destSize, fmt, args); // va_list version
 stringIsWhitespace(c);                     // bool_t
 // Parse:
 stringToI32(str, &out)   → bool_t
 stringToI64(str, &out)   → bool_t
 stringToI16(str, &out)   → bool_t
 stringToU16(str, &out)   → bool_t
 stringToF32(str, &out)   → bool_t
 // Suffix checks:
 stringEndsWith(str, suffix)                 → bool_t
 stringEndsWithCaseInsensitive(str, suffix)  → bool_t
 stringIncludesString(haystack, needle)      → bool_t
 ```
 ---
 ## Memory (`util/memory.h`)
 **Always use these instead of `malloc`/`free`/`memcpy`/`memset` directly.**
 ```c
 memoryAllocate(size)          → void *      // malloc + tracks pointer count
 memoryAlign(alignment, size)  → void *      // aligned malloc
 memoryFree(ptr)                             // free + decrements count
 memoryReallocate(&ptr, size)               // realloc
 memoryResize(&ptr, oldSize, newSize)       // realloc + copy (safe reshape)
 memoryTrack(ptr)                           // track externally-malloc'd pointer
 memoryCopy(dest, src, size)                // memcpy
 memoryMove(dest, src, size)                // memmove
 memorySet(dest, value, size)               // memset
 memoryZero(dest, size)                     // memset 0
 memoryCompare(a, b, size)     → int_t      // memcmp
 // Useful for uploading vertex data with different source/dest layouts:
 memoryCopyInterleaved(dest, destStride, src, srcStride, elementSize, count);
 memoryCopyRangeSafe(dest, start, end, sizeMax);  // copy with bounds check
 memoryGetAllocatedCount()     → size_t     // current malloc'd block count
 ```
 ---
 ## Math (`util/math.h`)
 ```c
 mathNextPowTwo(value)    → uint32_t   // next power of two >= value
 mathMax(a, b)                         // macro
 mathMin(a, b)                         // macro
 mathClamp(x, lower, upper)            // macro
 mathAbs(amt)                          // macro
 mathModFloat(x, y)       → float_t    // always non-negative modulo
 mathLerp(a, b, t)        → float_t    // linear interpolation (floats)
 ```
 For fixed-point lerp use `fixedLerp(a, b, t)` from `util/fixed.h`.
 `MATH_PI` is defined as `M_PI`.
 ---
 ## Fixed-point (`util/fixed.h`)
 Q24.8 format: 24-bit integer part, 8-bit fractional part (`int32_t`). See [architecture.md](architecture.md#fixed-point-math) for the full API.
 Quick reference:
 ```c
 FIXED(1.5f)               // compile-time literal
 fixedFromI32(3)           // runtime int → fixed
 fixedToFloat(f)           // fixed → float (only for GL/platform APIs)
 fixedMul(a, b)            // multiplication (not just addition)
 fixedDiv(a, b)            // division
 fixedLerp(a, b, t)        // lerp where t ∈ [0, FIXED_ONE]
 ```
 ---
 ## Array (`util/array.h`)
 ```c
 arrayReverse(array, count, size);   // in-place reverse; size = sizeof(element)
 ```
 ---
 ## Sort (`util/sort.h`)
 ```c
 sortQuick(array, count, size, compare);   // quicksort
 sortBubble(array, count, size, compare);  // bubble sort (small arrays)
 sort(array, count, size, compare);        // macro alias for sortQuick
 // Convenience uint8_t sorter:
 sortArrayU8(array, count);
 int sortArrayU8Compare(const void *a, const void *b);   // comparator
 ```
 `sortcompare_t` matches `qsort` comparator signature: `int (*)(const void *, const void *)`.
 ---
 ## Reference counting (`util/ref.h`)
 ```c
 refInit(&ref, dataPtr, onLock, onUnlock, onAllUnlocked);
 refLock(&ref);              // increments count, calls onLock
 bool_t hit_zero = refUnlock(&ref);   // decrements; calls onAllUnlocked when 0
 ```
 Used internally by the asset entry system to track how many callers hold a reference to a loaded asset entry.
 ---
 ## CRC32 (`util/crypt.h`)
 ```c
 // One-shot:
 uint32_t crc = cryptCRC32(data, size);
 // Streaming:
 uint32_t acc = cryptCRC32Begin();
 cryptCRC32Update(&acc, chunk1, len1);
 cryptCRC32Update(&acc, chunk2, len2);
 uint32_t final = cryptCRC32End(acc);
 ```
 Used by the save stream to checksum save files.
 ---
 ## Endian (`util/endian.h`)
 All serialized data (save files, asset headers) is little-endian. Convert to/from host byte order:
 ```c
 uint32_t val = endianLittleToHost32(rawU32);
 uint16_t val = endianLittleToHost16(rawU16);
 float_t  val = endianLittleToHostFloat(rawFloat);
 ```
 `isHostLittleEndian()` returns a bool at runtime. The compile-time defines `DUSK_PLATFORM_ENDIAN_LITTLE` / `DUSK_PLATFORM_ENDIAN_BIG` are set by `cmake/targets/<target>.cmake`.
@@ -1,11 +1,8 @@
 name: Build Dusk
 on:
  push:
-    branches:
+    tags:
-      - main
+      - '*'
  pull_request:
    branches:
      - main
 jobs:
  run-tests:
    runs-on: ubuntu-latest
@@ -144,7 +141,7 @@ jobs:
      - name: Copy output files.
        run: |
          mkdir -p ./git-artifcats/Dusk/apps/Dusk
-          cp build-wii/Dusk.dol ./git-artifcats/Dusk/apps/Dusk/boot.dol
+          cp build-wii/boot.dol ./git-artifcats/Dusk/apps/Dusk/boot.dol
          cp build-wii/dusk.dsk ./git-artifcats/Dusk/apps/Dusk/dusk.dsk
          cp build-wii/meta.xml ./git-artifcats/Dusk/apps/Dusk/meta.xml
      - name: Upload Wii binary
@@ -106,3 +106,4 @@ yarn.lock
 /build*
 /assets/test
 /tools_old
 /assets/test.png
@@ -0,0 +1,65 @@
 # CLAUDE.md
 This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
 ## Project
 Dusk is a C11 RPG game targeting resource-constrained hardware (PSP, GameCube, Wii, PS Vita, Knulli handhelds) and Linux/OpenGL. All game code lives in `src/dusk/`; platform-specific backends live in `src/dusk{platform}/` (e.g. `src/duskgl/`, `src/duskpsp/`, `src/duskdolphin/`).
 Assets are zipped into `dusk.dsk` at build time and loaded at runtime via the asset system.
 ## Build
 ```bash
 # Linux (host)
 ./scripts/build-linux.sh          # outputs build-linux/Dusk
 # Other targets (require Docker)
 ./scripts/build-psp-docker.sh
 ./scripts/build-gamecube-docker.sh
 ./scripts/build-wii-docker.sh
 ./scripts/build-knulli-docker.sh
 ```
 Each script is a thin wrapper around:
 ```bash
 cmake -S . -B build-<target> -DDUSK_TARGET_SYSTEM=<target>
 cmake --build build-<target> -- -j$(nproc)
 ```
 ## Tests
 ```bash
 ./scripts/test-linux.sh           # builds and runs all tests
 # Manually run a single test binary after building:
 ./build-tests/test/<module>/test_<name>
 ```
 Tests use [cmocka](https://cmocka.org/) and are only compiled when `DUSK_BUILD_TESTS=ON`. Test sources live under `test/`.
 ## Key conventions
 - Use `stringCompare`, `stringCopy`, `stringEquals`, etc. from `util/string.h` — never `strcmp`, `strcpy`, and friends directly.
 - All functions that can fail return `errorret_t`. Use `errorThrow(...)`, `errorChain(call())`, and `errorOk()` macros — see `error/error.h`.
 - Positions and game-world values use `fixed_t` (Q24.8 fixed-point, `int32_t`) — not `float`. Use `FIXED(x)` for literals and the `fixedFrom*`/`fixedTo*` helpers in `util/fixed.h`.
 ## Coding style
 See [`.claude/style.md`](.claude/style.md) for the full style guide: indentation, line length, naming, typedefs, defines, include order, `const` usage, assertion placement, error handling, struct initialization, and platform conditionals.
 ## Architecture & systems
 | Doc | Covers |
 |---|---|
 | [`.claude/architecture.md`](.claude/architecture.md) | Platform abstraction pattern, subsystem lifecycle, error handling, code-generation pipeline |
 | [`.claude/display.md`](.claude/display.md) | Rendering pipeline: display state, screen, framebuffer, mesh, shader, texture, spritebatch, text |
 | [`.claude/input.md`](.claude/input.md) | Input actions, buttons, bindings, axis helpers, events |
 | [`.claude/asset.md`](.claude/asset.md) | Asset archive, entry lifecycle, loader types, async/sync split, low-level file I/O |
 | [`.claude/ui.md`](.claude/ui.md) | UI element system, textbox, frames, loading overlay, fullbox transitions, FPS counter |
 | [`.claude/animation.md`](.claude/animation.md) | Keyframe animation, easing functions |
 | [`.claude/systems.md`](.claude/systems.md) | Time, threading, mutex, events, console, logging, system/platform, network |
 | [`.claude/util.md`](.claude/util.md) | String, memory, math, fixed-point, array, sort, ref counting, CRC32, endian |
 | [`.claude/save.md`](.claude/save.md) | Save slots, stream serialization with CRC, locale/i18n |
 | [`.claude/rpg/index.md`](.claude/rpg/index.md) | RPG layer overview → [world](.claude/rpg/world.md), [entities](.claude/rpg/entity.md), [cutscenes](.claude/rpg/cutscene.md), [story/items](.claude/rpg/story.md) |
 | [`.claude/display-refactor.md`](.claude/display-refactor.md) | Planned render-queue refactor (Saturn port context) |
@@ -0,0 +1,28 @@
 # Copyright (c) 2025 Dominic Masters
 #
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 # Sources
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
  PUBLIC
    display.c
 )
 # Subdirectories
 add_subdirectory(framebuffer)
 add_subdirectory(mesh)
 add_subdirectory(screen)
 add_subdirectory(shader)
 add_subdirectory(spritebatch)
 add_subdirectory(text)
 add_subdirectory(texture)
 # Color definitions
 dusk_run_python(
  dusk_color_defs
  tools.color.csv
    --csv ${CMAKE_CURRENT_SOURCE_DIR}/color.csv
    --output ${DUSK_GENERATED_HEADERS_DIR}/display/color.h
 )
 add_dependencies(${DUSK_LIBRARY_TARGET_NAME} dusk_color_defs)
@@ -0,0 +1,23 @@
 name,r,g,b,a
 black,0,0,0,1
 white,1,1,1,1
 red,1,0,0,1
 green,0,1,0,1
 blue,0,0,1,1
 yellow,1,1,0,1
 cyan,0,1,1,1
 magenta,1,0,1,1
 transparent,0,0,0,0
 transparent_white,1,1,1,0
 transparent_black,0,0,0,0
 gray,0.5,0.5,0.5,1
 light_gray,0.75,0.75,0.75,1
 dark_gray,0.25,0.25,0.25,1
 orange,1,0.65,0,1
 purple,0.5,0,0.5,1
 brown,0.6,0.4,0.2,1
 pink,1,0.75,0.8,1
 lime,0.75,1,0,1
 navy,0,0,0.5,1
 teal,0,0.5,0.5,1
 cornflower_blue,0.39,0.58,0.93,1
@@ -0,0 +1,116 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "display/display.h"
 #include "display/framebuffer/framebuffer.h"
 #include "scene/scene.h"
 #include "display/spritebatch/spritebatch.h"
 #include "display/mesh/quad.h"
 #include "display/mesh/cube.h"
 #include "display/mesh/sphere.h"
 #include "display/mesh/plane.h"
 #include "display/mesh/capsule.h"
 #include "display/mesh/triprism.h"
 #include "display/screen/screen.h"
 #include "ui/ui.h"
 #include "display/text/text.h"
 #include "assert/assert.h"
 #include "util/memory.h"
 #include "util/string.h"
 #include "asset/asset.h"
 #include "display/shader/shaderlist.h"
 #include "time/time.h"
 display_t DISPLAY = { 0 };
 errorret_t displayInit(void) {
  memoryZero(&DISPLAY, sizeof(DISPLAY));
  #ifdef displayPlatformInit
    errorChain(displayPlatformInit());
  #endif
  errorChain(displaySetState((displaystate_t){ .flags = 0 }));
  errorChain(textureInit(
    &TEXTURE_WHITE, 4, 4,
    TEXTURE_FORMAT_RGBA, (texturedata_t){ .rgbaColors = TEXTURE_WHITE_PIXELS }
  ));
  errorChain(textureInit(
    &TEXTURE_TEST, 4, 4,
    TEXTURE_FORMAT_RGBA, (texturedata_t){ .rgbaColors = TEXTURE_TEST_PIXELS }
  ));
  // Standard meshes
  errorChain(quadInit());
  errorChain(cubeInit());
  errorChain(sphereInit());
  errorChain(planeInit());
  errorChain(capsuleInit());
  errorChain(triPrismInit());
  errorChain(frameBufferInitBackBuffer());
  errorChain(spriteBatchInit());
  errorChain(textInit());
  errorChain(screenInit());
  // Setup initial shader with default values
  errorChain(shaderListInit());
  errorOk();
 }
 errorret_t displayUpdate(void) {
  #ifdef displayPlatformUpdate
    errorChain(displayPlatformUpdate());
  #endif
  // Reset state
  spriteBatchClear();
  errorChain(frameBufferBind(NULL));
  // Bind screen and render scene
  errorChain(screenBind());
  frameBufferClear(
    FRAMEBUFFER_CLEAR_COLOR | FRAMEBUFFER_CLEAR_DEPTH,
    SCREEN.background
  );
  errorChain(sceneRender());
  // Finish up
  screenUnbind();
  screenRender();
  // Swap and return.
  #ifdef displayPlatformSwap
    errorChain(displayPlatformSwap());
  #endif
  errorOk();
 }
 errorret_t displaySetState(displaystate_t state) {
  #ifdef displayPlatformSetState
    errorChain(displayPlatformSetState(state));
  #endif
  errorOk();
 }
 errorret_t displayDispose(void) {
  errorChain(shaderListDispose());
  errorChain(spriteBatchDispose());
  screenDispose();
  errorChain(textDispose());
  errorChain(textureDispose(&TEXTURE_WHITE));
  errorChain(textureDispose(&TEXTURE_TEST));
  #ifdef displayPlatformDispose
    displayPlatformDispose();
  #endif
  // For now, we just return an OK error.
  errorOk();
 }
@@ -0,0 +1,65 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "display/displayplatform.h"
 // Expecting some definitions to be provided
 #ifndef DUSK_DISPLAY_SIZE_DYNAMIC
  #ifndef DUSK_DISPLAY_WIDTH
    #error "DUSK_DISPLAY_WIDTH must be defined."
  #endif
  #ifndef DUSK_DISPLAY_HEIGHT
    #error "DUSK_DISPLAY_HEIGHT must be defined"
  #endif
  #define DUSK_DISPLAY_WIDTH_DEFAULT DUSK_DISPLAY_WIDTH
  #define DUSK_DISPLAY_HEIGHT_DEFAULT DUSK_DISPLAY_HEIGHT
 #else
  #ifndef DUSK_DISPLAY_WIDTH_DEFAULT
    #error "DUSK_DISPLAY_WIDTH_DEFAULT must be defined."
  #endif
  #ifndef DUSK_DISPLAY_HEIGHT_DEFAULT
    #error "DUSK_DISPLAY_HEIGHT_DEFAULT must be defined."
  #endif
  #ifdef DUSK_DISPLAY_WIDTH
    #error "DUSK_DISPLAY_WIDTH should not be defined."
  #endif
  #ifdef DUSK_DISPLAY_HEIGHT
    #error "DUSK_DISPLAY_HEIGHT should not be defined."
  #endif
 #endif
 // Main Display Struct, platform-speicifc
 typedef displayplatform_t display_t;
 extern display_t DISPLAY;
 /**
 * Initializes the display system.
 * @return An errorret_t indicating success or failure.
 */
 errorret_t displayInit(void);
 /**
 * Tells the display system to actually draw the frame.
 * @return An errorret_t indicating success or failure.
 */
 errorret_t displayUpdate(void);
 /**
 * Sets the display state.
 * 
 * @param state The state to set.
 * @return An errorret_t indicating success or failure.
 */
 errorret_t displaySetState(displaystate_t state);
 /**
 * Disposes of the display system.
 * @return An errorret_t indicating success or failure.
 */
 errorret_t displayDispose(void);
@@ -0,0 +1,17 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "dusk.h"
 #define DISPLAY_STATE_FLAG_CULL (1 << 0)
 #define DISPLAY_STATE_FLAG_DEPTH_TEST (1 << 1)
 #define DISPLAY_STATE_FLAG_BLEND (1 << 2)
 typedef struct {
  uint8_t flags;
 } displaystate_t;
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,4 +1,4 @@
-// Copyright (c) 2025 Dominic Masters
+// Copyright (c) 2026 Dominic Masters
 // 
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
@@ -74,7 +74,7 @@ void planeBuffer(
  const float_t u0 = uvMin[0], u1 = uvMax[0];
  const float_t v0 = uvMin[1], v1 = uvMax[1];
-  switch (axis) {
+  switch(axis) {
    case PLANE_AXIS_XY: {
      /* Flat in XY at z = min[2]; spans X and Y. */
      const float_t z = min[2];
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -50,70 +50,95 @@ errorret_t spriteBatchBuffer(
  }
  // Buffer the vertices.
-  for(uint32_t i = 0; i < count; i++ ){
+  uint32_t remaining = count;
-    spritebatchsprite_t sprite = sprites[i];
+  do {
    uint32_t spritesBeforeFlush = (
      SPRITEBATCH_SPRITES_MAX_PER_FLUSH - SPRITEBATCH.spriteCount
    );
    if(spritesBeforeFlush == 0) {
      // Flush if we have no capacity before flushing.
      errorChain(spriteBatchFlush());
      spritesBeforeFlush = SPRITEBATCH_SPRITES_MAX_PER_FLUSH;
    }
    // Many we buffering?
    const uint32_t batchCount = mathMin(
      remaining,
      spritesBeforeFlush
    );
    // Destination
    meshvertex_t *v = &SPRITEBATCH_VERTICES[
      (SPRITEBATCH.spriteCount + (SPRITEBATCH.spriteFlush *
      SPRITEBATCH_SPRITES_MAX_PER_FLUSH)) * QUAD_VERTEX_COUNT
    ];
    // Buffer to the mesh vertices.
    spriteBatchBufferToMesh(
      sprites, batchCount, v, batchCount * QUAD_VERTEX_COUNT
    );
    SPRITEBATCH.spriteCount += batchCount;
    remaining -= batchCount;
  } while(remaining > 0);
  errorOk();
 }
 void spriteBatchBufferToMesh(
  const spritebatchsprite_t *sprites,
  const uint32_t count,
  meshvertex_t *vertices,
  const uint32_t verticesSize
 ) {
  assertNotNull(sprites, "Sprites cannot be null");
  assertTrue(count > 0, "Count must be greater than zero");
  assertNotNull(vertices, "Vertices cannot be null");
  assertTrue(
    verticesSize >= count * QUAD_VERTEX_COUNT, "Vertices array too small"
  );
  for(uint32_t i = 0; i < count; i++ ){
    spritebatchsprite_t sprite = sprites[i];
    meshvertex_t *v = &vertices[i * QUAD_VERTEX_COUNT];
    // Buffer the quad
    v[0].pos[0] = sprite.min[0];
    v[0].pos[1] = sprite.min[1];
    v[0].pos[2] = sprite.min[2];
    v[0].uv[0] = sprite.uvMin[0];
    v[0].uv[1] = sprite.uvMin[1];
    v[1].pos[0] = sprite.max[0];
    v[1].pos[1] = sprite.min[1];
    v[1].pos[2] = sprite.min[2];
    v[1].uv[0] = sprite.uvMax[0];
    v[1].uv[1] = sprite.uvMin[1];
    v[2].pos[0] = sprite.max[0];
    v[2].pos[1] = sprite.max[1];
    v[2].pos[2] = sprite.max[2];
    v[2].uv[0] = sprite.uvMax[0];
    v[2].uv[1] = sprite.uvMax[1];
    v[3].pos[0] = sprite.min[0];
    v[3].pos[1] = sprite.min[1];
    v[3].pos[2] = sprite.min[2];
    v[3].uv[0] = sprite.uvMin[0];
    v[3].uv[1] = sprite.uvMin[1];
    v[4].pos[0] = sprite.max[0];
    v[4].pos[1] = sprite.max[1];
    v[4].pos[2] = sprite.max[2];
    v[4].uv[0] = sprite.uvMax[0];
    v[4].uv[1] = sprite.uvMax[1];
    v[5].pos[0] = sprite.min[0];
    v[5].pos[1] = sprite.max[1];
    v[5].pos[2] = sprite.max[2];
    v[5].uv[0] = sprite.uvMin[0];
    v[5].uv[1] = sprite.uvMax[1];
    // Do we need to flush?
    SPRITEBATCH.spriteCount++;
    if(SPRITEBATCH.spriteCount >= SPRITEBATCH_SPRITES_MAX_PER_FLUSH) {
      errorChain(spriteBatchFlush());
    }
  }
  errorOk();
 }
 void spriteBatchClear() {
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -47,7 +47,7 @@ errorret_t spriteBatchInit();
 /**
 * Lowest-level buffer function. Writes sprites into the internal vertex buffer.
 * Flushes automatically when the per-flush capacity is reached. Does not
- * modify material state — call spriteBatchSetState or use a high-level push
+ * modify material state - call spriteBatchSetState or use a high-level push
 * function before buffering.
 *
 * @param sprites Pointer to the sprite array.
@@ -63,6 +63,26 @@ errorret_t spriteBatchBuffer(
  const shadermaterial_t material
 );
 /**
 * Buffers an array of sprites to a given array of mesh vertices. This is the
 * internal method that is used to buffer to the internal spritebatch mesh, but
 * you can use it to achieve sprite buffering to a mesh you own.
 * 
 * verticesSize is the size of the vertices array, we use this to ensure no 
 * buffer overflows.
 * 
 * @param sprites Pointer to the sprite array.
 * @param count Number of sprites to buffer.
 * @param vertices Pointer to the vertex array to write to.
 * @param verticesSize Size of the vertex array, in number of vertices.
 */
 void spriteBatchBufferToMesh(
  const spritebatchsprite_t *sprites,
  const uint32_t count,
  meshvertex_t *vertices,
  const uint32_t verticesSize
 );
 /**
 * Resets sprite and flush counters and clears the current material state.
 * Calling spriteBatchFlush after this renders nothing.
@@ -93,15 +93,6 @@ errorret_t textDraw(
  float_t posX = x;
  float_t posY = y;
  errorChain(shaderSetTexture(
    &SHADER_UNLIT, SHADER_UNLIT_TEXTURE, font->texture
  ));
  #if MESH_ENABLE_COLOR
  #else
    errorChain(shaderSetColor(&SHADER_UNLIT, SHADER_UNLIT_COLOR, color));
  #endif
  char_t c;
  int32_t i = 0;
  while((c = text[i++]) != '\0') {
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -19,6 +19,14 @@ color_t TEXTURE_WHITE_PIXELS[4*4] = {
  COLOR_WHITE, COLOR_WHITE, COLOR_WHITE, COLOR_WHITE,
 };
 texture_t TEXTURE_TEST;
 color_t TEXTURE_TEST_PIXELS[4*4] = {
  COLOR_BLACK, COLOR_MAGENTA, COLOR_BLACK, COLOR_MAGENTA,
  COLOR_MAGENTA, COLOR_BLACK, COLOR_MAGENTA, COLOR_BLACK,
  COLOR_BLACK, COLOR_MAGENTA, COLOR_BLACK, COLOR_MAGENTA,
  COLOR_MAGENTA, COLOR_BLACK, COLOR_MAGENTA, COLOR_BLACK,
 };
 errorret_t textureInit(
  texture_t *texture,
  const int32_t width,
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -30,6 +30,8 @@ typedef union texturedata_u {
 extern texture_t TEXTURE_WHITE;
 extern color_t TEXTURE_WHITE_PIXELS[4*4];
 extern texture_t TEXTURE_TEST;
 extern color_t TEXTURE_TEST_PIXELS[4*4];
 /**
 * Initializes a texture.
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -16,7 +16,6 @@ typedef enum {
 typedef struct {
  rpgcameramode_t mode;
  union {
    worldpos_t free;
    struct {
@@ -1,4 +1,7 @@
-Console.print('This is called from JavaScript');
+// Copyright (c) 2026 Dominic Masters
 //
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 const platformNames = {
  [System.PLATFORM_LINUX]:    'Linux',
@@ -8,5 +11,11 @@ const platformNames = {
  [System.PLATFORM_WII]:      'Wii',
 };
-const platformName = platformNames[System.platform] || 'Unknown';
+Console.print('Platform: ' + (platformNames[System.platform] || 'Unknown'));
-Console.print('Platform: ' + platformName);
+
 UIFullboxOver.setColor(Color.BLACK);
 requireAsync('testscene.js').then(Scene.set).catch(err => {
  Console.print('Error loading scene: ' + err);
  Engine.exit();
 });
@@ -0,0 +1,63 @@
 // Copyright (c) 2026 Dominic Masters
 //
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 const PLAYER_SPEED = 5.0;
 // 1 world unit = 16 pixels.
 const PIXEL_SCALE = 1.0 / 16.0;
 // Player sprite is 32x32 px (test.png dimensions).
 const PLAYER_W = 32 * PIXEL_SCALE;
 const PLAYER_H = 32 * PIXEL_SCALE;
 var player = {};
 player.getAssets = () => {
  return [
    { path: 'test.png', type: Asset.TYPE_TEXTURE, format: Texture.FORMAT_RGBA }
  ];
 }
 player.init = function(scene) {
  var texture = scene.assets.getAssetByPath('test.png');
  Console.print('Player init: got texture ' + texture);
  _entity   = Entity.create();
  _position = _entity.add(Component.POSITION);
  _physics  = _entity.add(Component.PHYSICS);
  _physics.bodyType   = Physics.DYNAMIC;
  _physics.shape      = Physics.SHAPE_CUBE;
  _physics.gravityScale = 1.0;
  var r       = _entity.add(Component.RENDERABLE);
  r.texture   = texture.texture;
  r.type      = Renderable.SPRITEBATCH;
  r.color     = new Color(220, 80, 80);
  // Upright quad centered on X, bottom-aligned on Y.
  r.sprites = [[-PLAYER_W/2, 0, 0, PLAYER_W/2, PLAYER_H, 0, 0, 1, 1, 0]];
  _position.localPosition = new Vec3(0, PLAYER_H, 0);
 };
 player.getPosition = function() {
  return _position;
 };
 player.update = function() {
  if(!_physics) return;
  var vx = Input.axis(INPUT_ACTION_LEFT, INPUT_ACTION_RIGHT) * PLAYER_SPEED;
  var vz = Input.axis(INPUT_ACTION_DOWN, INPUT_ACTION_UP) * PLAYER_SPEED;
  // Preserve vertical velocity so gravity and landing work correctly.
  var vy = _physics.velocity.y;
  _physics.velocity = new Vec3(vx, vy, vz);
 };
 player.dispose = function() {
  Entity.dispose(_entity);
  _entity   = null;
  _position = null;
  _physics  = null;
 };
 module.exports = player;
@@ -1,8 +0,0 @@
 const cam = Entity.create();
 const pos = cam.add(Component.POSITION);
 cam.add(Component.CAMERA);
 pos.localPosition = new Vec3(3, 3, 3);
 pos.lookAt(new Vec3(0, 0, 0));
 Console.print('Camera entity ID: ' + cam.toString());
@@ -0,0 +1,42 @@
 // Copyright (c) 2026 Dominic Masters
 //
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 var scene  = {};
 // Pokemon DS-style camera: ~34 degrees elevation (atan(6/9)).
 // CAM_HEIGHT / CAM_DIST ratio controls the tilt - keep it under 0.7 for
 // the characteristically shallow DS angle.
 const CAM_HEIGHT = 6;
 const CAM_DIST   = 9;
 scene.init = async function() {
  // Camera
  scene.cam = Entity.create();
  var camPos = scene.cam.add(Component.POSITION);
  var cam = scene.cam.add(Component.CAMERA);
  camPos.localPosition = new Vec3(3, 3, 3);
  camPos.lookAt(new Vec3(0, 0, 0));
  // Floor - large flat slab, no texture needed.
  scene.floor = Entity.create();
  var floorPos = scene.floor.add(Component.POSITION);
  var floorR = scene.floor.add(Component.RENDERABLE);
  floorR.type  = Renderable.SHADER_MATERIAL;
  floorR.color = Color.BLUE;
  // floorPos.localScale = new Vec3(16, 0.2, 16);
  // floorPos.localPosition = new Vec3(0, -0.1, 0);
  await UIFullboxOver.transition(Color.BLACK, Color.TRANSPARENT, 1.0);
 };
 scene.update = function() {
 };
 scene.dispose = function() {
  Entity.dispose(scene.floor);
  Entity.dispose(scene.cam);
 };
 module.exports = scene;
@@ -1,96 +0,0 @@
 # Copyright (c) 2026 Dominic Masters
 #
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 # Turn things off we don't need
 set(JERRY_CMDLINE OFF CACHE BOOL "" FORCE)
 set(JERRY_EXT ON CACHE BOOL "" FORCE)
 set(JERRY_DEBUGGER OFF CACHE BOOL "" FORCE)
 set(JERRY_BUILTIN_DATE OFF CACHE BOOL "" FORCE)
 set(ENABLE_LTO OFF CACHE BOOL "" FORCE)
 # Fetch Jerry
 include(FetchContent)
 FetchContent_Declare(
  jerryscript
  GIT_REPOSITORY https://git.wish.moe/YourWishes/jerryscript
  GIT_TAG float32-fix
 )
 FetchContent_MakeAvailable(jerryscript)
 # Mark found
 set(jerryscript_FOUND ON)
 # Define targets
 if(TARGET jerryscript-core)
  set(JERRY_CORE_TARGET jerryscript-core)
 elseif(TARGET jerry-core)
  set(JERRY_CORE_TARGET jerry-core)
 endif()
 if(TARGET jerryscript-ext)
  set(JERRY_EXT_TARGET jerryscript-ext)
 elseif(TARGET jerry-ext)
  set(JERRY_EXT_TARGET jerry-ext)
 endif()
 if(TARGET jerryscript-port-default)
  set(JERRY_PORT_TARGET jerryscript-port-default)
 elseif(TARGET jerry-port-default)
  set(JERRY_PORT_TARGET jerry-port-default)
 elseif(TARGET jerryscript-port)
  set(JERRY_PORT_TARGET jerryscript-port)
 elseif(TARGET jerry-port)
  set(JERRY_PORT_TARGET jerry-port)
 endif()
 if(NOT JERRY_CORE_TARGET)
  message(FATAL_ERROR "JerryScript core target not found")
 endif()
 if(NOT JERRY_EXT_TARGET)
  message(FATAL_ERROR "JerryScript ext target not found")
 endif()
 if(NOT JERRY_PORT_TARGET)
  message(FATAL_ERROR "JerryScript port target not found")
 endif()
 foreach(tgt IN ITEMS
  ${JERRY_CORE_TARGET}
  ${JERRY_EXT_TARGET}
  ${JERRY_PORT_TARGET}
 )
  if(TARGET ${tgt})
    set_property(TARGET ${tgt} PROPERTY INTERPROCEDURAL_OPTIMIZATION OFF)
    target_compile_definitions(${JERRY_CORE_TARGET} PRIVATE
      JERRY_NUMBER_TYPE_FLOAT64=0
      JERRY_BUILTIN_DATE=0
    )
  endif()
 endforeach()
 # Export include dirs through the targets
 target_include_directories(${JERRY_CORE_TARGET} INTERFACE
  ${jerryscript_SOURCE_DIR}/jerry-core/include
 )
 target_include_directories(${JERRY_EXT_TARGET} INTERFACE
  ${jerryscript_SOURCE_DIR}/jerry-ext/include
 )
 target_include_directories(${JERRY_PORT_TARGET} INTERFACE
  ${jerryscript_SOURCE_DIR}/jerry-port/default/include
 )
 # Suppress JerryScript-only warning
 if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
  target_compile_options(${JERRY_CORE_TARGET} PRIVATE
    -Wno-error
  )
 endif()
 add_library(jerryscript::core ALIAS ${JERRY_CORE_TARGET})
 add_library(jerryscript::ext ALIAS ${JERRY_EXT_TARGET})
 add_library(jerryscript::port ALIAS ${JERRY_PORT_TARGET})
@@ -1,15 +1,18 @@
-# Build type: FAT (SD/USB via libfat) or ISO (DVD disc via libogc DVD driver)
+# Build type: DOL (SD/USB via libfat) or ISO (DVD disc via libogc DVD driver)
-set(DUSK_DOLPHIN_BUILD_TYPE "FAT" CACHE STRING "Dolphin asset source: FAT (SD/USB) or ISO (DVD disc)")
+set(DUSK_DOLPHIN_BUILD_TYPE "DOL" CACHE STRING "Dolphin asset source: DOL (SD/USB) or ISO (DVD disc)")
-set_property(CACHE DUSK_DOLPHIN_BUILD_TYPE PROPERTY STRINGS "FAT" "ISO")
+set_property(CACHE DUSK_DOLPHIN_BUILD_TYPE PROPERTY STRINGS "DOL" "ISO")
-# Target definitions
+# Numeric tokens so #if DUSK_DOLPHIN_BUILD_TYPE == DOL works in C.
 # DUSK_DOLPHIN_BUILD_TYPE is passed without quotes so it expands to the identifier.
 target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
  DUSK_DOLPHIN
  DUSK_INPUT_GAMEPAD
  DUSK_DISPLAY_WIDTH=640
  DUSK_DISPLAY_HEIGHT=480
  DUSK_THREAD_PTHREAD
-  DUSK_DOLPHIN_BUILD_TYPE="${DUSK_DOLPHIN_BUILD_TYPE}"
+  DOL=1
  ISO=2
  DUSK_DOLPHIN_BUILD_TYPE=${DUSK_DOLPHIN_BUILD_TYPE}
 )
 # Custom compiler flags
@@ -1,3 +1,3 @@
 #!/bin/bash
 docker build -t dusk-dolphin -f docker/dolphin/Dockerfile .
-docker run --rm -v $(pwd):/workdir dusk-dolphin /bin/bash -c "./scripts/build-gamecube.sh"
+docker run --rm -v "$(pwd):/workdir" dusk-dolphin /bin/bash -c "./scripts/build-gamecube.sh"
@@ -1,3 +1,3 @@
 #!/bin/bash
 docker build -t dusk-dolphin -f docker/dolphin/Dockerfile .
-docker run --rm -v $(pwd):/workdir dusk-dolphin /bin/bash -c "./scripts/build-gamecube-iso.sh"
+docker run --rm -v "$(pwd):/workdir" dusk-dolphin /bin/bash -c "./scripts/build-gamecube-iso.sh"
@@ -7,6 +7,7 @@ fi
 mkdir -p build-gamecube
 cmake -S. -Bbuild-gamecube \
  -DDUSK_TARGET_SYSTEM=gamecube \
  -DDUSK_DOLPHIN_BUILD_TYPE=DOL \
  -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/GameCube.cmake" \
  -DDKP_OGC_PLATFORM_LIBRARY=libogc2
 cd build-gamecube
@@ -1,3 +1,3 @@
 #!/bin/bash
 docker build -t dusk-knulli -f docker/knulli/Dockerfile .
-docker run --rm -v $(pwd):/workdir dusk-knulli /bin/bash -c "./scripts/build-knulli.sh"
+docker run --rm -v "$(pwd):/workdir" dusk-knulli /bin/bash -c "./scripts/build-knulli.sh"
@@ -1,3 +1,3 @@
 #!/bin/bash
 docker build -t dusk-linux -f docker/linux/Dockerfile .
-docker run --rm -v $(pwd):/workdir dusk-linux /bin/bash -c "./scripts/build-linux.sh"
+docker run --rm -v "$(pwd):/workdir" dusk-linux /bin/bash -c "./scripts/build-linux.sh"
@@ -1,3 +1,3 @@
 #!/bin/bash
 docker build -t dusk-psp -f docker/psp/Dockerfile .
-docker run --rm -v $(pwd):/workdir dusk-psp /bin/bash -c "./scripts/build-psp.sh"
+docker run --rm -v "$(pwd):/workdir" dusk-psp /bin/bash -c "./scripts/build-psp.sh"
@@ -1,3 +1,3 @@
 #!/bin/bash
 docker build -t dusk-vita -f docker/vita/Dockerfile .
-docker run --rm -v $(pwd):/workdir dusk-vita /bin/bash -c "./scripts/build-vita.sh"
+docker run --rm -v "$(pwd):/workdir" dusk-vita /bin/bash -c "./scripts/build-vita.sh"
@@ -1,3 +1,3 @@
 #!/bin/bash
 docker build -t dusk-dolphin -f docker/dolphin/Dockerfile .
-docker run --rm -v $(pwd):/workdir dusk-dolphin /bin/bash -c "./scripts/build-wii.sh"
+docker run --rm -v "$(pwd):/workdir" dusk-dolphin /bin/bash -c "./scripts/build-wii.sh"
@@ -1,3 +1,3 @@
 #!/bin/bash
 docker build -t dusk-dolphin -f docker/dolphin/Dockerfile .
-docker run --rm -v $(pwd):/workdir dusk-dolphin /bin/bash -c "./scripts/build-wii-iso.sh"
+docker run --rm -v "$(pwd):/workdir" dusk-dolphin /bin/bash -c "./scripts/build-wii-iso.sh"
@@ -5,6 +5,10 @@ if [ -z "$DEVKITPRO" ]; then
 fi
 mkdir -p build-wii
-cmake -S. -Bbuild-wii -DDUSK_TARGET_SYSTEM=wii -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/Wii.cmake"
+cmake -S. -Bbuild-wii \
  -DDUSK_TARGET_SYSTEM=wii \
  -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/Wii.cmake" \
  -DDUSK_DOLPHIN_BUILD_TYPE=DOL
 cd build-wii
 make -j$(nproc) VERBOSE=1
 mv Dusk.dol boot.dol
@@ -1,3 +1,7 @@
 #!/bin/bash
 docker build -t dusk-linux -f docker/linux/Dockerfile .
-docker run --rm -v $(pwd):/workdir dusk-linux /bin/bash -c "./scripts/test-linux.sh"
+docker run \
  --rm \
  -v "${GITHUB_WORKSPACE}:/workdir" \
  dusk-linux \
  /bin/bash -c "./scripts/test-linux.sh"
@@ -32,15 +32,6 @@ if(NOT yyjson_FOUND)
  endif()
 endif()
 if(NOT jerryscript_FOUND)
  find_package(jerryscript REQUIRED)
  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
    jerryscript::core
    jerryscript::ext
    jerryscript::port
  )
 endif()
 if(DUSK_BACKTRACE)
  target_link_options(${DUSK_LIBRARY_TARGET_NAME} PUBLIC -rdynamic)
  target_compile_definitions(${DUSK_BINARY_TARGET_NAME} PUBLIC
@@ -65,25 +56,20 @@ add_subdirectory(animation)
 add_subdirectory(event)
 add_subdirectory(assert)
 add_subdirectory(asset)
 add_subdirectory(cutscene)
 add_subdirectory(item)
 add_subdirectory(story)
 add_subdirectory(console)
 add_subdirectory(display)
 add_subdirectory(render)
 add_subdirectory(log)
 add_subdirectory(engine)
 add_subdirectory(entity)
 add_subdirectory(error)
 add_subdirectory(input)
 add_subdirectory(locale)
-add_subdirectory(physics)
+add_subdirectory(rpg)
 add_subdirectory(scene)
 add_subdirectory(script)
 add_subdirectory(system)
 add_subdirectory(time)
 add_subdirectory(ui)
 add_subdirectory(network)
 add_subdirectory(overworld)
 add_subdirectory(save)
 add_subdirectory(util)
 add_subdirectory(thread)
@@ -6,7 +6,7 @@
 #include "animation.h"
 #include "assert/assert.h"
 #include "util/memory.h"
-#include "util/math.h"
+#include "util/fixed.h"
 void animationInit(
  animation_t *anim,
@@ -21,7 +21,7 @@ void animationInit(
  anim->keyframeCount = keyframeCount;
 }
-float_t animationGetValue(animation_t *anim, const float_t time) {
+fixed_t animationGetValue(animation_t *anim, const fixed_t time) {
  assertNotNull(anim, "Animation pointer cannot be null.");
  assertNotNull(anim->keyframes, "Keyframes pointer cannot be null.");
  assertTrue(anim->keyframeCount > 0, "Keyframe count invalid.");
@@ -47,6 +47,13 @@ float_t animationGetValue(animation_t *anim, const float_t time) {
    }
  } while(true);
-  float_t t = (time - start->time) / (end->time - start->time);
+  fixed_t span = fixedSub(end->time, start->time);
-  return mathLerp(start->value, end->value, easingApply(start->easing, t));
+  fixed_t progress = span != 0
    ? fixedDiv(fixedSub(time, start->time), span)
    : FIXED_ONE;
  return fixedLerp(
    start->value,
    end->value,
    easingApply(start->easing, progress)
  );
 }
@@ -31,4 +31,4 @@ void animationInit(
 * @param time The time at which to get the value, in seconds.
 * @return The value of the animation at the given time.
 */
-float_t animationGetValue(animation_t *anim, const float_t time);
+fixed_t animationGetValue(animation_t *anim, const fixed_t time);
@@ -5,7 +5,12 @@
 #include "easing.h"
 #include "assert/assert.h"
-#include <math.h>
+#include "util/math.h"
 #include "util/fixed.h"
 #define EASING_C1 1.70158f
 #define EASING_C2 (EASING_C1 * 1.525f)
 #define EASING_C3 (EASING_C1 + 1.0f)
 const easingfn_t EASING_FUNCTIONS[EASING_COUNT] = {
  easingLinear,
@@ -26,86 +31,101 @@ const easingfn_t EASING_FUNCTIONS[EASING_COUNT] = {
  easingInOutBack,
 };
-float_t easingApply(const easingtype_t type, const float_t t) {
+fixed_t easingApply(const easingtype_t type, const fixed_t t) {
  assertTrue(type < EASING_COUNT, "Invalid easing type");
  return EASING_FUNCTIONS[type](t);
 }
-float_t easingLinear(const float_t t) {
+fixed_t easingLinear(const fixed_t t) {
  return t;
 }
-float_t easingInSine(const float_t t) {
+fixed_t easingInSine(const fixed_t t) {
-  return 1.0f - cosf(t * EASING_PI * 0.5f);
+  float_t f = fixedToFloat(t);
  return fixedFromFloat(1.0f - cosf(f * MATH_PI * 0.5f));
 }
-float_t easingOutSine(const float_t t) {
+fixed_t easingOutSine(const fixed_t t) {
-  return sinf(t * EASING_PI * 0.5f);
+  float_t f = fixedToFloat(t);
  return fixedFromFloat(sinf(f * MATH_PI * 0.5f));
 }
-float_t easingInOutSine(const float_t t) {
+fixed_t easingInOutSine(const fixed_t t) {
-  return -(cosf(EASING_PI * t) - 1.0f) * 0.5f;
+  float_t f = fixedToFloat(t);
  return fixedFromFloat(-(cosf(MATH_PI * f) - 1.0f) * 0.5f);
 }
-float_t easingInQuad(const float_t t) {
+fixed_t easingInQuad(const fixed_t t) {
-  return t * t;
+  float_t f = fixedToFloat(t);
  return fixedFromFloat(f * f);
 }
-float_t easingOutQuad(const float_t t) {
+fixed_t easingOutQuad(const fixed_t t) {
-  float_t u = 1.0f - t;
+  float_t f = fixedToFloat(t);
-  return 1.0f - u * u;
+  float_t u = 1.0f - f;
  return fixedFromFloat(1.0f - u * u);
 }
-float_t easingInOutQuad(const float_t t) {
+fixed_t easingInOutQuad(const fixed_t t) {
-  if(t < 0.5f) return 2.0f * t * t;
+  float_t f = fixedToFloat(t);
-  float_t u = -2.0f * t + 2.0f;
+  if(f < 0.5f) return fixedFromFloat(2.0f * f * f);
-  return 1.0f - u * u * 0.5f;
+  float_t u = -2.0f * f + 2.0f;
  return fixedFromFloat(1.0f - u * u * 0.5f);
 }
-float_t easingInCubic(const float_t t) {
+fixed_t easingInCubic(const fixed_t t) {
-  return t * t * t;
+  float_t f = fixedToFloat(t);
  return fixedFromFloat(f * f * f);
 }
-float_t easingOutCubic(const float_t t) {
+fixed_t easingOutCubic(const fixed_t t) {
-  float_t u = 1.0f - t;
+  float_t f = fixedToFloat(t);
-  return 1.0f - u * u * u;
+  float_t u = 1.0f - f;
  return fixedFromFloat(1.0f - u * u * u);
 }
-float_t easingInOutCubic(const float_t t) {
+fixed_t easingInOutCubic(const fixed_t t) {
-  if(t < 0.5f) return 4.0f * t * t * t;
+  float_t f = fixedToFloat(t);
-  float_t u = -2.0f * t + 2.0f;
+  if(f < 0.5f) return fixedFromFloat(4.0f * f * f * f);
-  return 1.0f - u * u * u * 0.5f;
+  float_t u = -2.0f * f + 2.0f;
  return fixedFromFloat(1.0f - u * u * u * 0.5f);
 }
-float_t easingInQuart(const float_t t) {
+fixed_t easingInQuart(const fixed_t t) {
-  return t * t * t * t;
+  float_t f = fixedToFloat(t);
  return fixedFromFloat(f * f * f * f);
 }
-float_t easingOutQuart(const float_t t) {
+fixed_t easingOutQuart(const fixed_t t) {
-  float_t u = 1.0f - t;
+  float_t f = fixedToFloat(t);
-  return 1.0f - u * u * u * u;
+  float_t u = 1.0f - f;
  return fixedFromFloat(1.0f - u * u * u * u);
 }
-float_t easingInOutQuart(const float_t t) {
+fixed_t easingInOutQuart(const fixed_t t) {
-  if(t < 0.5f) return 8.0f * t * t * t * t;
+  float_t f = fixedToFloat(t);
-  float_t u = -2.0f * t + 2.0f;
+  if(f < 0.5f) return fixedFromFloat(8.0f * f * f * f * f);
-  return 1.0f - u * u * u * u * 0.5f;
+  float_t u = -2.0f * f + 2.0f;
  return fixedFromFloat(1.0f - u * u * u * u * 0.5f);
 }
-float_t easingInBack(const float_t t) {
+fixed_t easingInBack(const fixed_t t) {
-  return EASING_C3 * t * t * t - EASING_C1 * t * t;
+  float_t f = fixedToFloat(t);
  return fixedFromFloat(EASING_C3 * f * f * f - EASING_C1 * f * f);
 }
-float_t easingOutBack(const float_t t) {
+fixed_t easingOutBack(const fixed_t t) {
-  float_t u = t - 1.0f;
+  float_t f = fixedToFloat(t);
-  return 1.0f + EASING_C3 * u * u * u + EASING_C1 * u * u;
+  float_t u = f - 1.0f;
  return fixedFromFloat(1.0f + EASING_C3 * u * u * u + EASING_C1 * u * u);
 }
-float_t easingInOutBack(const float_t t) {
+fixed_t easingInOutBack(const fixed_t t) {
-  if(t < 0.5f) {
+  float_t f = fixedToFloat(t);
-    float_t u = 2.0f * t;
+  if(f < 0.5f) {
-    return u * u * ((EASING_C2 + 1.0f) * u - EASING_C2) * 0.5f;
+    float_t u = 2.0f * f;
    return fixedFromFloat(u * u * ((EASING_C2 + 1.0f) * u - EASING_C2) * 0.5f);
  }
-  float_t u = 2.0f * t - 2.0f;
+  float_t u = 2.0f * f - 2.0f;
-  return (u * u * ((EASING_C2 + 1.0f) * u + EASING_C2) + 2.0f) * 0.5f;
+  return fixedFromFloat((u * u * ((EASING_C2 + 1.0f) * u + EASING_C2) + 2.0f) * 0.5f);
 }
@@ -5,11 +5,7 @@
 #pragma once
 #include "dusk.h"
-
+#include "util/fixed.h"
 #define EASING_PI 3.14159265358979323846f
 #define EASING_C1 1.70158f
 #define EASING_C2 (EASING_C1 * 1.525f)
 #define EASING_C3 (EASING_C1 + 1.0f)
 typedef enum {
  EASING_LINEAR,
@@ -32,7 +28,7 @@ typedef enum {
  EASING_COUNT
 } easingtype_t;
-typedef float_t (*easingfn_t)(const float_t t);
+typedef fixed_t (*easingfn_t)(const fixed_t t);
 extern const easingfn_t EASING_FUNCTIONS[EASING_COUNT];
@@ -40,24 +36,24 @@ extern const easingfn_t EASING_FUNCTIONS[EASING_COUNT];
 * Applies the specified easing function to t.
 *
 * @param type The easing type to apply.
- * @param t The input time, in the range [0, 1].
+ * @param t The input progress in [0, FIXED_ONE].
- * @return The eased value, in the range [0, 1].
+ * @return The eased value in [0, FIXED_ONE].
 */
-float_t easingApply(const easingtype_t type, const float_t t);
+fixed_t easingApply(const easingtype_t type, const fixed_t t);
-float_t easingLinear(const float_t t);
+fixed_t easingLinear(const fixed_t t);
-float_t easingInSine(const float_t t);
+fixed_t easingInSine(const fixed_t t);
-float_t easingOutSine(const float_t t);
+fixed_t easingOutSine(const fixed_t t);
-float_t easingInOutSine(const float_t t);
+fixed_t easingInOutSine(const fixed_t t);
-float_t easingInQuad(const float_t t);
+fixed_t easingInQuad(const fixed_t t);
-float_t easingOutQuad(const float_t t);
+fixed_t easingOutQuad(const fixed_t t);
-float_t easingInOutQuad(const float_t t);
+fixed_t easingInOutQuad(const fixed_t t);
-float_t easingInCubic(const float_t t);
+fixed_t easingInCubic(const fixed_t t);
-float_t easingOutCubic(const float_t t);
+fixed_t easingOutCubic(const fixed_t t);
-float_t easingInOutCubic(const float_t t);
+fixed_t easingInOutCubic(const fixed_t t);
-float_t easingInQuart(const float_t t);
+fixed_t easingInQuart(const fixed_t t);
-float_t easingOutQuart(const float_t t);
+fixed_t easingOutQuart(const fixed_t t);
-float_t easingInOutQuart(const float_t t);
+fixed_t easingInOutQuart(const fixed_t t);
-float_t easingInBack(const float_t t);
+fixed_t easingInBack(const fixed_t t);
-float_t easingOutBack(const float_t t);
+fixed_t easingOutBack(const fixed_t t);
-float_t easingInOutBack(const float_t t);
+fixed_t easingInOutBack(const fixed_t t);
@@ -5,9 +5,10 @@
 #pragma once
 #include "easing.h"
 #include "util/fixed.h"
 typedef struct {
-  float_t time;
+  fixed_t time;
-  float_t value;
+  fixed_t value;
  easingtype_t easing;
 } keyframe_t;
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2023 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -10,7 +10,17 @@
 #include "util/string.h"
 #include "util/memory.h"
 #ifdef DUSK_THREAD_PTHREAD
  pthread_t ASSERT_MAIN_THREAD_ID = 0;
 #endif
 #ifndef DUSK_ASSERTIONS_FAKED
  void assertInit(void) {
    #ifdef DUSK_THREAD_PTHREAD
      ASSERT_MAIN_THREAD_ID = pthread_self();
    #endif
  }
  #ifdef DUSK_TEST_ASSERT
    void assertTrueImpl(
      const char *file,
@@ -132,4 +142,29 @@
  ) {
    assertTrueImpl(file, line, stringCompare(a, b) == 0, message);
  }
  void assertIsMainThreadImpl(
    const char *file,
    const int32_t line,
    const char *message
  ) {
    #ifdef DUSK_THREAD_PTHREAD
      assertTrueImpl(
        file, line, pthread_self() == ASSERT_MAIN_THREAD_ID, message
      );
    #endif
  }
  void assertNotMainThreadImpl(
    const char *file,
    const int32_t line,
    const char *message
  ) {
    #ifdef DUSK_THREAD_PTHREAD
      assertTrueImpl(
        file, line, pthread_self() != ASSERT_MAIN_THREAD_ID, message
      );
    #endif
  }
 #endif
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2023 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -16,7 +16,18 @@
  #endif
 #endif
 #ifdef DUSK_THREAD_PTHREAD
  #include "thread/thread.h"
  extern pthread_t ASSERT_MAIN_THREAD_ID;
 #endif
 #ifndef DUSK_ASSERTIONS_FAKED
  /**
   * Initializes the assert system. Must be the very first call in engine
   * startup.
   */
  void assertInit(void);
  /**
   * Assert a given value to be true.
   * 
@@ -121,6 +132,28 @@
    const char *message
  );
  /**
   * Asserts that the current thread is the main thread.
   *
   * @param message Message to throw against assertion failure.
   */
  void assertIsMainThreadImpl(
    const char *file,
    const int32_t line,
    const char *message
  );
  /**
   * Asserts that the current thread is NOT the main thread.
   *
   * @param message Message to throw against assertion failure.
   */
  void assertNotMainThreadImpl(
    const char *file,
    const int32_t line,
    const char *message
  );
  /**
   * Asserts a given value to be true.
   * 
@@ -205,8 +238,28 @@
  #define assertStringEqual(a, b, message) \
    assertStringEqualImpl(__FILE__, __LINE__, a, b, message)
  /**
   * Asserts that the current thread is the main thread.
   *
    * @param message Message to throw against assertion failure.
    */
  #define assertIsMainThread(message) \
    assertIsMainThreadImpl(__FILE__, __LINE__, message)
  /**
   * Asserts that the current thread is NOT the main thread.
    *
    * @param message Message to throw against assertion failure.
    */
  #define assertNotMainThread(message) \
    assertNotMainThreadImpl(__FILE__, __LINE__, message)
 #else
  // If assertions are faked, we define the macros to do nothing.
  #define assertInit() ((void)0)
  #define assertMainThreadInit() ((void)0)
  #define assertIsMainThread(message) ((void)0)
  #define assertNotMainThread(message) ((void)0)
  #define assertTrue(x, message) ((void)0)
  #define assertFalse(x, message) ((void)0)
  #define assertUnreachable(message) ((void)0)
@@ -215,11 +268,13 @@
  #define assertDeprecated(message) ((void)0)
  #define assertStrLenMax(str, len, message) ((void)0)
  #define assertStrLenMin(str, len, message) ((void)0)
  #define assertStringEqual(a, b, message) ((void)0)
  #define assertIsMainThread(message) ((void)0)
  #define assertNotMainThread(message) ((void)0)
 #endif
 // Static Assertions
 #define assertStructSize(struct, size) \
  _Static_assert(sizeof(struct) == size, "Size of " #struct " must be " #size)
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -78,9 +78,28 @@ assetentry_t * assetGetEntry(
  return NULL;
 }
 uint32_t assetGetEntriesOfType(
  assetentry_t **outEntries,
  const assetloadertype_t type
 ) {
  assertNotNull(outEntries, "Output entries cannot be NULL.");
  uint32_t count = 0;
  assetentry_t *entry = ASSET.entries;
  do {
    if(entry->type == type) {
      outEntries[count++] = entry;
    }
    entry++;
  } while(entry < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
  return count;
 }
 errorret_t assetRequireLoaded(assetentry_t *entry) {
  assertNotNull(entry, "Entry cannot be NULL.");
  assertTrue(entry->type != ASSET_LOADER_TYPE_NULL, "Invalid loader type.");
  assertIsMainThread("Currently only works on main thread.");
  if(entry->state == ASSET_ENTRY_STATE_LOADED) {
    errorOk();
@@ -102,6 +121,43 @@ errorret_t assetRequireLoaded(assetentry_t *entry) {
  errorOk();
 }
 errorret_t assetRequireDisposed(assetentry_t *entry) {
  assertNotNull(entry, "Entry cannot be NULL.");
  assertTrue(entry->type != ASSET_LOADER_TYPE_NULL, "Invalid loader type.");
  assertIsMainThread("Currently only works on main thread.");
  if(entry->type == ASSET_LOADER_TYPE_NULL) {
    errorOk();
  }
  if(
    entry->state == ASSET_ENTRY_STATE_NOT_STARTED ||
    entry->state == ASSET_ENTRY_STATE_ERROR
  ) {
    errorOk();
  }
  assertTrue(
    entry->refs.count == 0,
    "Cannot require disposal of an entry with active references."
  );
  // Lock to prevent the reaper from collecting the entry mid-spin.
  assetEntryLock(entry);
  while(entry->type != ASSET_LOADER_TYPE_NULL) {
    usleep(1000);
    errorret_t ret = assetUpdate();
    if(errorIsNotOk(ret)) {
      assetEntryUnlock(entry);
      errorChain(ret);
    }
  }
  assetEntryUnlock(entry);
  errorOk();
 }
 assetentry_t * assetLock(
  const char_t *name,
  const assetloadertype_t type,
@@ -114,14 +170,19 @@ assetentry_t * assetLock(
 void assetUnlock(const char_t *name) {
  assertNotNull(name, "Name cannot be NULL.");
  assetentry_t *entry = ASSET.entries;
  do {
-    if(entry->type != ASSET_LOADER_TYPE_NULL && stringEquals(entry->name, name)) {
+    if(
      entry->type != ASSET_LOADER_TYPE_NULL &&
      stringEquals(entry->name, name)
    ) {
      assetEntryUnlock(entry);
      return;
    }
    entry++;
  } while(entry < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
  assertUnreachable("Asset entry not found for unlock.");
 }
@@ -131,6 +192,8 @@ void assetUnlockEntry(assetentry_t *entry) {
 }
 errorret_t assetUpdate(void) {
  assertIsMainThread("assetUpdate must be called from the main thread.");
  // Determine how many available loading slots we have.
  assetloading_t *availableLoading[ASSET_LOADING_COUNT_MAX];
  uint8_t availableLoadingCount = 0;
@@ -197,8 +260,12 @@ errorret_t assetUpdate(void) {
    switch(loading->entry->state) {
      // This thing is pending synchronous loading.
      case ASSET_ENTRY_STATE_PENDING_SYNC:
        // Perform sync load.
        loading->entry->state = ASSET_ENTRY_STATE_LOADING_SYNC;
        // Unlock before calling loadSync. The sync loader may re-enter
        // assetUpdate (e.g. a script loading another asset), and the async
        // thread never touches LOADING_SYNC entries, so this is safe.
        threadMutexUnlock(&loading->mutex);
        errorret_t ret = (
          ASSET_LOADER_CALLBACKS[loading->type].loadSync(loading)
        );
@@ -212,25 +279,25 @@ errorret_t assetUpdate(void) {
          "Loader did not set entry state to loaded or error on finished load."
        );
        // If an error occured these things need to be true, basically just
        // ensuring the sync loader is setting the error correctly.
        if(errorIsNotOk(ret)) {
          errorCatch(errorPrint(ret));
          assertTrue(
            loading->entry->state == ASSET_ENTRY_STATE_ERROR,
            "Loader did not set entry state to error on failed load."
          );
        } else if(loading->entry->state == ASSET_ENTRY_STATE_LOADED) {
          eventInvoke(&loading->entry->onLoaded, loading->entry);
        }
        threadMutexUnlock(&loading->mutex);
        loading++;
        break;
      case ASSET_ENTRY_STATE_LOADING_SYNC:
-        assertUnreachable(
+        // A re-entrant assetUpdate call (e.g. from a script loading another
-          "Entry is in a pending sync state still?"
+        // asset) will see this entry mid-sync-load. Skip it.
-        );
+        threadMutexUnlock(&loading->mutex);
-        break;
+        loading++;
        continue;
      // Done loading, we can just free it up.
      case ASSET_ENTRY_STATE_LOADED:
@@ -239,10 +306,14 @@ errorret_t assetUpdate(void) {
        loading++;
        break;
-      case ASSET_ENTRY_STATE_ERROR:
+      case ASSET_ENTRY_STATE_ERROR: {
        assetentry_t *errEntry = loading->entry;
        loading->entry = NULL;
        threadMutexUnlock(&loading->mutex);
        eventInvoke(&errEntry->onError, errEntry);
        errorThrow("Failed to load asset asynchronously.");
        break;
      }
      default:
        threadMutexUnlock(&loading->mutex);
@@ -252,9 +323,7 @@ errorret_t assetUpdate(void) {
  } while(loading < ASSET.loading + ASSET_LOADING_COUNT_MAX);
-  // Reap entries that have no external locks (refs.count == 0) AND have been
+  // Reap unused entries.
  // explicitly locked at least once. Entries that were never locked are left
  // alone — raw-pointer callers hold no ref but should not lose the entry.
  entry = ASSET.entries;
  do {
    if(entry->state != ASSET_ENTRY_STATE_LOADED) {
@@ -267,11 +336,6 @@ errorret_t assetUpdate(void) {
      continue;
    }
    if(!entry->wasLocked) {
      entry++;
      continue;
    }
    if(entry->refs.count > 0) {
      entry++;
      continue;
@@ -286,6 +350,8 @@ errorret_t assetUpdate(void) {
 }
 void assetUpdateAsync(thread_t *thread) {
  assertNotMainThread("assetUpdateAsync must not run on the main thread.");
  while(!threadShouldStop(thread)) {
    // Walk over each asset
    assetloading_t *loading;
@@ -342,11 +408,19 @@ void assetUpdateAsync(thread_t *thread) {
 }
 errorret_t assetDispose(void) {
  assertIsMainThread("Must be called from the main thread.");
  threadStop(&ASSET.loadThread);
-  for(size_t i = 0; i < ASSET_LOADING_COUNT_MAX; i++) {
+  // Dispose every non-null entry so type-specific dispose callbacks
-    threadMutexDispose(&ASSET.loading[i].mutex);
+  // (e.g. assetScriptDispose freeing jerry values) run before the
-  }
+  // scripting engine is torn down.
  assetentry_t *entry = ASSET.entries;
  do {
    if(entry->type != ASSET_LOADER_TYPE_NULL) {
      errorChain(assetEntryDispose(entry));
    }
    entry++;
  } while(entry < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
  // Cleanup zip file.
  if(ASSET.zip != NULL) {
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025 Dominic Masters
+ * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
@@ -56,7 +56,7 @@ errorret_t assetInit(void);
 bool_t assetFileExists(const char_t *filename);
 /**
- * Gets, or creates, a new asset entry. Internal — prefer assetLock.
+ * Gets, or creates, a new asset entry. Internal - prefer assetLock.
 *
 * @param name Filename of the asset.
 * @param type Type of the asset.
@@ -68,6 +68,18 @@ assetentry_t * assetGetEntry(
  assetloaderinput_t *input
 );
 /**
 * Gets all asset entries of a given type.
 *
 * @param outEntries Output array to write the entries to.
 * @param type Type of the asset entries to get.
 * @return The number of entries written to outEntries.
 */
 uint32_t assetGetEntriesOfType(
  assetentry_t **outEntries,
  const assetloadertype_t type
 );
 /**
 * Gets, creates, and locks an asset entry. The asset will begin loading on
 * the next assetUpdate. Call assetUnlock when done to allow the entry to be
@@ -109,6 +121,15 @@ void assetUnlockEntry(assetentry_t *entry);
 */
 errorret_t assetRequireLoaded(assetentry_t *entry);
 /**
 * Requires an asset entry to be disposed. This will block until the asset entry
 * is fully disposed.
 * 
 * @param entry The asset entry to require disposal of.
 * @return An error code if the asset entry could not be disposed properly.
 */
 errorret_t assetRequireDisposed(assetentry_t *entry);
 /**
 * Updates the asset system.
 *
@@ -19,15 +19,53 @@ void assetBatchInit(
  assertNotNull(batch, "Batch cannot be NULL.");
  assertNotNull(descs, "Descs cannot be NULL.");
  assertTrue(count > 0, "Count must be greater than 0.");
-  assertTrue(count <= ASSET_BATCH_COUNT_MAX, "Count exceeds ASSET_BATCH_COUNT_MAX.");
+  assertTrue(
    count <= ASSET_BATCH_COUNT_MAX, "Count exceeds ASSET_BATCH_COUNT_MAX."
  );
  memoryZero(batch, sizeof(assetbatch_t));
  batch->count = count;
  eventInit(
    &batch->onLoaded,
    batch->onLoadedCallbacks, batch->onLoadedUsers, ASSET_BATCH_EVENT_MAX
  );
  eventInit(
    &batch->onEntryLoaded,
    batch->onEntryLoadedCallbacks,
    batch->onEntryLoadedUsers,
    ASSET_BATCH_EVENT_MAX
  );
  eventInit(
    &batch->onError,
    batch->onErrorCallbacks, batch->onErrorUsers, ASSET_BATCH_EVENT_MAX
  );
  eventInit(
    &batch->onEntryError,
    batch->onEntryErrorCallbacks,
    batch->onEntryErrorUsers,
    ASSET_BATCH_EVENT_MAX
  );
  for(uint16_t i = 0; i < count; i++) {
    // Copy input into batch-owned storage so the descriptor need not persist.
    batch->inputs[i] = descs[i].input;
-    batch->entries[i] = assetLock(descs[i].path, descs[i].type, &batch->inputs[i]);
+    batch->entries[i] = assetLock(
      descs[i].path, descs[i].type, &batch->inputs[i]
    );
    if(batch->entries[i]->state == ASSET_ENTRY_STATE_LOADED) {
      // Already loaded (cached) - count it now, no subscription needed.
      batch->loadedCount++;
    } else if(batch->entries[i]->state == ASSET_ENTRY_STATE_ERROR) {
      batch->errorCount++;
    } else {
      eventSubscribe(
        &batch->entries[i]->onLoaded, assetBatchEntryOnLoadedCb, batch
      );
      eventSubscribe(
        &batch->entries[i]->onError, assetBatchEntryOnErrorCb, batch
      );
    }
  }
 }
@@ -88,7 +126,40 @@ errorret_t assetBatchRequireLoaded(assetbatch_t *batch) {
 void assetBatchDispose(assetbatch_t *batch) {
  assertNotNull(batch, "Batch cannot be NULL.");
  for(uint16_t i = 0; i < batch->count; i++) {
-    assetUnlockEntry(batch->entries[i]);
+    if(batch->entries[i]) {
      // Unsubscribe while we still hold a lock so the entry is live.
      eventUnsubscribe(&batch->entries[i]->onLoaded, assetBatchEntryOnLoadedCb);
      eventUnsubscribe(&batch->entries[i]->onError, assetBatchEntryOnErrorCb);
      assetUnlockEntry(batch->entries[i]);
    }
  }
  memoryZero(batch, sizeof(assetbatch_t));
 }
 void assetBatchEntryOnLoadedCb(void *params, void *user) {
  assetentry_t *entry = (assetentry_t *)params;
  assetbatch_t *batch = (assetbatch_t *)user;
  batch->loadedCount++;
  eventInvoke(&batch->onEntryLoaded, entry);
  if((uint16_t)(batch->loadedCount + batch->errorCount) >= batch->count) {
    if(batch->errorCount == 0) {
      eventInvoke(&batch->onLoaded, batch);
    } else {
      eventInvoke(&batch->onError, batch);
    }
  }
 }
 void assetBatchEntryOnErrorCb(void *params, void *user) {
  assetentry_t *entry = (assetentry_t *)params;
  assetbatch_t *batch = (assetbatch_t *)user;
  batch->errorCount++;
  eventInvoke(&batch->onEntryError, entry);
  if((uint16_t)(batch->loadedCount + batch->errorCount) >= batch->count) {
    eventInvoke(&batch->onError, batch);
  }
 }
@@ -8,8 +8,10 @@
 #pragma once
 #include "asset/loader/assetentry.h"
 #include "asset/loader/assetloader.h"
 #include "event/event.h"
-#define ASSET_BATCH_COUNT_MAX 64
+#define ASSET_BATCH_COUNT_MAX  64
 #define ASSET_BATCH_EVENT_MAX  4
 typedef struct {
  const char_t *path;
@@ -21,6 +23,28 @@ typedef struct {
  assetentry_t *entries[ASSET_BATCH_COUNT_MAX];
  assetloaderinput_t inputs[ASSET_BATCH_COUNT_MAX];
  uint16_t count;
  uint16_t loadedCount;
  uint16_t errorCount;
  /** Fires once when every entry loaded. params = assetbatch_t * */
  event_t onLoaded;
  eventcallback_t onLoadedCallbacks[ASSET_BATCH_EVENT_MAX];
  void *onLoadedUsers[ASSET_BATCH_EVENT_MAX];
  /** Fires each time a single entry loads. params = assetentry_t * */
  event_t onEntryLoaded;
  eventcallback_t onEntryLoadedCallbacks[ASSET_BATCH_EVENT_MAX];
  void *onEntryLoadedUsers[ASSET_BATCH_EVENT_MAX];
  /** Fires when all entries finish (any with errors). params: assetbatch_t * */
  event_t onError;
  eventcallback_t onErrorCallbacks[ASSET_BATCH_EVENT_MAX];
  void *onErrorUsers[ASSET_BATCH_EVENT_MAX];
  /** Fires each time a single entry errors. params = assetentry_t * */
  event_t onEntryError;
  eventcallback_t onEntryErrorCallbacks[ASSET_BATCH_EVENT_MAX];
  void *onEntryErrorUsers[ASSET_BATCH_EVENT_MAX];
 } assetbatch_t;
 /**
@@ -80,3 +104,21 @@ errorret_t assetBatchRequireLoaded(assetbatch_t *batch);
 * @param batch Batch to dispose.
 */
 void assetBatchDispose(assetbatch_t *batch);
 /**
 * Event trampoline invoked when a batch entry finishes loading.
 * Increments the loaded counter and fires batch-level events.
 *
 * @param params The loaded assetentry_t pointer.
 * @param user   The owning assetbatch_t pointer.
 */
 void assetBatchEntryOnLoadedCb(void *params, void *user);
 /**
 * Event trampoline invoked when a batch entry fails to load.
 * Increments the error counter and fires batch-level events.
 *
 * @param params The errored assetentry_t pointer.
 * @param user   The owning assetbatch_t pointer.
 */
 void assetBatchEntryOnErrorCb(void *params, void *user);
@@ -117,6 +117,51 @@ errorret_t assetFileDispose(assetfile_t *file) {
  errorOk();
 }
 errorret_t assetFileReadEntire(
  assetfile_t *file,
  uint8_t **outBuffer,
  size_t *outSize
 ) {
  assertNotNull(file, "Asset file cannot be NULL.");
  assertNotNull(outBuffer, "outBuffer cannot be NULL.");
  assertNotNull(outSize, "outSize cannot be NULL.");
  assertTrue(
    file->size > 0,
    "Asset file has no size; call assetFileInit first."
  );
  // File should be closed currently.
  assertNull(file->zipFile, "Asset file must be closed before reading entire.");
  // Open file
  errorret_t ret = assetFileOpen(file);
  if(errorIsNotOk(ret)) {
    errorChain(ret);
  }
  // Set output.
  size_t size = (size_t)file->size;
  uint8_t *buffer = (uint8_t *)memoryAllocate(size);
  // Read entire file.
  ret = assetFileRead(file, buffer, size);
  if(errorIsNotOk(ret)) {
    memoryFree(buffer);
    errorChain(ret);
  }
  // Close the file.
  ret = assetFileClose(file);
  if(errorIsNotOk(ret)) {
    memoryFree(buffer);
    errorChain(ret);
  }
  *outBuffer = buffer;
  *outSize   = size;
  errorOk();
 }
 // Line Reader;
 void assetFileLineReaderInit(
  assetfilelinereader_t *reader,
@@ -92,6 +92,21 @@ errorret_t assetFileClose(assetfile_t *file);
 */
 errorret_t assetFileDispose(assetfile_t *file);
 /**
 * Reads the entire contents of the asset file into a newly allocated buffer.
 * The caller is responsible for freeing the buffer with memoryFree.
 *
 * @param file       The asset file to read. Must be initialized but not open.
 * @param outBuffer  Receives a pointer to the allocated buffer.
 * @param outSize    Receives the number of bytes written to the buffer.
 * @return An error code if the file could not be read.
 */
 errorret_t assetFileReadEntire(
  assetfile_t *file,
  uint8_t **outBuffer,
  size_t *outSize
 );
 typedef struct {
  assetfile_t *file;
  uint8_t *readBuffer;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
YourWishes	57b2cdb9d1	prog	2026-06-18 20:25:54 -05:00
YourWishes	730a5b2b10	Docs	2026-06-18 14:59:21 -05:00
YourWishes	6135d60ddc	Interact	2026-06-18 13:34:36 -05:00
YourWishes	4c2a883038	Bit more cleanup of floats	2026-06-18 13:03:57 -05:00
YourWishes	c88b672f42	Fixed_t updates	2026-06-18 12:44:23 -05:00
YourWishes	a162002af2	Show player pos, fix chunks off screen	2026-06-18 10:24:45 -05:00
YourWishes	9810fd51ab	Compiles again	2026-06-18 10:17:53 -05:00
YourWishes	857c6b3d47	Fuck	2026-06-16 09:18:13 -05:00
YourWishes	e1498f538d	Optimize chunk tile mesh	2026-06-11 14:45:53 -05:00
YourWishes	aa246eff94	RPG stuff	2026-06-11 12:18:13 -05:00
YourWishes	5be21a21d5	prog	2026-06-10 19:06:19 -05:00
YourWishes	8131bcd4d4	Build on github tag	2026-06-09 15:43:31 -05:00
YourWishes	4ba11e3363	Test Build Dusk / run-tests (push) Failing after 15m50s Details	2026-06-08 18:01:19 -05:00
YourWishes	acf2be3f66	Try set Build Dusk / run-tests (push) Failing after 7s Details	2026-06-08 17:04:07 -05:00
YourWishes	f5df0195e2	Docker compose Build Dusk / run-tests (push) Failing after 7s Details	2026-06-08 17:02:58 -05:00
YourWishes	d26995b48d	pwd Build Dusk / run-tests (push) Failing after 6s Details	2026-06-08 16:59:39 -05:00
YourWishes	617f8120ae	Docker exec Build Dusk / run-tests (push) Failing after 14s Details	2026-06-08 16:48:17 -05:00
YourWishes	06c517c9aa	chmod Build Dusk / run-tests (push) Failing after 7s Details	2026-06-08 16:47:45 -05:00
YourWishes	593ed6408c	test2 Build Dusk / run-tests (push) Successful in 7s Details	2026-06-08 16:47:03 -05:00
YourWishes	fb7d3ed122	LS stuff Build Dusk / run-tests (push) Successful in 7s Details	2026-06-08 16:45:59 -05:00
YourWishes	19b88ec858	Test linux? Build Dusk / run-tests (push) Failing after 6s Details	2026-06-08 16:08:24 -05:00
YourWishes	160e65be7f	Run on ubuntu-latest Build Dusk / run-tests (push) Failing after 16s Details	2026-06-08 15:34:31 -05:00
YourWishes	079b0d2cf6	Update test script back to what it was Build Dusk / run-tests (push) Has been cancelled Details	2026-06-08 15:18:40 -05:00
YourWishes	78f1310f41	Update test script Build Dusk / run-tests (push) Failing after 7s Details	2026-06-08 15:14:53 -05:00
YourWishes	eb1974c113	Update to docker-host Build Dusk / run-tests (push) Failing after 6m15s Details	2026-06-08 14:55:31 -05:00
YourWishes	551409a023	Force run again Build Dusk / run-tests (push) Failing after 9m15s Details	2026-06-08 13:58:11 -05:00
YourWishes	a11e14daac	Try without setup docker Build Dusk / run-tests (push) Failing after 8m28s Details	2026-06-08 13:15:15 -05:00
YourWishes	7441e15e76	Run on ubuntu-latest Build Dusk / run-tests (push) Failing after 3m15s Details	2026-06-08 13:09:53 -05:00
YourWishes	46506228a6	One thing at a time Build Dusk / run-tests (push) Has been cancelled Details	2026-06-08 12:46:38 -05:00
YourWishes	17c49c74cf	Try tests updated Build Dusk / build-linux (push) Failing after 29s Details Build Dusk / build-psp (push) Failing after 1m13s Details Build Dusk / run-tests (push) Has been cancelled Details Build Dusk / build-gamecube (push) Has been cancelled Details Build Dusk / build-gamecube-iso (push) Has been cancelled Details Build Dusk / build-knulli (push) Has been cancelled Details Build Dusk / build-wii (push) Has been cancelled Details Build Dusk / build-wii-iso (push) Has been cancelled Details	2026-06-08 12:44:22 -05:00
YourWishes	3f8024d4db	Workflows Build Dusk / run-tests (push) Failing after 58s Details Build Dusk / build-linux (push) Failing after 1m11s Details Build Dusk / build-psp (push) Failing after 46s Details Build Dusk / build-knulli (push) Failing after 53s Details Build Dusk / build-gamecube (push) Failing after 47s Details Build Dusk / build-gamecube-iso (push) Failing after 49s Details Build Dusk / build-wii (push) Failing after 49s Details Build Dusk / build-wii-iso (push) Failing after 1m14s Details	2026-06-08 12:25:48 -05:00
YourWishes	8675e44d28	GitTea actions	2026-06-08 12:24:09 -05:00
YourWishes	1301d9a718	idk why I btoher with github actions	2026-06-08 12:23:18 -05:00
YourWishes	da3db50ca8	Want to test this in PSP	2026-06-08 11:32:59 -05:00
YourWishes	2ca6780305	Just trying to fix things now	2026-06-08 09:39:09 -05:00
YourWishes	be68fe5a35	Emdashless	2026-06-07 21:27:59 -05:00
YourWishes	dc41c0e302	Cleanup	2026-06-07 21:16:46 -05:00
YourWishes	51388c90d5	we ball I guess	2026-06-07 19:51:54 -05:00
YourWishes	f8c9d33df2	Fix some script bugs	2026-06-07 18:47:34 -05:00
YourWishes	ed0420fdce	Cleanup of script modules.	2026-06-07 12:59:17 -05:00
YourWishes	47a6f396fa	Fix typedefs	2026-06-06 19:06:52 -05:00
YourWishes	9edb2aa0c1	Example scene working	2026-06-06 18:46:08 -05:00
YourWishes	003b647d83	Fix tests	2026-06-06 17:36:13 -05:00
YourWishes	2849ff8844	Fix linux?	2026-06-06 17:14:42 -05:00
YourWishes	9f3089742a	Fixed ISO builds.	2026-06-06 17:07:30 -05:00
YourWishes	b286a9bbcd	Fixed wii build	2026-06-06 16:53:06 -05:00
YourWishes	6204e745ba	Fixed gamecube building.	2026-06-06 16:47:07 -05:00
YourWishes	bbe0e48d23	Builds again?	2026-06-06 16:42:12 -05:00
YourWishes	79054080c0	Cleanup a bit.	2026-06-06 16:39:27 -05:00
YourWishes	81024c4c09	Require async	2026-06-06 10:55:10 -05:00
YourWishes	9068d96130	Add timeouts	2026-06-06 10:38:10 -05:00
YourWishes	6f47543720	Update jerryscript each frame.	2026-06-06 10:30:22 -05:00
YourWishes	5a08384ae1	start async	2026-06-05 19:42:24 -05:00
YourWishes	45d8fda0e4	require() working as I like	2026-06-05 18:49:10 -05:00
YourWishes	a9e664492f	First round of asset refactoring	2026-06-05 13:18:08 -05:00
YourWishes	3c8b6cb2cc	Scene script code	2026-06-04 13:36:35 -05:00
YourWishes	2b3abbe13b	ABout to try scene and script merger	2026-06-02 16:46:39 -05:00
YourWishes	241a52b94a	nuke unused overworld code	2026-06-02 13:23:11 -05:00
YourWishes	82c300b077	Add some script modules	2026-06-02 12:55:32 -05:00
YourWishes	0f8b629e20	Add logging to Wii	2026-06-02 11:01:54 -05:00
YourWishes	36f6ac65f2	Builds and works on Gamecube	2026-06-02 09:53:56 -05:00
YourWishes	a25871a849	Test sprite from script	2026-06-02 09:32:07 -05:00