Fixed dolphin aspect ratio

fix chunk loading based on player position
Fixed dolphin ratioing
2026-06-25 22:47:23 -05:00 · 2026-06-25 22:29:13 -05:00 · 2026-06-25 22:21:12 -05:00 · 2026-06-25 21:30:44 -05:00 · 2026-06-25 20:58:44 -05:00 · 2026-06-25 19:56:14 -05:00
473 changed files with 6251 additions and 17919 deletions
@@ -1,74 +0,0 @@
 # 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.
@@ -1,81 +0,0 @@
 # 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.
@@ -1,115 +0,0 @@
 # 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.
@@ -1,92 +0,0 @@
 # 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.
@@ -1,352 +0,0 @@
 # 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).
 ---
 ## Render / ROP system (`display/render/`)
 The ROP (Render OPcode) system is the low-level, backend-agnostic drawing API. All game drawing goes through this layer; backends (`rendergl.c`, `renderpsp.c`, `renderdolphin.c`) execute the commands at display flush time.
 ### API (`display/render/render.h`)
 ```c
 /* Clear the framebuffer */
 void renderClear(color_t color);
 /* 2D textured quad at pixel coordinates */
 void renderSprite(
  int16_t x, int16_t y, int16_t w, int16_t h,
  int16_t depth,                       /* 0=front … 32767=back */
  rtexture_t texture, color_t tint
 );
 /* Set perspective projection for subsequent 3D draws */
 void renderSetProjection(
  fixed_t fovY, fixed_t aspect, fixed_t nearZ, fixed_t farZ
 );
 /* Set camera position/target for subsequent 3D draws */
 void renderSetView(
  int16_t eyeX, int16_t eyeY, int16_t eyeZ,
  int16_t tgtX, int16_t tgtY, int16_t tgtZ
 );
 /* World-space quad: center point + right half-extent + up half-extent */
 void renderQuad3D(
  int16_t cx, int16_t cy, int16_t cz,
  int16_t rx, int16_t ry, int16_t rz,
  int16_t ux, int16_t uy, int16_t uz,
  int16_t depth,
  rtexture_t texture, color_t tint
 );
 /* Create / dispose an 8-bit indexed palette texture */
 rtexture_t renderTextureCreate(
  uint16_t w, uint16_t h,
  const uint8_t *indices,    /* w×h pixel indices (0-255) */
  const color_t *palette     /* 256 RGBA colour entries */
 );
 void renderTextureDispose(rtexture_t tex);
 /* Mutable pointers to the texture's CPU-side data.
 * Write directly to these; the next draw call picks up the changes.
 *   GL:      dirty flag set on getter call; glTexSubImage2D at next bind.
 *   PSP:     re-pads indices and converts palette → ABGR at bind time.
 *   Dolphin: re-tiles CI8 and converts palette → RGB5A3 at bind time. */
 color_t *renderTextureGetPalette(rtexture_t tex);  /* color_t[256]  */
 uint8_t *renderTextureGetIndices(rtexture_t tex);  /* uint8_t[w*h]  */
 ```
 ### Coordinate conventions
 | Domain | Type | Scale | Notes |
 |---|---|---|---|
 | 3D world positions | `int16_t` | 1 unit = 1 cm | Matches PS1 GTE / N64 RSP native format |
 | Camera/projection params | `fixed_t` | Q24.8 | `FIXED(x)` for literals |
 | 2D screen positions | `int16_t` | pixels | Origin top-left |
 | UV coords | `uint8_t` | 0–255 → 0.0–1.0 | Stored in ROP structs |
 ### Palettized textures
 All textures are 8-bit indexed. `renderTextureCreate` takes:
 - `indices`: one `uint8_t` per pixel (0–255), row-major
 - `palette`: exactly **256** `color_t` RGBA entries
 **Per-platform storage:**
 | Platform | CPU source of truth | GPU/native format | When derived |
 |---|---|---|---|
 | GL (Linux/Vita) | `color_t palette[256]` + `uint8_t *cpuIndices` in slot | `GL_R8` index tex + `GL_RGBA` 256×1 palette tex | Lazy: dirty flag set by getter, `glTexSubImage2D` at next bind |
 | PSP | `color_t palette[256]` + unpadded `uint8_t *cpuIndices` | Stride-padded indices (POT ≥ 8) + ABGR8888 CLUT in shared `pspAbgrBuf` | Every `bindTexture` call; dcache-flushed before GU reads |
 | Dolphin/GC/Wii | `color_t palette[256]` + unpadded `uint8_t *cpuIndices` | CI8 tiled (8×4 tiles, 32 B/tile) + RGB5A3 TLUT in `tlutData` | Every `bindTexture` call; `DCFlushRange` before GX load |
 **GL palette shader detail**: The fragment shader samples the R8 index texture, converts the normalised float back to an exact texel centre with `raw*(255/256) + 0.5/256`, then looks up the 256×1 palette texture. This gives pixel-exact results for all 256 index values and allows independent real-time updates to indices or palette.
 **Dolphin RGB5A3 encoding**:
 - Opaque (`a == 255`): bit 15 = 1, RGB555
 - Transparent: bit 15 = 0, A3RGB4 (alpha quantised to 3 bits — dithered transparency is planned for a future pass)
 ### ROP buffer (`display/render/ropbuffer.h` / `rop.h`)
 Commands are written into `ROPBUFFER` (a static byte array) then replayed by the backend at flush time. All ops are fixed-size aligned structs:
 | Op | Struct | Size |
 |---|---|---|
 | `ROP_CLEAR` | `ropclear_t` | 32 bytes |
 | `ROP_DRAW_SPRITE` | `ropsprite_t` | 32 bytes |
 | `ROP_SET_PROJECTION` | `ropprojection_t` | 32 bytes |
 | `ROP_SET_VIEW` | `ropview_t` | 32 bytes |
 | `ROP_DRAW_QUAD_3D` | `ropquad3d_t` | 64 bytes |
 | `ROP_DRAW_TILEMAP_CHUNK` | `roptilemapc_t` | 32 bytes |
 `ropOpSize(op)` returns the byte size for any op. Backends iterate with `offset += ropOpSize(op)`.
 ### Texture handles (`display/render/rtexture.h`)
 `rtexture_t` is a `uint16_t` index into the platform's texture table. `RTEXTURE_NONE` (0 or a sentinel) means "white fallback". Tables are platform-static; handles are valid until `renderTextureDispose` is called.
 ### Tilemap chunk handles (`display/render/rtilemapchunk.h`)
 `rtilemapchunk_t` is a `uint16_t` index into the platform's chunk table. `RTILEMAPCHUNK_INVALID` (0) means no-op. Chunks are pre-built at map load time; each backend constructs its native draw structure once (VAO+VBO on GL, display list on PSP/GX/N64) and the ROP entry costs only a handle lookup + single native draw call per frame.
 ```c
 /* Build once at map load */
 rtilemapchunk_t chunk = renderTilemapChunkCreate(
  chunkW, chunkH,     /* size in tiles */
  tileW, tileH,       /* pixels per tile */
  tileset,            /* rtexture_t of the packed tileset */
  tileIndices         /* uint8_t[chunkW*chunkH], row-major tile indices */
 );
 /* Each frame for visible chunks */
 renderTilemapChunk(screenX, screenY, depth, chunk);
 /* At map unload */
 renderTilemapChunkDispose(chunk);
 ```
 Animated tiles should be drawn on top as separate `renderSprite()` calls; the chunk itself is treated as static geometry and never rebuilt at runtime.
 **Per-platform build:**
 | Platform | What's built at create time | Draw cost per frame |
 |---|---|---|
 | GL (Linux/Vita) | VAO + VBO (`GL_STATIC_DRAW`), `uOffset` uniform translates to screen pos | 1 `glDrawArrays` |
 | PSP | GU display list in uncached EDRAM | 1 `sceGuCallList` |
 | GC/Wii | Compiled GX display list | 1 `GX_CallDispList` |
 | PS1 | Pre-linked POLY_FT4/SPRT chain | Linked into OT at one slot |
 | N64 | RDP display list with pre-scheduled `LOAD_TILE` batches (TMEM-aware) | 1 `gSPDisplayList` |
 | Saturn | VDP2 plane config + VRAM tilemap data | Scroll register write only |
 ---
 ## 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.
@@ -1,93 +0,0 @@
 # 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/`.
@@ -1,149 +0,0 @@
 # 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.
@@ -1,140 +0,0 @@
 # 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.
@@ -1,18 +0,0 @@
 # 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`.
@@ -1,124 +0,0 @@
 # 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.
@@ -1,114 +0,0 @@
 # 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.
@@ -1,96 +0,0 @@
 # 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.
@@ -1,403 +0,0 @@
 # 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);
 ```
 ---
 ## Unused parameters
 Do **not** use `(void)param;` casts to suppress unused-parameter warnings. They are
 redundant noise. If a callback signature is fixed by a function-pointer type and the
 parameter is genuinely unused, just leave it — do not suppress:
 ```c
 // correct — parameter unused, no cast
 errorret_t sceneTestUpdate(scenedata_t *data) {
  errorOk();
 }
 // wrong
 errorret_t sceneTestUpdate(scenedata_t *data) {
  (void)data;
  errorOk();
 }
 ```
 ---
 ## 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.
@@ -1,177 +0,0 @@
 # 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.
@@ -1,123 +0,0 @@
 # 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.
@@ -1,162 +0,0 @@
 # 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,65 +1,432 @@
-# CLAUDE.md
+# Dusk — Claude Code rules
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+## File headers
 Every C, H, and JS file starts with:
-## Project
+```c
-
+/**
-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/`).
+ * Copyright (c) 2026 Dominic Masters
-
+ *
-Assets are zipped into `dusk.dsk` at build time and loaded at runtime via the asset system.
+ * This software is released under the MIT License.
-
+ * https://opensource.org/licenses/MIT
-## 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:
+JS files use `//` comment style instead.
-```bash
+
-cmake -S . -B build-<target> -DDUSK_TARGET_SYSTEM=<target>
+---
-cmake --build build-<target> -- -j$(nproc)
+
 ## C conventions
 ### Types
 Always use the project-defined aliases instead of bare C primitives:
 | Use       | Not          |
 |-----------|--------------|
 | `bool_t`  | `bool`       |
 | `int_t`   | `int`        |
 | `float_t` | `float`      |
 | `char_t`  | `char`       |
 Use `uint8_t`, `uint16_t`, `int32_t`, etc. for fixed-width integers.
 All struct and enum types end in `_t` (`animation_t`, `errorret_t`, …).
 ### Naming
 - **Functions** — snake_case, prefixed with their module:
  `assetLock()`, `entityPositionInit()`, `moduleAssetBatchCtor()`
 - **Struct fields** — camelCase: `keyframeCount`, `localPosition`
 - **Macros / constants** — UPPER_SNAKE_CASE:
  `ENTITY_ID_INVALID`, `ERROR_OK`, `COMPONENT_TYPE_COUNT`
 - **Files** — snake_case matching the primary type: `entityposition.c`,
  `moduleassetbatch.c`
 ### Header files (`.h`)
 - Use `#pragma once` — no include guards.
 - Declare every public function, `#define`, and `extern` global.
 - Write a JSDoc block (`/** … */`) above every declaration explaining
  purpose, `@param`s, and `@returns`.
 - Only include headers that the `.h` file itself strictly requires for
  the types it exposes. Move everything else to the `.c` file.
  Do not use forward declarations as a workaround — use the real
  include in the `.c` file instead.
 ### Implementation files (`.c`)
 - Contain function bodies only; no declarations.
 - Pull in whatever additional includes the implementation needs.
 - Do not use `static` or `inline` on **functions**. Every function,
  including internal helpers, must be declared in the matching `.h` and
  defined in the `.c` file. Internal helpers belong near the bottom of
  the `.c` file, not at the top with a `static` qualifier.
  `static` and `inline` on functions are only appropriate when the
  function body is written directly inside a `.h` file.
  `static` on **variables** (file-scope state) is fine and expected.
 ### Formatting
 - Hard-wrap all lines at **80 characters**.
 ### Error handling
 Return `errorret_t` from fallible functions. Use these macros:
 ```c
 errorOk();                    // return success
 errorThrow("msg %d", val);    // return failure with message
 errorChain(someCall());       // propagate failure, continue on success
 errorIsOk(ret) / errorIsNotOk(ret)  // test a result
 errorCatch(ret);              // handle + free an error
 ```
-## Tests
+Never return raw error codes or use `errno` for in-engine errors.
-```bash
+### Memory
-./scripts/test-linux.sh           # builds and runs all tests
+Use the project allocator — never raw `malloc`/`free`:
-# Manually run a single test binary after building:
+```c
-./build-tests/test/<module>/test_<name>
+memoryAllocate(size)          // allocate
 memoryFree(ptr)               // free
 memoryZero(dest, size)        // zero a block
 memoryCopy(dest, src, size)   // copy
 ```
-Tests use [cmocka](https://cmocka.org/) and are only compiled when `DUSK_BUILD_TESTS=ON`. Test sources live under `test/`.
+### Asserts
 Prefer specific assert macros over bare `assert()`:
-## Key conventions
+```c
 assertNotNull(ptr, "msg");
 assertTrue(cond, "msg");
 assertFalse(cond, "msg");
 assertUnreachable("msg");
 assertIsMainThread("msg");
 ```
- 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`.
+## Build system
 Each subdirectory has its own `CMakeLists.txt` that adds sources with:
 ```cmake
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
  PUBLIC
    myfile.c
 )
 ```
 Never add source files to the root `CMakeLists.txt` directly.
 ---
 ## Platform support
 ### Targets
 Set `DUSK_TARGET_SYSTEM` at CMake configure time to select a platform:
 | `DUSK_TARGET_SYSTEM` | Macro defined     | Platform         |
 |----------------------|-------------------|------------------|
 | `linux`              | `DUSK_LINUX`      | Linux desktop    |
 | `knulli`             | `DUSK_KNULLI`     | Knulli (handheld)|
 | `psp`                | `DUSK_PSP`        | Sony PSP         |
 | `vita`               | `DUSK_VITA`       | PlayStation Vita |
 | `gamecube`           | `DUSK_GAMECUBE`   | Nintendo GameCube|
 | `wii`                | `DUSK_WII`        | Nintendo Wii     |
 ### Layer structure
 ```
 src/dusk/          core, platform-agnostic game logic
 src/duskgl/        OpenGL abstraction (Linux, Knulli, PSP, Vita)
 src/dusksdl2/      SDL2 window + input (Linux, Knulli, PSP, Vita)
 src/dusklinux/     Linux + Knulli platform impl
 src/duskpsp/       PSP platform impl
 src/duskvita/      Vita platform impl
 src/duskdolphin/   GameCube / Wii platform impl (no SDL2/OpenGL)
 ```
 Dolphin is the only target that bypasses SDL2 and OpenGL entirely —
 it uses native GameCube/Wii rendering and input APIs.
 ### Platform guards
 Use the compile-time macros for platform-specific code:
 ```c
 #ifdef DUSK_PSP
  // PSP-only path
 #elif defined(DUSK_GAMECUBE) || defined(DUSK_WII)
  // GameCube / Wii path
 #else
  // Generic / Linux fallback
 #endif
 ```
 Additional capability macros set per-target:
 `DUSK_SDL2`, `DUSK_OPENGL`, `DUSK_OPENGL_ES`, `DUSK_OPENGL_LEGACY`,
 `DUSK_INPUT_GAMEPAD`, `DUSK_INPUT_KEYBOARD`, `DUSK_INPUT_POINTER`,
 `DUSK_PLATFORM_ENDIAN_BIG` / `DUSK_PLATFORM_ENDIAN_LITTLE`.
 ### Abstraction pattern
 Platform-specific implementations are wired in via `#define` macros in
 each platform's `displayplatform.h` / `inputplatform.h` etc., which
 the core calls through. Functions that a platform does not support are
 simply left undefined — the core guards calls with `#ifdef`.
 ### Adding platform-specific code
 - Put it under `src/dusk<platform>/` in the matching subsystem folder.
 - Gate any core call-site with the appropriate `#ifdef DUSK_<PLATFORM>`
  or capability macro.
 - Keep the `src/dusk/` core free of platform ifdefs — delegate through
  the platform header macros instead.
 ---
 ## Adding a new asset loader type
 1. Add an enum value to `assetloadertype_t` (before `_COUNT`) in
   `src/dusk/asset/loader/assetloader.h`.
 2. Add fields to the input/loading/output unions in `assetloader.h`.
 3. Implement `assetXxxLoaderSync`, `assetXxxLoaderAsync`, and
   `assetXxxDispose` in a new `src/dusk/asset/loader/xxx/` directory.
 4. Register the three callbacks in `ASSET_LOADER_CALLBACKS[]` in
   `src/dusk/asset/loader/assetloader.c`.
 5. If user-facing, create a JS module (see below) and a `.d.ts` file.
 ---
 ## Adding a new entity component
 1. Create `src/dusk/entity/component/<category>/entityMyComp.h/.c` with
   struct `entityMyComp_t`, `entityMyCompInit()`, and optionally
   `entityMyCompDispose()`.
 2. Add the include to `src/dusk/entity/componentlist.h` header block.
 3. Add a row to `src/dusk/entity/componentlist.h`:
   ```c
   X(MYCOMP, entityMyComp_t, myComp, entityMyCompInit, NULL, NULL)
   ```
   This auto-generates the enum, union field, and definition entry.
 4. If JS-facing, create the script module and `.d.ts` (see below).
 ---
 ## Adding a new script (JS) module
 1. Create `src/dusk/script/module/<category>/moduleMyMod.h/.c`.
   - Declare `extern scriptproto_t MODULE_MYMOD_PROTO;` in the header.
   - Use `moduleBaseFunction(name)` to define JS-callable functions.
   - Register props/funcs in `moduleMyModInit()` with
     `scriptProtoDefineProp` / `scriptProtoDefineFunc` /
     `scriptProtoDefineStaticFunc`.
 2. `#include` the header in
   `src/dusk/script/module/modulelist.c` and call
   `moduleMyModInit()` in `moduleListInit()` (and `Dispose` in
   `moduleListDispose()`).
 3. For component modules also register in
   `src/dusk/script/module/entity/component/modulecomponentlist.c`
   so `entity.add()` returns the typed wrapper.
 4. Create `types/<category>/mymod.d.ts` and add a
   `/// <reference path="..." />` line to `types/index.d.ts`.
 ---
 ## Script module type declarations
 Whenever a `src/dusk/script/module/**/*.c` file is created or modified,
 check whether the corresponding `types/**/*.d.ts` needs updating and
 apply any changes before finishing the task.
 ---
 ## JavaScript (asset scripts)
 - Use `var` for module-level state; `const` for values that never
  change.
 - Always use semicolons.
 - Scene objects are plain objects (`var scene = {}`) with assigned
  methods.
 - Export via `module.exports = scene`.
 - Async scene init should use `async function` and `await`.
 ---
 ## 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.
+### ASCII only
 Source files (`.c`, `.h`, `.js`) must contain only ASCII characters (U+0000–U+007F).
 Non-ASCII characters are banned even in comments and string literals.
 Use ASCII-only substitutes instead:
 - `--` or `-` instead of `—` (em dash)
 - `->` instead of `→` (arrow)
 - `x` or `*` instead of `×` (multiplication)
-## Architecture & systems
+Only non-script asset files (e.g. `.po` locale files) may contain non-ASCII text.
-| Doc | Covers |
+### Indentation
-|---|---|
+2 spaces. No tabs.
-| [`.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 |
+### Keyword and operator spacing
-| [`.claude/input.md`](.claude/input.md) | Input actions, buttons, bindings, axis helpers, events |
+No space between a keyword or function name and its opening parenthesis:
-| [`.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 |
+```c
-| [`.claude/animation.md`](.claude/animation.md) | Keyframe animation, easing functions |
+if(!ptr) return;
-| [`.claude/systems.md`](.claude/systems.md) | Time, threading, mutex, events, console, logging, system/platform, network |
+for(uint8_t i = 0; i < count; i++) {
-| [`.claude/util.md`](.claude/util.md) | String, memory, math, fixed-point, array, sort, ref counting, CRC32, endian |
+while(entry->state != DONE) {
-| [`.claude/save.md`](.claude/save.md) | Save slots, stream serialization with CRC, locale/i18n |
+switch(type) {
-| [`.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) |
+sizeof(assetbatch_t)
-| [`.claude/display-refactor.md`](.claude/display-refactor.md) | Planned render-queue refactor (Saturn port context) |
+memoryZero(ptr, size)
 ```
 Spaces around all binary operators and after every comma:
 ```c
 pos->flags |= ENTITY_POSITION_FLAG_WORLD_DIRTY;
 (size_t)end - (size_t)start
 foo(a, b, c)
 ```
 ### Braces
 Opening brace on the **same line** as the statement (K&R style) for all
 constructs — functions, `if`, `else`, `for`, `while`, `switch`:
 ```c
 void assetEntryLock(assetentry_t *entry) {
  ...
 }
 if(dirty) {
  ...
 } else {
  ...
 }
 ```
 ### Guard returns
 Short guards go on one line with no braces:
 ```c
 if(!ptr) return;
 if(!b || !b->batch) return jerry_undefined();
 if(!(flags & DIRTY)) return;
 ```
 ### Blank lines
 - One blank line between functions; no blank line at the start or end of
  a function body.
 - One blank line between logical blocks inside a function body.
 - No trailing blank lines at the end of a file.
 ### Pointer placement
 `*` is attached to the variable name, not the type:
 ```c
 assetentry_t *entry
 const char_t *name
 void *ptr
 uint8_t *d = (uint8_t *)dest;
 ```
 ### Casts
 Space between cast and operand:
 ```c
 (assetbatch_t *)user
 (uint8_t *)dest
 (textureformat_t)v
 ```
 ### Return
 No parentheses around the return value:
 ```c
 return ptr;
 return MEMORY_POINTERS_IN_USE;
 ```
 ### switch / case
 `case` indented 2 spaces from `switch`; body indented 2 more from `case`:
 ```c
 switch(type) {
  case ASSET_LOADER_TYPE_TEXTURE:
    descs[i].input.texture = (textureformat_t)v;
    break;
  default:
    break;
 }
 ```
 ### Multi-line function signatures
 When parameters don't fit on one line, put each on its own line indented
 2 spaces; the closing `) {` (definition) or `);` (declaration) goes on
 its own line at column 0:
 ```c
 void assetEntryInit(
  assetentry_t *entry,
  const char_t *name,
  const assetloadertype_t type,
  assetloaderinput_t *input
 ) {
 errorret_t memoryCompare(
  const void *a,
  const void *b,
  const size_t size
 );
 ```
 ### Structs and enums
 Anonymous inner struct or enum with a `typedef`, `_t` suffix, closing
 brace and name on the same line:
 ```c
 typedef struct {
  errorcode_t code;
  char_t *message;
 } errorstate_t;
 typedef enum {
  ASSET_LOADER_TYPE_NULL,
  ASSET_LOADER_TYPE_COUNT
 } assetloadertype_t;
 ```
 ### Designated initialisers
 Spaces inside braces; `.field = value`:
 ```c
 jsassetentry_t e = { .entry = entry };
 assetbatchloadedpend_t init = { .batch = batch };
 ```
 ### Ternary operator
 Spaces around `?` and `:`:
 ```c
 const float val = psx > 0.0f ? pt[0][0] / psx : 0.0f;
 ```
 ### const placement
 `const` before the type, `*` attached to the variable:
 ```c
 const char_t *name
 const void *src
 const size_t size
 ```
 ### Comments in `.c` files
 - Do not use section dividers (`/* ---- ... ---- */`). Just let the
  functions follow one another with a single blank line between them.
 - Multi-line explanatory comments inside function bodies use `//` lines:
  ```c
  // Script modules are freed; orphaned JS wrapper objects now get GC'd
  // so their finalizers fire before assetDispose() checks ref counts.
  jerry_heap_gc(JERRY_GC_PRESSURE_HIGH);
  ```
 - Do not use `/* */` for inline or inline-block comments inside `.c`
  function bodies.
 ### Comments in `.h` files
 Every public declaration gets a Javadoc block (`/** … */`) with
 `@param` and `@returns` where relevant. Keep it on the lines immediately
 above the declaration with no blank line in between.
 ---
 ## Tests
 - Tests live in `test/` mirroring `src/dusk/` structure.
 - Use cmocka; include `dusktest.h`.
 - Test functions: `static void test_something(void **state)`.
 - After each test, assert `memoryGetAllocatedCount() == 0` to catch
  leaks.
 - Build with `-DDUSK_BUILD_TESTS=ON`.
@@ -14,9 +14,8 @@ cmake_policy(SET CMP0079 NEW)
 option(DUSK_BUILD_TESTS "Enable tests" OFF)
 # Game identity — override these per-project
 set(DUSK_GAME_NAME "Dusk" CACHE STRING "Game display name")
-set(DUSK_GAME_AUTHOR            "YouWish"             CACHE STRING "Game author / coder")
+set(DUSK_GAME_AUTHOR "YourWishes" CACHE STRING "Game author / coder")
 set(DUSK_GAME_SHORT_DESCRIPTION "Dusk game" CACHE STRING "One-line description")
 set(DUSK_GAME_LONG_DESCRIPTION  "No description yet." CACHE STRING "Full description")
@@ -1,12 +0,0 @@
 import sys, os
 import argparse
 # Check if the script is run with the correct arguments
 parser = argparse.ArgumentParser(description="Generate chunk header files")
 parser.add_argument('--assets', required=True, help='Dir to output built assets')
 parser.add_argument('--headers-dir', required=True, help='Directory to output individual asset headers (required for header build)')
 parser.add_argument('--output-headers', help='Output header file for built assets (required for header build)')
 parser.add_argument('--output-assets', required=True, help='Output directory for built assets')
 parser.add_argument('--output-file', required=True, help='Output file for built assets (required for wad build)')
 parser.add_argument('--input', required=True, help='Input assets to process', nargs='+')
 args = parser.parse_args()
@@ -1,66 +0,0 @@
 import sys, os
 from tools.asset.args import args
 from tools.asset.process.asset import processAsset
 from tools.asset.process.palette import processPaletteList
 from tools.asset.process.tileset import processTilesetList
 from tools.asset.process.language import processLanguageList
 from tools.asset.path import getBuiltAssetsRelativePath
 import zipfile
 # Parse input file args.
 inputAssets = []
 for inputArg in args.input:
  files = inputArg.split('$')
  for file in files:
    if str(file).strip() == '':
      continue
    pieces = file.split('#')
    if len(pieces) < 2:
      print(f"Error: Invalid input asset format '{file}'. Expected format: type#path[#option1%option2...]")
      sys.exit(1)
    options = {}
    if len(pieces) > 2:
      optionParts = pieces[2].split('%')
      for part in optionParts:
        partSplit = part.split('=')
        if len(partSplit) < 1:
          continue
        if len(partSplit) == 2:
          options[partSplit[0]] = partSplit[1]
        else:
          options[partSplit[0]] = True
    inputAssets.append({
      'type': pieces[0],
      'path': pieces[1],
      'options': options
    })
 if not inputAssets:
  print("Error: No input assets provided.")
  sys.exit(1)
 # Process each asset.
 files = []
 for asset in inputAssets:
  asset = processAsset(asset)
  files.extend(asset['files'])
 # Generate additional files
 files.extend(processLanguageList()['files'])
 # Take assets and add to a zip archive.
 outputFileName = args.output_file
 print(f"Creating output file: {outputFileName}")
 with zipfile.ZipFile(outputFileName, 'w') as zipf:
  for file in files:
    relativeOutputPath = getBuiltAssetsRelativePath(file)
    zipf.write(file, arcname=relativeOutputPath)
 # Generate additional headers.
 processPaletteList()
 processTilesetList()
@@ -1,12 +0,0 @@
 processedAssets = {}
 def assetGetCache(assetPath):
  if assetPath in processedAssets:
    return processedAssets[assetPath]
  return None
 def assetCache(assetPath, processedData):
  if assetPath in processedAssets:
    return processedAssets[assetPath]
  processedAssets[assetPath] = processedData
  return processedData
@@ -1,10 +0,0 @@
 import os
 from tools.asset.args import args
 def getAssetRelativePath(fullPath):
  # Get the relative path to the asset
  return os.path.relpath(fullPath, start=args.assets).replace('\\', '/')
 def getBuiltAssetsRelativePath(fullPath):
  # Get the relative path to the built asset
  return os.path.relpath(fullPath, start=args.output_assets).replace('\\', '/')
@@ -1,33 +0,0 @@
 import sys
 # from processtileset import processTileset
 from tools.asset.process.image import processImage
 from tools.asset.process.palette import processPalette
 from tools.asset.process.tileset import processTileset
 from tools.asset.process.map import processMap
 from tools.asset.process.language import processLanguage
 from tools.asset.process.script import processScript
 processedAssets = []
 def processAsset(asset):
  if asset['path'] in processedAssets:
    return
  processedAssets.append(asset['path'])
  # Handle tiled tilesets
  t = asset['type'].lower()
  if t == 'palette':
    return processPalette(asset)
  elif t == 'image':
    return processImage(asset)
  elif t == 'tileset':
    return processTileset(asset)
  elif t == 'map':
    return processMap(asset)
  elif t == 'language':
    return processLanguage(asset)
  elif t == 'script':
    return processScript(asset)
  else:
    print(f"Error: Unknown asset type '{asset['type']}' for path '{asset['path']}'")
    sys.exit(1)
@@ -1,134 +0,0 @@
 import os
 import sys
 from PIL import Image
 from tools.asset.process.palette import extractPaletteFromImage, palettes
 from tools.asset.args import args
 from tools.asset.path import getAssetRelativePath
 from tools.asset.cache import assetGetCache, assetCache
 images = []
 def processImage(asset):
  cache = assetGetCache(asset['path'])
  if cache is not None:
    return cache
  type = None
  if 'type' in asset['options']:
    type = asset['options'].get('type', 'PALETTIZED').upper()
  if type == 'PALETTIZED' or type is None:
    return assetCache(asset['path'], processPalettizedImage(asset))
  elif type == 'ALPHA':
    return assetCache(asset['path'], processAlphaImage(asset))
  else:
    print(f"Error: Unknown image type {type} for asset {asset['path']}")
    sys.exit(1)
 def processPalettizedImage(asset):
  assetPath = asset['path']
  cache = assetGetCache(assetPath)
  if cache is not None:
    return cache
  image = Image.open(assetPath)
  imagePalette = extractPaletteFromImage(image)
  # Find palette that contains every color
  palette = None
  for p in palettes:
    hasAllColors = True
    for color in imagePalette:
      for palColor in p['pixels']:
        if color[0] == palColor[0] and color[1] == palColor[1] and color[2] == palColor[2] and color[3] == palColor[3]:
          break
        elif color[3] == 0 and palColor[3] == 0:
          break
      else:
        print('Pallete {} does not contain color #{}'.format(p['paletteName'], '{:02x}{:02x}{:02x}{:02x}'.format(color[0], color[1], color[2], color[3])))
        hasAllColors = False
        break
    if hasAllColors:
      palette = p
      break
  if palette is None:
    palette = palettes[0]  # Just to avoid reference error
    print(f"No matching palette found for {assetPath}!")
    # Find which pixel is missing
    for color in imagePalette:
      if color in palette['pixels']:
        continue
      # Convert to hex (with alpha)
      hexColor = '#{:02x}{:02x}{:02x}{:02x}'.format(color[0], color[1], color[2], color[3])
      print(f"Missing color: {hexColor} in palette {palette['paletteName']}")
    sys.exit(1)
  print(f"Converting image {assetPath} to use palette")
  paletteIndexes = []
  for pixel in list(image.getdata()):
    if pixel[3] == 0:
      pixel = (0, 0, 0, 0)
    paletteIndex = palette['pixels'].index(pixel)
    paletteIndexes.append(paletteIndex)
  data = bytearray()
  data.extend(b"DPI")  # Dusk Palettized Image
  data.extend(image.width.to_bytes(4, 'little'))   # Width
  data.extend(image.height.to_bytes(4, 'little'))  # Height
  data.append(palette['paletteIndex'])   # Palette index
  for paletteIndex in paletteIndexes:
    if paletteIndex > 255 or paletteIndex < 0:
      print(f"Error: Palette index {paletteIndex} exceeds 255!")
      sys.exit(1)
    data.append(paletteIndex.to_bytes(1, 'little')[0])  # Pixel index
  relative = getAssetRelativePath(assetPath)
  fileNameWithoutExt = os.path.splitext(os.path.basename(assetPath))[0]
  outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dpi")
  outputFilePath = os.path.join(args.output_assets, outputFileRelative)
  os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
  with open(outputFilePath, "wb") as f:
    f.write(data)
  outImage = {
    "imagePath": outputFileRelative,
    "files": [ outputFilePath ],
    'width': image.width,
    'height': image.height,
  }
  return assetCache(assetPath, outImage)
 def processAlphaImage(asset):
  assetPath = asset['path']
  cache = assetGetCache(assetPath)
  if cache is not None:
    return cache
  print(f"Processing alpha image: {assetPath}")
  data = bytearray()
  data.extend(b"DAI")  # Dusk Alpha Image
  image = Image.open(assetPath).convert("RGBA")
  data.extend(image.width.to_bytes(4, 'little'))   # Width
  data.extend(image.height.to_bytes(4, 'little'))  # Height
  for pixel in list(image.getdata()):
    # Only write alpha channel
    data.append(pixel[3].to_bytes(1, 'little')[0])  # Pixel alpha
  relative = getAssetRelativePath(assetPath)
  fileNameWithoutExt = os.path.splitext(os.path.basename(assetPath))[0]
  outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dai")
  outputFilePath = os.path.join(args.output_assets, outputFileRelative)
  os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
  with open(outputFilePath, "wb") as f:
    f.write(data)
  outImage = {
    "imagePath": outputFileRelative,
    "files": [ outputFilePath ],
    'width': image.width,
    'height': image.height,
  }
  return assetCache(assetPath, outImage)
@@ -1,228 +0,0 @@
 import sys
 import os
 from tools.asset.args import args
 from tools.asset.cache import assetCache, assetGetCache
 from tools.asset.path import getAssetRelativePath
 from tools.dusk.defs import defs
 import polib
 import re
 LANGUAGE_CHUNK_CHAR_COUNT = int(defs.get('ASSET_LANG_CHUNK_CHAR_COUNT'))
 LANGUAGE_DATA = {}
 LANGUAGE_KEYS = []
 def processLanguageList():
  # Language keys header data
  headerKeys = "// Auto-generated language keys header file.\n"
  headerKeys += "#pragma once\n"
  headerKeys += "#include \"dusk.h\"\n\n"
  # This is the desired chunk groups list.. if a language key STARTS with any
  # of the keys in this list we would "like to" put it in that chunk group.
  # If there is no match, or the list is full then we will add it to the next
  # available chunk group (that isn't a 'desired' one). If the chunk becomes
  # full, then we attempt to make another chunk with the same prefix so that
  # a second batching can occur.
  desiredChunkGroups = {
    'ui': 0
  }
  # Now, for each language key, create the header reference and index.
  keyIndex = 0
  languageKeyIndexes = {}
  languageKeyChunk = {}
  languageKeyChunkIndexes = {}
  languageKeyChunkOffsets = {}
  for key in LANGUAGE_KEYS:
    headerKeys += f"#define {getLanguageVariableName(key)} {keyIndex}\n"
    languageKeyIndexes[key] = keyIndex
    keyIndex += 1
    # Find desired chunk group
    assignedChunk = None
    for desiredKey in desiredChunkGroups:
      if key.lower().startswith(desiredKey):
        assignedChunk = desiredChunkGroups[desiredKey]
        break
    # If no desired chunk group matched, assign to -1
    if assignedChunk is None:
      assignedChunk = -1
    languageKeyChunk[key] = assignedChunk
    # Setup header.
    for lang in LANGUAGE_DATA:
      if key not in LANGUAGE_DATA[lang]:
        print(f"Warning: Missing translation for key '{key}' in language '{lang}'")
        sys.exit(1)
  # Seal the header.
  headerKeys += f"\n#define LANG_KEY_COUNT {len(LANGUAGE_KEYS)}\n"
  # Now we can generate the language string chunks.
  nextChunkIndex = max(desiredChunkGroups.values()) + 1
  files = []
  for lang in LANGUAGE_DATA:
    langData = LANGUAGE_DATA[lang]
    # Key = chunkIndex, value = chunkInfo
    languageChunks = {}
    for key in LANGUAGE_KEYS:
      keyIndex = languageKeyIndexes[key]
      chunkIndex = languageKeyChunk[key]
      wasSetChunk = chunkIndex != -1
      # This will keep looping until we find a chunk
      while True:
        # Determine the next chunkIndex IF chunkIndex is -1
        if chunkIndex == -1:
          chunkIndex = nextChunkIndex
        # Is the chunk full?
        curLen = languageChunks.get(chunkIndex, {'len': 0})['len']
        newLen = curLen + len(langData[key])
        if newLen > LANGUAGE_CHUNK_CHAR_COUNT:
          # Chunk is full, need to create a new chunk.
          chunkIndex = -1
          if wasSetChunk:
            wasSetChunk = False
          else:
            nextChunkIndex += 1
          continue
        # Chunk is not full, we can use it.
        if chunkIndex not in languageChunks:
          languageChunks[chunkIndex] = {
            'len': 0,
            'keys': []
          }
        languageChunks[chunkIndex]['len'] = newLen
        languageChunks[chunkIndex]['keys'].append(key)
        languageKeyChunkIndexes[key] = chunkIndex
        languageKeyChunkOffsets[key] = curLen
        break
    # We have now chunked all the keys for this language!
    langBuffer = b""
    # Write header info 
    langBuffer += b'DLF'  # Dusk Language File
    for key in LANGUAGE_KEYS:
      # Write the chunk that this key belongs to as uint32_t
      chunkIndex = languageKeyChunkIndexes[key]
      langBuffer += chunkIndex.to_bytes(4, byteorder='little')
      # Write the offset for this key as uint32_t
      offset = languageKeyChunkOffsets[key]
      langBuffer += offset.to_bytes(4, byteorder='little')
      # Write the length of the string as uint32_t
      strData = langData[key].encode('utf-8')
      langBuffer += len(strData).to_bytes(4, byteorder='little')
    # Now write out each chunk's string data, packed tight and no null term.
    for chunkIndex in sorted(languageChunks.keys()):
      chunkInfo = languageChunks[chunkIndex]
      for key in chunkInfo['keys']:
        strData = langData[key].encode('utf-8')
        langBuffer += strData
      # Now pad the chunk to full size
      curLen = chunkInfo['len']
      if curLen < LANGUAGE_CHUNK_CHAR_COUNT:
        padSize = LANGUAGE_CHUNK_CHAR_COUNT - curLen
        langBuffer += b'\0' * padSize
    # Write out the language data file
    outputFile = os.path.join(args.output_assets, "language", f"{lang}.dlf")
    files.append(outputFile)
    os.makedirs(os.path.dirname(outputFile), exist_ok=True)
    with open(outputFile, "wb") as f:
      f.write(langBuffer)
  # Write out the language keys header file
  outputFile = os.path.join(args.headers_dir, "locale", "language", "keys.h")
  os.makedirs(os.path.dirname(outputFile), exist_ok=True)
  with open(outputFile, "w") as f:
    f.write(headerKeys)
  # Generate language list.
  langValues = {}
  headerLocale = "#pragma once\n#include \"locale/localeinfo.h\"\n\n"
  headerLocale += "typedef enum {\n"
  count = 0
  headerLocale += f"  DUSK_LOCALE_NULL = {count},\n"
  count += 1
  for lang in LANGUAGE_DATA:
    langKey = lang.replace('-', '_').replace(' ', '_').upper()
    langValues[lang] = count
    headerLocale += f"  DUSK_LOCALE_{langKey} = {count},\n"
    count += 1
  headerLocale += f"  DUSK_LOCALE_COUNT = {count}\n"
  headerLocale += "} dusklocale_t;\n\n"
  headerLocale += f"static const localeinfo_t LOCALE_INFOS[DUSK_LOCALE_COUNT] = {{\n"
  for lang in LANGUAGE_DATA:
    langKey = lang.replace('-', '_').replace(' ', '_').upper()
    headerLocale += f"  [DUSK_LOCALE_{langKey}] = {{\n"
    headerLocale += f"    .file = \"{lang}\"\n"
    headerLocale += f"  }},\n"
  headerLocale += "};\n"
  headerLocale += f"static const char_t *LOCALE_SCRIPT = \n"
  for lang in LANGUAGE_DATA:
    langKey = lang.replace('-', '_').replace(' ', '_').upper()
    langValue = langValues[lang]
    headerLocale += f"  \"DUSK_LOCALE_{langKey} = {langValue}\\n\"\n"
  headerLocale +=  ";\n"
  # Write out the locale enum header file
  outputFile = os.path.join(args.headers_dir, "locale", "locale.h")
  os.makedirs(os.path.dirname(outputFile), exist_ok=True)
  with open(outputFile, "w") as f:
    f.write(headerLocale)
  return {
    'files': files
  }
 def getLanguageVariableName(languageKey):
  # Take the language key, prepend LANG_, uppercase, replace any non symbols
  # with _
  key = languageKey.strip().upper()
  key = re.sub(r'[^A-Z0-9]', '_', key)
  return f"LANG_{key}"
 def processLanguage(asset):
  cache = assetGetCache(asset['path'])
  if cache is not None:
    return cache
  # Load PO File
  po = polib.pofile(asset['path'])
  langName = po.metadata.get('Language')
  if langName not in LANGUAGE_DATA:
    LANGUAGE_DATA[langName] = {}
  for entry in po:
    key = entry.msgid
    val = entry.msgstr
    if key not in LANGUAGE_KEYS:
      LANGUAGE_KEYS.append(key)
    if key not in LANGUAGE_DATA[langName]:
      LANGUAGE_DATA[langName][key] = val
    else:
      print(f"Error: Duplicate translation key '{key}' in language '{langName}'")
      sys.exit(1)
  outLanguageData = {
    'data': po,
    'path': asset['path'],
    'files': []
  }
  return assetCache(asset['path'], outLanguageData)
@@ -1,154 +0,0 @@
 import struct
 import sys
 import os
 import json
 from tools.asset.args import args
 from tools.asset.cache import assetCache, assetGetCache
 from tools.asset.path import getAssetRelativePath
 from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, CHUNK_TILE_COUNT
 from tools.dusk.map import Map
 from tools.dusk.chunk import Chunk
 def convertModelData(modelData):
  # TLDR; Model data stores things efficiently with indices, but we buffer it 
  # out to 6 vertex quads for simplicity.
  outVertices = []
  outUVs = []
  outColors = []
  for indice in modelData['indices']:
    vertex = modelData['vertices'][indice]
    uv = modelData['uvs'][indice]
    color = modelData['colors'][indice]
    outVertices.append(vertex)
    outUVs.append(uv)
    outColors.append(color)
  return {
    'vertices': outVertices,
    'uvs': outUVs,
    'colors': outColors
  }
 def processChunk(chunk):
  cache = assetGetCache(chunk.getFilename())
  if cache:
    return cache
  baseModel = {
    'vertices': [],
    'colors': [],
    'uvs': []
  }
  models = [ baseModel ]
  for tileIndex, tile in chunk.tiles.items():
    tileBase = tile.getBaseTileModel()
    convertedBase = convertModelData(tileBase)
    baseModel['vertices'].extend(convertedBase['vertices'])
    baseModel['colors'].extend(convertedBase['colors'])
    baseModel['uvs'].extend(convertedBase['uvs'])
  # Generate binary buffer for efficient output
  buffer = bytearray()
  buffer.extend(b'DMC')# Header
  buffer.extend(len(chunk.tiles).to_bytes(4, 'little'))  # Number of tiles
  buffer.extend(len(models).to_bytes(1, 'little'))  # Number of models
  buffer.extend(len(chunk.entities).to_bytes(1, 'little'))  # Number of entities
  # Buffer tile data as array of uint8_t
  for tileIndex, tile in chunk.tiles.items():
    buffer.extend(tile.shape.to_bytes(1, 'little'))
  # # For each model
  for model in models:
    vertexCount = len(model['vertices'])
    buffer.extend(vertexCount.to_bytes(4, 'little'))
    for i in range(vertexCount):
      vertex = model['vertices'][i]
      uv = model['uvs'][i]
      color = model['colors'][i]
      buffer.extend(color[0].to_bytes(1, 'little'))
      buffer.extend(color[1].to_bytes(1, 'little'))
      buffer.extend(color[2].to_bytes(1, 'little'))
      buffer.extend(color[3].to_bytes(1, 'little'))
      buffer.extend(bytearray(struct.pack('<f', uv[0])))
      buffer.extend(bytearray(struct.pack('<f', uv[1])))
      buffer.extend(bytearray(struct.pack('<f', vertex[0])))
      buffer.extend(bytearray(struct.pack('<f', vertex[1])))
      buffer.extend(bytearray(struct.pack('<f', vertex[2])))
  # For each entity
  for entity in chunk.entities.values():
    buffer.extend(entity.type.to_bytes(1, 'little'))
    buffer.extend(entity.localX.to_bytes(1, 'little'))
    buffer.extend(entity.localY.to_bytes(1, 'little'))
    buffer.extend(entity.localZ.to_bytes(1, 'little'))
    pass
  # Write out map file
  relative = getAssetRelativePath(chunk.getFilename())
  fileNameWithoutExt = os.path.splitext(os.path.basename(relative))[0]
  outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dmc")
  outputFilePath = os.path.join(args.output_assets, outputFileRelative)
  os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
  with open(outputFilePath, "wb") as f:
    f.write(buffer)
  outChunk = {
    'files': [ outputFilePath ],
    'chunk': chunk
  }
  return assetCache(chunk.getFilename(), outChunk)
 def processMap(asset):
  cache = assetGetCache(asset['path'])
  if cache is not None:
    return cache
  map = Map(None)
  map.load(asset['path'])
  chunksDir = map.getChunkDirectory()
  files = os.listdir(chunksDir)
  if len(files) == 0:
    print(f"Error: No chunk files found in {chunksDir}.")
    sys.exit(1)
  chunkFiles = []
  for fileName in files:
    if not fileName.endswith('.json'):
      continue
    fNameNoExt = os.path.splitext(fileName)[0]
    fnPieces = fNameNoExt.split('_')
    if len(fnPieces) != 3:
      print(f"Error: Chunk filename {fileName} does not contain valid chunk coordinates.")
      sys.exit(1)
    chunk = Chunk(map, int(fnPieces[0]), int(fnPieces[1]), int(fnPieces[2]))
    chunk.load()
    result = processChunk(chunk)
    chunkFiles.extend(result['files'])
  # Map file
  outBuffer = bytearray()
  outBuffer.extend(b'DMF')
  outBuffer.extend(len(chunkFiles).to_bytes(4, 'little'))
  # DMF (Dusk Map file)
  fileRelative = getAssetRelativePath(asset['path'])
  fileNameWithoutExt = os.path.splitext(os.path.basename(fileRelative))[0]
  outputMapRelative = os.path.join(os.path.dirname(fileRelative), f"{fileNameWithoutExt}.dmf")
  outputMapPath = os.path.join(args.output_assets, outputMapRelative)
  os.makedirs(os.path.dirname(outputMapPath), exist_ok=True)
  with open(outputMapPath, "wb") as f:
    f.write(outBuffer)
  outMap = {
    'files': chunkFiles
  }
  outMap['files'].append(outputMapPath)
  return assetCache(asset['path'], outMap)
@@ -1,96 +0,0 @@
 import json
 import os
 from PIL import Image
 import datetime
 from tools.asset.args import args
 from tools.asset.cache import assetCache, assetGetCache
 palettes = []
 def extractPaletteFromImage(image):
  # goes through and finds all unique colors in the image
  if image.mode != 'RGBA':
    image = image.convert('RGBA')
  pixels = list(image.getdata())
  uniqueColors = []
  for color in pixels:
    # We treat all alpha 0 as rgba(0,0,0,0) for palette purposes
    if color[3] == 0:
      color = (0, 0, 0, 0)
    if color not in uniqueColors:
      uniqueColors.append(color)
  return uniqueColors
 def processPalette(asset):
  print(f"Processing palette: {asset['path']}")
  cache = assetGetCache(asset['path'])
  if cache is not None:
    return cache
  paletteIndex = len(palettes)
  image = Image.open(asset['path'])
  pixels = extractPaletteFromImage(image)
  fileNameWithoutExt = os.path.splitext(os.path.basename(asset['path']))[0]
  fileNameWithoutPalette = os.path.splitext(fileNameWithoutExt)[0]
  # PSP requires that the palette size be a power of two, so we will pad the
  # palette with transparent colors if needed.
  def mathNextPowTwo(x):
    return 1 << (x - 1).bit_length()
  nextPowTwo = mathNextPowTwo(len(pixels))
  while len(pixels) < nextPowTwo:
    pixels.append((0, 0, 0, 0))
  # Header
  now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
  data = f"// Palette Generated for {asset['path']} at {now}\n"
  data += f"#include \"display/palette/palette.h\"\n\n"
  data += f"#define PALETTE_{paletteIndex}_COLOR_COUNT {len(pixels)}\n\n"
  data += f"#pragma pack(push, 1)\n"
  data += f"static const color_t PALETTE_{paletteIndex}_COLORS[PALETTE_{paletteIndex}_COLOR_COUNT] = {{\n"
  for pixel in pixels:
    data += f"  {{ 0x{pixel[0]:02X}, 0x{pixel[1]:02X}, 0x{pixel[2]:02X}, 0x{pixel[3]:02X} }},\n"
  data += f"}};\n"
  data += f"#pragma pack(pop)\n\n"
  data += f"static const palette_t PALETTE_{paletteIndex} = {{\n"
  data += f"  .colorCount = PALETTE_{paletteIndex}_COLOR_COUNT,\n"
  data += f"  .colors = PALETTE_{paletteIndex}_COLORS,\n"
  data += f"}};\n"
  # Write Header
  outputFile = os.path.join(args.headers_dir, "display", "palette", f"palette_{paletteIndex}.h")
  os.makedirs(os.path.dirname(outputFile), exist_ok=True)
  with open(outputFile, "w") as f:
    f.write(data)
  palette = {
    "paletteIndex": paletteIndex,
    "paletteName": fileNameWithoutPalette,
    "pixels": pixels,
    "headerFile": os.path.relpath(outputFile, args.headers_dir),
    "asset": asset,
    "files": [ ],# No zippable files.
  }
  palettes.append(palette)
  return assetCache(asset['path'], palette)
 def processPaletteList():
  data = f"// Auto-generated palette list\n"
  print(f"Generating palette list with {len(palettes)} palettes.")
  for palette in palettes:
    data += f"#include \"{palette['headerFile']}\"\n"
  data += f"\n"
  data += f"#define PALETTE_LIST_COUNT {len(palettes)}\n\n"
  data += f"static const palette_t* PALETTE_LIST[PALETTE_LIST_COUNT] = {{\n"
  for palette in palettes:
    data += f"  &PALETTE_{palette['paletteIndex']},\n"
  data += f"}};\n"
  # Write the palette list to a header file
  outputFile = os.path.join(args.headers_dir, "display", "palette", "palettelist.h")
  os.makedirs(os.path.dirname(outputFile), exist_ok=True)
  with open(outputFile, "w") as f:
    f.write(data)
@@ -1,43 +0,0 @@
 import sys
 import os
 from tools.asset.args import args
 from tools.asset.cache import assetCache, assetGetCache
 from tools.asset.path import getAssetRelativePath
 from tools.dusk.defs import fileDefs
 def processScript(asset):
  cache = assetGetCache(asset['path'])
  if cache is not None:
    return cache
  # Load the lua file as a string
  with open(asset['path'], 'r', encoding='utf-8') as f:
    luaCode = f.read()
  # TODO: I will precompile or minify the Lua code here in the future
  # Replace all definitions in the code
  for key, val in fileDefs.items():
    luaCode = luaCode.replace(key, str(val))
  # Create output Dusk Script File (DSF) data
  data = ""
  data += "DSF"
  data += luaCode
  # Write to relative output file path.
  relative = getAssetRelativePath(asset['path'])
  fileNameWithoutExt = os.path.splitext(os.path.basename(asset['path']))[0]
  outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dsf")
  outputFilePath = os.path.join(args.output_assets, outputFileRelative)
  os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
  with open(outputFilePath, "wb") as f:
    f.write(data.encode('utf-8'))
  outScript = {
    'data': data,
    'path': asset['path'],
    'files': [ outputFilePath ],
    'scriptPath': outputFileRelative,
  }
  return assetCache(asset['path'], outScript)
@@ -1,178 +0,0 @@
 import json
 import sys
 import os
 import datetime
 from xml.etree import ElementTree
 from tools.asset.process.image import processImage
 from tools.asset.path import getAssetRelativePath
 from tools.asset.args import args
 from tools.asset.cache import assetGetCache, assetCache
 tilesets = []
 def loadTilesetFromTSX(asset):
  # Load the TSX file
  tree = ElementTree.parse(asset['path'])
  root = tree.getroot()
  # Expect tileheight, tilewidth, columns and tilecount attributes
  if 'tilewidth' not in root.attrib or 'tileheight' not in root.attrib or 'columns' not in root.attrib or 'tilecount' not in root.attrib:
    print(f"Error: TSX file {asset['path']} is missing required attributes (tilewidth, tileheight, columns, tilecount)")
    sys.exit(1)
  tileWidth = int(root.attrib['tilewidth'])
  tileHeight = int(root.attrib['tileheight'])
  columns = int(root.attrib['columns'])
  tileCount = int(root.attrib['tilecount'])
  rows = (tileCount + columns - 1) // columns  # Calculate rows based on tileCount and columns
  # Find the image element
  imageElement = root.find('image')
  if imageElement is None or 'source' not in imageElement.attrib:
    print(f"Error: TSX file {asset['path']} is missing an image element with a source attribute")
    sys.exit(1)
  imagePath = imageElement.attrib['source']
  # Image is relative to the TSX file
  imageAssetPath = os.path.join(os.path.dirname(asset['path']), imagePath)
  image = processImage({
    'path': imageAssetPath,
    'options': asset['options'],
  })
  return {
    "image": image,
    "tileWidth": tileWidth,
    "tileHeight": tileHeight,
    "columns": columns,
    "rows": rows,
    "originalWidth": tileWidth * columns,
    "originalHeight": tileHeight * rows,
  }
 def loadTilesetFromArgs(asset):
  # We need to determine how big each tile is. This can either be provided as
  # an arg of tileWidth/tileHeight or as a count of rows/columns.
  # Additionally, if the image has been factored, then the user can provide both
  # tile sizes AND cols/rows to indicate the original size of the image.
  image = processImage(asset)
  tileWidth, tileHeight = None, None
  columns, rows = None, None
  originalWidth, originalHeight = image['width'], image['height']
  if 'tileWidth' in asset['options'] and 'columns' in asset['options']:
    tileWidth = int(asset['options']['tileWidth'])
    columns = int(asset['options']['columns'])
    originalWidth = tileWidth * columns
  elif 'tileWidth' in asset['options']:
    tileWidth = int(asset['options']['tileWidth'])
    columns = image['width'] // tileWidth
  elif 'columns' in asset['options']:
    columns = int(asset['options']['columns'])
    tileWidth = image['width'] // columns
  else:
    print(f"Error: Tileset {asset['path']} must specify either tileWidth or columns")
    sys.exit(1)
  if 'tileHeight' in asset['options'] and 'rows' in asset['options']:
    tileHeight = int(asset['options']['tileHeight'])
    rows = int(asset['options']['rows'])
    originalHeight = tileHeight * rows
  elif 'tileHeight' in asset['options']:
    tileHeight = int(asset['options']['tileHeight'])
    rows = image['height'] // tileHeight
  elif 'rows' in asset['options']:
    rows = int(asset['options']['rows'])
    tileHeight = image['height'] // rows
  else:
    print(f"Error: Tileset {asset['path']} must specify either tileHeight or rows")
    sys.exit(1)
  return {
    "image": image,
    "tileWidth": tileWidth,
    "tileHeight": tileHeight,
    "columns": columns,
    "rows": rows,
    "originalWidth": originalWidth,
    "originalHeight": originalHeight,
  }
 def processTileset(asset):
  cache = assetGetCache(asset['path'])
  if cache is not None:
    return cache
  print(f"Processing tileset: {asset['path']}")
  tilesetData = None
  if asset['path'].endswith('.tsx'):
    tilesetData = loadTilesetFromTSX(asset)
  else:
    tilesetData = loadTilesetFromArgs(asset)
  fileNameWithoutExtension = os.path.splitext(os.path.basename(asset['path']))[0]
  now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
  tilesetName = fileNameWithoutExtension
  tilesetNameUpper = tilesetName.upper()
  widthScale = tilesetData['originalWidth'] / tilesetData['image']['width']
  heightScale = tilesetData['originalHeight'] / tilesetData['image']['height']
  # Create header
  data = f"// Tileset Generated for {asset['path']} at {now}\n"
  data += f"#pragma once\n"
  data += f"#include \"display/tileset/tileset.h\"\n\n"
  data += f"static const tileset_t TILESET_{tilesetNameUpper} = {{\n"
  data += f"  .name = {json.dumps(tilesetName)},\n"
  data += f"  .tileWidth = {tilesetData['tileWidth']},\n"
  data += f"  .tileHeight = {tilesetData['tileHeight']},\n"
  data += f"  .tileCount = {tilesetData['columns'] * tilesetData['rows']},\n"
  data += f"  .columns = {tilesetData['columns']},\n"
  data += f"  .rows = {tilesetData['rows']},\n"
  data += f"  .uv = {{ {widthScale / tilesetData['columns']}f, {heightScale / tilesetData['rows']}f }},\n"
  data += f"  .image = {json.dumps(tilesetData['image']['imagePath'])},\n"
  data += f"}};\n"
  # Write Header
  outputFile = os.path.join(args.headers_dir, "display", "tileset", f"tileset_{tilesetName}.h")
  os.makedirs(os.path.dirname(outputFile), exist_ok=True)
  with open(outputFile, 'w') as f:
    f.write(data)
  print(f"Write header for tileset: {outputFile}")
  tileset = {
    "files": [],
    "image": tilesetData['image'],
    "headerFile": os.path.relpath(outputFile, args.headers_dir),
    "tilesetName": tilesetName,
    "tilesetNameUpper": tilesetNameUpper,
    "tilesetIndex": len(tilesets),
    "tilesetData": tilesetData,
    "files": tilesetData['image']['files'],
  }
  tilesets.append(tileset)
  return assetCache(asset['path'], tileset)
 def processTilesetList():
  data = f"// Tileset List Generated at {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
  data += f"#pragma once\n"
  for tileset in tilesets:
    data += f"#include \"{tileset['headerFile']}\"\n"
  data += f"\n"
  data += f"#define TILESET_LIST_COUNT {len(tilesets)}\n\n"
  data += f"static const tileset_t* TILESET_LIST[TILESET_LIST_COUNT] = {{\n"
  for tileset in tilesets:
    data += f"  &TILESET_{tileset['tilesetNameUpper']},\n"
  data += f"}};\n"
  # Write header.
  outputFile = os.path.join(args.headers_dir, "display", "tileset", f"tilesetlist.h")
  os.makedirs(os.path.dirname(outputFile), exist_ok=True)
  with open(outputFile, 'w') as f:
    f.write(data)
@@ -1,47 +0,0 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "assetpalette.h"
 #include "asset/assettype.h"
 #include "assert/assert.h"
 errorret_t assetPaletteLoad(assetentire_t entire) {
  assertNotNull(entire.data, "Data pointer cannot be NULL.");
  assertNotNull(entire.output, "Output pointer cannot be NULL.");
  assetpalette_t *assetData = (assetpalette_t *)entire.data;
  palette_t *palette = (palette_t *)entire.output;
  // Read header and version (first 4 bytes)
  if(
    assetData->header[0] != 'D' || 
    assetData->header[1] != 'P' ||
    assetData->header[2] != 'F'
  ) {
    errorThrow("Invalid palette header");
  }
  // Version (can only be 1 atm)
  if(assetData->version != 0x01) {
    errorThrow("Unsupported palette version");
  }
  // Check color count.
  if(
    assetData->colorCount == 0 || 
    assetData->colorCount > PALETTE_COLOR_COUNT_MAX
  ) {
    errorThrow("Invalid palette color count");
  }
  paletteInit(
    palette,
    assetData->colorCount,
    assetData->colors
  );
  errorOk();
 }
@@ -1,30 +0,0 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "error/error.h"
 #include "display/texture/palette.h"
 typedef struct assetentire_s assetentire_t;
 #pragma pack(push, 1)
 typedef struct {
  char_t header[3];
  uint8_t version;
  uint8_t colorCount;
  color_t colors[PALETTE_COLOR_COUNT_MAX];
 } assetpalette_t;
 #pragma pack(pop)
 /**
 * Loads a palette from the given data pointer into the output palette.
 *
 * @param entire Data received from the asset loader system.
 * @return An error code.
 */
 errorret_t assetPaletteLoad(assetentire_t entire);
@@ -1,107 +0,0 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "camera.h"
 #include "display/display.h"
 #include "assert/assert.h"
 #include "display/framebuffer/framebuffer.h"
 #include "display/screen/screen.h"
 void cameraInit(camera_t *camera) {
  cameraInitPerspective(camera);
 }
 void cameraInitPerspective(camera_t *camera) {
  assertNotNull(camera, "Not a camera component");
  camera->projType = CAMERA_PROJECTION_TYPE_PERSPECTIVE;
  camera->perspective.fov = glm_rad(45.0f);
  camera->nearClip = 0.1f;
  camera->farClip = 10000.0f;
  camera->viewType = CAMERA_VIEW_TYPE_LOOKAT;
  glm_vec3_copy((vec3){ 5.0f, 5.0f, 5.0f }, camera->lookat.position);
  glm_vec3_copy((vec3){ 0.0f, 1.0f, 0.0f }, camera->lookat.up);
  glm_vec3_copy((vec3){ 0.0f, 0.0f, 0.0f }, camera->lookat.target);
 }
 void cameraInitOrthographic(camera_t *camera) {
  assertNotNull(camera, "Not a camera component");
  camera->projType = CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC;
  camera->orthographic.left = 0.0f;
  camera->orthographic.right = SCREEN.width;
  camera->orthographic.top = SCREEN.height;
  camera->orthographic.bottom = 0.0f;
  camera->nearClip = 0.1f;
  camera->farClip = 1.0f;
  camera->viewType = CAMERA_VIEW_TYPE_2D;
  glm_vec2_copy((vec2){ 0.0f, 0.0f }, camera->_2d.position);
  camera->_2d.zoom = 1.0f;
 }
 void cameraGetProjectionMatrix(camera_t *camera, mat4 dest) {
  assertNotNull(camera, "Not a camera component");
  assertNotNull(dest, "Destination matrix must not be null");
  if(
    camera->projType == CAMERA_PROJECTION_TYPE_PERSPECTIVE ||
    camera->projType == CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED
  ) {
    glm_mat4_identity(dest);
    glm_perspective(
      camera->perspective.fov,
      SCREEN.aspect,
      camera->nearClip,
      camera->farClip,
      dest
    );
    if(camera->projType == CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED) {
      dest[1][1] *= -1.0f;
    }
  } else if(camera->projType == CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
    glm_mat4_identity(dest);
    glm_ortho(
      camera->orthographic.left,
      camera->orthographic.right,
      camera->orthographic.top,
      camera->orthographic.bottom,
      camera->nearClip,
      camera->farClip,
      dest
    );
  }
 }
 void cameraGetViewMatrix(camera_t *camera, mat4 dest) {
  assertNotNull(camera, "Not a camera component");
  assertNotNull(dest, "Destination matrix must not be null");
  if(camera->viewType == CAMERA_VIEW_TYPE_MATRIX) {
    glm_mat4_ucopy(camera->view, dest);
  } else if(camera->viewType == CAMERA_VIEW_TYPE_LOOKAT) {
    glm_mat4_identity(dest);
    glm_lookat(
      camera->lookat.position,
      camera->lookat.target,
      camera->lookat.up,
      dest
    );
  } else if(camera->viewType == CAMERA_VIEW_TYPE_2D) {
    glm_mat4_identity(dest);
    glm_lookat(
      (vec3){ camera->_2d.position[0], camera->_2d.position[1], 0.5f },
      (vec3){ camera->_2d.position[0], camera->_2d.position[1], 0.0f },
      (vec3){ 0.0f, 1.0f, 0.0f },
      dest
    );
  } else if(camera->viewType == CAMERA_VIEW_TYPE_LOOKAT_PIXEL_PERFECT) {
    assertUnreachable("LOOKAT_PIXEL_PERFECT view type is not implemented yet");
  }
 }
@@ -1,97 +0,0 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "dusk.h"
 #include "display/color.h"
 #include "display/camera/cameraplatform.h"
 #ifndef cameraPushMatrixPlatform
  #error "cameraPushMatrixPlatform must be defined"
 #endif
 typedef enum {
  CAMERA_VIEW_TYPE_MATRIX,
  CAMERA_VIEW_TYPE_LOOKAT,
  CAMERA_VIEW_TYPE_2D,
  CAMERA_VIEW_TYPE_LOOKAT_PIXEL_PERFECT
 } cameraviewtype_t;
 typedef struct camera_s {
  union {
    mat4 view;
    struct {
      vec3 position;
      vec3 target;
      vec3 up;
    } lookat;
    struct {
      vec3 offset;
      vec3 target;
      vec3 up;
      float_t pixelsPerUnit;
    } lookatPixelPerfect;
    struct {
      vec2 position;
      float_t zoom;
    } _2d;
  };
  union {
    struct {
      float_t fov;
    } perspective;
    struct {
      float_t left;
      float_t right;
      float_t top;
      float_t bottom;
    } orthographic;
  };
  float_t nearClip;
  float_t farClip;
  cameraprojectiontype_t projType;
  cameraviewtype_t viewType;
 } camera_t;
 /**
 * Initializes a camera to default values. This calls cameraInitPerspective.
 */
 void cameraInit(camera_t *camera);
 /**
 * Initializes a camera for perspective projection.
 */
 void cameraInitPerspective(camera_t *camera);
 /**
 * Initializes a camera for orthographic projection.
 */
 void cameraInitOrthographic(camera_t *camera);
 /**
 * Gets the projection matrix for a camera.
 * 
 * @param camera Camera to get the projection matrix for
 * @param dest Matrix to store the projection matrix in
 */
 void cameraGetProjectionMatrix(camera_t *camera, mat4 dest);
 /**
 * Gets the view matrix for a camera.
 * 
 * @param camera Camera to get the view matrix for
 * @param dest Matrix to store the view matrix in
 */
 void cameraGetViewMatrix(camera_t *camera, mat4 dest);
@@ -1,158 +0,0 @@
 import json
 import os
 from tools.dusk.event import Event
 from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, CHUNK_VERTEX_COUNT_MAX, TILE_SHAPE_NULL
 from tools.dusk.tile import Tile
 from tools.dusk.entity import Entity
 from tools.dusk.region import Region
 from tools.editor.map.vertexbuffer import VertexBuffer
 from OpenGL.GL import *
 class Chunk:
  def __init__(self, map, x, y, z):
    self.map = map
    self.x = x
    self.y = y
    self.z = z
    self.current = {}
    self.original = {}
    self.entities = {}
    self.regions = {}
    self.onChunkData = Event()
    self.dirty = False
    self.tiles = {}
    self.vertexBuffer = VertexBuffer()
    # Test Region
    region = self.regions[0] = Region(self)
    region.minX = 0
    region.minY = 0
    region.minZ = 0
    region.maxX = 32
    region.maxY = 32
    region.maxZ = 32
    region.updateVertexs()
    # Gen tiles.
    tileIndex = 0
    for tz in range(CHUNK_DEPTH):
      for ty in range(CHUNK_HEIGHT):
        for tx in range(CHUNK_WIDTH):
          self.tiles[tileIndex] = Tile(self, tx, ty, tz, tileIndex)
          tileIndex += 1
    # Update vertices
    self.tileUpdateVertices()
  def reload(self, newX, newY, newZ):
    self.x = newX
    self.y = newY
    self.z = newZ
    self.entities = {}
    for tile in self.tiles.values():
      tile.chunkReload(newX, newY, newZ)
    self.load()
  def tileUpdateVertices(self):
    self.vertexBuffer.clear()
    for tile in self.tiles.values():
      tile.buffer(self.vertexBuffer)
    self.vertexBuffer.buildData()
  def load(self):
    fname = self.getFilename()
    if not fname or not os.path.exists(fname):
      self.new()
      return
    try:
      with open(fname, 'r') as f:
        data = json.load(f)
      if not 'shapes' in data:
        data['shapes'] = []
      # For each tile.
      for tile in self.tiles.values():
        tile.load(data)
      # For each entity.
      self.entities = {}
      if 'entities' in data:
        for id, entData in enumerate(data['entities']):
          ent = Entity(self)
          ent.load(entData)
          self.entities[id] = ent
      self.tileUpdateVertices()
      self.dirty = False
      self.onChunkData.invoke(self)
      self.map.onEntityData.invoke()
    except Exception as e:
      raise RuntimeError(f"Failed to load chunk file: {e}")
  def save(self):
    if not self.isDirty():
      return
    dataOut = {
      'shapes': [],
      'entities': []
    }
    for tile in self.tiles.values():
      dataOut['shapes'].append(tile.shape)
    for ent in self.entities.values():
      entData = {}
      ent.save(entData)
      dataOut['entities'].append(entData)
    fname = self.getFilename()
    if not fname:
      raise ValueError("No filename specified for saving chunk.")
    try:
      with open(fname, 'w') as f:
        json.dump(dataOut, f)
      self.dirty = False
      self.onChunkData.invoke(self)
    except Exception as e:
      raise RuntimeError(f"Failed to save chunk file: {e}")
  def new(self):
    for tile in self.tiles.values():
      tile.shape = TILE_SHAPE_NULL
    self.tileUpdateVertices()
    self.dirty = False
    self.onChunkData.invoke(self)
  def isDirty(self):
    return self.dirty
  def getFilename(self):
    if not self.map or not hasattr(self.map, 'getChunkDirectory'):
      return None
    dirPath = self.map.getChunkDirectory()
    if dirPath is None:
      return None
    return f"{dirPath}/{self.x}_{self.y}_{self.z}.json"
  def draw(self):
    self.vertexBuffer.draw()
  def addEntity(self, localX=0, localY=0, localZ=0):
    ent = Entity(self, localX, localY, localZ)
    self.entities[len(self.entities)] = ent
    self.map.onEntityData.invoke()
    self.dirty = True
    return ent
  def removeEntity(self, entity):
    for key, val in list(self.entities.items()):
      if val == entity:
        del self.entities[key]
        self.map.onEntityData.invoke()
        self.dirty = True
        return True
    return False
@@ -1,49 +0,0 @@
 from dotenv import load_dotenv, dotenv_values
 import os
 import sys
 current_file_path = os.path.abspath(__file__)
 duskDefsPath = os.path.join(os.path.dirname(current_file_path), "..", "..", "src", "duskdefs.env")
 # Ensure the .env file exists
 if not os.path.isfile(duskDefsPath):
  print(f"Error: .env file not found at {duskDefsPath}")
  sys.exit(1)
 load_dotenv(dotenv_path=duskDefsPath)
 defs = {key: os.getenv(key) for key in os.environ.keys()}
 fileDefs = dotenv_values(dotenv_path=duskDefsPath)
 # Parsed out definitions
 CHUNK_WIDTH = int(defs.get('CHUNK_WIDTH'))
 CHUNK_HEIGHT = int(defs.get('CHUNK_HEIGHT'))
 CHUNK_DEPTH = int(defs.get('CHUNK_DEPTH'))
 CHUNK_TILE_COUNT = CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH
 CHUNK_VERTEX_COUNT_MAX = int(defs.get('CHUNK_VERTEX_COUNT_MAX'))
 TILE_WIDTH = float(defs.get('TILE_WIDTH'))
 TILE_HEIGHT = float(defs.get('TILE_HEIGHT'))
 TILE_DEPTH = float(defs.get('TILE_DEPTH'))
 RPG_CAMERA_PIXELS_PER_UNIT = float(defs.get('RPG_CAMERA_PIXELS_PER_UNIT'))
 RPG_CAMERA_Z_OFFSET = float(defs.get('RPG_CAMERA_Z_OFFSET'))
 RPG_CAMERA_FOV = float(defs.get('RPG_CAMERA_FOV'))
 MAP_WIDTH = 5
 MAP_HEIGHT = 5
 MAP_DEPTH = 3
 MAP_CHUNK_COUNT = MAP_WIDTH * MAP_HEIGHT * MAP_DEPTH
 TILE_SHAPES = {}
 for key in defs.keys():
  if key.startswith('TILE_SHAPE_'):
    globals()[key] = int(defs.get(key))
    TILE_SHAPES[key] = int(defs.get(key))
 ENTITY_TYPES = {}
 for key in defs.keys():
  if key.startswith('ENTITY_TYPE_'):
    globals()[key] = int(defs.get(key))
    if key != 'ENTITY_TYPE_COUNT':
      ENTITY_TYPES[key] = int(defs.get(key))
@@ -1,90 +0,0 @@
 from tools.dusk.defs import ENTITY_TYPE_NULL, ENTITY_TYPE_NPC, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
 from tools.editor.map.vertexbuffer import VertexBuffer
 class Entity:
  def __init__(self, chunk, localX=0, localY=0, localZ=0):
    self.type = ENTITY_TYPE_NPC
    self.name = "Unititled"
    self.localX = localX % CHUNK_WIDTH
    self.localY = localY % CHUNK_HEIGHT
    self.localZ = localZ % CHUNK_DEPTH
    self.chunk = chunk
    self.vertexBuffer = VertexBuffer()
    pass
  def load(self, obj):
    self.type = obj.get('type', ENTITY_TYPE_NULL)
    self.localX = obj.get('x', 0)
    self.localY = obj.get('y', 0)
    self.localZ = obj.get('z', 0)
    self.name = obj.get('name', "Untitled")
    pass
  def save(self, obj):
    obj['type'] = self.type
    obj['name'] = self.name
    obj['x'] = self.localX
    obj['y'] = self.localY
    obj['z'] = self.localZ
    pass
  def setType(self, entityType):
    if self.type == entityType:
      return
    self.type = entityType
    self.chunk.dirty = True
    self.chunk.map.onEntityData.invoke()
  def setName(self, name):
    if self.name == name:
      return
    self.name = name
    self.chunk.dirty = True
    self.chunk.map.onEntityData.invoke()
  def draw(self):
    self.vertexBuffer.clear()
    startX = (self.chunk.x * CHUNK_WIDTH + self.localX) * TILE_WIDTH
    startY = (self.chunk.y * CHUNK_HEIGHT + self.localY) * TILE_HEIGHT
    startZ = (self.chunk.z * CHUNK_DEPTH + self.localZ) * TILE_DEPTH
    w = TILE_WIDTH
    h = TILE_HEIGHT
    d = TILE_DEPTH
    # Center
    startX -= w / 2
    startY -= h / 2
    startZ -= d / 2
    # Offset upwards a little
    startZ += 1
    # Buffer simple quad at current position (need 6 positions)
    self.vertexBuffer.vertices = [
      startX,     startY,     startZ,
      startX + w, startY,     startZ,
      startX + w, startY + h, startZ,
      startX,     startY,     startZ,
      startX + w, startY + h, startZ,
      startX,     startY + h, startZ,
    ]
    self.vertexBuffer.colors = [
      1.0, 0.0, 1.0, 1.0,
      1.0, 0.0, 1.0, 1.0,
      1.0, 0.0, 1.0, 1.0,
      1.0, 0.0, 1.0, 1.0,
      1.0, 0.0, 1.0, 1.0,
      1.0, 0.0, 1.0, 1.0,
    ]
    self.vertexBuffer.uvs = [
      0.0, 0.0,
      1.0, 0.0,
      1.0, 1.0,
      0.0, 0.0,
      1.0, 1.0,
      0.0, 1.0,
    ]
    self.vertexBuffer.buildData()
    self.vertexBuffer.draw()
@@ -1,18 +0,0 @@
 class Event:
  def __init__(self):
    self._subscribers = []
  def sub(self, callback):
    """Subscribe a callback to the event."""
    if callback not in self._subscribers:
      self._subscribers.append(callback)
  def unsub(self, callback):
    """Unsubscribe a callback from the event."""
    if callback in self._subscribers:
      self._subscribers.remove(callback)
  def invoke(self, *args, **kwargs):
    """Invoke all subscribers with the given arguments."""
    for callback in self._subscribers:
      callback(*args, **kwargs)
@@ -1,259 +0,0 @@
 import json
 import sys
 from tools.dusk.event import Event
 from PyQt5.QtWidgets import QFileDialog, QMessageBox
 from PyQt5.QtCore import QTimer
 import os
 from tools.dusk.chunk import Chunk
 from tools.dusk.defs import MAP_WIDTH, MAP_HEIGHT, MAP_DEPTH, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH
 import traceback
 MAP_DEFAULT_PATH = os.path.join(os.path.dirname(__file__), '../../assets/map/')
 EDITOR_CONFIG_PATH = os.path.join(os.path.dirname(__file__), '.editor')
 class Map:
  def __init__(self, parent):
    self.parent = parent
    self.data = {}
    self.dataOriginal = {}
    self.position = [None, None, None]  # x, y, z
    self.topLeftX = None
    self.topLeftY = None
    self.topLeftZ = None
    self.chunks = {}
    self.onMapData = Event()
    self.onPositionChange = Event()
    self.onEntityData = Event()
    self.mapFileName = None
    self.lastFile = None
    self.firstLoad = True
    index = 0
    for x in range(MAP_WIDTH):
      for y in range(MAP_HEIGHT):
        for z in range(MAP_DEPTH):
          self.chunks[index] = Chunk(self, x, y, z)
          index += 1
    # Only in editor instances:
    self.moveTo(0, 0, 0)
    if parent is not None:
      QTimer.singleShot(16, self.loadLastFile)
  def loadLastFile(self):
    if not os.path.exists(EDITOR_CONFIG_PATH):
      return
    try:
      with open(EDITOR_CONFIG_PATH, 'r') as f:
        config = json.load(f)
      lastFile = config.get('lastFile')
      lastPosition = config.get('lastPosition')
      leftPanelIndex = config.get('leftPanelIndex')
      if lastFile and os.path.exists(lastFile):
        self.load(lastFile)
      if lastPosition and isinstance(lastPosition, list) and len(lastPosition) == 3:
        self.moveTo(*lastPosition)
      if leftPanelIndex is not None:
        self.parent.leftPanel.tabs.setCurrentIndex(leftPanelIndex)
    except Exception:
      traceback.print_exc()
  def updateEditorConfig(self):
    if self.parent is None:
      return
    try:
      mapFileName = self.getMapFilename()
      config = {
        'lastFile': mapFileName if mapFileName else "",
        'lastPosition': self.position,
        'leftPanelIndex': self.parent.leftPanel.tabs.currentIndex()
      }
      config_dir = os.path.dirname(EDITOR_CONFIG_PATH)
      if not os.path.exists(config_dir):
        os.makedirs(config_dir, exist_ok=True)
      with open(EDITOR_CONFIG_PATH, 'w') as f:
        json.dump(config, f, indent=2)
    except Exception:
      traceback.print_exc()
  def newFile(self):
    self.data = {}
    self.dataOriginal = {}
    self.mapFileName = None
    self.lastFile = None
    for chunk in self.chunks.values():
      chunk.new()
    self.moveTo(0, 0, 0)
    self.onMapData.invoke(self.data)
    self.updateEditorConfig()
  def save(self, fname=None):
    if not self.getMapFilename() and fname is None:
      filePath, _ = QFileDialog.getSaveFileName(None, "Save Map File", MAP_DEFAULT_PATH, "Map Files (*.json)")
      if not filePath:
        return
      self.mapFileName = filePath
    if fname:
      self.mapFileName = fname
    try:
      with open(self.getMapFilename(), 'w') as f:
        json.dump(self.data, f, indent=2)
      self.dataOriginal = json.loads(json.dumps(self.data))  # Deep copy
      for chunk in self.chunks.values():
        chunk.save()
      self.updateEditorConfig()
    except Exception as e:
      traceback.print_exc()
      QMessageBox.critical(None, "Save Error", f"Failed to save map file:\n{e}")
  def load(self, fileName):
    try:
      with open(fileName, 'r') as f:
        self.data = json.load(f)
      self.mapFileName = fileName
      self.dataOriginal = json.loads(json.dumps(self.data))  # Deep copy
      for chunk in self.chunks.values():
        chunk.load()
      self.onMapData.invoke(self.data)
      self.updateEditorConfig()
    except Exception as e:
      traceback.print_exc()
      QMessageBox.critical(None, "Load Error", f"Failed to load map file:\n{e}")
  def isMapFileDirty(self):
    return json.dumps(self.data, sort_keys=True) != json.dumps(self.dataOriginal, sort_keys=True)
  def isDirty(self):
    return self.isMapFileDirty() or self.anyChunksDirty()
  def getMapFilename(self):
    return self.mapFileName if self.mapFileName and os.path.exists(self.mapFileName) else None
  def getMapDirectory(self):
    if self.mapFileName is None:
      return None
    dirname = os.path.dirname(self.mapFileName)
    return dirname
  def getChunkDirectory(self):
    dirName = self.getMapDirectory()
    if dirName is None:
      return None
    return os.path.join(dirName, 'chunks')
  def anyChunksDirty(self):
    for chunk in self.chunks.values():
      if chunk.isDirty():
        return True
    return False
  def moveTo(self, x, y, z):
    if self.position == [x, y, z]:
      return
    # We need to decide if the chunks should be unloaded here or not.
    newTopLeftChunkX = x // CHUNK_WIDTH - (MAP_WIDTH // 2)
    newTopLeftChunkY = y // CHUNK_HEIGHT - (MAP_HEIGHT // 2)
    newTopLeftChunkZ = z // CHUNK_DEPTH - (MAP_DEPTH // 2)
    if(newTopLeftChunkX != self.topLeftX or
        newTopLeftChunkY != self.topLeftY or
        newTopLeftChunkZ != self.topLeftZ):
      chunksToUnload = []
      chunksToKeep = []
      for chunk in self.chunks.values():
        chunkWorldX = chunk.x
        chunkWorldY = chunk.y
        chunkWorldZ = chunk.z
        if(chunkWorldX < newTopLeftChunkX or
            chunkWorldX >= newTopLeftChunkX + MAP_WIDTH or
            chunkWorldY < newTopLeftChunkY or
            chunkWorldY >= newTopLeftChunkY + MAP_HEIGHT or
            chunkWorldZ < newTopLeftChunkZ or
            chunkWorldZ >= newTopLeftChunkZ + MAP_DEPTH):
          chunksToUnload.append(chunk)
        else:
          chunksToKeep.append(chunk)
      # Unload chunks that are out of the new bounds.
      for chunk in chunksToUnload:
        if chunk.isDirty():
          print(f"Can't move map, some chunks are dirty: ({chunk.x}, {chunk.y}, {chunk.z})")
          return
      # Now we can safely unload the chunks.
      chunkIndex = 0
      newChunks = {}
      for chunk in chunksToKeep:
        newChunks[chunkIndex] = chunk
        chunkIndex += 1
      for xPos in range(newTopLeftChunkX, newTopLeftChunkX + MAP_WIDTH):
        for yPos in range(newTopLeftChunkY, newTopLeftChunkY + MAP_HEIGHT):
          for zPos in range(newTopLeftChunkZ, newTopLeftChunkZ + MAP_DEPTH):
            # Check if we already have this chunk.
            found = False
            for chunk in chunksToKeep:
              if chunk.x == xPos and chunk.y == yPos and chunk.z == zPos:
                found = True
                break
            if not found:
              # Create a new chunk.
              newChunk = chunksToUnload.pop()
              newChunk.reload(xPos, yPos, zPos)
              newChunks[chunkIndex] = newChunk
              chunkIndex += 1
      self.chunks = newChunks
      self.topLeftX = newTopLeftChunkX
      self.topLeftY = newTopLeftChunkY
      self.topLeftZ = newTopLeftChunkZ
    self.position = [x, y, z]
    self.onPositionChange.invoke(self.position)
    if not self.firstLoad:
      self.updateEditorConfig()
    self.firstLoad = False
  def moveRelative(self, x, y, z):
    self.moveTo(
      self.position[0] + x,
      self.position[1] + y,
      self.position[2] + z
    )
  def draw(self):
    for chunk in self.chunks.values():
      chunk.draw()
    for chunk in self.chunks.values():
      for entity in chunk.entities.values():
        entity.draw()
    # Only render on Region tab
    if self.parent.leftPanel.tabs.currentWidget() == self.parent.leftPanel.regionPanel:
      for chunk in self.chunks.values():
        for region in chunk.regions.values():
          region.draw()
  def getChunkAtWorldPos(self, x, y, z):
    chunkX = x // CHUNK_WIDTH
    chunkY = y // CHUNK_HEIGHT
    chunkZ = z // CHUNK_DEPTH
    for chunk in self.chunks.values():
      if chunk.x == chunkX and chunk.y == chunkY and chunk.z == chunkZ:
        return chunk
    return None
  def getTileAtWorldPos(self, x, y, z):
    chunk = self.getChunkAtWorldPos(x, y, z)
    if not chunk:
      print("No chunk found at position:", (x, y, z))
      return None
    tileX = x % CHUNK_WIDTH
    tileY = y % CHUNK_HEIGHT
    tileZ = z % CHUNK_DEPTH
    tileIndex = tileX + tileY * CHUNK_WIDTH + tileZ * CHUNK_WIDTH * CHUNK_HEIGHT
    return chunk.tiles.get(tileIndex)
@@ -1,141 +0,0 @@
 from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
 from tools.editor.map.vertexbuffer import VertexBuffer
 from OpenGL.GL import *
 from OpenGL.GLU import *
 class Region:
  def __init__(self, chunk):
    self.minX = 0
    self.minY = 0
    self.minZ = 0
    self.maxX = 0
    self.maxY = 0
    self.maxZ = 0
    self.chunk = chunk
    self.vertexBuffer = VertexBuffer()
    self.color = (1.0, 0.0, 0.0)
    self.updateVertexs()
    pass
  def updateVertexs(self):
    # Draw a quad, semi transparent with solid outlines
    vminX = (self.minX * CHUNK_WIDTH) * TILE_WIDTH
    vminY = (self.minY * CHUNK_HEIGHT) * TILE_HEIGHT
    vminZ = (self.minZ * CHUNK_DEPTH) * TILE_DEPTH
    vmaxX = (self.maxX * CHUNK_WIDTH) * TILE_WIDTH
    vmaxY = (self.maxY * CHUNK_HEIGHT) * TILE_HEIGHT
    vmaxZ = (self.maxZ * CHUNK_DEPTH) * TILE_DEPTH
    alpha = 0.25
    # Move back half a tile width
    vminX -= TILE_WIDTH / 2
    vmaxX -= TILE_WIDTH / 2
    vminY -= TILE_HEIGHT / 2
    vmaxY -= TILE_HEIGHT / 2
    vminZ -= TILE_DEPTH / 2
    vmaxZ -= TILE_DEPTH / 2
    # Cube (6 verts per face)
    self.vertexBuffer.vertices = [
      # Front face
      vminX, vminY, vmaxZ,
      vmaxX, vminY, vmaxZ,
      vmaxX, vmaxY, vmaxZ,
      vminX, vminY, vmaxZ,
      vmaxX, vmaxY, vmaxZ,
      vminX, vmaxY, vmaxZ,
      # Back face
      vmaxX, vminY, vminZ,
      vminX, vminY, vminZ,
      vminX, vmaxY, vminZ,
      vmaxX, vminY, vminZ,
      vminX, vmaxY, vminZ,
      vmaxX, vmaxY, vminZ,
      # Left face
      vminX, vminY, vminZ,
      vminX, vminY, vmaxZ,
      vminX, vmaxY, vmaxZ,
      vminX, vminY, vminZ,
      vminX, vmaxY, vmaxZ,
      vminX, vmaxY, vminZ,
      # Right face
      vmaxX, vminY, vmaxZ,
      vmaxX, vminY, vminZ,
      vmaxX, vmaxY, vminZ,
      vmaxX, vminY, vmaxZ,
      vmaxX, vmaxY, vminZ,
      vmaxX, vmaxY, vmaxZ,
      # Top face
      vminX, vmaxY, vmaxZ,
      vmaxX, vmaxY, vmaxZ,
      vmaxX, vmaxY, vminZ,
      vminX, vmaxY, vmaxZ,
      vmaxX, vmaxY, vminZ,
      vminX, vmaxY, vminZ,
      # Bottom face
      vminX, vminY, vminZ,
      vmaxX, vminY, vminZ,
      vmaxX, vminY, vmaxZ,
      vminX, vminY, vminZ,
      vmaxX, vminY, vmaxZ,
      vminX, vminY, vmaxZ,
    ]
    self.vertexBuffer.colors = [
      # Front face
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      # Back face
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      # Left face
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      # Right face
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      # Top face
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      # Bottom face
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
      self.color[0], self.color[1], self.color[2], alpha,
    ]
    self.vertexBuffer.buildData()
  def draw(self):
    self.vertexBuffer.draw()
@@ -1,206 +0,0 @@
 from OpenGL.GL import *
 from tools.dusk.defs import (
  TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH,
  CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH,
  TILE_SHAPE_NULL, TILE_SHAPE_FLOOR,
  TILE_SHAPE_RAMP_NORTH, TILE_SHAPE_RAMP_SOUTH,
  TILE_SHAPE_RAMP_EAST, TILE_SHAPE_RAMP_WEST,
  TILE_SHAPE_RAMP_SOUTHWEST, TILE_SHAPE_RAMP_SOUTHEAST,
  TILE_SHAPE_RAMP_NORTHWEST, TILE_SHAPE_RAMP_NORTHEAST
 )
 def getItem(arr, index, default):
  if index < len(arr):
    return arr[index]
  return default
 class Tile:
  def __init__(self, chunk, x, y, z, tileIndex):
    self.shape = TILE_SHAPE_NULL
    self.chunk = chunk
    self.x = x
    self.y = y
    self.z = z
    self.index = tileIndex
    self.posX = x * TILE_WIDTH + chunk.x * CHUNK_WIDTH * TILE_WIDTH
    self.posY = y * TILE_HEIGHT + chunk.y * CHUNK_HEIGHT * TILE_HEIGHT
    self.posZ = z * TILE_DEPTH + chunk.z * CHUNK_DEPTH * TILE_DEPTH
  def chunkReload(self, newX, newY, newZ):
    self.posX = self.x * TILE_WIDTH + newX * CHUNK_WIDTH * TILE_WIDTH
    self.posY = self.y * TILE_HEIGHT + newY * CHUNK_HEIGHT * TILE_HEIGHT
    self.posZ = self.z * TILE_DEPTH + newZ * CHUNK_DEPTH * TILE_DEPTH
  def load(self, chunkData):
    self.shape = getItem(chunkData['shapes'], self.index, TILE_SHAPE_NULL)
  def setShape(self, shape):
    if shape == self.shape:
      return
    self.shape = shape
    self.chunk.dirty = True
    self.chunk.tileUpdateVertices()
    self.chunk.onChunkData.invoke(self.chunk)
  def getBaseTileModel(self):
    vertices = []
    indices = []
    uvs = []
    colors = [] 
    if self.shape == TILE_SHAPE_NULL:
      pass
    elif self.shape == TILE_SHAPE_FLOOR:
      vertices = [
        (self.posX, self.posY, self.posZ),
        (self.posX + TILE_WIDTH, self.posY, self.posZ),
        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
        (self.posX, self.posY + TILE_HEIGHT, self.posZ)
      ]
      indices = [0, 1, 2, 0, 2, 3]
      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
      colors = [ (255, 255, 255, 255) ] * 4
    elif self.shape == TILE_SHAPE_RAMP_NORTH:
      vertices = [
        (self.posX, self.posY, self.posZ + TILE_DEPTH),
        (self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
        (self.posX, self.posY + TILE_HEIGHT, self.posZ)
      ]
      indices = [0, 1, 2, 0, 2, 3]
      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
      colors = [ (255, 0, 0, 255) ] * 4
    elif self.shape == TILE_SHAPE_RAMP_SOUTH:
      vertices = [
        (self.posX, self.posY, self.posZ),
        (self.posX + TILE_WIDTH, self.posY, self.posZ),
        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
        (self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
      ]
      indices = [0, 1, 2, 0, 2, 3]
      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
      colors = [ (0, 255, 0, 255) ] * 4
    elif self.shape == TILE_SHAPE_RAMP_EAST:
      vertices = [
        (self.posX, self.posY, self.posZ),
        (self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
        (self.posX, self.posY + TILE_HEIGHT, self.posZ)
      ]
      indices = [0, 1, 2, 0, 2, 3]
      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
      colors = [ (0, 0, 255, 255) ] * 4
    elif self.shape == TILE_SHAPE_RAMP_WEST:
      vertices = [
        (self.posX, self.posY, self.posZ + TILE_DEPTH),
        (self.posX + TILE_WIDTH, self.posY, self.posZ),
        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
        (self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
      ]
      indices = [0, 1, 2, 0, 2, 3]
      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
      colors = [ (255, 255, 0, 255) ] * 4
    elif self.shape == TILE_SHAPE_RAMP_SOUTHWEST:
      vertices = [
        (self.posX, self.posY, self.posZ + TILE_DEPTH),
        (self.posX + TILE_WIDTH, self.posY, self.posZ),
        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
        (self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
      ]
      indices = [0, 1, 2, 0, 2, 3]
      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
      colors = [ (255, 128, 0, 255) ] * 4
    elif self.shape == TILE_SHAPE_RAMP_NORTHWEST:
      vertices = [
        (self.posX, self.posY, self.posZ + TILE_DEPTH),
        (self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
        (self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
      ]
      indices = [0, 1, 2, 0, 2, 3]
      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
      colors = [ (128, 255, 0, 255) ] * 4
    elif self.shape == TILE_SHAPE_RAMP_NORTHEAST:
      vertices = [
        (self.posX, self.posY, self.posZ + TILE_DEPTH),
        (self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
        (self.posX, self.posY + TILE_HEIGHT, self.posZ)
      ]
      indices = [0, 1, 2, 0, 2, 3]
      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
      colors = [ (0, 255, 128, 255) ] * 4
    elif self.shape == TILE_SHAPE_RAMP_SOUTHEAST:
      vertices = [
        (self.posX, self.posY, self.posZ),
        (self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
        (self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
      ]
      indices = [0, 1, 2, 0, 2, 3]
      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
      colors = [ (255, 128, 255, 255) ] * 4
    else:
      # Solid black cube for unknown shape
      x0, y0, z0 = self.posX, self.posY, self.posZ
      x1, y1, z1 = self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH
      vertices = [
        (x0, y0, z0), (x1, y0, z0), (x1, y1, z0), (x0, y1, z0), # bottom
        (x0, y0, z1), (x1, y0, z1), (x1, y1, z1), (x0, y1, z1)  # top
      ]
      indices = [
        0,1,2, 0,2,3,   # bottom
        4,5,6, 4,6,7,   # top
        0,1,5, 0,5,4,   # front
        2,3,7, 2,7,6,   # back
        1,2,6, 1,6,5,   # right
        3,0,4, 3,4,7    # left
      ]
      uvs = [ (0,0) ] * 8
      colors = [ (0,0,0,255) ] * 8
    return {
      'vertices': vertices,
      'indices': indices,
      'uvs': uvs,
      'colors': colors
    }
  def buffer(self, vertexBuffer):
    if self.shape == TILE_SHAPE_NULL:
      return
    # New code:
    baseData = self.getBaseTileModel()
    # Base data is indiced but we need to buffer unindiced data
    for index in baseData['indices']:
      verts = baseData['vertices'][index]
      uv = baseData['uvs'][index]
      color = baseData['colors'][index]
      vertexBuffer.vertices.extend([
        verts[0] - (TILE_WIDTH / 2.0),
        verts[1] - (TILE_HEIGHT / 2.0),
        verts[2] - (TILE_DEPTH / 2.0)
      ])
      vertexBuffer.colors.extend([
        color[0] / 255.0,
        color[1] / 255.0,
        color[2] / 255.0,
        color[3] / 255.0
      ])
@@ -1,57 +0,0 @@
 #!/usr/bin/env python3
 import sys
 from PyQt5.QtWidgets import (
  QApplication, QVBoxLayout, QPushButton,
  QDialog
 )
 from OpenGL.GL import *
 from OpenGL.GLU import *
 from tools.editor.maptool import MapWindow
 from tools.editor.langtool import LangToolWindow
 from tools.editor.cutscenetool import CutsceneToolWindow
 DEFAULT_TOOL = None
 DEFAULT_TOOL = "map"
 # DEFAULT_TOOL = "cutscene"
 TOOLS = [
  ("Map Editor", "map", MapWindow),
  ("Language Editor", "language", LangToolWindow),
  ("Cutscene Editor", "cutscene", CutsceneToolWindow),
 ]
 class EditorChoiceDialog(QDialog):
  def __init__(self):
    super().__init__()
    self.setWindowTitle("Choose Tool")
    layout = QVBoxLayout(self)
    self.selected = None
    for label, key, win_cls in TOOLS:
      btn = QPushButton(label)
      btn.clicked.connect(lambda checked, w=win_cls: self.choose_tool(w))
      layout.addWidget(btn)
  def choose_tool(self, win_cls):
    self.selected = win_cls
    self.accept()
  def get_choice(self):
    return self.selected
 def main():
  app = QApplication(sys.argv)
  tool_map = { key: win_cls for _, key, win_cls in TOOLS }
  if DEFAULT_TOOL in tool_map:
    win_cls = tool_map[DEFAULT_TOOL]
  else:
    choice_dialog = EditorChoiceDialog()
    if choice_dialog.exec_() == QDialog.Accepted:
      win_cls = choice_dialog.get_choice()
    else:
      sys.exit(0)
  win = win_cls()
  win.show()
  sys.exit(app.exec_())
 if __name__ == "__main__":
  main()
@@ -1,58 +0,0 @@
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLineEdit, QLabel, QSizePolicy, QComboBox, QHBoxLayout, QSpacerItem
 from PyQt5.QtCore import Qt, pyqtSignal
 from .cutscenewait import CutsceneWaitEditor
 from .cutscenetext import CutsceneTextEditor
 EDITOR_MAP = (
  ( "wait", "Wait", CutsceneWaitEditor ),
  ( "text", "Text", CutsceneTextEditor )
 )
 class CutsceneItemEditor(QWidget):
  def __init__(self, parent=None):
    super().__init__(parent)
    self.layout = QVBoxLayout(self)
    self.layout.setAlignment(Qt.AlignTop | Qt.AlignLeft)
    self.layout.addWidget(QLabel("Item Properties:"))
    rowLayout = QHBoxLayout()
    rowLayout.setSpacing(8)
    rowLayout.addWidget(QLabel("Name:"))
    self.nameInput = QLineEdit()
    rowLayout.addWidget(self.nameInput)
    rowLayout.addWidget(QLabel("Type:"))
    self.typeDropdown = QComboBox()
    self.typeDropdown.addItems([typeName for typeKey, typeName, editorClass in EDITOR_MAP])
    rowLayout.addWidget(self.typeDropdown)
    self.layout.addLayout(rowLayout)
    self.activeEditor = None
    # Events
    self.nameInput.textChanged.connect(self.onNameChanged)
    self.typeDropdown.currentTextChanged.connect(self.onTypeChanged)
    # First load
    self.onNameChanged(self.nameInput.text())
    self.onTypeChanged(self.typeDropdown.currentText())
  def onNameChanged(self, nameText):
    pass
  def onTypeChanged(self, typeText):
    typeKey = typeText.lower()
    # Remove existing editor
    if self.activeEditor:
      self.layout.removeWidget(self.activeEditor)
      self.activeEditor.deleteLater()
      self.activeEditor = None
    # Create new editor
    for key, name, editorClass in EDITOR_MAP:
      if key == typeKey:
        self.activeEditor = editorClass()
        self.layout.addWidget(self.activeEditor)
        break
@@ -1,54 +0,0 @@
 from PyQt5.QtWidgets import QMenuBar, QAction, QFileDialog, QMessageBox
 from PyQt5.QtGui import QKeySequence
 class CutsceneMenuBar(QMenuBar):
  def __init__(self, parent):
    super().__init__(parent)
    self.parent = parent
    fileMenu = self.addMenu("File")
    self.newAction = QAction("New", self)
    self.newAction.setShortcut(QKeySequence.New)
    self.newAction.triggered.connect(self.newFile)
    fileMenu.addAction(self.newAction)
    self.openAction = QAction("Open", self)
    self.openAction.setShortcut(QKeySequence.Open)
    self.openAction.triggered.connect(self.openFile)
    fileMenu.addAction(self.openAction)
    self.saveAction = QAction("Save", self)
    self.saveAction.setShortcut(QKeySequence.Save)
    self.saveAction.triggered.connect(self.saveFile)
    fileMenu.addAction(self.saveAction)
    self.saveAsAction = QAction("Save As", self)
    self.saveAsAction.setShortcut(QKeySequence.SaveAs)
    self.saveAsAction.triggered.connect(self.saveFileAs)
    fileMenu.addAction(self.saveAsAction)
  def newFile(self):
    self.parent.clearCutscene()
  def openFile(self):
    path, _ = QFileDialog.getOpenFileName(self.parent, "Open Cutscene File", "", "JSON Files (*.json);;All Files (*)")
    if not path:
      return
    # TODO: Load file contents into timeline
    self.parent.currentFile = path
    pass
  def saveFile(self):
    if not self.parent.currentFile:
      self.saveFileAs()
      return
    # TODO: Save timeline to self.parent.currentFile
    pass
  def saveFileAs(self):
    path, _ = QFileDialog.getSaveFileName(self.parent, "Save Cutscene File As", "", "JSON Files (*.json);;All Files (*)")
    if path:
      self.parent.currentFile = path
      self.saveFile()
@@ -1,21 +0,0 @@
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QTextEdit
 from PyQt5.QtCore import Qt
 class CutsceneTextEditor(QWidget):
  def __init__(self, parent=None):
    super().__init__(parent)
    layout = QVBoxLayout(self)
    layout.setContentsMargins(0, 0, 0, 0)
    layout.setSpacing(0)
    label = QLabel("Text:")
    label.setSizePolicy(label.sizePolicy().Expanding, label.sizePolicy().Fixed)
    layout.addWidget(label)
    self.textInput = QTextEdit()
    self.textInput.setSizePolicy(self.textInput.sizePolicy().Expanding, self.textInput.sizePolicy().Expanding)
    layout.addWidget(self.textInput, stretch=1)
  def setText(self, text):
    self.textInput.setPlainText(text)
  def getText(self):
    return self.textInput.toPlainText()
@@ -1,20 +0,0 @@
 from PyQt5.QtWidgets import QWidget, QFormLayout, QDoubleSpinBox, QLabel
 class CutsceneWaitEditor(QWidget):
  def __init__(self, parent=None):
    super().__init__(parent)
    layout = QFormLayout(self)
    layout.setContentsMargins(0, 0, 0, 0)
    layout.setSpacing(0)
    self.waitTimeInput = QDoubleSpinBox()
    self.waitTimeInput.setMinimum(0.0)
    self.waitTimeInput.setMaximum(9999.0)
    self.waitTimeInput.setDecimals(2)
    self.waitTimeInput.setSingleStep(0.1)
    layout.addRow(QLabel("Wait Time (seconds):"), self.waitTimeInput)
  def setWaitTime(self, value):
    self.waitTimeInput.setValue(value)
  def getWaitTime(self):
    return self.waitTimeInput.value()
@@ -1,101 +0,0 @@
 from PyQt5.QtWidgets import QMainWindow, QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QListWidget, QListWidgetItem, QMenuBar, QAction, QFileDialog, QMessageBox
 from PyQt5.QtGui import QKeySequence
 from tools.editor.cutscene.cutsceneitemeditor import CutsceneItemEditor
 from tools.editor.cutscene.cutscenemenubar import CutsceneMenuBar
 import sys
 class CutsceneToolWindow(QMainWindow):
  def __init__(self):
    super().__init__()
    self.setWindowTitle("Dusk Cutscene Editor")
    self.setGeometry(100, 100, 800, 600)
    self.nextItemNumber = 1  # Track next available number
    self.currentFile = None
    self.dirty = False  # Track unsaved changes
    # File menu (handled by CutsceneMenuBar)
    menubar = CutsceneMenuBar(self)
    self.setMenuBar(menubar)
    # Main layout: horizontal split
    central = QWidget()
    mainLayout = QHBoxLayout(central)
    self.setCentralWidget(central)
    # Timeline
    leftPanel = QWidget()
    leftLayout = QVBoxLayout(leftPanel)
    self.timelineList = QListWidget()
    self.timelineList.setSelectionMode(QListWidget.SingleSelection)
    leftLayout.addWidget(QLabel("Cutscene Timeline"))
    leftLayout.addWidget(self.timelineList)
    btnLayout = QHBoxLayout()
    self.addBtn = QPushButton("Add")
    self.removeBtn = QPushButton("Remove")
    btnLayout.addWidget(self.addBtn)
    btnLayout.addWidget(self.removeBtn)
    leftLayout.addLayout(btnLayout)
    mainLayout.addWidget(leftPanel, 2)
    # Property editor
    self.editorPanel = QWidget()
    self.editorLayout = QVBoxLayout(self.editorPanel)
    self.itemEditor = None  # Only create when needed
    mainLayout.addWidget(self.editorPanel, 3)
    # Events
    self.timelineList.currentItemChanged.connect(self.onItemSelected)
    self.addBtn.clicked.connect(self.addCutsceneItem)
    self.removeBtn.clicked.connect(self.removeCutsceneItem)
  def addCutsceneItem(self):
    name = f"Cutscene item {self.nextItemNumber}"
    timelineItem = QListWidgetItem(name)
    self.timelineList.addItem(timelineItem)
    self.timelineList.setCurrentItem(timelineItem)
    self.nextItemNumber += 1
    self.dirty = True
  def removeCutsceneItem(self):
    row = self.timelineList.currentRow()
    if row < 0:
      return
    self.timelineList.takeItem(row)
    self.dirty = True
    # Remove editor if nothing selected
    if self.timelineList.currentItem() is None or self.itemEditor is None:
      return
    self.editorLayout.removeWidget(self.itemEditor)
    self.itemEditor.deleteLater()
    self.itemEditor = None
  def clearCutscene(self):
    self.timelineList.clear()
    self.nextItemNumber = 1
    self.currentFile = None
    self.dirty = False
    if self.itemEditor:
      self.editorLayout.removeWidget(self.itemEditor)
  def onItemSelected(self, current, previous):
    if current:
      if not self.itemEditor:
        self.itemEditor = CutsceneItemEditor()
        self.editorLayout.addWidget(self.itemEditor)
      return
    if not self.itemEditor:
      return
    self.editorLayout.removeWidget(self.itemEditor)
    self.itemEditor.deleteLater()
    self.itemEditor = None
 if __name__ == "__main__":
  app = QApplication(sys.argv)
  window = CutsceneToolWindow()
  window.show()
  sys.exit(app.exec_())
@@ -1,202 +0,0 @@
 #!/usr/bin/env python3
 from PyQt5.QtWidgets import QMainWindow, QApplication, QAction, QMenuBar, QMessageBox, QFileDialog, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit, QTableWidget, QTableWidgetItem, QHeaderView, QPushButton, QTabWidget, QFormLayout
 from PyQt5.QtCore import Qt
 import sys
 import os
 import polib
 class LangToolWindow(QMainWindow):
  def __init__(self):
    super().__init__()
    self.setWindowTitle("Dusk Language Editor")
    self.setGeometry(100, 100, 800, 600)
    self.current_file = None
    self.dirty = False
    self.init_menu()
    self.init_ui()
  def init_ui(self):
    central = QWidget()
    layout = QVBoxLayout(central)
    tabs = QTabWidget()
    # Header Tab
    header_tab = QWidget()
    header_layout = QFormLayout(header_tab)
    self.language_edit = QLineEdit()
    self.language_edit.setMaximumWidth(220)
    header_layout.addRow(QLabel("Language:"), self.language_edit)
    self.plural_edit = QLineEdit()
    self.plural_edit.setMaximumWidth(320)
    header_layout.addRow(QLabel("Plural-Forms:"), self.plural_edit)
    self.content_type_edit = QLineEdit("text/plain; charset=UTF-8")
    self.content_type_edit.setMaximumWidth(320)
    header_layout.addRow(QLabel("Content-Type:"), self.content_type_edit)
    tabs.addTab(header_tab, "Header")
    # Strings Tab
    strings_tab = QWidget()
    strings_layout = QVBoxLayout(strings_tab)
    self.po_table = QTableWidget()
    self.po_table.setColumnCount(2)
    self.po_table.setHorizontalHeaderLabels(["msgid", "msgstr"])
    self.po_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
    self.po_table.verticalHeader().setMinimumWidth(22)
    self.po_table.verticalHeader().setDefaultAlignment(Qt.AlignRight | Qt.AlignVCenter)
    strings_layout.addWidget(self.po_table)
    row_btn_layout = QHBoxLayout()
    add_row_btn = QPushButton("Add Row")
    remove_row_btn = QPushButton("Remove Row")
    row_btn_layout.addWidget(add_row_btn)
    row_btn_layout.addWidget(remove_row_btn)
    strings_layout.addLayout(row_btn_layout)
    tabs.addTab(strings_tab, "Strings")
    layout.addWidget(tabs)
    add_row_btn.clicked.connect(self.add_row)
    remove_row_btn.clicked.connect(self.remove_row)
    self.add_row_btn = add_row_btn
    self.remove_row_btn = remove_row_btn
    self.setCentralWidget(central)
    # Connect edits to dirty flag
    self.language_edit.textChanged.connect(self.set_dirty)
    self.plural_edit.textChanged.connect(self.set_dirty)
    self.content_type_edit.textChanged.connect(self.set_dirty)
    self.po_table.itemChanged.connect(self.set_dirty)
  def set_dirty(self):
    self.dirty = True
    self.update_save_action()
  def init_menu(self):
    menubar = self.menuBar()
    file_menu = menubar.addMenu("File")
    new_action = QAction("New", self)
    open_action = QAction("Open", self)
    save_action = QAction("Save", self)
    save_as_action = QAction("Save As", self)
    new_action.triggered.connect(lambda: self.handle_file_action("new"))
    open_action.triggered.connect(lambda: self.handle_file_action("open"))
    save_action.triggered.connect(self.handle_save)
    save_as_action.triggered.connect(self.handle_save_as)
    file_menu.addAction(new_action)
    file_menu.addAction(open_action)
    file_menu.addAction(save_action)
    file_menu.addAction(save_as_action)
    self.save_action = save_action  # Store reference for enabling/disabling
    self.update_save_action()
  def update_save_action(self):
    self.save_action.setEnabled(self.current_file is not None)
  def handle_file_action(self, action):
    if self.dirty:
      reply = QMessageBox.question(self, "Save Changes?", "Do you want to save changes before proceeding?", QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
      if reply == QMessageBox.Cancel:
        return
      elif reply == QMessageBox.Yes:
        self.handle_save()
    if action == "new":
      self.new_file()
    elif action == "open":
      default_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../assets/locale"))
      file_path, _ = QFileDialog.getOpenFileName(self, "Open Language File", default_dir, "PO Files (*.po)")
      if file_path:
        self.open_file(file_path)
  def new_file(self):
    self.current_file = None
    self.dirty = False
    self.language_edit.setText("")
    self.plural_edit.setText("")
    self.po_table.setRowCount(0)
    self.update_save_action()
  def open_file(self, file_path):
    self.current_file = file_path
    self.dirty = False
    self.update_save_action()
    self.load_po_file(file_path)
  def load_po_file(self, file_path):
    po = polib.pofile(file_path)
    language = po.metadata.get('Language', '')
    plural = po.metadata.get('Plural-Forms', '')
    content_type = po.metadata.get('Content-Type', 'text/plain; charset=UTF-8')
    self.language_edit.setText(language)
    self.plural_edit.setText(plural)
    self.content_type_edit.setText(content_type)
    self.po_table.setRowCount(len(po))
    for row, entry in enumerate(po):
      self.po_table.setItem(row, 0, QTableWidgetItem(entry.msgid))
      self.po_table.setItem(row, 1, QTableWidgetItem(entry.msgstr))
  def save_file(self, file_path):
    po = polib.POFile()
    po.metadata = {
      'Language': self.language_edit.text(),
      'Content-Type': self.content_type_edit.text(),
      'Plural-Forms': self.plural_edit.text(),
    }
    for row in range(self.po_table.rowCount()):
      msgid_item = self.po_table.item(row, 0)
      msgstr_item = self.po_table.item(row, 1)
      msgid = msgid_item.text() if msgid_item else ''
      msgstr = msgstr_item.text() if msgstr_item else ''
      if msgid or msgstr:
        entry = polib.POEntry(msgid=msgid, msgstr=msgstr)
        po.append(entry)
    po.save(file_path)
    self.dirty = False
    self.update_save_action()
  def handle_save(self):
    if self.current_file:
      self.save_file(self.current_file)
    else:
      self.handle_save_as()
  def handle_save_as(self):
    default_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../assets/locale"))
    file_path, _ = QFileDialog.getSaveFileName(self, "Save Language File As", default_dir, "PO Files (*.po)")
    if file_path:
      self.current_file = file_path
      self.update_save_action()
      self.save_file(file_path)
  def add_row(self):
    row = self.po_table.rowCount()
    self.po_table.insertRow(row)
    self.po_table.setItem(row, 0, QTableWidgetItem(""))
    self.po_table.setItem(row, 1, QTableWidgetItem(""))
    self.po_table.setCurrentCell(row, 0)
    self.set_dirty()
  def remove_row(self):
    row = self.po_table.currentRow()
    if row >= 0:
      self.po_table.removeRow(row)
      self.set_dirty()
  def closeEvent(self, event):
    if self.dirty:
      reply = QMessageBox.question(self, "Save Changes?", "Do you want to save changes before exiting?", QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
      if reply == QMessageBox.Cancel:
        event.ignore()
        return
      elif reply == QMessageBox.Yes:
        self.handle_save()
    event.accept()
 if __name__ == "__main__":
  app = QApplication(sys.argv)
  window = LangToolWindow()
  window.show()
  sys.exit(app.exec_())
@@ -1,55 +0,0 @@
 import math
 import time
 from OpenGL.GL import *
 from OpenGL.GLU import *
 from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH, RPG_CAMERA_PIXELS_PER_UNIT, RPG_CAMERA_Z_OFFSET, RPG_CAMERA_FOV
 class Camera:
  def __init__(self, parent):
    self.parent = parent
    self.pixelsPerUnit = RPG_CAMERA_PIXELS_PER_UNIT
    self.yOffset = RPG_CAMERA_Z_OFFSET
    self.fov = RPG_CAMERA_FOV
    self.scale = 8.0
    self.lastTime = time.time()
    self.lookAtTarget = [0.0, 0.0, 0.0]
  def setup(self, vw, vh, duration=0.1):
    now = time.time()
    delta = now - self.lastTime
    self.lastTime = now
    # Calculate ease factor for exponential smoothing over 'duration' seconds
    ease = 1 - math.exp(-delta / duration)
    z = (vh / 2.0) / (
      (self.pixelsPerUnit * self.scale) * math.tan(math.radians(self.fov / 2.0))
    )
    lookAt = [
      self.parent.map.position[0] * TILE_WIDTH,
      self.parent.map.position[1] * TILE_HEIGHT,
      self.parent.map.position[2] * TILE_DEPTH,
    ]
    aspectRatio = vw / vh
    # Ease the lookAt target
    for i in range(3):
      self.lookAtTarget[i] += (lookAt[i] - self.lookAtTarget[i]) * ease
    # Camera position is now based on the eased lookAtTarget
    cameraPosition = (
      self.lookAtTarget[0],
      self.lookAtTarget[1] + self.yOffset,
      self.lookAtTarget[2] + z
    )
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    gluPerspective(self.fov, aspectRatio, 0.1, 1000.0)
    glScalef(1.0, -1.0, 1.0)  # Flip the projection matrix upside down
    glMatrixMode(GL_MODELVIEW)
    glLoadIdentity()
    gluLookAt(
      cameraPosition[0], cameraPosition[1], cameraPosition[2],
      self.lookAtTarget[0], self.lookAtTarget[1], self.lookAtTarget[2],
      0.0, 1.0, 0.0
    )
@@ -1,80 +0,0 @@
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QGridLayout, QTreeWidget, QTreeWidgetItem, QComboBox
 from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_SHAPES
 class ChunkPanel(QWidget):
  def __init__(self, parent):
    super().__init__(parent)
    self.parent = parent
    layout = QVBoxLayout(self)
    # Tile shape dropdown
    self.tileShapeDropdown = QComboBox()
    self.tileShapeDropdown.addItems(TILE_SHAPES.keys())
    self.tileShapeDropdown.setToolTip("Tile Shape")
    layout.addWidget(self.tileShapeDropdown)
    # Add expandable tree list
    self.tree = QTreeWidget()
    self.tree.setHeaderLabel("Chunks")
    self.tree.expandAll()  # Expand by default, remove if you want collapsed
    layout.addWidget(self.tree)  # Removed invalid stretch factor
    # Add stretch so tree expands
    layout.setStretchFactor(self.tree, 1)
    # Event subscriptions
    self.parent.map.onMapData.sub(self.onMapData)
    self.parent.map.onPositionChange.sub(self.onPositionChange)
    self.tileShapeDropdown.currentTextChanged.connect(self.onTileShapeChanged)
    # For each chunk
    for chunk in self.parent.map.chunks.values():
      # Create tree element
      item = QTreeWidgetItem(self.tree, ["Chunk ({}, {}, {})".format(chunk.x, chunk.y, chunk.z)])
      chunk.chunkPanelTree = item
      chunk.chunkPanelTree.setExpanded(True)
      item.setData(0, 0, chunk)  # Store chunk reference
      chunk.onChunkData.sub(self.onChunkData)
  def onMapData(self, data):
    pass
  def onPositionChange(self, pos):
    self.updateChunkList()
    tile = self.parent.map.getTileAtWorldPos(*self.parent.map.position)
    if tile is None:
      return
    key = "TILE_SHAPE_NULL"
    for k, v in TILE_SHAPES.items():
      if v != tile.shape:
        continue
      key = k
      break
    self.tileShapeDropdown.setCurrentText(key)
  def onTileShapeChanged(self, shape_key):
    tile = self.parent.map.getTileAtWorldPos(*self.parent.map.position)
    if tile is None or shape_key not in TILE_SHAPES:
      return
    tile.setShape(TILE_SHAPES[shape_key])
  def updateChunkList(self):
    # Clear existing items
    currentChunk = self.parent.map.getChunkAtWorldPos(*self.parent.map.position)
    # Example tree items
    for chunk in self.parent.map.chunks.values():
      title = "Chunk ({}, {}, {})".format(chunk.x, chunk.y, chunk.z)
      if chunk == currentChunk:
        title += " [C]"
      if chunk.isDirty():
        title += " *"
      item = chunk.chunkPanelTree
      item.setText(0, title)
  def onChunkData(self, chunk):
    self.updateChunkList()
@@ -1,154 +0,0 @@
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QComboBox, QHBoxLayout, QPushButton, QLineEdit, QListWidget, QListWidgetItem
 from PyQt5.QtCore import Qt
 from tools.dusk.entity import Entity
 from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, ENTITY_TYPES, ENTITY_TYPE_NULL
 class EntityPanel(QWidget):
  def __init__(self, parent):
    super().__init__(parent)
    self.parent = parent
    layout = QVBoxLayout(self)
    self.setLayout(layout)
    # Top panel placeholder
    topWidget = QLabel("Entity Editor")
    layout.addWidget(topWidget)
    # Name input
    nameLayout = QHBoxLayout()
    nameLabel = QLabel("Name:")
    self.nameInput = QLineEdit()
    nameLayout.addWidget(nameLabel)
    nameLayout.addWidget(self.nameInput)
    layout.addLayout(nameLayout)
    # Entity Type dropdown (single selection)
    typeLayout = QHBoxLayout()
    typeLabel = QLabel("Type:")
    self.typeDropdown = QComboBox()
    self.typeDropdown.addItems(ENTITY_TYPES)
    typeLayout.addWidget(typeLabel)
    typeLayout.addWidget(self.typeDropdown)
    layout.addLayout(typeLayout)
    # Entity list and buttons
    self.entityList = QListWidget()
    self.entityList.addItems([])
    layout.addWidget(self.entityList, stretch=1)
    btnLayout = QHBoxLayout()
    self.btnAdd = QPushButton("Add")
    self.btnRemove = QPushButton("Remove")
    btnLayout.addWidget(self.btnAdd)
    btnLayout.addWidget(self.btnRemove)
    layout.addLayout(btnLayout)
    # Events
    self.btnAdd.clicked.connect(self.onAddEntity)
    self.btnRemove.clicked.connect(self.onRemoveEntity)
    self.parent.map.onEntityData.sub(self.onEntityData)
    self.parent.map.onPositionChange.sub(self.onPositionChange)
    self.entityList.itemClicked.connect(self.onEntityClicked)
    self.entityList.itemDoubleClicked.connect(self.onEntityDoubleClicked)
    self.typeDropdown.currentIndexChanged.connect(self.onTypeSelected)
    self.nameInput.textChanged.connect(self.onNameChanged)
    # Call once to populate
    self.onEntityData()
    self.onEntityUnselect()
  def onEntityUnselect(self):
    self.entityList.setCurrentItem(None)
    self.nameInput.setText("")
    self.typeDropdown.setCurrentIndex(ENTITY_TYPE_NULL)
  def onEntitySelect(self, entity):
    self.entityList.setCurrentItem(entity.item)
    self.nameInput.setText(entity.name)
    self.typeDropdown.setCurrentIndex(entity.type)
  def onEntityDoubleClicked(self, item):
    entity = item.data(Qt.UserRole)
    chunk = entity.chunk
    worldX = (chunk.x * CHUNK_WIDTH) + entity.localX
    worldY = (chunk.y * CHUNK_HEIGHT) + entity.localY
    worldZ = (chunk.z * CHUNK_DEPTH) + entity.localZ
    self.parent.map.moveTo(worldX, worldY, worldZ)
  def onEntityClicked(self, item):
    pass
  def onAddEntity(self):
    chunk = self.parent.map.getChunkAtWorldPos(*self.parent.map.position)
    if chunk is None:
      return
    localX = (self.parent.map.position[0] - (chunk.x * CHUNK_WIDTH)) % CHUNK_WIDTH
    localY = (self.parent.map.position[1] - (chunk.y * CHUNK_HEIGHT)) % CHUNK_HEIGHT
    localZ = (self.parent.map.position[2] - (chunk.z * CHUNK_DEPTH)) % CHUNK_DEPTH
    # Make sure there's not already an entity here
    for ent in chunk.entities.values():
      if ent.localX == localX and ent.localY == localY and ent.localZ == localZ:
        print("Entity already exists at this location")
        return
    ent = chunk.addEntity(localX, localY, localZ)
  def onRemoveEntity(self):
    item = self.entityList.currentItem()
    if item is None:
      return
    entity = item.data(Qt.UserRole)
    if entity:
      chunk = entity.chunk
      chunk.removeEntity(entity)
    pass
  def onEntityData(self):
    self.onEntityUnselect()
    self.entityList.clear()
    for chunk in self.parent.map.chunks.values():
      for id, entity in chunk.entities.items():
        item = QListWidgetItem(entity.name)
        item.setData(Qt.UserRole, entity)  # Store the entity object
        entity.item = item
        self.entityList.addItem(item)
    # Select if there is something at current position
    self.onPositionChange(self.parent.map.position)
  def onPositionChange(self, position):
    self.onEntityUnselect()
    # Get Entity at..
    chunk = self.parent.map.getChunkAtWorldPos(*position)
    if chunk is None:
      return
    localX = (position[0] - (chunk.x * CHUNK_WIDTH)) % CHUNK_WIDTH
    localY = (position[1] - (chunk.y * CHUNK_HEIGHT)) % CHUNK_HEIGHT
    localZ = (position[2] - (chunk.z * CHUNK_DEPTH)) % CHUNK_DEPTH
    for ent in chunk.entities.values():
      if ent.localX != localX or ent.localY != localY or ent.localZ != localZ:
        continue
      self.onEntitySelect(ent)
      self.entityList.setCurrentItem(ent.item)
      break
  def onTypeSelected(self, index):
    item = self.entityList.currentItem()
    if item is None:
      return
    entity = item.data(Qt.UserRole)
    if entity:
      entity.setType(index)
  def onNameChanged(self, text):
    item = self.entityList.currentItem()
    if item is None:
      return
    entity = item.data(Qt.UserRole)
    if entity:
      entity.setName(text)
@@ -1,41 +0,0 @@
 from PyQt5.QtCore import QTimer
 from PyQt5.QtWidgets import QOpenGLWidget
 from OpenGL.GL import *
 from OpenGL.GLU import *
 class GLWidget(QOpenGLWidget):
  def __init__(self, parent):
    super().__init__(parent)
    self.parent = parent
    self.timer = QTimer(self)
    self.timer.timeout.connect(self.update)
    self.timer.start(16)  # ~60 FPS
  def initializeGL(self):
    glClearColor(0.392, 0.584, 0.929, 1.0)
    glEnable(GL_DEPTH_TEST)
    glEnable(GL_BLEND)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
    glEnable(GL_POLYGON_OFFSET_FILL)
    glPolygonOffset(1.0, 1.0)
    glDisable(GL_POLYGON_OFFSET_FILL)
  def resizeGL(self, w, h):
    pass
  def paintGL(self):
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
    glLoadIdentity()
    w = self.width()
    h = self.height()
    if h <= 0:
      h = 1
    if w <= 0:
      w = 1
    glViewport(0, 0, w, h)
    self.parent.camera.setup(w, h)
    self.parent.grid.draw()
    self.parent.map.draw()
    self.parent.selectBox.draw()
@@ -1,46 +0,0 @@
 from OpenGL.GL import *
 from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
 class Grid:
  def __init__(self, lines=1000):
    self.cellWidth = TILE_WIDTH
    self.cellHeight = TILE_HEIGHT
    self.lines = lines
    self.enabled = True
  def draw(self):
    if not self.enabled:
      return
    center = [0.01,0.01,0.01]
    halfWidth = self.cellWidth * self.lines // 2
    halfHeight = self.cellHeight * self.lines // 2
    # Draw origin axes
    glBegin(GL_LINES)
    # X axis - RED
    glColor3f(1.0, 0.0, 0.0)
    glVertex3f(center[0] - halfWidth, center[1], center[2])
    glVertex3f(center[0] + halfWidth, center[1], center[2])
    # Y axis - GREEN
    glColor3f(0.0, 1.0, 0.0)
    glVertex3f(center[0], center[1] - halfHeight, center[2])
    glVertex3f(center[0], center[1] + halfHeight, center[2])
    # Z axis - BLUE
    glColor3f(0.0, 0.0, 1.0)
    glVertex3f(center[0], center[1], center[2] - halfWidth)
    glVertex3f(center[0], center[1], center[2] + halfWidth)
    glEnd()
    # Draw grid
    glColor3f(0.8, 0.8, 0.8)
    glBegin(GL_LINES)
    for i in range(-self.lines // 2, self.lines // 2 + 1):
      # Vertical lines
      glVertex3f(center[0] + i * self.cellWidth, center[1] - halfHeight, center[2])
      glVertex3f(center[0] + i * self.cellWidth, center[1] + halfHeight, center[2])
      # Horizontal lines
      glVertex3f(center[0] - halfWidth, center[1] + i * self.cellHeight, center[2])
      glVertex3f(center[0] + halfWidth, center[1] + i * self.cellHeight, center[2])
    glEnd()
@@ -1,83 +0,0 @@
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QLineEdit, QPushButton, QHBoxLayout, QMessageBox
 from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH
 class MapInfoPanel(QWidget):
  def __init__(self, parent):
    super().__init__(parent)
    self.parent = parent
    # Components
    layout = QVBoxLayout()
    mapTitleLabel = QLabel("Map Title")
    self.mapTitleInput = QLineEdit()
    layout.addWidget(mapTitleLabel)
    layout.addWidget(self.mapTitleInput)
    tilePositionLabel = QLabel("Tile Position")
    layout.addWidget(tilePositionLabel)
    tilePositionRow = QHBoxLayout()
    self.tileXInput = QLineEdit()
    self.tileXInput.setPlaceholderText("X")
    tilePositionRow.addWidget(self.tileXInput)
    self.tileYInput = QLineEdit()
    self.tileYInput.setPlaceholderText("Y")
    tilePositionRow.addWidget(self.tileYInput)
    self.tileZInput = QLineEdit()
    self.tileZInput.setPlaceholderText("Z")
    tilePositionRow.addWidget(self.tileZInput)
    self.tileGo = QPushButton("Go")
    tilePositionRow.addWidget(self.tileGo)
    layout.addLayout(tilePositionRow)
    self.chunkPosLabel = QLabel()
    layout.addWidget(self.chunkPosLabel)
    self.chunkLabel = QLabel()
    layout.addWidget(self.chunkLabel)
    layout.addStretch()
    self.setLayout(layout)
    # Events
    self.tileGo.clicked.connect(self.goToPosition)
    self.tileXInput.returnPressed.connect(self.goToPosition)
    self.tileYInput.returnPressed.connect(self.goToPosition)
    self.tileZInput.returnPressed.connect(self.goToPosition)
    self.parent.map.onPositionChange.sub(self.updatePositionLabels)
    self.parent.map.onMapData.sub(self.onMapData)
    self.mapTitleInput.textChanged.connect(self.onMapNameChange)
    # Initial label setting
    self.updatePositionLabels(self.parent.map.position)
  def goToPosition(self):
    try:
      x = int(self.tileXInput.text())
      y = int(self.tileYInput.text())
      z = int(self.tileZInput.text())
      self.parent.map.moveTo(x, y, z)
    except ValueError:
      QMessageBox.warning(self, "Invalid Input", "Please enter valid integer coordinates.")
  def updatePositionLabels(self, pos):
    self.tileXInput.setText(str(pos[0]))
    self.tileYInput.setText(str(pos[1]))
    self.tileZInput.setText(str(pos[2]))
    chunkTileX = pos[0] % CHUNK_WIDTH
    chunkTileY = pos[1] % CHUNK_HEIGHT
    chunkTileZ = pos[2] % CHUNK_DEPTH
    chunkTileIndex = chunkTileX + chunkTileY * CHUNK_WIDTH + chunkTileZ * CHUNK_WIDTH * CHUNK_HEIGHT
    self.chunkPosLabel.setText(f"Chunk Position: {chunkTileX}, {chunkTileY}, {chunkTileZ} ({chunkTileIndex})")
    chunkX = pos[0] // CHUNK_WIDTH
    chunkY = pos[1] // CHUNK_HEIGHT
    chunkZ = pos[2] // CHUNK_DEPTH
    self.chunkLabel.setText(f"Chunk: {chunkX}, {chunkY}, {chunkZ}")
  def onMapData(self, data):
    self.updatePositionLabels(self.parent.map.position)
    self.mapTitleInput.setText(data.get("mapName", ""))
  def onMapNameChange(self, text):
    self.parent.map.data['mapName'] = text
@@ -1,51 +0,0 @@
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QGridLayout, QPushButton, QTabWidget, QLabel
 from tools.editor.map.chunkpanel import ChunkPanel
 from tools.editor.map.entitypanel import EntityPanel
 from tools.editor.map.regionpanel import RegionPanel
 class MapLeftPanel(QWidget):
  def __init__(self, parent):
    super().__init__(parent)
    self.parent = parent
    layout = QVBoxLayout(self)
    self.setLayout(layout)
    # Nav buttons
    self.chunkInfoLabel = QLabel("Tile Information")
    layout.addWidget(self.chunkInfoLabel)
    grid = QGridLayout()
    self.btnUp = QPushButton("U")
    self.btnN = QPushButton("N")
    self.btnDown = QPushButton("D")
    self.btnW = QPushButton("W")
    self.btnS = QPushButton("S")
    self.btnE = QPushButton("E")
    grid.addWidget(self.btnUp, 0, 0)
    grid.addWidget(self.btnN, 0, 1)
    grid.addWidget(self.btnDown, 0, 2)
    grid.addWidget(self.btnW, 1, 0)
    grid.addWidget(self.btnS, 1, 1)
    grid.addWidget(self.btnE, 1, 2)
    layout.addLayout(grid)
    # Panels
    self.chunkPanel = ChunkPanel(self.parent)
    self.entityPanel = EntityPanel(self.parent)
    self.regionPanel = RegionPanel(self.parent)
    # Tabs
    self.tabs = QTabWidget()
    self.tabs.addTab(self.chunkPanel, "Tiles")
    self.tabs.addTab(self.entityPanel, "Entities")
    self.tabs.addTab(self.regionPanel, "Regions")
    self.tabs.addTab(None, "Triggers")
    layout.addWidget(self.tabs)
    # Event subscriptions
    self.btnN.clicked.connect(lambda: self.parent.map.moveRelative(0, -1, 0))
    self.btnS.clicked.connect(lambda: self.parent.map.moveRelative(0, 1, 0))
    self.btnE.clicked.connect(lambda: self.parent.map.moveRelative(1, 0, 0))
    self.btnW.clicked.connect(lambda: self.parent.map.moveRelative(-1, 0, 0))
    self.btnUp.clicked.connect(lambda: self.parent.map.moveRelative(0, 0, 1))
    self.btnDown.clicked.connect(lambda: self.parent.map.moveRelative(0, 0, -1))
@@ -1,46 +0,0 @@
 import os
 from PyQt5.QtWidgets import QAction, QMenuBar, QFileDialog
 from PyQt5.QtGui import QKeySequence
 from tools.dusk.map import MAP_DEFAULT_PATH
 class MapMenubar:
  def __init__(self, parent):
    self.parent = parent
    self.menubar = QMenuBar(parent)
    parent.setMenuBar(self.menubar)
    self.fileMenu = self.menubar.addMenu("File")
    self.actionNew = QAction("New", parent)
    self.actionOpen = QAction("Open", parent)
    self.actionSave = QAction("Save", parent)
    self.actionSaveAs = QAction("Save As", parent)
    self.actionNew.setShortcut(QKeySequence("Ctrl+N"))
    self.actionOpen.setShortcut(QKeySequence("Ctrl+O"))
    self.actionSave.setShortcut(QKeySequence("Ctrl+S"))
    self.actionSaveAs.setShortcut(QKeySequence("Ctrl+Shift+S"))
    self.actionNew.triggered.connect(self.newFile)
    self.actionOpen.triggered.connect(self.openFile)
    self.actionSave.triggered.connect(self.saveFile)
    self.actionSaveAs.triggered.connect(self.saveAsFile)
    self.fileMenu.addAction(self.actionNew)
    self.fileMenu.addAction(self.actionOpen)
    self.fileMenu.addAction(self.actionSave)
    self.fileMenu.addAction(self.actionSaveAs)
  def newFile(self):
    self.parent.map.newFile()
  def openFile(self):
    filePath, _ = QFileDialog.getOpenFileName(self.menubar, "Open Map File", MAP_DEFAULT_PATH, "Map Files (*.json)")
    if filePath:
      self.parent.map.load(filePath)
  def saveFile(self):
    self.parent.map.save()
  def saveAsFile(self):
    filePath, _ = QFileDialog.getSaveFileName(self.menubar, "Save Map File As", MAP_DEFAULT_PATH, "Map Files (*.json)")
    if filePath:
      self.parent.map.save(filePath)
@@ -1,15 +0,0 @@
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QComboBox, QHBoxLayout, QPushButton, QLineEdit, QListWidget, QListWidgetItem
 from PyQt5.QtCore import Qt
 from tools.dusk.entity import Entity
 from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, ENTITY_TYPES, ENTITY_TYPE_NULL
 class RegionPanel(QWidget):
  def __init__(self, parent):
    super().__init__(parent)
    self.parent = parent
    layout = QVBoxLayout(self)
    self.setLayout(layout)
    # Top panel placeholder
    topWidget = QLabel("Region Editor")
    layout.addWidget(topWidget)
@@ -1,44 +0,0 @@
 import OpenGL.GL as gl
 from tools.dusk.defs import defs
 import colorsys
 from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
 class SelectBox:
  def __init__(self, parent):
    self.parent = parent
    self.hue = 0.0
  def draw(self):
    position = [
      self.parent.map.position[0] * TILE_WIDTH - (TILE_WIDTH / 2.0),
      self.parent.map.position[1] * TILE_HEIGHT - (TILE_HEIGHT / 2.0),
      self.parent.map.position[2] * TILE_DEPTH - (TILE_DEPTH / 2.0)
    ]
    vertices = [
      (position[0], position[1], position[2]),
      (position[0]+TILE_WIDTH, position[1], position[2]),
      (position[0]+TILE_WIDTH, position[1]+TILE_HEIGHT, position[2]),
      (position[0], position[1]+TILE_HEIGHT, position[2]),
      (position[0], position[1], position[2]+TILE_DEPTH),
      (position[0]+TILE_WIDTH, position[1], position[2]+TILE_DEPTH),
      (position[0]+TILE_WIDTH, position[1]+TILE_HEIGHT, position[2]+TILE_DEPTH),
      (position[0], position[1]+TILE_HEIGHT, position[2]+TILE_DEPTH)
    ]
    edges = [
      (0, 1), (1, 2), (2, 3), (3, 0),  # bottom face
      (4, 5), (5, 6), (6, 7), (7, 4),  # top face
      (4, 5), (5, 6), (6, 7), (7, 4),  # top face
      (0, 4), (1, 5), (2, 6), (3, 7)   # vertical edges
    ]
    # Cycle hue
    self.hue = (self.hue + 0.01) % 1.0
    r, g, b = colorsys.hsv_to_rgb(self.hue, 1.0, 1.0)
    gl.glColor3f(r, g, b)
    gl.glLineWidth(2.0)
    gl.glBegin(gl.GL_LINES)
    for edge in edges:
      for vertex in edge:
        gl.glVertex3f(*vertices[vertex])
    gl.glEnd()
@@ -1,18 +0,0 @@
 from PyQt5.QtWidgets import QStatusBar, QLabel
 class StatusBar(QStatusBar):
  def __init__(self, parent=None):
    super().__init__(parent)
    self.parent = parent
    self.leftLabel = QLabel("")
    self.rightLabel = QLabel("")
    self.addWidget(self.leftLabel, 1)
    self.addPermanentWidget(self.rightLabel)
    parent.map.onMapData.sub(self.onMapData)
  def setStatus(self, message):
    self.leftLabel.setText(message)
  def onMapData(self, data):
    self.rightLabel.setText(self.parent.map.mapFileName if self.parent.map.mapFileName else "Untitled.json")
@@ -1,80 +0,0 @@
 from OpenGL.GL import *
 import array
 class VertexBuffer:
  def __init__(self, componentsPerVertex=3):
    self.componentsPerVertex = componentsPerVertex
    self.vertices = []
    self.colors = []
    self.uvs = []
    self.data = None
    self.colorData = None
    self.uvData = None
  def buildData(self):
    hasColors = len(self.colors) > 0
    hasUvs = len(self.uvs) > 0
    vertexCount = len(self.vertices) // self.componentsPerVertex
    dataList = []
    colorList = []
    uvList = []
    for i in range(vertexCount):
      vStart = i * self.componentsPerVertex
      dataList.extend(self.vertices[vStart:vStart+self.componentsPerVertex])
      if hasColors:
        cStart = i * 4  # Assuming RGBA
        colorList.extend(self.colors[cStart:cStart+4])
      if hasUvs:
        uStart = i * 2  # Assuming UV
        uvList.extend(self.uvs[uStart:uStart+2])
    self.data = array.array('f', dataList)
    if hasColors:
      self.colorData = array.array('f', colorList)
    else:
      self.colorData = None
    if hasUvs:
      self.uvData = array.array('f', uvList)
    else:
      self.uvData = None
  def draw(self, mode=GL_TRIANGLES, count=-1):
    if count == -1:
      count = len(self.data) // self.componentsPerVertex
    if count == 0:
      return
    glEnableClientState(GL_VERTEX_ARRAY)
    glVertexPointer(self.componentsPerVertex, GL_FLOAT, 0, self.data.tobytes())
    if self.colorData:
      glEnableClientState(GL_COLOR_ARRAY)
      glColorPointer(4, GL_FLOAT, 0, self.colorData.tobytes())
    if self.uvData:
      glEnableClientState(GL_TEXTURE_COORD_ARRAY)
      glTexCoordPointer(2, GL_FLOAT, 0, self.uvData.tobytes())
    glDrawArrays(mode, 0, count)
    glDisableClientState(GL_VERTEX_ARRAY)
    if self.colorData:
      glDisableClientState(GL_COLOR_ARRAY)
    if self.uvData:
      glDisableClientState(GL_TEXTURE_COORD_ARRAY)
  def clear(self):
    self.vertices = []
    self.colors = []
    self.uvs = []
    self.data = array.array('f')
    self.colorData = None
    self.uvData = None
@@ -1,143 +0,0 @@
 import os
 from PyQt5.QtWidgets import QMainWindow, QWidget, QHBoxLayout, QMessageBox
 from PyQt5.QtCore import Qt
 from tools.editor.map.glwidget import GLWidget
 from tools.editor.map.mapleftpanel import MapLeftPanel
 from tools.editor.map.mapinfopanel import MapInfoPanel
 from tools.editor.map.menubar import MapMenubar
 from tools.editor.map.statusbar import StatusBar
 from tools.dusk.map import Map
 from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_SHAPE_NULL, TILE_SHAPE_FLOOR
 from tools.editor.map.selectbox import SelectBox
 from tools.editor.map.camera import Camera
 from tools.editor.map.grid import Grid
 class MapWindow(QMainWindow):
  def __init__(self):
    super().__init__()
    self.insertPressed = False
    self.deletePressed = False
    # Subclasses
    self.map = Map(self)
    self.camera = Camera(self)
    self.grid = Grid()
    self.selectBox = SelectBox(self)
    # Window setup
    self.setWindowTitle("Dusk Map Editor")
    self.resize(1600, 900)
    # Menubar (TESTING)
    self.menubar = MapMenubar(self)
    central = QWidget()
    self.setCentralWidget(central)
    mainLayout = QHBoxLayout(central)
    # Left panel (tabs + nav buttons)
    self.leftPanel = MapLeftPanel(self)
    self.leftPanel.setFixedWidth(350)
    mainLayout.addWidget(self.leftPanel)
    # Center panel (GLWidget + controls)
    self.glWidget = GLWidget(self)
    mainLayout.addWidget(self.glWidget, stretch=3)
    # Right panel (MapInfoPanel)
    self.mapInfoPanel = MapInfoPanel(self)
    rightWidget = self.mapInfoPanel
    rightWidget.setFixedWidth(250)
    mainLayout.addWidget(rightWidget)
    # Status bar
    self.statusBar = StatusBar(self)
    self.setStatusBar(self.statusBar)
    self.installEventFilter(self)
    self.installEventFilterRecursively(self)
  def installEventFilterRecursively(self, widget):
    for child in widget.findChildren(QWidget):
      child.installEventFilter(self)
      self.installEventFilterRecursively(child)
  def closeEvent(self, event):
    if not self.map.isDirty():
      event.accept()
      return
    reply = QMessageBox.question(
      self,
      "Unsaved Changes",
      "You have unsaved changes. Do you want to save before closing?",
      QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel,
      QMessageBox.Save
    )
    if reply == QMessageBox.Save:
      self.map.save()
    elif reply == QMessageBox.Cancel:
      event.ignore()
      return
    event.accept()
  def eventFilter(self, obj, event):
    if event.type() == event.KeyPress:
      amtX, amtY, amtZ = 0, 0, 0
      key = event.key()
      if key == Qt.Key_Left:
        amtX = -1
      elif key == Qt.Key_Right:
        amtX = 1
      elif key == Qt.Key_Up:
        amtY = -1
      elif key == Qt.Key_Down:
        amtY = 1
      elif key == Qt.Key_PageUp:
        amtZ = 1
      elif key == Qt.Key_PageDown:
        amtZ = -1
      if event.modifiers() & Qt.ShiftModifier:
        amtX *= CHUNK_WIDTH
        amtY *= CHUNK_HEIGHT
        amtZ *= CHUNK_DEPTH
      if amtX != 0 or amtY != 0 or amtZ != 0:
        self.map.moveRelative(amtX, amtY, amtZ)
        if self.insertPressed:
          tile = self.map.getTileAtWorldPos(*self.map.position)
          if tile is not None and tile.shape == TILE_SHAPE_NULL:
            tile.setShape(TILE_SHAPE_FLOOR)
        if self.deletePressed:
          tile = self.map.getTileAtWorldPos(*self.map.position)
          if tile is not None:
            tile.setShape(TILE_SHAPE_NULL)
        event.accept()
        return True
      if key == Qt.Key_Delete:
        tile = self.map.getTileAtWorldPos(*self.map.position)
        self.deletePressed = True
        if tile is not None:
          tile.setShape(TILE_SHAPE_NULL)
        event.accept()
        return True
      if key == Qt.Key_Insert:
        tile = self.map.getTileAtWorldPos(*self.map.position)
        self.insertPressed = True
        if tile is not None and tile.shape == TILE_SHAPE_NULL:
          tile.setShape(TILE_SHAPE_FLOOR)
        event.accept()
    elif event.type() == event.KeyRelease:
      key = event.key()
      if key == Qt.Key_Delete:
        self.deletePressed = False
        event.accept()
        return True
      if key == Qt.Key_Insert:
        self.insertPressed = False
        event.accept()
    return super().eventFilter(obj, event)
@@ -1,13 +0,0 @@
 # 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
    assettexture.c
    assettileset.c
    assetlanguage.c
    assetscript.c
 )
@@ -1,45 +0,0 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "asset/asset.h"
 #include "assert/assert.h"
 #include "locale/localemanager.h"
 errorret_t assetLanguageHandler(assetcustom_t custom) {
  assertNotNull(custom.zipFile, "Custom asset zip file cannot be NULL");
  assertNotNull(custom.output, "Custom asset output cannot be NULL");
  assetlanguage_t *lang = (assetlanguage_t *)custom.output;
  errorChain(assetLanguageInit(lang, custom.zipFile));
  errorOk();
 }
 errorret_t assetLanguageInit(
  assetlanguage_t *lang,
  zip_file_t *zipFile
 ) {
  errorThrow("Language asset initialization is not yet implemented.");
 }
 errorret_t assetLanguageRead(
  assetlanguage_t *lang,
  const uint32_t key,
  char_t *buffer,
  const uint32_t bufferSize,
  uint32_t *outLength
 ) {
  errorThrow("Language string reading is not yet implemented.");
 }
 void assetLanguageDispose(assetlanguage_t *lang) {
  assertNotNull(lang, "Language asset cannot be NULL");
  if(lang->zip) {
    zip_fclose(lang->zip);
  }
 }
@@ -1,61 +0,0 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "error/error.h"
 #include "duskdefs.h"
 #include <zip.h>
 typedef struct {
  zip_file_t *zip;
  zip_int64_t chunksOffset;
 } assetlanguage_t;
 typedef struct assetcustom_s assetcustom_t;
 /**
 * Receiving function from the asset manager to handle language assets.
 * 
 * @param custom Custom asset loading data.
 * @return Error code.
 */
 errorret_t assetLanguageHandler(assetcustom_t custom);
 /**
 * Initializes a language asset and loads the header data into memory.
 * 
 * @param lang Language asset to initialize.
 * @param zipFile Zip file handle for the language asset.
 * @return Error code.
 */
 errorret_t assetLanguageInit(assetlanguage_t *lang, zip_file_t *zipFile);
 /**
 * Reads a string from the language asset into the provided buffer.
 * 
 * @param lang Language asset to read from.
 * @param key Language key to read.
 * @param buffer Buffer to read the string into.
 * @param bufferSize Size of the provided buffer.
 * @param outLength Pointer to store the length of the string read.
 * @return Error code.
 */
 errorret_t assetLanguageRead(
  assetlanguage_t *lang,
  const uint32_t key,
  char_t *buffer,
  const uint32_t bufferSize,
  uint32_t *outLength
 );
 /**
 * Disposes of language asset resources.
 * 
 * @param custom Custom asset loading data.
 * @return Error code.
 */
 void assetLanguageDispose(assetlanguage_t *lang);
@@ -1,58 +0,0 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "asset/asset.h"
 #include "assert/assert.h"
 errorret_t assetScriptHandler(assetcustom_t custom) {
  assertNotNull(custom.zipFile, "Custom asset zip file cannot be NULL");
  assertNotNull(custom.output, "Custom asset output cannot be NULL");
  assetscript_t *script = (assetscript_t *)custom.output;
  errorChain(assetScriptInit(script, custom.zipFile));
  errorOk();
 }
 errorret_t assetScriptInit(
  assetscript_t *script,
  zip_file_t *zipFile
 ) {
  assertNotNull(script, "Script asset cannot be NULL");
  assertNotNull(zipFile, "Zip file cannot be NULL");
  // We now own the zip file handle.
  script->zip = zipFile;
  errorOk();
 }
 const char_t * assetScriptReader(lua_State* lState, void* data, size_t* size) {
  assetscript_t *script = (assetscript_t *)data;
  zip_int64_t bytesRead = zip_fread(
    script->zip, script->buffer, sizeof(script->buffer)
  );
  if(bytesRead < 0) {
    *size = 0;
    return NULL;
  }
  *size = (size_t)bytesRead;
  return script->buffer;
 }
 errorret_t assetScriptDispose(assetscript_t *script) {
  assertNotNull(script, "Script asset cannot be NULL");
  if(script->zip != NULL) {
    zip_fclose(script->zip);
    script->zip = NULL;
  }
  errorOk();
 }
@@ -1,57 +0,0 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "error/error.h"
 #include "duskdefs.h"
 #include <zip.h>
 #include "script/scriptcontext.h"
 #define ASSET_SCRIPT_BUFFER_SIZE 1024
 typedef struct assetscript_s {
  zip_file_t *zip;
  char_t buffer[ASSET_SCRIPT_BUFFER_SIZE];
 } assetscript_t;
 typedef struct assetcustom_s assetcustom_t;
 /**
 * Receiving function from the asset manager to handle script assets.
 * 
 * @param custom Custom asset loading data.
 * @return Error code.
 */
 errorret_t assetScriptHandler(assetcustom_t custom);
 /**
 * Initializes a script asset.
 * 
 * @param script Script asset to initialize.
 * @param zipFile Zip file handle for the script asset.
 * @return Error code.
 */
 errorret_t assetScriptInit(assetscript_t *script, zip_file_t *zipFile);
 /**
 * Reader function for Lua to read script data from the asset.
 * 
 * @param L Lua state.
 * @param data Pointer to the assetscript_t structure.
 * @param size Pointer to store the size of the read data.
 * @return Pointer to the read data buffer.
 */
 const char_t * assetScriptReader(lua_State* L, void* data, size_t* size);
 /**
 * Disposes of a script asset, freeing any allocated resources.
 * 
 * @param script Script asset to dispose of.
 * @return Error code.
 */
 errorret_t assetScriptDispose(assetscript_t *script);
@@ -1,78 +0,0 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "assettexture.h"
 #include "asset/assettype.h"
 #include "assert/assert.h"
 #include "display/texture/texture.h"
 #include "util/endian.h"
 errorret_t assetTextureLoad(assetentire_t entire) {
  assertNotNull(entire.data, "Data pointer cannot be NULL.");
  assertNotNull(entire.output, "Output pointer cannot be NULL.");
  assettexture_t *assetData = (assettexture_t *)entire.data;
  texture_t *texture = (texture_t *)entire.output;
  // Read header and version (first 4 bytes)
  if(
    assetData->header[0] != 'D' || 
    assetData->header[1] != 'T' ||
    assetData->header[2] != 'X'
  ) {
    errorThrow("Invalid texture header");
  }
  // Version (can only be 1 atm)
  if(assetData->version != 0x01) {
    errorThrow("Unsupported texture version");
  }
  // Fix endian
  assetData->width = endianLittleToHost32(assetData->width);
  assetData->height = endianLittleToHost32(assetData->height);
  // Check dimensions.
  if(
    assetData->width == 0 || assetData->width > ASSET_TEXTURE_WIDTH_MAX ||
    assetData->height == 0 || assetData->height > ASSET_TEXTURE_HEIGHT_MAX
  ) {
    errorThrow("Invalid texture dimensions");
  }
  // Validate format
  textureformat_t format;
  texturedata_t data;
  switch(assetData->type) {
    case 0x00: // RGBA8888
      format = TEXTURE_FORMAT_RGBA;
      data.rgbaColors = (color_t *)assetData->data;
      break;
    // case 0x01:
    //   format = TEXTURE_FORMAT_RGB;
    //   break;
    // case 0x02:
    //   format = TEXTURE_FORMAT_RGB565;
    //   break;
    // case 0x03:
    //   format = TEXTURE_FORMAT_RGB5A3;
    //   break;
    default:
      errorThrow("Unsupported texture format");
  }
  errorChain(textureInit(
    texture, assetData->width, assetData->height, format, data
  ));
  errorOk();
 }
@@ -1,39 +0,0 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "error/error.h"
 #include "display/color.h"
 #define ASSET_TEXTURE_WIDTH_MAX 2048
 #define ASSET_TEXTURE_HEIGHT_MAX 2048
 #define ASSET_TEXTURE_SIZE_MAX ( \
  ASSET_TEXTURE_WIDTH_MAX * ASSET_TEXTURE_HEIGHT_MAX \
 )
 typedef struct assetentire_s assetentire_t;
 #pragma pack(push, 1)
 typedef struct {
  char_t header[3];
  uint8_t version;
  uint8_t type;
  uint32_t width;
  uint32_t height;
  uint8_t data[ASSET_TEXTURE_SIZE_MAX * sizeof(color4b_t)];
 } assettexture_t;
 #pragma pack(pop)
 /**
 * Loads a palettized texture from the given data pointer into the output
 * texture.
 *
 * @param data Pointer to the raw assettexture_t data.
 * @param output Pointer to the texture_t to load the image into.
 * @return An error code.
 */
 errorret_t assetTextureLoad(assetentire_t entire);
@@ -1,70 +0,0 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "asset/asset.h"
 #include "assert/assert.h"
 #include "display/texture/tileset.h"
 #include "util/memory.h"
 #include "util/endian.h"
 errorret_t assetTilesetLoad(assetentire_t entire) {
  assertNotNull(entire.data, "Asset data cannot be null");
  assertNotNull(entire.output, "Asset output cannot be null");
  assettileset_t *tilesetData = (assettileset_t *)entire.data;
  tileset_t *tileset = (tileset_t *)entire.output;
  if(
    tilesetData->header[0] != 'D' || 
    tilesetData->header[1] != 'T' ||
    tilesetData->header[2] != 'F'
  ) {
    errorThrow("Invalid tileset header");
  }
  if(tilesetData->version != 0x00) {
    errorThrow("Unsupported tileset version");
  }
  // Fix endianness
  tilesetData->tileWidth = endianLittleToHost16(tilesetData->tileWidth);
  tilesetData->tileHeight = endianLittleToHost16(tilesetData->tileHeight);
  tilesetData->columnCount = endianLittleToHost16(tilesetData->columnCount);
  tilesetData->rowCount = endianLittleToHost16(tilesetData->rowCount);
  tilesetData->right = endianLittleToHost16(tilesetData->right);
  tilesetData->bottom = endianLittleToHost16(tilesetData->bottom);
  if(tilesetData->tileWidth == 0) {
    errorThrow("Tile width cannot be 0");
  }
  if(tilesetData->tileHeight == 0) {
    errorThrow("Tile height cannot be 0");
  }
  if(tilesetData->columnCount == 0) {
    errorThrow("Column count cannot be 0");
  }
  if(tilesetData->rowCount == 0) {
    errorThrow("Row count cannot be 0");
  }
  tilesetData->u0 = endianLittleToHostFloat(tilesetData->u0);
  tilesetData->v0 = endianLittleToHostFloat(tilesetData->v0);
  if(tilesetData->v0 < 0.0f || tilesetData->v0 > 1.0f) {
    errorThrow("Invalid v0 value in tileset");
  }
  // Setup tileset
  tileset->tileWidth = tilesetData->tileWidth;
  tileset->tileHeight = tilesetData->tileHeight;
  tileset->tileCount = tilesetData->columnCount * tilesetData->rowCount;
  tileset->columns = tilesetData->columnCount;
  tileset->rows = tilesetData->rowCount;
  tileset->uv[0] = tilesetData->u0;
  tileset->uv[1] = tilesetData->v0;
  errorOk();
 }
@@ -1,32 +0,0 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "error/error.h"
 #pragma pack(push, 1)
 typedef struct {
  char_t header[3];
  uint8_t version;
  uint16_t tileWidth;
  uint16_t tileHeight;
  uint16_t columnCount;
  uint16_t rowCount;
  uint16_t right;
  uint16_t bottom;
  float_t u0;
  float_t v0;
 } assettileset_t;
 #pragma pack(pop)
 /**
 * Loads a tileset from the given data pointer into the output tileset.
 *
 * @param entire Data received from the asset loader system.
 * @return An error code.
 */
 errorret_t assetTilesetLoad(assetentire_t entire);
@@ -1,6 +0,0 @@
 # Copyright (c) 2025 Dominic Masters
 # 
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 add_subdirectory(testmap)
@@ -1,6 +0,0 @@
 # Copyright (c) 2025 Dominic Masters
 # 
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 add_asset(MAP testmap.json)
@@ -1 +0,0 @@
 {"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
@@ -1 +0,0 @@
 {"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
@@ -1 +0,0 @@
 {"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
@@ -1 +0,0 @@
 {"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
@@ -1 +0,0 @@
 {"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
@@ -1 +0,0 @@
 {"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
@@ -1 +0,0 @@
 {"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 2, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
@@ -1 +0,0 @@
 {"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
@@ -1 +0,0 @@
 {"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
@@ -1 +0,0 @@
 {"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
@@ -1 +0,0 @@
 {"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}
@@ -1 +0,0 @@
 {"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}
@@ -1,3 +0,0 @@
 {
  "name": "Test"
 }
@@ -1,49 +0,0 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "script/scriptcontext.h"
 #include "debug/debug.h"
 #include "assert/assert.h"
 #include "rpg/overworld/map.h"
 int moduleMapLoad(lua_State *L) {
  assertNotNull(L, "Lua state cannot be NULL");
  if(!lua_isstring(L, 1)) {
    luaL_error(L, "Expected string map filename");
    return 0;
  }
  // Potentially provide up to 3 params
  chunkpos_t initial = { .x = 0, .y = 0, .z = 0 };
  if(lua_isnumber(L, 2)) {
    initial.x = (chunkunit_t)lua_tonumber(L, 2);
  }
  if(lua_isnumber(L, 3)) {
    initial.y = (chunkunit_t)lua_tonumber(L, 3);
  }
  if(lua_isnumber(L, 4)) {
    initial.z = (chunkunit_t)lua_tonumber(L, 4);
  }
  // Load the map.
  errorret_t ret = mapLoad(luaL_checkstring(L, 1), initial);
  if(ret.code != ERROR_OK) {
    luaL_error(L, "Failed to load map");
    errorCatch(errorPrint(ret));
    return 0;
  }
  return 0;
 }
 void moduleMapSystem(scriptcontext_t *context) {
  assertNotNull(context, "Script context cannot be NULL");
  lua_register(context->luaState, "mapLoad", moduleMapLoad);
 }
@@ -1,28 +0,0 @@
 # 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)
@@ -1,23 +0,0 @@
 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
@@ -1,116 +0,0 @@
 /**
 * 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();
 }
@@ -1,65 +0,0 @@
 /**
 * 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);
@@ -1,17 +0,0 @@
 /**
 * 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,12 +0,0 @@
 # 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
    sdl2.c
    psp.c
    dolphin.c
 )
@@ -1,92 +0,0 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "dolphin.h"
 void displayInitDolphin(void) {
  VIDEO_Init();
  DISPLAY.screenMode = VIDEO_GetPreferredMode(NULL);
  DISPLAY.frameBuffer[0] = MEM_K0_TO_K1(
    SYS_AllocateFramebuffer(DISPLAY.screenMode)
  );
  DISPLAY.frameBuffer[1] = MEM_K0_TO_K1(
    SYS_AllocateFramebuffer(DISPLAY.screenMode)
  );
  VIDEO_Configure(DISPLAY.screenMode);
  VIDEO_SetNextFramebuffer(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer]);
  // VIDEO_SetPostRetraceCallback(copy_buffers);
  VIDEO_SetBlack(FALSE);
  VIDEO_Flush();
  VIDEO_WaitVSync();
  if(DISPLAY.screenMode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync();
  DISPLAY.fifoBuffer = memalign(32, DISPLAY_FIFO_SIZE);
  memoryZero(DISPLAY.fifoBuffer, DISPLAY_FIFO_SIZE);
  GX_Init(DISPLAY.fifoBuffer, DISPLAY_FIFO_SIZE);
  // This seems to be mostly related to interlacing vs progressive
  GX_SetViewport(
    0, 0,
    DISPLAY.screenMode->fbWidth, DISPLAY.screenMode->efbHeight,
    0, 1
  );
  float_t yscale = GX_GetYScaleFactor(
    DISPLAY.screenMode->efbHeight, DISPLAY.screenMode->xfbHeight
  );
  uint32_t xfbHeight = GX_SetDispCopyYScale(yscale);
  GX_SetScissor(
    0, 0,
    DISPLAY.screenMode->fbWidth, DISPLAY.screenMode->efbHeight
  );
  GX_SetDispCopySrc(
    0, 0,
    DISPLAY.screenMode->fbWidth, DISPLAY.screenMode->efbHeight
  );
  GX_SetDispCopyDst(DISPLAY.screenMode->fbWidth, xfbHeight);
  GX_SetCopyFilter(
    DISPLAY.screenMode->aa,
    DISPLAY.screenMode->sample_pattern,
    GX_TRUE,
    DISPLAY.screenMode->vfilter
  );
  GX_SetFieldMode(
    DISPLAY.screenMode->field_rendering,
    (
      (DISPLAY.screenMode->viHeight == 2 * DISPLAY.screenMode->xfbHeight) ?
      GX_ENABLE :
      GX_DISABLE
    )
  );
  // Setup cull modes
  GX_SetCullMode(GX_CULL_NONE);
  GX_SetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
  GX_CopyDisp(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer], GX_TRUE);
  GX_SetDispCopyGamma(GX_GM_1_0);
  GX_ClearVtxDesc();
  GX_SetVtxDesc(GX_VA_POS,  GX_INDEX16);
  GX_SetVtxDesc(GX_VA_CLR0, GX_INDEX16);
  GX_SetVtxDesc(GX_VA_TEX0, GX_INDEX16);
  GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
  GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_U8, 0);
  GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
 }
 void displayDolphinSwap(void) {
  GX_DrawDone();
  DISPLAY.whichFrameBuffer ^= 1;
  GX_SetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
  GX_SetColorUpdate(GX_TRUE);
  GX_CopyDisp(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer], GX_TRUE);
  VIDEO_SetNextFramebuffer(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer]);
  VIDEO_Flush();
  VIDEO_WaitVSync();
 }
@@ -1,27 +0,0 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "dusk.h"
 #include "display/displaydefs.h"
 typedef struct {
  void *frameBuffer[2];// Double-Bufferred
  int whichFrameBuffer;
  GXRModeObj *screenMode;
  void *fifoBuffer;
 } displaydolphin_t;
 /**
 * Initializes the display for Dolphin.
 */
 void displayDolphinInit(void);
 /**
 * Swaps the back buffer to the front for Dolphin.
 */
 void displayDolphinSwap(void);
@@ -1,12 +0,0 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "psp.h"
 void displayInitPSP(void) {
  DISPLAY.usingShaderedPalettes = false;
 }
@@ -1,13 +0,0 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 /**
 * Initializes the display for PSP.
 */
 void displayInitPSP(void);
@@ -1,32 +0,0 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "sdl2.h"
 void displaySDL2Update(void) {
 }
 void displaySDL2Swap(void) {
  SDL_GL_SwapWindow(DISPLAY.window);
  GLenum err;
  while((err = glGetError()) != GL_NO_ERROR) {
    debugPrint("GL Error: %d\n", err);
  }
 }
 void displaySDL2Dispose(void) {
  if(DISPLAY.glContext) {
    SDL_GL_DeleteContext(DISPLAY.glContext);
    DISPLAY.glContext = NULL;
  }
  if(DISPLAY.window) {
    SDL_DestroyWindow(DISPLAY.window);
    DISPLAY.window = NULL;
  }
  SDL_Quit();
 }
@@ -1,35 +0,0 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "dusk.h"
 typedef struct {
  SDL_Window *window;
  SDL_GLContext glContext;
  bool_t usingShaderedPalettes;
 } displaysdl2_t;
 /**
 * Initializes the display for SDL2.
 */
 void displaySDL2Init(void);
 /**
 * Updates the display for SDL2.
 */
 void displaySDL2Update(void);
 /**
 * Swaps the display buffers for SDL2.
 */
 void displaySDL2Swap(void);
 /**
 * Disposes of the display for SDL2.
 */
 void displaySDL2Dispose(void);
@@ -1,17 +0,0 @@
 # 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
    rpg.c
    rpgcamera.c
    rpgtextbox.c
 )
 # Subdirs
 add_subdirectory(cutscene)
 add_subdirectory(entity)
 add_subdirectory(overworld)
@@ -1,14 +0,0 @@
 # 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
    cutscenesystem.c
    cutscenemode.c
 )
 # Subdirs
 add_subdirectory(item)
@@ -1,14 +0,0 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "rpg/cutscene/item/cutsceneitem.h"
 typedef struct cutscene_s {
  const cutsceneitem_t *items;
  uint8_t itemCount;
 } cutscene_t;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
YourWishes	24631990bd	Fixed dolphin aspect ratio	2026-06-25 22:47:23 -05:00
YourWishes	0c8c0d24ba	fix chunk loading based on player position	2026-06-25 22:29:13 -05:00
YourWishes	454b8a91ba	Fixed dolphin ratioing	2026-06-25 22:21:12 -05:00
YourWishes	a74f1568e9	Small improvements to performance	2026-06-25 21:30:44 -05:00
YourWishes	3f35d56be4	UI Frame finally doing things	2026-06-25 20:58:44 -05:00
YourWishes	722fe2ccfb	Some label fixes	2026-06-25 19:56:14 -05:00
YourWishes	d85737cc08	UI menu	2026-06-25 19:35:33 -05:00
YourWishes	ce29435831	Example settings more or less done, showing full ui example basically.	2026-06-25 18:34:49 -05:00
YourWishes	d3715eece8	Time and tick helpers	2026-06-25 18:16:46 -05:00
YourWishes	335d79f2c4	NUked archive	2026-06-25 18:01:11 -05:00
YourWishes	a9e33660cb	UI Frame	2026-06-25 15:33:17 -05:00
YourWishes	8faf881399	Bit if UI cleanup	2026-06-25 14:56:48 -05:00
YourWishes	c4969a36cc	Add UI cropping	2026-06-25 12:13:04 -05:00
YourWishes	26fcaf6e75	Restored some stuff	2026-06-25 11:53:15 -05:00
		`@@ -1 +0,0 @@`
			{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}