Extract player entity setup into a Player class

Moves the capsule/physics/renderable/PLAYER setup out of overworldscene.js's inline init() into assets/scripts/Player.js so the scene module just instantiates it.
Add UDP socket client/server multiplayer protocol
2026-08-02 21:06:31 -05:00 · 2026-08-02 21:06:23 -05:00 · 2026-07-31 15:02:17 -05:00 · 2026-07-31 13:53:06 -05:00 · 2026-07-31 13:21:57 -05:00 · 2026-07-31 09:40:53 -05:00
969 changed files with 50310 additions and 16743 deletions
@@ -0,0 +1,858 @@
+# Dusk Code Check
+
+A working checklist for walking through `src/dusk/` (the core, platform-
+agnostic engine layer) one subsystem at a time and reviewing how it
+actually looks today -- not just what it's supposed to do. Pairs with
+`STATUS.md` (maturity snapshot) and `ROADMAP.md` (forward-looking work);
+this doc is about auditing what's already there.
+
+Each section below: **Purpose**, **Key files**, and a **Review status**
+line to fill in as each system gets walked through (e.g. `Not started` /
+`In progress` / `Reviewed 2026-08-01: <one-line finding>`).
+
+First full pass completed 2026-08-01 (all 23 sections below reviewed).
+See "Top cross-cutting findings" right after the index for the
+highest-priority items across all of them before diving into any one
+section -- this doc is long, don't make someone read all 23 to find
+the load-bearing bugs.
+
+Game-specific code lives in `src/duskrpg/` (not covered here) and
+platform-specific implementations live in `src/dusk<platform>/` /
+`src/duskgl/` / `src/dusksdl2/` (also not covered here) -- see `CLAUDE.md`
+for the layer structure.
+
+---
+
+## Index
+
+- [error](#error)
+- [assert](#assert)
+- [util](#util)
+- [event](#event)
+- [time](#time)
+- [thread](#thread)
+- [log](#log)
+- [system](#system)
+- [console](#console)
+- [asset](#asset)
+- [locale](#locale)
+- [save](#save)
+- [network](#network)
+- [display](#display)
+- [ui](#ui)
+- [entity](#entity)
+- [scene](#scene)
+- [physics](#physics)
+- [animation](#animation)
+- [script](#script)
+- [input](#input)
+- [engine](#engine)
+- [game](#game)
+
+---
+
+## Top cross-cutting findings
+
+Ranked roughly by real-world impact, not by section order. Each links
+to its full writeup below.
+
+1. **Bounds/capacity checks that matter at runtime are `assert*` calls,
+   which compile to no-ops in release (`DUSK_ASSERTIONS_FAKED`, set
+   whenever `NDEBUG` is defined) -- confirmed by reading `assert.h`
+   directly.** This shows up in [entity](#entity) (`entitymanager.c`,
+   `component.c` -- reachable from JerryScript via `moduleentity.c`
+   with no return-value check) and [scene](#scene) (`sceneCreate`'s
+   pool-exhaustion path, reachable from `new Scene()`). Untrusted
+   script input can silently get back an invalid ID that later indexes
+   a fixed array out of bounds in a release build -- the exact
+   "validate untrusted data with errorThrow, not asserts" case
+   CLAUDE.md/project memory already calls out, just not applied here.
+2. **FIXED 2026-08-01.** `util/ref.c`'s `refUnlock` decremented an
+   unsigned `count` guarded only by a tautological `count >= 0` assert
+   ([util](#util)) -- a double-unlock silently underflowed to
+   `UINT32_MAX` instead of tripping an assert. This wasn't just a
+   `util/` nit: it's the lock/unlock primitive `asset/loader/assetentry.c`
+   builds on (see [asset](#asset)), so an over-unlocked asset entry
+   became permanently un-reapable rather than erroring loudly. Now
+   asserts `count > 0` before decrementing; the pointless
+   `count >= 0` check in `refLock` was removed too.
+3. **`texture.c:42-52`'s `textureInit()` reads `texture->format` to
+   decide which `data` fields to validate *before* the struct is
+   zeroed a few lines later** ([display](#display)) -- it's validating
+   whatever stale value happened to be in the caller's (possibly
+   stack) memory, not the `format` parameter actually being requested.
+4. **FIXED 2026-08-01 (confirmed real before fixing).** PSP's
+   `timeGetRealTimeZonePSP` returned hours; every other platform
+   (`timeGetRealTimeZoneLinux`/Dolphin) returns seconds, and
+   `timeEpochInit`/`timeEpochGetHours` etc. add the timezone value
+   directly to a Unix-epoch-seconds timestamp -- confirmed by reading
+   all three platform implementations plus `timeepoch.c` directly, not
+   just trusting the review agent's claim. The PSP function's own
+   comment even said "Return timezone offset in hours". Now divides by
+   `1000000.0` only (microseconds -> seconds), matching the other
+   platforms. See [time](#time).
+5. **Discussed, not changed.** `consolePrint` aborts the process (via
+   `stringFormatVA`'s `assert(ret < destSize)`) instead of truncating
+   when a single debug line exceeds 511 bytes. This is a real, if rare,
+   crash risk (any format producing >511 bytes of runtime-variable
+   content -- a long path, a long error string -- takes the whole
+   process down over a debug print), but changing `stringFormatVA`
+   itself would affect every caller in the codebase, and a
+   console-local truncating rewrite is easy to do wrong (vsnprintf
+   directly, bypassing the project's string-utils convention) without
+   more time to get right. Left as-is pending a decision on which
+   fix shape is wanted. See [console](#console).
+6. **FIXED 2026-08-01.** `thread.c`'s `threadHandler` signaled
+   `THREAD_STATE_STOPPED` before resetting `threadId = 0`, and
+   `threadStartRequest` wasn't synchronized against that reset -- a
+   real (if rare-window) race, not hypothetical: the test suite was
+   already working around it by re-calling `threadInit()` instead of
+   exercising true stop/start reuse. `threadId` is now reset inside the
+   same mutex-locked section before the STOPPED signal/unlock;
+   `test_thread_restart` now loops 20x on the same `thread_t` without
+   re-initializing, which would have caught the old race. See
+   [thread](#thread).
+7. **FIXED 2026-08-01.** `tools/color.py` emitted invalid C float
+   literals (`0f`, `1f`, etc.) for any whole-number CSV channel --
+   confirmed by actually running the generator against `color.csv`
+   before and after. Was dormant only because `COLOR_*_3F`/`_4F` were
+   unreferenced anywhere in the repo; the first real use of a float
+   color variant wouldn't have compiled. Now routes channel values
+   through Python `float()` before interpolating (always stringifies
+   with a decimal point, e.g. `0.0`/`1.0`), and `test/display/test_color.c`
+   gained two tests that reference `COLOR_BLACK_3F`/`COLOR_WHITE_4F`/
+   `COLOR_RED_3B`/`COLOR_GRAY_3F` directly -- giving the previously-dead
+   generated macros real compile-time + value coverage instead of
+   silently bit-rotting again. See [display](#display).
+8. **`assetModelLoaderAsync` is confirmed fully dead** -- model loading
+   is genuinely synchronous end-to-end (verified by tracing the state
+   machine, not just repeating STATUS.md's claim). See [asset](#asset).
+9. **No cycle guard on prefab `extends` chains** in
+   `scenePrefabResolveAndApply` -- a self-referencing or A->B->A prefab
+   table is a stack-overflow crash from what looks like a harmless
+   typo in hand-authored data. See [scene](#scene).
+10. **Untested-code hot spots worth prioritizing** if test investment
+    is on the table: `util/ref.c`/`random.c`/`crypt.c`/`endian.c`
+    (zero tests), `animation/easing.c` (13 of 16 functions untested),
+    `event/`, `console/`, `system/`, `log/`, `input/`, `engine/`,
+    `locale/`, `save/`, and most of `display/` (mesh, shader, texture,
+    tileset, text, screen, framebuffer) have no dedicated tests at
+    all.
+
+Convention-only items (real, but lower stakes than the above): raw
+stdlib string functions (`strlen`/`strchr`/`strstr`/etc.) show up
+instead of `util/string.h` wrappers in `network/http/` and
+`asset/loader/locale/assetlocaleloader.c` ([network](#network),
+[asset](#asset)); several `display/mesh/` files use `//` header
+comments and `/* */` inline comments where CLAUDE.md wants the
+opposite ([display](#display)); `animation/`'s core files all use `//`
+copyright headers instead of `/** */` ([animation](#animation)).
+
+---
+
+## error
+
+**Purpose:** The engine's single error-handling convention. Every
+fallible function returns `errorret_t`, built with `errorOk()` /
+`errorThrow(fmt, ...)` / `errorChain(call)` and consumed with
+`errorIsOk()`/`errorIsNotOk()`/`errorCatch()`. No `errno`, no raw error
+codes anywhere else in the engine.
+
+**Key files:** `error.c/h`.
+
+**Review status:** Reviewed 2026-08-01. Solid, and tested unusually well
+(`test/error/test_error.c` covers thread isolation and concurrent
+throws, not just happy path). Two issues: `errorChainImpl` (error.c:86-91)
+hand-rolls `snprintf`/`strlen` instead of `util/string.h`'s
+`stringFormat`/`stringFormatVA` wrappers that `errorThrowImpl` uses one
+function above it -- an inconsistency, not just a style nit, since
+CLAUDE.md requires the wrappers everywhere. `errorThrowWithCode`
+(error.h:100) is dead code -- zero call sites anywhere in `src/`/`test/`.
+
+---
+
+## assert
+
+**Purpose:** Debug-time invariant checks -- `assertNotNull`, `assertTrue`,
+`assertFalse`, `assertUnreachable`, `assertIsMainThread`. Distinct from
+`error/`: asserts are for programmer mistakes/invariants, `errorret_t` is
+for runtime-recoverable failures (see `CLAUDE.md`'s note on validating
+untrusted data with `errorThrow` rather than asserting).
+
+**Key files:** `assert.c/h`.
+
+**Review status:** Reviewed 2026-08-01. Clean, no issues found. Impl
+functions + macros wrapping `__FILE__`/`__LINE__` and a proper
+`DUSK_ASSERTIONS_FAKED` no-op path for release builds;
+`assertNotNullImpl` (assert.c:109-111) does a real "touch" dereference
+after the null check as a belt-and-braces addition. Test coverage
+exercises both success and `expect_assert_failure` failure paths for
+every variant, including `assertDeprecated`/`assertIsMainThread`.
+
+---
+
+## util
+
+**Purpose:** Small stand-alone helpers with no engine-state dependencies:
+`array` (dynamic array), `crypt` (hashing/checksum), `endian` (byte-order
+swap), `math` (clamp/lerp/pow2/etc.), `memory` (`memoryAllocate`/`Free`/
+`Zero`/`Copy`/`Compare` -- the only allocator the rest of the engine is
+allowed to call directly), `random`, `ref` (refcounted handle with
+lock/unlock callbacks), `sort` (bubble sort used for one-time static list
+ordering), `string` (`stringCopy`/`Compare`/`Format`/etc. -- required in
+place of libc `str*` functions per `CLAUDE.md`).
+
+**Key files:** `array.c/h`, `crypt.c/h`, `endian.c/h`, `math.c/h`,
+`memory.c/h`, `random.c/h`, `ref.c/h`, `sort.c/h`, `string.c/h`.
+
+**Review status:** Reviewed 2026-08-01. Several real issues, worst was
+in `ref.c`: `refUnlock` (ref.c:37-39) decremented `count` (`uint32_t`)
+guarded only by `assertTrue(ref->count >= 0, ...)` -- tautologically
+always true on an unsigned type, so a double-unlock silently underflowed
+to `UINT32_MAX` and kept invoking `onUnlock` instead of tripping an
+assert (confirmed by reading ref.c directly). **Fixed 2026-08-01** --
+`refUnlock` now asserts `count > 0` before decrementing; also fixed
+`refInit`'s doc comment, which claimed a fresh ref starts at count 1
+when the code has always started it at 0. Same tautological unsigned
+`>= 0` assert remains in `memory.c:98` (lower stakes -- `memoryFree`'s
+own counter, not a shared lock/unlock primitive other subsystems build
+on -- left as-is). `memory.h:11` declares
+`static size_t MEMORY_POINTERS_IN_USE = 0;` directly in the header --
+confirmed present -- meaning every TU including it gets its own private
+copy (only "works" because the accessors all live in memory.c).
+`random.c`'s `randomInt` (confirmed, random.c:15-16) does
+`rand() % (max - min)` with no `max > min` check (UB on `max <= min`),
+and `srand()` is never called anywhere in the repo -- unseeded,
+deterministic RNG. `sort.c:1` has `#include <stdlib.h>` before the
+copyright header (confirmed). Test coverage: array/math/memory/sort/
+string are thorough; `ref.c`, `random.c`, `crypt.c`, `endian.c` have
+**zero** tests. `randomInt`/`randomFloat` also appear unused
+engine-wide (dead code, not just untested).
+
+---
+
+## event
+
+**Purpose:** Generic pub/sub primitive -- `event_t` wraps a caller-owned
+array of `eventcallback_t`/user-pointer pairs; `eventInit`/`eventSubscribe`/
+`eventInvoke`. Used for things like `uifullbox_t`'s transition-end
+callback and `uiloading_t`'s show/hide callbacks. Per `STATUS.md`: "Clean,
+small, finished", built to replace the old input system's callback
+pattern.
+
+**Key files:** `event.c/h`.
+
+**Review status:** Reviewed 2026-08-01. Well-formed -- correctly uses
+swap-with-last for O(1) unsubscribe, asserts on capacity overflow and
+duplicate-subscribe, no dead code (`eventUnsubscribe` used in 3 other
+files). No `errorret_t` needed here since these are programmer-error
+assertions rather than runtime-data validation, consistent with
+CLAUDE.md's assert-vs-error guidance. One gap: `test/event/` doesn't
+exist -- zero unit coverage, including the capacity-exceeded and
+double-subscribe assert paths.
+
+---
+
+## time
+
+**Purpose:** Frame delta/elapsed time (`TIME.delta`, exposed to JS via
+`moduleTime`) plus `timeepoch_t` wall-clock timestamps (used by
+`uifps.c` for the FPS counter).
+
+**Key files:** `time.c/h`, `timeepoch.c/h`.
+
+**Review status:** Reviewed 2026-08-01. `time.c:52-56` unconditionally
+formats an epoch string into a 256-byte stack buffer every single
+`timeUpdate()` call purely to feed a commented-out `consolePrint` --
+burns the leap-year/day-counting loop three times a frame for a
+discarded value. `timeepoch.c`'s day-counting loops have no
+handling/guard for negative epoch/timezone values (pre-1970). Test
+coverage is solid for `time.c` (mocked ticks, boundary/backwards-time
+cases) but `timeepoch.c`'s date math (leap year, rollover, format
+specifiers) has no dedicated tests despite being the more bug-prone
+half. The PSP-specific timezone unit bug flagged in the cross-cutting
+findings (#4) was confirmed and fixed 2026-08-01 --
+`timeGetRealTimeZonePSP` was returning hours where `timeepoch.c`
+expects seconds.
+
+---
+
+## thread
+
+**Purpose:** Thin cross-platform thread/mutex/thread-local wrappers.
+Used by the asset system's background loading and the POSIX console's
+input-polling thread.
+
+**Key files:** `thread.c/h`, `threadmutex.c/h`, `threadlocal.h`.
+
+**Review status:** Reviewed 2026-08-01. Conventions followed
+throughout. Real race condition, **fixed 2026-08-01**: `threadHandler`
+used to unlock `stateMutex` and signal `THREAD_STATE_STOPPED` *before*
+resetting `thread->threadId = 0`, but `threadStartRequest` asserts
+`threadId == 0` with no synchronization against that reset --
+`threadStop()` immediately followed by `threadStart()` on the same
+struct could intermittently trip the assert. Telling sign it was real,
+not theoretical: `test/thread/test_thread.c` already re-called
+`threadInit()` before restarting specifically "so threadId/state are
+reset" -- the test suite was working around the bug rather than
+exercising true reuse. `threadId` is now reset inside the same
+mutex-locked section, before the signal/unlock; the test now loops
+stop/start 20x on the same `thread_t` with no `threadInit()` in
+between. Otherwise test coverage is good (real pthreads, try-lock
+coordination, a 4-thread x 10k-iteration mutex contention test).
+
+---
+
+## log
+
+**Purpose:** `logDebug`/`logError` -- the engine's only print/debug-output
+path. Header-only declarations; each platform provides the actual
+implementation (see `src/dusk<platform>/log/`).
+
+**Key files:** `log.h` (declarations only, no `.c` in core).
+
+**Review status:** Reviewed 2026-08-01. Clean 2-function API; all
+three platform implementations (`dusklinux`, `duskpsp`, `duskdolphin`)
+match the declared signatures with correct `va_copy` usage for the
+dual stdout+file writes. Dolphin's `logError` correctly falls back to
+raw VIDEO/console init when the framebuffer isn't ready yet and blocks
+on a START-button dismiss loop; PSP writes to
+`ms0:/PSP/GAME/Dusk/*.log`. No bugs found. No `test/log/` exists --
+understandable for I/O/side-effect code, but zero coverage.
+
+---
+
+## system
+
+**Purpose:** Very early engine init (`systemInit`), the
+`systemplatform_t` enum (via the `systemplatformlist.h` X-macro pattern),
+and native OS dialog boxes (`systemdialogtype_t`: render-blocking vs
+tick-blocking).
+
+**Key files:** `system.c/h`, `systemplatformlist.h`.
+
+**Review status:** Reviewed 2026-08-01. X-macro platform enum and
+compile-time `#error` guards for missing platform macros used
+correctly; all three platforms define the required
+`systemInitPlatform`/`systemGetActiveDialogTypePlatform`/
+`systemGetCyclesPlatform`. Dead code confirmed: `systemPSPGetLanguage()`
+(`duskpsp/system/systempsp.c:51`) and `systemGetLanguageDolphin()`
+(`duskdolphin/system/systemdolphin.c:40`) are defined but never called
+anywhere -- likely intended for locale wiring that hasn't landed. No
+`test/system/` exists.
+
+---
+
+## console
+
+**Purpose:** In-engine dev console: fixed-size scrollback
+(`CONSOLE_HISTORY_MAX` lines x `CONSOLE_LINE_MAX` chars), `consolePrint`,
+a `dirty` flag consumers (namely `ui/debug/uiconsole.c`) watch to know
+when to rebuild their own cached representation. POSIX builds also poll
+stdin on a background thread for interactive script execution.
+
+**Key files:** `console.c/h`, `consoledefs.h`.
+
+**Review status:** Reviewed 2026-08-01. Two real issues. `consolePrint`
+(console.c:32-44) gets its length from `stringFormatVA(buffer,
+CONSOLE_LINE_MAX, ...)`, and `stringFormatVA` (util/string.c:100)
+**asserts** `ret < destSize` rather than truncating -- so any single
+debug line over 511 bytes aborts the process instead of just getting
+cut off, a harsh failure mode for a dev console. Separately,
+`consoleUpdate`'s doc ("Processes pending queued script lines") and
+`CONSOLE_EXEC_BUFFER_MAX` (consoledefs.h:12) describe a queued-script-
+execution feature that doesn't exist -- `console_t` has no exec-queue
+fields, `consoleUpdate` only toggles `visible`, and
+`CONSOLE_EXEC_BUFFER_MAX` is unreferenced elsewhere (dead constant,
+stale doc). No `test/console/` exists.
+
+---
+
+## asset
+
+**Purpose:** The asset pipeline: `dusk.dsk` zip archive reading
+(`assetfile.c/h`), lock/ref-counted entries (`asset/loader/assetentry.c/h`,
+built on `util/ref.h`), batch loading (`assetbatch.c/h`), and the loader
+registry (`asset/loader/assetloader.c/h`, plus one subfolder per loader
+type: `dmf/` mesh+model, `display/` texture+tileset, `locale/`, `json/`,
+`animation/`). See `CLAUDE.md`'s "Adding a new asset loader type" for the
+extension pattern. Per `STATUS.md`: model loading's "async" path is
+actually synchronous -- the one known stub in core.
+
+**Key files:** `asset.c/h`, `assetfile.c/h`, `assetbatch.c/h`,
+`loader/assetentry.c/h`, `loader/assetloader.c/h`.
+
+**Review status:** Reviewed 2026-08-01. Core is well-structured and the
+multi-pass reaper correctly handles parent/child dependency chains.
+Found: `assetFileInit` (assetfile.c:29) has `if(!zip_stat(...) == 0)` --
+precedence makes this `(!zip_stat(...)) == 0`, which happens to
+evaluate correctly for zip's 0/nonzero convention but reads as broken
+and should just be `zip_stat(...) != 0`. More seriously,
+`assetEntryLock`/`Unlock` sit on top of `util/ref.c`'s confirmed
+double-unlock underflow bug (see **util** above) -- an over-unlocked
+asset entry silently becomes un-reapable forever instead of asserting.
+**Confirmed via code-trace** (not just citing STATUS.md):
+`assetModelLoaderAsync` (assetmodelloader.c:19-23) is genuinely dead --
+`assetEntryStartLoading` unconditionally sets
+`ASSET_ENTRY_STATE_PENDING_SYNC`, and `assetModelLoaderSync`'s state
+machine never transitions to `PENDING_ASYNC` the way mesh/texture/
+tileset/locale/json/animation all do, so model loading runs fully
+synchronously via `assetRequireLoaded`'s busy-loop; grep confirms
+`assetModelLoaderAsync` has no callers. `assetlocaleloader.c` uses raw
+stdlib (`strstr`/`strncmp`/`strchr`/`strtol`/`atoi`) instead of
+`util/string.h` wrappers throughout, and tests line-prefixes via
+`memoryCompare(lineBuffer, "msgid", 5)` without confirming the reused
+stack buffer actually holds 5 valid bytes at that point -- a short line
+could spuriously prefix-match against stale buffer contents. Test
+coverage: good breadth for entry lifecycle, tileset/JSON/animation
+loaders, and locale parsing; no dedicated tests for mesh/model/texture
+loader internals or `assetfile.c`'s line reader.
+
+---
+
+## locale
+
+**Purpose:** Active-locale tracking (`LOCALE.locale`/`LOCALE.entry`) over
+`.po`-derived locale assets loaded through the asset system. See
+`assets/locale/en_US.po` -- per memory, currently placeholder/test
+content, not real shipped game text.
+
+**Key files:** `localemanager.c/h`, `localeinfo.h`.
+
+**Review status:** Reviewed 2026-08-01. Clean, no bugs found --
+correctly balances `assetEntryLock`/`Unlock` in both `SetLocale` and
+`Dispose` (unlocks the old entry before adopting the new one). Minor
+nit: `localeinfo.h` declares `static const localeinfo_t` globals
+(`LOCALE_EN_US` etc.) directly in the header, so every including TU
+gets its own duplicate copy -- harmless given how few TUs include it.
+No `test/locale/` directory; `test/asset/test_assetlocale.c` tests the
+loader, not `localemanager.c` itself.
+
+---
+
+## save
+
+**Purpose:** Slot-based save data (`SAVE_FILE_COUNT_MAX` fixed slots),
+yyjson documents persisted with size + CRC32 checksum. `saveLoad`/
+`saveSave` read/write JSON fresh every call; callers own the returned
+doc and must free it. Actual file I/O goes through platform stream hooks
+(`saveplatform_t`, one impl per platform) -- core `save.c` must never
+touch the filesystem directly. `savesettings.c/h` layers engine settings
+(display/audio/input/general) on top. Per `CLAUDE.md`: "mature, but
+undocumented" beyond the one paragraph there -- no tests.
+
+**Key files:** `save.c/h`, `savefile.h`, `savestream.c/h`,
+`savesettings.c/h`.
+
+**Review status:** Reviewed 2026-08-01. Clean and convention-compliant
+-- `save.c` genuinely never touches the filesystem directly (every I/O
+path goes through `saveXxxPlatform` macros, all three platforms define
+them), yyjson doc ownership is honored at every call site checked, and
+CRC32 is validated before parsing with every error path freeing `buf`.
+One real gap: `saveFileLoad`'s `memoryAllocate(file->size)`
+(savestream.c:122) allocates straight from an on-disk size field with
+no sanity bound before the allocation -- a corrupted/tampered save
+could request an oversized allocation, worth a max-size guard given the
+"never trust incoming data" principle (arguably applies to save files,
+not just network packets). Confirmed no `test/save/` exists. `saveDelete`/
+`saveExists`/`saveGet` are public API not yet called anywhere in the
+repo -- likely just unconsumed so far, not truly dead.
+
+---
+
+## network
+
+**Purpose:** Connection-state layer only (`networkstate_t`:
+`DISCONNECTED`/`CONNECTING`/`CONNECTED`/`DISCONNECTING`) plus a one-off
+HTTP client (`network/http/`: request/header/URL/thread/process split
+across files). **Not** a multiplayer/replication protocol yet -- that's
+`ROADMAP.md` items 8-17. Platform-specific connection polling (PSP's
+`sceNetApctl`, GameCube/Wii's `if_config()`) lives under
+`src/dusk<platform>/network/`. Has HTTP tests only (`test/network/http/`).
+
+**Key files:** `network.c/h`, `networkinfo.c/h`, `http/networkhttp.c/h`,
+`http/networkhttprequest.c/h`, `http/networkhttpthread.c/h`.
+
+**Review status:** Reviewed 2026-08-01. Genuinely stays a thin
+connection-state layer (grepped for "packet"/"replicat"/"multiplayer"/
+"udp" -- no hits, no scope creep). The HTTP client correctly validates
+untrusted server input with `errorThrow` rather than trusting it
+(malformed status lines, oversized headers, bad `Content-Length`,
+early-closed connections all throw) -- exactly what CLAUDE.md calls
+out. `networkhttpthread.c`'s request handoff is actually correct
+despite request fields being written outside the mutex: the final
+`state = PENDING` write happens under the same mutex the worker
+acquires, giving a valid release/acquire handoff (worth a comment, not
+a bug). One recurring convention violation:
+`networkhttpprocess.c`/`networkhttpurl.c` use raw stdlib
+`strlen`/`strchr`/`strstr`/`strncasecmp`/`strcspn` instead of
+`util/string.h` wrappers in several places -- `util/string.h` currently
+has no direct substitute for `strchr`/`strstr`/`strcspn`, so this may
+be a missing-utility gap rather than pure oversight. No leaks found
+(request/response bodies freed exactly once via
+`networkHttpRequestReset`, redirect loop frees the intermediate body).
+Real test coverage exists: `test/network/http/test_networkhttp.c` runs
+six tests against a fake loopback server (GET/POST/PUT, query encoding,
+redirects, connection-refused), each asserting zero leaked allocations.
+
+---
+
+## display
+
+**Purpose:** The engine's most mature, most-optimized subsystem --
+platform-agnostic rendering built on top of `duskgl`/`duskdolphin`.
+Subfolders: `mesh/` (primitive builders: cube/sphere/capsule/plane/
+triprism/quad, plus the shared `meshvertex_t`/`mesh_t` API), `shader/`
+(currently one material type, unlit), `spritebatch/` (the shared
+`SPRITEBATCH_SPRITES_MAX`-capacity quad batcher everything 2D goes
+through -- flushes on shader/material change), `texture/` (texture +
+tileset + palette), `text/` (`font_t`/`FONT_DEFAULT`'s baked-in bitmap
+glyphs, `textBuildSpriteCache`/`textDrawSpriteCache`'s build-once/
+translate-per-frame pattern), `screen/` (scan-safe area), `framebuffer/`.
+`color.csv` + `tools/color/csv/__main__.py` code-generate `color.h` --
+never hand-edit the generated header.
+
+**Key files:** `display.c/h`, `mesh/mesh.c/h`, `spritebatch/spritebatch.c/h`,
+`spritebatch/spritebatchsprite.c/h`, `text/font.c/h`, `text/text.c/h`,
+`texture/texture.c/h`, `texture/tileset.c/h`, `shader/shader.c/h`.
+
+**Review status:** Reviewed 2026-08-01. "Most mature" oversold it
+slightly -- real bugs found, several confirmed by direct read:
+- **texture.c:42-52 (confirmed)** -- `textureInit()` branches on
+  `texture->format` to validate the incoming `data` union *before*
+  `memoryZero(texture, ...)` runs a few lines later, so it's reading
+  whatever stale/uninitialized value was already in the caller's
+  struct, not the `format` parameter actually being requested.
+  Validation is effectively checking garbage.
+- `spritebatchsprite.c:20-25` -- `spriteBatchSpriteTilesetPosition`'s
+  zero-width/height early return zeroes `sprite.min`/`max` but leaves
+  `uvMin`/`uvMax` uninitialized (stack garbage); the existing
+  zero-size test doesn't check uv fields, so this isn't caught.
+- `mesh.c:43` -- `meshFlush`'s offset assert (`vertexOffset <
+  vertCount - 1`) wrongly rejects a valid offset at the very last
+  vertex; off-by-one.
+- `text.c:34-37` -- bounds assert uses `tileIndex <= tileCount`
+  (should be `<`), currently unreachable in practice since a preceding
+  clamp already guards it, but the assert itself is wrong.
+- `framebuffer.c:23-28` -- `frameBufferBind(NULL)` recurses into
+  binding the backbuffer without `errorChain`, discarding any failure
+  and unconditionally returning `errorOk()`.
+- `displayInit()`'s six static "SIMPLE" primitive meshes
+  (quad/cube/sphere/plane/capsule/triprism) are never disposed in
+  `displayDispose()` -- one VBO+VAO leaked per primitive on the
+  non-legacy GL path.
+- **Confirmed and fixed 2026-08-01.** `tools/color.py` (not the
+  `tools/color/csv/__main__.py` path CLAUDE.md's doc comment names --
+  that's a stale path, only a `__pycache__/` remnant exists there; the
+  live script is `tools/color.py`) emitted invalid C float literals
+  for whole-number CSV channels (`0`, `1` -- every black/white/primary
+  color), e.g. `color3f(0f, 0f, 0f)`. Was harmless *only* because
+  `COLOR_*_3F`/`_4F` were never referenced anywhere in `src/`/`test/`
+  -- confirmed by actually running the generator before and after the
+  fix, not just reading the source. Now routes channel values through
+  Python `float()` first (always stringifies with a decimal point);
+  `test/display/test_color.c` gained tests referencing
+  `COLOR_BLACK_3F`/`COLOR_WHITE_4F`/`COLOR_RED_3B`/`COLOR_GRAY_3F`
+  directly so the previously-dead macros now have real compile-time +
+  value coverage.
+- Style drift: `mesh.h` uses `//` header comments instead of `/** */`;
+  sphere/capsule/triprism use `/* */` block comments inside function
+  bodies where CLAUDE.md mandates `//`; every primitive builder's
+  JSDoc still documents a `@param color` that no longer exists in the
+  signature (leftover from before color moved out of `meshvertex_t`).
+- The primitive `*Buffer()` flexible-geometry functions (sphereBuffer,
+  capsuleBuffer, etc.) are confirmed unused outside their own
+  `*Init()` -- only the fixed default mesh instances are actually
+  consumed (via `script/module/display/modulemesh.c`).
+
+Test coverage: `test/display/` only registers `test_color.c` and
+`test_spritebatchsprite.c` -- mesh/shader/texture/tileset/palette/text/
+font/screen/framebuffer all have zero unit tests.
+
+---
+
+## ui
+
+**Purpose:** Flat, static, singleton-driven widget framework -- no scene
+graph. Top level is a compile-time X-macro registry
+(`uielementlist.h`/`uielement.c/h`) of `{init, update, draw, dispose,
+order}` tuples (screens: frame/confirm/settings/overlays/console/fps),
+spliced with `duskrpg`'s own list. Composition below that is `uimenu_t`
+(`widget/uimenu.c/h`) -- a flat tagged-union array of widgets laid out in
+a simple row/column grid via the `MENU_*` authoring macros; no nesting.
+Widgets: `uilabel`/`uiwidgetlabel` (cached glyph sprites, the pattern
+every other widget's text now uses), `uibutton`, `uicheckbox`,
+`uislider`, `uidropdown`, `uitab`, `uiscrolling` (empty placeholder).
+`focus/` is the gamepad/keyboard directional-navigation stack (no mouse/
+pointer hit-testing exists anywhere). `frame/` is the 9-slice box plus
+the confirm dialog and settings screens. `overlay/` is fullscreen
+fades/loading/crop bars. `debug/` is the FPS counter and dev console
+renderer.
+
+As of 2026-07-31: slider/tab/frame (`uiFrameDrawCached`)/duskrpg's
+textbox all cache their sprite geometry instead of rebuilding it every
+frame; console uses a fixed-size vertex buffer instead of alloc/free.
+Still open: sprite-batch flushes are keyed on material/color, so
+per-widget highlight-color changes still force a flush per widget (see
+`ROADMAP.md` item 5 in the debt backlog). No JS bindings exist for UI
+yet. `test/ui/`/`test/display/test_spritebatchsprite.c` cover the new
+caching *logic* only -- nothing exercises real `uiXxxDraw()` calls, since
+those need a live GL context (`FONT_DEFAULT`/`UI_FRAME` textures) this
+repo's test binaries don't have.
+
+**Key files:** `ui.c/h`, `uielement.c/h`, `focus/uifocus.c/h`,
+`widget/uimenu.c/h`, `widget/uilabel.c/h`, `frame/uiframe.c/h`,
+`debug/uiconsole.c/h`.
+
+**Review status:** Reviewed 2026-07-31 (this session's sprite-caching
+pass) -- see notes above; per-material flush granularity and hit-testing
+still open.
+
+---
+
+## entity
+
+**Purpose:** Fixed-size-array ECS. `entitymanager_t` owns
+`ENTITY_COUNT_MAX` entities, each with up to `ENTITY_COMPONENT_COUNT_MAX`
+components stored in a tagged union (`componentdata_t` -- flagged in
+`PSP_OPTIMIZATION_PLAN.md` as the biggest PSP memory-waste candidate,
+since every entity reserves space for every component type's largest
+variant). `componentlist.h`'s `X()` macro auto-generates the component
+enum/union/dispatch table from `entity/component/**`; engine-level
+`entityprefablist.h` is an empty sentinel (real prefabs live in
+`duskrpg/entity/entityprefablist.h`, resolved via
+`entityPrefabResolveAndApply`). No JSON serialize/deserialize (removed by
+design in favor of C-coded prefabs or JerryScript `Entity`/`Component`).
+
+**Key files:** `entitymanager.c/h`, `entity.c/h`, `component.c/h`,
+`componentlist.h`, `entityprefab.c/h`.
+
+**Review status:** Reviewed 2026-08-01. Structurally sound (sentinel
+prefab list, X-macro shape both match CLAUDE.md), but there's a real
+security-relevant gap: **every capacity/bounds guard
+(`entitymanager.c:35`, `entity.c:56`, `component.c:37-39,58-62,75-76,
+140-141`) is an `assert*` call**, and `assert.h` compiles these to
+`((void)0)` under `DUSK_ASSERTIONS_FAKED` (auto-set whenever `NDEBUG`
+is defined -- confirmed by reading assert.h directly, this is a real
+release-mode no-op, not a hypothetical). `moduleentity.c:30,67` create
+entities/components from JerryScript with no return-value check, so a
+script that exceeds `ENTITY_COUNT_MAX`/the per-entity component cap
+silently gets back an invalid ID in release builds, which then indexes
+fixed arrays out-of-bounds later. This directly contradicts the
+project's own "untrusted-data limits need errorThrow, not asserts"
+guidance -- and script input is about as untrusted as it gets. Minor:
+`component.h:100`/`component.c:52` misplace the `*` in `void *
+componentGetData(`. Dead code: `entityUpdateRemove`/
+`entityDisposeRemove`/`entityDisposeAdd` have zero call sites.
+
+---
+
+## scene
+
+**Purpose:** Same shape as `entity/` one level up -- `SCENE_COUNT_MAX`
+fixed-count scenes, each an isolated entity-manager pool; engine-level
+`sceneprefablist.h` is an empty sentinel (real prefabs in
+`duskrpg/scene/`). As of the `Scene.set()` work (2026-07-31), JerryScript
+can install a `{init, update, dispose}` module as the active scene via
+`modulescene.c`'s `moduleSceneSetStatic`/`moduleSceneUpdateCurrent`/
+`moduleSceneTeardownCurrent` (see `script` below) -- scene IDs are reused
+from a small pool immediately after `sceneDestroy`, so don't assume a
+freshly created scene has a "new" ID.
+
+**Key files:** `scene.c/h`, `scenebase.h`, `sceneprefab.c/h`.
+
+**Review status:** Reviewed 2026-08-01. Shares entity/'s assert-not-
+errorThrow bounds gap (`sceneCreate` hits `assertUnreachable` then
+falls through to `SCENE_ID_INVALID` on pool exhaustion in release --
+reachable from `new Scene()` in JS). Additional finding:
+`scenePrefabResolveAndApply`/`scenePrefabInit` (sceneprefab.c:31-54)
+recurse through a prefab's `extends` chain with **no cycle guard** -- a
+self-referencing or A→B→A prefab table causes unbounded recursion/
+stack overflow from what's otherwise a one-typo mistake in a
+hand-authored prefab list. No dead code, no use-after-free. Tests cover
+create/destroy/isolation/update cadence well but have zero coverage for
+pool exhaustion, `sceneRender()`, or `sceneprefab.c` (no prefab test
+file exists at all).
+
+---
+
+## physics
+
+**Purpose:** `physicsworld_t` step simulation over `physicsbodytype_t`
+(static/dynamic/kinematic) and `physicshapetype_t` (cube/sphere/capsule/
+plane/custom, plus mesh shapes via `physicsshapemesh.c/h`).
+`triggersystem.c/h` layers trigger-volume enter/exit events on top. Per
+`STATUS.md`: "mature, recently churned" -- a revert/re-disable of "old
+ent code" suggests component wiring isn't fully settled yet. Well
+tested (`test/physics/`).
+
+**Key files:** `physicsworld.c/h`, `physicsbodytype.h`, `physicsshape.h`,
+`physicsshapemesh.c/h`, `triggersystem.c/h`.
+
+**Review status:** Reviewed 2026-08-01. `STATUS.md`'s "component
+wiring isn't fully settled" caveat looks stale on closer look:
+`physicsWorldStep`/`triggerSystemStep` are live-wired in `scene.c:89-90`
+and `duskrpg`'s player prefab actively uses both PHYSICS and TRIGGER --
+no `#if 0`/TODO/commented-out code found; the disable-then-revert in
+history reads like a same-day whole-ECS revert, not something
+physics-specific. Two real bugs found instead:
+`physicsbodytype.h:23-27` documents kinematic bodies as capable of
+being a player controller, but `physicsworld.c:124,166-167` only ever
+writes `onGround` for the dynamic side of a collision pair -- a
+kinematic controller's `onGround` is permanently false (latent today,
+since the one existing player prefab uses DYNAMIC, not KINEMATIC).
+`physicstest.c:213`'s barycentric interior-test branch has no guard
+against a zero-area triangle (divide-by-zero/NaN risk in mesh-sphere
+collision). Dead code: `physicsShapeMeshCreate` (mesh-terrain
+collision) has zero production callers despite being well-tested in
+isolation; `entityPhysicsGetShape`/`GetCollideMask` are unwired to the
+JS module. Test depth is genuinely strong for what's implemented
+(gravity convergence, dynamic-vs-dynamic separation, mask filtering,
+mesh sphere/capsule resting) -- "well tested" is earned for the
+features that exist, though the unused mesh-collision path and
+missing trigger→JS bridge mean the subsystem's *integration* maturity
+is a bit narrower than its test depth suggests.
+
+---
+
+## animation
+
+**Purpose:** Keyframe + easing only -- no blend trees or state machines
+yet. `keyframe_t`/`keyframeset_t` interpolate values over time via
+`easing.c/h`'s easing functions; `animation.c/h` ties a keyframe set to
+playback state. Per `STATUS.md`: terse commit history ("ANIM") suggests
+still iterating.
+
+**Key files:** `animation.c/h`, `easing.c/h`, `keyframe.c/h`,
+`keyframeset.c/h`.
+
+**Review status:** Reviewed 2026-08-01. All 8 core files use `//`
+copyright headers instead of the required `/** */` block, inconsistent
+with the correctly-formatted `entityanimation.{c,h}` next door. Math
+checks out: all 16 easing functions satisfy f(0)=0/f(1)=1 with no
+precision issues, and keyframe interpolation clamps (doesn't
+extrapolate) outside the time range with no reachable divide-by-zero
+-- though it doesn't validate that keyframe times are ascending. 15 of
+16 `easing.h` declarations lack Javadoc. Biggest gap: **no
+`test_easing.c` exists** -- only linear/in-quad get incidental coverage
+via `test_keyframe.c`, so 13 of 16 easing functions are completely
+untested. Dead code (test-only, unused by any `duskrpg` game code):
+`keyframeSetGetValues`, `keyframeSetFireCallback`, `animationSetEvent`,
+`entityAnimationSetKeyframes`/`GetValue`.
+
+---
+
+## script
+
+**Purpose:** Embedded JerryScript integration. `scriptmanager.c/h` owns
+the JerryScript context lifecycle and the exec/call helpers
+(`scriptManagerExec`/`ExecFile`/`CallGlobal`/`CallValue`, the last two
+sharing exception + promise-draining logic). `scriptproto.c/h` is the
+`scriptproto_t` prototype-wrapping helper every module builds on.
+`module/` holds each registered JS-facing module:
+- `modulebase.h` -- the shared macro toolkit (`moduleBaseFunction`,
+  `moduleBaseRequireArgs`/`RequireString`/etc., `moduleBaseDefineProp`/
+  `Func`/`StaticFunc`, `moduleBaseSetWrappedPointer`, `moduleBaseThrowError`).
+- `moduleplatform.h`, `entity/moduleentity.c/h` +
+  `entity/component/*` (generic `Component` plus typed Position/Physics/
+  Renderable wrappers via `modulecomponentlist.c/h`), `scene/modulescene.c/h`
+  (`Scene`, including `Scene.set()`), `display/modulemesh.c/h`,
+  `time/moduletime.c/h`, `require/modulerequire.c/h` (CommonJS-style
+  `require()`/`module.exports`, with a directory stack for relative
+  resolution -- `scriptManagerExecFile` now pushes its own file's
+  directory before exec so a top-level entry script's relative
+  `require()` calls resolve correctly).
+- `modulelist.c/h` -- registers/disposes every module above in order;
+  `moduleListDispose()` is now actually called from
+  `scriptManagerDispose()` (was a latent bug -- it wasn't, until
+  2026-07-31).
+
+Entry point convention: `assets/scripts/init.js` does
+`require('./scenefile.js')` + `Scene.set(module)`. Has unit tests
+(`test/script/`), including one that reads the real shipped
+`overworldscene.js` off disk rather than an embedded copy.
+
+**Key files:** `scriptmanager.c/h`, `scriptproto.c/h`,
+`module/modulebase.h`, `module/modulelist.c/h`,
+`module/require/modulerequire.c/h`, `module/scene/modulescene.c/h`.
+
+**Review status:** Reviewed 2026-07-31 (this session's Scene.set() +
+require()-dir-stack work) -- see notes above.
+
+---
+
+## input
+
+**Purpose:** Bind-based input (`inputaction.c/h` maps
+`INPUT_BIND_*` names to raw `inputbutton_t`s per platform), with a
+configurable analog deadzone. Platform button/axis backends live under
+`src/dusk<platform>/input/`; capability macros (`DUSK_INPUT_GAMEPAD`/
+`KEYBOARD`/`POINTER`) gate what's available per target. Pointer axis
+values are plumbed through (`DUSK_INPUT_POINTER`), but nothing in `ui/`
+consumes them yet -- no hit-testing exists (see `ui` above).
+
+**Key files:** `input.c/h`, `inputaction.c/h`, `inputbutton.c/h`.
+
+**Review status:** Reviewed 2026-08-01. Clean and convention-compliant;
+deadzone math (`inputDeadzone`, input.c:244) is correct and safe. One
+naming nit: `inputBind`'s param is named `act` in input.h:216 while its
+own doc comment calls it `action`. **Confirmed, not just cited from
+STATUS.md**: pointer input is genuinely wired end-to-end, not a
+dead-end at the platform layer -- SDL2's `inputUpdateSDL2` populates
+`INPUT.platform.mouseX/Y`/scroll from `SDL_GetMouseState`,
+`inputButtonGetValueSDL2` handles the pointer-axis cases, and
+`duskrpg/input/inputbindmap.h` binds `mouse_x`/`mouse_y` to
+`INPUT_BIND_POINTERX/Y`. The dead end is specifically at the
+*consumption* layer: grepping `src/dusk/ui/` for those binds or any
+pointer-axis read turns up nothing -- exactly as STATUS.md says, just
+now confirmed rather than assumed. No tests exist for `input/`.
+
+---
+
+## engine
+
+**Purpose:** Top-level init/update/dispose orchestration
+(`engineInit`/`engineUpdate`/`engineDispose`) -- the thing `main.c` calls,
+which in turn calls into every subsystem above plus `game/gameInit` etc.
+`ENGINE.running`/`ENGINE.version` are the only bits of global state
+outside the per-subsystem structs.
+
+**Key files:** `engine.c/h`.
+
+**Review status:** Reviewed 2026-08-01, confirmed by direct read of
+`engineInit`/`engineDispose`. Init order is safe (time -> console ->
+system -> input -> asset -> scriptManager -> save/saveSettings ->
+locale -> display -> ui -> network -> scene -> game), with display
+before UI and scriptManager before scene/game so JS `Entity`/`Scene`
+wrappers exist before any script runs. `engineDispose` is **not** a
+clean reverse of that order, though: `localeManagerDispose()` runs
+*before* `uiDispose()`/`displayDispose()`, even though locale was
+initialized *before* both -- correct reverse order would tear down
+UI/display first, and as written there's a real risk of UI/display
+teardown code touching already-freed locale data (e.g. any localized
+string still held/logged during dispose). Separately, `void
+engineExit(void)` (engine.c:95) is defined but **not declared in
+engine.h**, and a repo-wide grep finds no caller anywhere -- dead,
+unreachable, and in violation of the "every public function must be
+declared in its header" rule. No tests exist for `engine/`.
+
+---
+
+## game
+
+**Purpose:** Intentionally header-only in core -- just declares
+`gameInit`/`gameUpdate`/`gameDispose`. The real implementation is
+`src/duskrpg/game/game.c` (currently: runs `scripts/init.js` on init).
+
+**Key files:** `game.h` (no `.c` in core).
+
+**Review status:** Reviewed 2026-08-01. Confirmed: no `.c` file exists
+in `src/dusk/game/` (only `game.h` + `CMakeLists.txt`) -- a pure
+interface, as intended. The real `src/duskrpg/game/game.c`
+implementation is a thin JS-bootstrap shim: `gameInit` just does
+`errorChain(scriptManagerExecFile("scripts/init.js", NULL))`, while
+`gameUpdate`/`gameDispose` are both empty (`errorOk()` only). Not a
+bug -- consistent with the ongoing migration of game logic into JS --
+but worth flagging as "not yet fleshed out" rather than broken if
+anything is expected to happen there per-frame at the C layer. No
+tests exist for this layer.
@@ -0,0 +1,49 @@
+name: Setup devkitPro
+description: Install devkitPro with GameCube/Wii packages on an Ubuntu runner
+
+runs:
+  using: composite
+  steps:
+    - name: Install apt dependencies
+      shell: bash
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y \
+          cmake \
+          python3 \
+          python3-pip \
+          python3-polib \
+          python3-pil \
+          python3-dotenv \
+          python3-pyqt5 \
+          python3-opengl \
+          xorriso
+    - name: Install devkitPro pacman
+      shell: bash
+      run: |
+        sudo ln -sf /proc/self/mounts /etc/mtab
+        wget https://apt.devkitpro.org/install-devkitpro-pacman \
+          -O /tmp/install-devkitpro-pacman
+        echo "=== installer script contents ==="
+        cat /tmp/install-devkitpro-pacman
+        echo "================================="
+        chmod +x /tmp/install-devkitpro-pacman
+        sudo /tmp/install-devkitpro-pacman
+        echo "DEVKITPRO=/opt/devkitpro" >> $GITHUB_ENV
+        echo "DEVKITPPC=/opt/devkitpro/devkitPPC" >> $GITHUB_ENV
+        echo "/opt/devkitpro/tools/bin" >> $GITHUB_PATH
+        echo "/opt/devkitpro/devkitPPC/bin" >> $GITHUB_PATH
+    - name: Install devkitPro GameCube/Wii packages
+      shell: bash
+      run: |
+        sudo dkp-pacman -S --needed --noconfirm \
+          gamecube-dev \
+          gamecube-sdl2 \
+          ppc-liblzma \
+          ppc-libzip \
+          libogc2 \
+          gamecube-tools \
+          ppc-libmad \
+          ppc-zlib-ng \
+          ppc-bzip2 \
+          ppc-zstd
@@ -0,0 +1,20 @@
+name: Setup pspdev
+description: Install the pspdev PSP toolchain on an Ubuntu runner
+
+runs:
+  using: composite
+  steps:
+    - name: Install dependencies
+      shell: bash
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y cmake python3 python3-pip python3-dotenv
+    - name: Install pspdev toolchain
+      shell: bash
+      run: |
+        wget -q \
+          https://github.com/pspdev/pspdev/releases/latest/download/pspdev-ubuntu-latest-x86_64.tar.gz \
+          -O /tmp/pspdev.tar.gz
+        sudo tar -xzf /tmp/pspdev.tar.gz -C /usr/local
+        echo "PSPDEV=/usr/local/pspdev" >> $GITHUB_ENV
+        echo "/usr/local/pspdev/bin" >> $GITHUB_PATH
@@ -4,27 +4,37 @@ on:
    tags:
      - '*'
 jobs:
-  run-tests:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-      - name: Set up Docker
-        uses: docker/setup-docker-action@v5
-      - name: Run tests in Docker
-        run: ./scripts/test-linux-docker.sh
-
  build-linux:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v6
-      - name: Set up Docker
-        uses: docker/setup-docker-action@v5
+        uses: actions/checkout@v4
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            build-essential \
+            cmake \
+            python3 \
+            python3-pip \
+            python3-polib \
+            python3-pil \
+            libsdl2-dev \
+            libgl1-mesa-dev \
+            libzip-dev \
+            python3-dotenv \
+            python3-pyqt5 \
+            python3-opengl \
+            xz-utils \
+            liblzma-dev \
+            libbz2-dev \
+            zlib1g-dev \
+            git \
+            libssl-dev
      - name: Build Linux
-        run: ./scripts/build-linux-docker.sh
+        run: ./scripts/build-linux.sh
      - name: Upload Linux binary
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v3
        with:
          name: dusk-linux
          path: build-linux/Dusk
@@ -34,53 +44,72 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v6
-      - name: Set up Docker
-        uses: docker/setup-docker-action@v5
-      - name: Build psp
-        run: ./scripts/build-psp-docker.sh
+        uses: actions/checkout@v4
+      - name: Setup pspdev
+        uses: ./.github/actions/setup-pspdev
+      - name: Build PSP
+        run: ./scripts/build-psp.sh
      - name: Move EBOOT.PBP to Dusk subfolder
        run: |
          mkdir -p ./git-artifcats/Dusk/PSP/GAME/Dusk
          cp build-psp/EBOOT.PBP ./git-artifcats/Dusk/PSP/GAME/Dusk/EBOOT.PBP
-      - name: Upload psp binary
-        uses: actions/upload-artifact@v6
+      - name: Upload PSP binary
+        uses: actions/upload-artifact@v3
        with:
          name: dusk-psp
          path: ./git-artifcats/Dusk
          if-no-files-found: error

-  # build-vita:
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - name: Checkout repository
-  #       uses: actions/checkout@v6
-  #     - name: Set up Docker
-  #       uses: docker/setup-docker-action@v5
-  #     - name: Build Vita
-  #       run: ./scripts/build-vita-docker.sh
-  #     - name: Upload Vita binary
-  #       uses: actions/upload-artifact@v6
-  #       with:
-  #         name: dusk-vita
-  #         path: build-vita/Dusk.vpk
-  #         if-no-files-found: error
-
  build-knulli:
    runs-on: ubuntu-latest
+    container:
+      image: debian:trixie
    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
      - name: Checkout repository
-        uses: actions/checkout@v6
-      - name: Set up Docker
-        uses: docker/setup-docker-action@v5
-      - name: Build knulli
-        run: ./scripts/build-knulli-docker.sh
+        uses: actions/checkout@v4
+      - name: Install dependencies
+        run: |
+          dpkg --add-architecture arm64
+          apt-get update
+          apt-get install -y --no-install-recommends \
+            crossbuild-essential-arm64 \
+            ca-certificates \
+            pkg-config \
+            cmake \
+            make \
+            ninja-build \
+            git \
+            file \
+            python3 \
+            python3-pip \
+            python3-polib \
+            python3-pil \
+            python3-dotenv \
+            python3-pyqt5 \
+            python3-opengl \
+            liblua5.4-dev:arm64 \
+            xz-utils:arm64 \
+            libbz2-dev:arm64 \
+            zlib1g-dev:arm64 \
+            libzip-dev:arm64 \
+            libssl-dev:arm64 \
+            libsdl2-dev:arm64 \
+            liblzma-dev:arm64 \
+            libopengl0:arm64 \
+            libgl1:arm64 \
+            libegl1:arm64 \
+            libgles2:arm64 \
+            libgl1-mesa-dev:arm64
+      - name: Build Knulli
+        run: ./scripts/build-knulli.sh
      - name: Move output to Dusk subfolder
        run: |
          mkdir -p ./git-artifcats/Dusk
          cp -r build-knulli/dusk ./git-artifcats/Dusk
-      - name: Upload knulli binary
-        uses: actions/upload-artifact@v6
+      - name: Upload Knulli binary
+        uses: actions/upload-artifact@v3
        with:
          name: dusk-knulli
          path: ./git-artifcats/Dusk
@@ -88,20 +117,31 @@ jobs:

  build-gamecube:
    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/extremscorner/libogc2:latest
    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
      - name: Checkout repository
-        uses: actions/checkout@v6
-      - name: Set up Docker
-        uses: docker/setup-docker-action@v5
+        uses: actions/checkout@v4
+      - name: Install additional dependencies
+        run: |
+          apt-get install -y \
+            python3-pip python3-polib python3-pil \
+            python3-dotenv python3-pyqt5 python3-opengl
+          dkp-pacman -Syu --noconfirm
+          dkp-pacman -S --needed --noconfirm \
+            gamecube-sdl2 ppc-liblzma ppc-libzip \
+            gamecube-tools ppc-libmad ppc-zlib-ng ppc-bzip2 ppc-zstd
      - name: Build GameCube
-        run: ./scripts/build-gamecube-docker.sh
-      - name: Copy output files.
+        run: ./scripts/build-gamecube.sh
+      - name: Copy output files
        run: |
          mkdir -p ./git-artifcats/Dusk
          cp build-gamecube/Dusk.dol ./git-artifcats/Dusk/Dusk.dol
          cp build-gamecube/dusk.dsk ./git-artifcats/Dusk/dusk.dsk
      - name: Upload GameCube binary
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v3
        with:
          name: dusk-gamecube
          path: ./git-artifcats/Dusk
@@ -109,21 +149,32 @@ jobs:

  build-gamecube-iso:
    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/extremscorner/libogc2:latest
    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
      - name: Checkout repository
-        uses: actions/checkout@v6
-      - name: Set up Docker
-        uses: docker/setup-docker-action@v5
+        uses: actions/checkout@v4
+      - name: Install additional dependencies
+        run: |
+          apt-get install -y \
+            python3-pip python3-polib python3-pil \
+            python3-dotenv python3-pyqt5 python3-opengl xorriso
+          dkp-pacman -Syu --noconfirm
+          dkp-pacman -S --needed --noconfirm \
+            gamecube-sdl2 ppc-liblzma ppc-libzip \
+            gamecube-tools ppc-libmad ppc-zlib-ng ppc-bzip2 ppc-zstd
      - name: Build GameCube ISO
-        run: ./scripts/build-gamecube-iso-docker.sh
-      - name: Copy output files.
+        run: ./scripts/build-gamecube-iso.sh
+      - name: Copy output files
        run: |
          mkdir -p ./git-artifcats/Dusk
          cp build-gamecube-iso/Dusk-NTSC-J.iso ./git-artifcats/Dusk/Dusk-NTSC-J.iso
          cp build-gamecube-iso/Dusk-NTSC-U.iso ./git-artifcats/Dusk/Dusk-NTSC-U.iso
          cp build-gamecube-iso/Dusk-PAL.iso    ./git-artifcats/Dusk/Dusk-PAL.iso
      - name: Upload GameCube ISO
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v3
        with:
          name: dusk-gamecube-iso
          path: ./git-artifcats/Dusk
@@ -131,21 +182,32 @@ jobs:

  build-wii:
    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/extremscorner/libogc2:latest
    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
      - name: Checkout repository
-        uses: actions/checkout@v6
-      - name: Set up Docker
-        uses: docker/setup-docker-action@v5
+        uses: actions/checkout@v4
+      - name: Install additional dependencies
+        run: |
+          apt-get install -y \
+            python3-pip python3-polib python3-pil \
+            python3-dotenv python3-pyqt5 python3-opengl
+          dkp-pacman -Syu --noconfirm
+          dkp-pacman -S --needed --noconfirm \
+            gamecube-sdl2 ppc-liblzma ppc-libzip \
+            gamecube-tools ppc-libmad ppc-zlib-ng ppc-bzip2 ppc-zstd
      - name: Build Wii
-        run: ./scripts/build-wii-docker.sh
-      - name: Copy output files.
+        run: ./scripts/build-wii.sh
+      - name: Copy output files
        run: |
          mkdir -p ./git-artifcats/Dusk/apps/Dusk
          cp build-wii/boot.dol ./git-artifcats/Dusk/apps/Dusk/boot.dol
          cp build-wii/dusk.dsk ./git-artifcats/Dusk/apps/Dusk/dusk.dsk
          cp build-wii/meta.xml ./git-artifcats/Dusk/apps/Dusk/meta.xml
      - name: Upload Wii binary
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v3
        with:
          name: dusk-wii
          path: ./git-artifcats/Dusk
@@ -153,21 +215,32 @@ jobs:

  build-wii-iso:
    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/extremscorner/libogc2:latest
    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
      - name: Checkout repository
-        uses: actions/checkout@v6
-      - name: Set up Docker
-        uses: docker/setup-docker-action@v5
+        uses: actions/checkout@v4
+      - name: Install additional dependencies
+        run: |
+          apt-get install -y \
+            python3-pip python3-polib python3-pil \
+            python3-dotenv python3-pyqt5 python3-opengl xorriso
+          dkp-pacman -Syu --noconfirm
+          dkp-pacman -S --needed --noconfirm \
+            gamecube-sdl2 ppc-liblzma ppc-libzip \
+            gamecube-tools ppc-libmad ppc-zlib-ng ppc-bzip2 ppc-zstd
      - name: Build Wii ISO
-        run: ./scripts/build-wii-iso-docker.sh
-      - name: Copy output files.
+        run: ./scripts/build-wii-iso.sh
+      - name: Copy output files
        run: |
          mkdir -p ./git-artifcats/Dusk
          cp build-wii-iso/Dusk-NTSC-J.iso ./git-artifcats/Dusk/Dusk-NTSC-J.iso
          cp build-wii-iso/Dusk-NTSC-U.iso ./git-artifcats/Dusk/Dusk-NTSC-U.iso
          cp build-wii-iso/Dusk-PAL.iso    ./git-artifcats/Dusk/Dusk-PAL.iso
      - name: Upload Wii ISO
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v3
        with:
          name: dusk-wii-iso
          path: ./git-artifcats/Dusk
@@ -0,0 +1,106 @@
+name: Test Dusk
+on:
+  pull_request:
+    branches:
+      - main
+jobs:
+  run-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            build-essential \
+            cmake \
+            python3 \
+            python3-pip \
+            python3-polib \
+            python3-pil \
+            libsdl2-dev \
+            libgl1-mesa-dev \
+            libzip-dev \
+            python3-dotenv \
+            python3-pyqt5 \
+            python3-opengl \
+            xz-utils \
+            liblzma-dev \
+            libbz2-dev \
+            zlib1g-dev \
+            git \
+            libssl-dev
+      - name: Run tests
+        run: ./scripts/test-linux.sh
+
+  # Emulator smoke tests: boot the built disc/EBOOT for a fixed window and
+  # confirm the emulator doesn't crash. Not yet verified against a real
+  # runner (no CI run has exercised these) -- continue-on-error so a
+  # flaky/broken emulator step doesn't block the required Linux test job.
+  run-tests-gamecube-dolphin:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ghcr.io/extremscorner/libogc2:latest
+    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install additional dependencies
+        run: |
+          apt-get install -y \
+            python3-pip python3-polib python3-pil \
+            python3-dotenv python3-pyqt5 python3-opengl xorriso \
+            dolphin-emu xvfb
+          dkp-pacman -Syu --noconfirm
+          dkp-pacman -S --needed --noconfirm \
+            gamecube-sdl2 ppc-liblzma ppc-libzip \
+            gamecube-tools ppc-libmad ppc-zlib-ng ppc-bzip2 ppc-zstd
+      - name: Build GameCube ISO and boot it in Dolphin
+        run: ./scripts/test-gamecube-dolphin.sh
+
+  run-tests-wii-dolphin:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ghcr.io/extremscorner/libogc2:latest
+    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install additional dependencies
+        run: |
+          apt-get install -y \
+            python3-pip python3-polib python3-pil \
+            python3-dotenv python3-pyqt5 python3-opengl xorriso \
+            dolphin-emu xvfb
+          dkp-pacman -Syu --noconfirm
+          dkp-pacman -S --needed --noconfirm \
+            gamecube-sdl2 ppc-liblzma ppc-libzip \
+            gamecube-tools ppc-libmad ppc-zlib-ng ppc-bzip2 ppc-zstd
+      - name: Build Wii ISO and boot it in Dolphin
+        run: ./scripts/test-wii-dolphin.sh
+
+  run-tests-psp-ppsspp:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Setup pspdev
+        uses: ./.github/actions/setup-pspdev
+      - name: Install PPSSPPHeadless build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y git cmake ninja-build libsdl2-dev zlib1g-dev
+      - name: Build PPSSPPHeadless
+        run: |
+          git clone --recursive --depth 1 https://github.com/hrydgard/ppsspp.git /tmp/ppsspp
+          cmake -S /tmp/ppsspp -B /tmp/ppsspp/build -DCMAKE_BUILD_TYPE=Release
+          cmake --build /tmp/ppsspp/build --target PPSSPPHeadless -- -j$(nproc)
+          echo "PPSSPP_HEADLESS_BIN=/tmp/ppsspp/build/PPSSPPHeadless" >> "$GITHUB_ENV"
+      - name: Build PSP EBOOT and boot it in PPSSPPHeadless
+        run: ./scripts/test-psp-ppsspp.sh
@@ -1,5 +1,9 @@
 # Dusk — Claude Code rules

+See `STATUS.md` for a periodically-refreshed inventory of subsystem
+maturity, test coverage gaps, and known open issues — check it before
+assuming a subsystem is fully wired up or before picking a next task.
+
 ## File headers
 Every C, H, and JS file starts with:

@@ -124,18 +128,16 @@ Set `DUSK_TARGET_SYSTEM` at CMake configure time to select a 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/duskgl/        OpenGL abstraction (Linux, Knulli, PSP)
+src/dusksdl2/      SDL2 window + input (Linux, Knulli, PSP)
 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)
 ```

@@ -190,21 +192,110 @@ simply left undefined — the core guards calls with `#ifdef`.
 ## 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`:
+   `entityMyCompDispose()`, `entityMyCompRender()`.
+2. Add the include to `src/dusk/entity/componentlist.h` header block
+   (or `src/duskrpg/entity/gamecomponentlist.h` for a game-specific
+   component, appended after the engine's inbuilt ones).
+3. Add a row:
   ```c
   X(MYCOMP, entityMyComp_t, myComp, entityMyCompInit, NULL, NULL)
   ```
-   This auto-generates the enum, union field, and definition entry.
+   Params are `(enumName, type, field, init, dispose, render)` — pass
+   `NULL` for any callback the component doesn't need. This
+   auto-generates the enum, union field, and definition entry.
 4. If JS-facing, create the script module and `.d.ts` (see below).

+Entities/components/scenes have no JSON serialize/deserialize path —
+that was removed in favor of building scenes from C-coded prefabs
+(below) or from JerryScript (`Entity`/`Component`/`Scene`, see
+"Adding a new script (JS) module").
+
 ---

+## Adding a new entity/scene prefab
+Entity prefabs (`src/dusk/entity/entityprefab.h`) and scene prefabs
+(`src/dusk/scene/sceneprefab.h`) follow the same pattern:
+1. Write an apply function: `errorret_t entityPrefabXxxApply(mgr,
+   entityId)` (or `errorret_t scenePrefabXxxApply(sceneId)`), building
+   up the entity/scene with the normal component/entity APIs.
+2. Add an entry to the sentinel-terminated `ENTITY_PREFABS[]` (in
+   `src/dusk/entity/entityprefablist.h`, or a game-specific list it
+   includes) or `SCENE_PREFABS[]`:
+   ```c
+   { .name = "MY_PREFAB", .extends = "", .apply = entityPrefabXxxApply }
+   ```
+   `extends` names another prefab to apply first (recurses through
+   `entityPrefabResolveAndApply`/`scenePrefabResolveAndApply`), or `""`
+   for none. Do not add an enum or count field — the array is iterated
+   until `.name[0] == '\0'`.
+3. `entityPrefabResolveAndApply`/`scenePrefabResolveAndApply` only
+   resolve names against the C-coded registry above — there is no JSON
+   asset fallback. Throws if no prefab with that name is registered.
+
+---
+
+## Adding a new cutscene item type
+1. Create `src/duskrpg/cutscene/item/<category>/cutsceneMyItem.h/.c`
+   with a data struct (e.g. `cutscenemyitem_t`) and
+   `cutsceneMyItemStart(item, data)` / `cutsceneMyItemUpdate(item,
+   data)` (the latter returns `true` once the item has completed). Add
+   a matching `cutscenemyitemdata_t` runtime-data struct only if the
+   item needs per-run state across ticks (most don't).
+2. Add `CUTSCENE_ITEM_TYPE_MY_ITEM` to the enum and a union member to
+   `cutsceneitem_t` (and `cutsceneitemdata_t` if it has runtime data) in
+   `src/duskrpg/cutscene/item/cutsceneitem.h`.
+3. Register the `{ start, update }` pair in `CUTSCENE_ITEM_CALLBACKS[]`
+   in `cutsceneitem.c`.
+4. Add an authoring macro to `src/duskrpg/cutscene/cutscene.h`:
+   ```c
+   #define CUTSCENE_MY_ITEM(ARGS...) \
+     { .type = CUTSCENE_ITEM_TYPE_MY_ITEM, .myItem = { ARGS } }
+   ```
+   used inside a `CUTSCENE(NAME, SIZE, PAUSE_TYPE, ...)` block.
+
+---
+
+## Save system
+Save data lives under `src/dusk/save/` (`save.h`/`savefile.h`/
+`saveplatform.h`). Slots are fixed-count (`SAVE_FILE_COUNT_MAX`), each
+holding a yyjson document persisted with its byte size and a CRC32
+checksum. `saveLoad`/`saveSave` read/write the JSON fresh every call —
+callers own the returned/passed `yyjson_doc`/`yyjson_mut_doc` and must
+free it themselves. Actual file I/O goes through platform-specific
+`saveplatform_t`/stream hooks (one implementation per platform under
+`src/dusk<platform>/save/`) — do not add direct filesystem calls to the
+core `save.c`, extend the platform stream hooks instead.
+
+## Network system
+`src/dusk/network/` (`network.h`) is a connection-state layer only — a
+`networkstate_t` state machine (`DISCONNECTED`/`CONNECTING`/`CONNECTED`/
+`DISCONNECTING`) plus an HTTP client (`network/http/`) used for one-off
+requests. It is not a multiplayer/replication protocol — that layer
+doesn't exist yet (see `ROADMAP.md` items on the socket server/client
+and packet handlers). Platform-specific connection logic (e.g. PSP's
+`sceNetApctl` polling, GameCube/Wii's `if_config()`) lives under
+`src/dusk<platform>/network/`, wired through `networkplatform.h` macros
+the same way display/input are. Whenever this eventually grows a
+multiplayer protocol, apply `ROADMAP.md`'s principle: never trust
+incoming packet data — validate defensively with `errorret_t`/
+`errorThrow()`, not asserts.
+
 ## Adding a new script (JS) module
+Dusk embeds JerryScript (`src/dusk/script/`, fetched via
+`cmake/modules/Findjerryscript.cmake`). Today only `Entity`, the
+generic `Component` wrapper, and `Scene` are registered (see
+`src/dusk/script/module/modulelist.c`) — no per-component-type typed
+wrappers exist yet (e.g. no `.position` on a `POSITION` component);
+`entity.add(TYPE)`/`entity.getComponent(TYPE)` always return the
+generic `Component`.
+
 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.
+   - Use `moduleBaseFunction(name)` to define JS-callable functions —
+     these are the one exception to "no `static` in `.c` files": the
+     macro itself expands to a `static jerry_value_t name(...)`
+     JerryScript external-handler trampoline, never called by name
+     from other C files, so it isn't declared in the `.h`.
   - Register props/funcs in `moduleMyModInit()` with
     `scriptProtoDefineProp` / `scriptProtoDefineFunc` /
     `scriptProtoDefineStaticFunc`.
@@ -212,9 +303,12 @@ simply left undefined — the core guards calls with `#ifdef`.
   `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.
+3. For a component module that adds a *typed* wrapper for a specific
+   component type, create
+   `src/dusk/script/module/entity/component/modulecomponentlist.c` (it
+   doesn't exist yet — the first such module creates it) so
+   `entity.add()` can return the typed wrapper instead of the generic
+   `Component`.
 4. Create `types/<category>/mymod.d.ts` and add a
   `/// <reference path="..." />` line to `types/index.d.ts`.

@@ -423,6 +517,29 @@ above the declaration with no blank line in between.

 ---

+## Color system
+
+Colors are defined in `src/dusk/display/color.csv` and code-generated
+into a `color.h` header by `tools/color/csv/__main__.py`.
+
+Each row in the CSV has `name,r,g,b,a` with channel values in `[0.0, 1.0]`.
+The script emits four `#define` variants per color plus a bare alias:
+
+```
+COLOR_<NAME>_4B   color4b(r8, g8, b8, a8)   // default alias target
+COLOR_<NAME>_3B   color3b(r8, g8, b8)
+COLOR_<NAME>_3F   color3f(rf, gf, bf)
+COLOR_<NAME>_4F   color4f(rf, gf, bf, af)
+COLOR_<NAME>      COLOR_<NAME>_4B
+```
+
+`color_t` is `color4b_t` (four `uint8_t` channels).
+
+To add a new color, append a row to `color.csv` and rebuild — do not
+hand-edit the generated header.
+
+---
+
 ## Tests
 - Tests live in `test/` mirroring `src/dusk/` structure.
 - Use cmocka; include `dusktest.h`.
@@ -14,10 +14,9 @@ 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_SHORT_DESCRIPTION "Dusk game"           CACHE STRING "One-line description")
+set(DUSK_GAME_NAME "Dusk" CACHE STRING "Game display name")
+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")

 # Prep cache
@@ -0,0 +1,260 @@
+# PSP Optimization Plan
+
+A survey of concrete memory and CPU (especially floating-point) optimization
+opportunities for the PSP target, done 2026-07-31 on branch `ac2` at commit
+`e61914ba` + this session's scripting work. Point-in-time findings, not a
+substitute for reading the referenced source before acting on it.
+
+## Why this exists
+
+The PSP (Allegrex MIPS CPU, 222-333MHz, single core, 32-64MB main RAM, 2MB
+eDRAM, 16KB I-cache / 16KB D-cache, no virtual memory or memory protection)
+is the tightest-constrained target this engine ships to. Two rules guide
+everything below, both already correctly applied in one place in this
+codebase (`entityposition_t` caching its transform matrices instead of
+recomputing them from position/rotation/scale every read — see "Already
+correct" below):
+
+- **Memory is finite and cannot be compacted.** No VM means a fragmented
+  heap after a few minutes of play can fail an allocation even with
+  "enough" total free bytes. Prefer static/pool allocation over
+  malloc/free churn; prefer trading memory for CPU only when the memory
+  cost is bounded and paid once.
+- **CPU is finite and floating-point math is not free**, especially
+  trig/sqrt on the plain scalar FPU. Prefer caching a computed result
+  behind a dirty flag over recomputing it unconditionally; prefer
+  avoiding a sqrt via squared-distance comparison wherever only a
+  yes/no or ordering result is needed.
+
+## Priority 1 — Entity/component memory: a union tax paid on every slot, times 4 scenes
+
+**The single biggest finding.** `entitymanager_t` (`src/dusk/entity/entitymanager.h:11-15`)
+is a flat, statically-sized struct:
+
+```c
+typedef struct entitymanager_t {
+  entity_t entities[ENTITY_COUNT_MAX];                              // 64
+  component_t components[ENTITY_COUNT_MAX * ENTITY_COMPONENT_COUNT_MAX]; // 64*16 = 1024
+  componentid_t entitiesWithComponent[COMPONENT_TYPE_COUNT * ENTITY_COUNT_MAX];
+} entitymanager_t;
+```
+
+`component_t` (`src/dusk/entity/component.h:69-72`) holds a **tagged union**
+(`componentdata_t`) sized to its largest variant. That variant is
+`entityrenderable_t`'s spritebatch payload (`entityrenderable.h:25-66`):
+`spritebatchsprite_t sprites[64]` at 40 bytes each (`vec3 min + vec3 max +
+vec2 uvMin + vec2 uvMax`) = **2560 bytes**, versus ~28-300 bytes for every
+other component type (camera, physics, animation, position, trigger).
+
+Because the union is embedded by value in a flat array — not behind a
+pointer, not sparse — **every one of the 1024 component slots in every
+entity manager costs ~2580 bytes, whether it holds a 28-byte camera or
+nothing at all.** `1024 * 2580 ≈ 2.52MB` per `entitymanager_t`, confirmed
+by the engine's own startup log every run: `Entity manager size: 2684992
+bytes (2622.06 KB)`.
+
+`scene_t` (`src/dusk/scene/scene.h:14-18`) embeds `entitymanager_t` by
+value too, and `SCENE_COUNT_MAX = 4` (`scene/scenebase.h:11`) with
+`SCENE_MANAGER` declared as a plain global (`scene/scene.c:20`) — so this
+~2.52MB exists as static BSS from process start for **all 4 scene slots**,
+used or not. **Total: ~10.1MB reserved permanently for entity storage
+alone** — 16-31% of PSP main RAM — before a single texture, mesh, or audio
+asset is loaded.
+
+**Options to fix (roughly increasing effort/risk):**
+1. Pull `entityrenderablespritebatch_t` out of the component union entirely
+   — store spritebatch entities via a pointer/handle into a separate,
+   smaller fixed pool sized to how many spritebatch-renderable entities
+   actually coexist (almost certainly far fewer than 64 per entity, and
+   far fewer entities need spritebatch at all vs. mesh/material
+   rendering). This alone would shrink the union's dominant variant from
+   ~2560 bytes to whatever the next-largest variant is (~300 bytes,
+   `entitytrigger_t`) — an ~88% reduction, dropping the ~10.1MB down to
+   roughly ~1.2MB.
+2. Reduce `SCENE_COUNT_MAX` from 4 if 4 concurrent scenes were never a
+   deliberate requirement (check with the project owner — this may just
+   be a round-number default nobody revisited), or make scene storage
+   pointer-based/lazily allocated so unused scene slots cost ~0 instead
+   of a full `entitymanager_t`.
+3. Reduce `ENTITY_COMPONENT_COUNT_MAX` (16) if entities realistically use
+   far fewer distinct component types simultaneously — check actual
+   usage across `entityprefablist.h`/`gameprefablist.h` prefabs.
+
+Do (1) first — it's the highest-leverage, most contained change (touches
+`entityrenderable.h`'s data layout and its render/dispose paths, not the
+general entity/component system), and re-measure via the same startup
+log line before deciding whether (2)/(3) are still worth doing.
+
+## Priority 2 — VFPU is completely unused; all vec/mat math is scalar
+
+The PSP's Allegrex CPU has a **VFPU** (vector floating-point unit) capable
+of fast SIMD-style 4-wide float ops and hardware-accelerated matrix
+operations, exposed by pspsdk's `pspvfpu`/GU "Geometry Utility" (`gum_*`)
+helpers. This engine links `pspvfpu` (`cmake/targets/psp.cmake`) but
+**never calls into it** — confirmed via a zero-hit grep for
+`vfpu|pspmath|gum_|vcst|gu_matrix` across `src/duskpsp/` and `src/duskgl/`.
+
+All vector/matrix math instead goes through cglm (`glm_vec3_*`,
+`glm_mat4_*`), which auto-detects SIMD only for x86 (`CGLM_SSE2`/`AVX`) or
+ARM (`CGLM_NEON`) — neither applies to MIPS, and no `CGLM_*` macros are
+set anywhere in this repo (confirmed zero hits). **Every `glm_mat4_mul`,
+every position/rotation rebuild, every physics vector op runs on the
+plain scalar MIPS FPU with the VFPU sitting idle.**
+
+This is the single largest *available* CPU win identified in this survey
+— larger than any specific hot-path fix below, because it's a multiplier
+on all of them. Concretely: route `entityposition.c`'s matrix
+rebuild/multiply path and `physicsworld.c`'s per-body vector math through
+`pspvfpu`/`gum_*` on the PSP build specifically (behind `#ifdef DUSK_PSP`,
+matching the project's existing platform-guard convention), while keeping
+cglm as the portable fallback for Linux/Knulli/GameCube/Wii. This is a
+genuinely large effort (new platform-specific math backend, careful
+correctness verification since VFPU has its own quirks around
+pipelining/hazards) — scope it as its own project, not a quick pass.
+
+## Priority 3 — UI/spritebatch rebuilds and redraws every vertex, every frame
+
+Already flagged in `STATUS.md`/`ROADMAP.md` (item 4/5) as a known open
+issue; this session's research adds concrete numbers. `meshvertex_t`
+(`display/mesh/meshvertex.h:14-17`) is `{ float uv[2]; float pos[3]; }` =
+**20 bytes/vertex**, no packing. `SPRITEBATCH_SPRITES_MAX = 512`,
+`SPRITEBATCH_FLUSH_COUNT = 16` → 32 sprites/flush = 192 vertices = **3,840
+bytes rebuilt and redrawn per flush**, with a flush forced on every
+shader/material change (`spritebatch.c:38-50`) and used unconditionally
+by every widget except `uiconsole.c` (`uitab.c:56`, `uislider.c:183/199/231`,
+final flush in `ui.c:51`). A UI screen with ~50-100 sprites and 2-3
+material changes costs an estimated **8-15KB of vertex rebuild + GU
+submission every single frame**, regardless of whether the UI changed
+since the last frame.
+
+Confirmed on the PSP legacy-GL path specifically: there's no GPU buffer
+re-upload cost (`meshFlushGL` is a literal no-op comment: "we use the
+glClientState stuff" — `meshgl.c:91-93`; `meshDrawGL` just points
+`glVertexPointer` at the CPU-side array each call), so the real cost is
+(a) the CPU-side per-sprite vertex rewrite every frame and (b) GU
+re-transforming the full vertex stream from RAM on every draw with no
+skip for unchanged geometry.
+
+**Fix direction** (already captured in `ROADMAP.md`'s debt backlog item 5):
+extend `uiconsole.c`'s cached-mesh, dirty-flag-gated rebuild pattern to
+the rest of the widget tree. This plan adds one refinement: also consider
+packing `meshvertex_t` down (next item) since it multiplies this cost.
+
+## Priority 4 — All-float vertex format wastes bandwidth and T&L cost
+
+`meshvertex_t` uses two `float` fields (20 bytes) for every mesh and
+sprite vertex, mesh-wide, with no normal or per-vertex color (color is
+already handled at the material level, so that part is already optimal).
+GU natively supports fixed-point 16-bit positions/UVs
+(`GU_VERTEX_16BIT`/`GU_TEXTURE_16BIT`), which would roughly halve
+per-vertex size and the corresponding vertex-fetch/transform cost, at the
+cost of position precision (fine for UI/sprite work and most world
+geometry at this engine's scale; worth checking against the largest
+world coordinates actually used before committing). Pair with Priority 3
+so the packing benefit compounds with the dirty-tracking benefit instead
+of just reducing the cost of a rebuild that still happens every frame.
+
+## Priority 5 — Running gameplay logic in JerryScript has a real per-frame cost on PSP
+
+This is new since last session's work, not a pre-existing issue: `assets/
+scripts/overworldscene.js`'s `update()` is now called every frame via
+`scriptManagerCallGlobal("update")` (wired into `engine.c`'s
+`engineUpdate()`), replacing what used to be a direct `cosf`/`sinf` C
+callback (`entityUpdateAdd`). Per call, `scriptManagerCallGlobal`
+(`scriptmanager.c:91-144`) does: a global-object property lookup (key is
+cached, but the `jerry_object_get` dispatch still runs), full JS
+interpreter call dispatch (frame setup, argument marshaling) for what's a
+two-line function, and an unconditional `jerry_value_is_promise` check
+every call even though `update()` is synchronous. Inside, `Math.cos`/
+`Math.sin` run as JS builtin calls rather than direct libm calls.
+
+Additionally: this project's JerryScript fork is already patched to use
+32-bit float internally (`JERRY_NUMBER_TYPE_FLOAT64=0`,
+`Findjerryscript.cmake`) — a deliberate, already-correct optimization for
+this exact concern — but the *public* engine API (`jerry_value_as_number()`)
+still returns `double`, so every native↔JS boundary crossing (every
+`moduleBaseArgFloat`, every `moduleBaseVec3ToObject`) still pays a
+float→double→float round trip. Also note `JERRY_MATH` is off, so
+`Math.sin`/`cos` fall through to whatever generic libm the platform
+provides rather than JerryScript's own fdlibm implementation — worth
+checking whether turning it on changes anything measurable on PSP.
+
+**This is one `update()` call for one scene-level script today — cheap in
+absolute terms.** It becomes a real problem only if the pattern scales:
+giving many individual entities their own per-frame JS update callback
+would multiply all of the above per entity. **Recommendation: keep
+high-frequency, hot per-entity logic (movement, camera math, physics
+response) in native C update callbacks (`entityUpdateAdd`, the existing
+mechanism), and reserve JS for one-time setup, infrequent/event-driven
+logic, and coarse-grained per-scene orchestration** — which is exactly
+what `require()` and the typed component wrappers built this session are
+suited for, not a per-entity-per-frame hot path. This is a design
+guideline to apply going forward, not a regression to fix in the current
+`overworldscene.js` (one scene-level `update()` call per frame is fine).
+
+## Priority 6 — No pooling/arena allocator; plain malloc/free everywhere
+
+`memoryAllocate`/`memoryFree` (`util/memory.c`) are direct `malloc`/`free`
+passthroughs (`memoryAlign`→`memalign`, `memoryReallocate`/`memoryResize`→
+`realloc`), with the only extra behavior being a global allocation-count
+tracker used solely for test leak detection. No pool, arena, free-list,
+or size-class allocator exists anywhere.
+
+This survey found **no rogue per-frame heap allocations** in the hot
+paths checked (render dispatch in `entityrenderable.c`, all of
+`physics/*.c`) — so this is not an active bug today. But it's a
+structural risk for a no-VM platform over a long play session: any future
+code that does frequent small alloc/free (dynamic lists, string
+building, temp buffers) will fragment the 32-64MB heap with no OS-level
+recovery mechanism. **Recommendation: before adding any new subsystem
+that allocates/frees frequently at runtime (not just at load time),
+default to a fixed-size pool or arena for it**, following the same
+"static, bounded" philosophy already used for `ENTITY_COUNT_MAX`/
+`SCENE_COUNT_MAX`/`ASSET_ENTRY_COUNT_MAX` elsewhere in the engine, rather
+than reaching for `memoryAllocate` per-instance.
+
+## Already correct — don't touch without new evidence
+
+- **`entityposition_t`'s matrix caching** (the pattern the project owner
+  called out as the reason for writing this plan). Verified: a full
+  "dirty" recompute chain (decompose + rebuild local + rebuild world) is
+  ~10 trig calls (`asinf`/`cosf`/`atan2f`) plus at most one 4x4 matrix
+  multiply, and `entityPositionEnsurePRS`/`EnsureLocal`/`EnsureWorld`
+  (`entityposition.c:596-669`) all early-return on a flag check, only
+  doing that work when something actually changed. The cache is correct
+  and clearly worth its ~128-byte-per-entity matrix storage cost.
+- **Physics narrow-phase sqrt avoidance.** All three `sqrtf` call sites
+  in `physicstest.c`/`physicsshapemesh.c` already sit behind a
+  squared-distance early-reject and only compute the real (linear)
+  distance once, when actually needed for penetration depth — no further
+  "use squared distance instead" opportunity was found here.
+- **No allocations in the render/physics hot loop** (Priority 6) — this
+  is good and worth preserving as new code is added to those files.
+- **Asset decompression already runs off the main thread.** Assets are
+  DEFLATE-compressed (not stored) in `dusk.dsk`, so loading pays a real
+  CPU cost for decompression — but every `*LoaderAsync` function
+  (`asset/loader/*/*.c`) runs via `ASSET.loadThread`
+  (`assertNotMainThread` in `asset.c:365`), so this cost is already kept
+  off the main thread. Low priority to change; if load-time CPU cost
+  becomes a measured problem later, revisit stored-vs-compressed as a
+  build-time flag rather than assuming compression is free.
+
+## Suggested approach
+
+1. **Measure before changing.** None of the above have been profiled on
+   real PSP hardware in this pass — this is a source-level survey, not a
+   profile. Before investing in Priority 1 or 2 especially, confirm with
+   an actual PSP build/run (or at minimum the existing "Entity manager
+   size" startup log plus a frame-time counter) that these are the real
+   bottlenecks, not just the largest numbers on paper.
+2. **Priority 1 first** — it's the most contained (one component's data
+   layout), has the clearest before/after metric (the startup log line),
+   and doesn't require new platform-specific code.
+3. **Priority 3 next** (extend the console's dirty-tracking pattern to
+   the rest of the UI) — already scoped in `ROADMAP.md`, no new design
+   needed, just implementation.
+4. **Priority 2 (VFPU) as a dedicated project**, not a quick pass — it's
+   the largest potential win but touches core math plumbing and needs
+   careful correctness verification on real hardware.
+5. Treat Priority 5 as a standing design guideline for all future
+   scripting work, not a one-time fix.
@@ -0,0 +1,105 @@
+# Dusk Roadmap
+
+Tracking upcoming milestones for the engine. See `PSP_OPTIMIZATION_PLAN.md`
+for a memory/CPU optimization survey specifically targeting the PSP build
+(milestone 4 below is its Priority 3).
+
+## Upcoming milestones
+
+1. Add a very basic physics engine, moving away from the current
+   tile-based movement.
+2. Give entities full freedom of movement (no longer locked to tile
+   grid positions).
+3. Update entity interaction, triggers, chunk management, and other
+   systems that currently assume tile-based positioning so they work
+   with the new 3D positioning/movement code.
+4. Investigate and fix poor UI rendering performance. First pass done
+   (2026-07-31): slider/tab/frame/textbox now cache their sprite
+   geometry instead of rebuilding it every frame, and the console's
+   vertex buffer is fixed-size instead of alloc/free churn (see
+   `STATUS.md`'s "UI rendering performance" note for detail). Still
+   open: per-widget material/color changes still force a sprite-batch
+   flush each time (color is per-material, not per-vertex), so a row of
+   alternating highlighted widgets still costs one draw call per
+   widget.
+5. Create UI elements for displaying status indicators, e.g. network
+   connection state and save-in-progress.
+6. Fully test saving end-to-end on all supported platforms.
+7. Remove the tile system from chunks in favor of meshes, with
+   dynamic hitboxes per chunk loaded in from the chunk file data.
+8. Create UI elements for network status: a connecting modal, an
+   error state, and a connected flag. Retire the test HTTP request
+   once these are in place.
+9. Build the socket server and client implementation, including
+   handlers for the different packet types.
+10. Add a dedicated multiplayer entity type, `clientplayer`, alongside
+    the existing `npc` and `player` types. Limit to 16 (defined
+    constant, see SERVER_CLIENT_COUNT_MAX/CLIENT_COUNT_MAX in
+    src/dusk/network/socket/) for now.
+11. Send and receive `clientplayer` position over the network.
+12. Create a UI menu for creating a server and joining a server. For
+    now, join IPs are hard-coded (testing against a fixed IP of
+    10.0.0.94).
+13. Create "handshake" packets. For now, just send the username,
+    enforced to be under 10 characters long.
+14. Server tracks all players' positions and broadcasts them to all
+    connected clients.
+15. Server sends disconnect packets for users who leave.
+16. Server assigns each client a UUID; all clients know every other
+    client's UUID (used to reference them across position updates,
+    disconnect packets, etc).
+17. Server notifies all clients (by UUID) when a user joins, leaves,
+    or is disconnected, so clients can spawn or remove the
+    corresponding `clientplayer` entity in the world.
+
+## Infrastructure / debt backlog
+
+Found during a full-codebase inventory pass (2026-07-30, see `STATUS.md`
+for the full survey). These aren't new feature milestones so much as
+loose ends worth closing, roughly in order of how cheap/safe they are to
+fix:
+
+1. Re-enable `test/item` (currently commented out in
+   `test/CMakeLists.txt`) -- confirm it still passes and turn it back on.
+2. Restore `itemgive.c/h` in `src/duskrpg/item/CMakeLists.txt` -- the
+   textbox UI dependency it was waiting on (`ui/textbox/`) is already
+   back.
+3. Decide the fate of the `vita` target: `scripts/build-vita.sh` and
+   `docker/vita/` reference `-DDUSK_TARGET_SYSTEM=vita`, but no
+   `cmake/targets/vita.cmake` exists, so the build is currently broken.
+   Either implement it or remove the dangling scripts/Dockerfile.
+4. Per-PR CI build coverage for non-Linux targets: first pass added
+   2026-07-31 as `run-tests-gamecube-dolphin`/`run-tests-wii-dolphin`
+   (build the ISO, boot it in Dolphin under Xvfb) and
+   `run-tests-psp-ppsspp` (build the EBOOT, boot it in PPSSPPHeadless)
+   in `.github/workflows/test.yml`, plus matching
+   `scripts/test-*-dolphin.sh`/`scripts/test-psp-ppsspp.sh` (+ `-docker`
+   variants). Marked `continue-on-error: true` since none of these have
+   actually been exercised on a real runner yet -- verify they pass
+   before relying on them, and drop the flag once they do. Knulli still
+   has no per-PR coverage at all.
+5. Milestone 4 above (poor UI rendering performance) has a first pass
+   in (2026-07-31, see `STATUS.md`) -- remaining concrete lead: sprite
+   batch flushes are keyed on shader+material (including tint color),
+   so per-widget color changes (e.g. focus highlight) still force a
+   flush per widget; moving tint to per-vertex color would let a whole
+   row of widgets batch into one draw call regardless of highlight
+   state.
+6. Revisit the GameCube/Wii networking static-IP workaround in
+   `networkdolphin.c` -- it's standing in for an unresolved suspected
+   memory-corruption bug in `if_config()`'s DHCP path.
+7. Decide whether the PSP dialog-based network connect UI needs to come
+   back -- it was removed entirely (not fixed) when the original
+   dialog-tearing bug proved hard to resolve.
+8. Backfill unit tests for the biggest untested surfaces: `ui/` (whole
+   widget framework), `save/`, `script/` (JerryScript bindings), `event/`.
+
+## Principles
+
+- Never trust the network implicitly. Neither side (server or client)
+  should assume the other's packets are well-formed or benign --
+  validate all incoming packet data defensively, since either side
+  may send garbage or malicious data. Use `errorret_t` /
+  `errorThrow()` for these runtime checks, not assert macros --
+  asserts are debug-only and won't guard release builds against
+  malformed or malicious packet data.
@@ -0,0 +1,120 @@
+# Dusk Engine - Status Snapshot
+
+This is a point-in-time inventory of the codebase's maturity, test coverage,
+and known gaps. It is not auto-maintained -- re-survey periodically (or
+whenever picking a new roadmap milestone) rather than trusting it blindly.
+See `ROADMAP.md` for the ordered feature milestones this status feeds into,
+and `CLAUDE.md` for coding conventions.
+
+Last surveyed: 2026-07-31, at commit `8f8fa8f8`.
+
+## Core engine (`src/dusk/`)
+
+| Subsystem  | Maturity                          | Notes |
+|------------|------------------------------------|-------|
+| asset      | Mature, fully wired                | Model loading's "async" path is actually synchronous (`assetmodelloader.h`) -- only real stub found in core. |
+| script     | Mature for its current scope       | Registered modules: `modulePlatform`, `moduleComponent`/`moduleComponentList` (typed Position/Physics/Renderable wrappers), `moduleEntity`, `moduleScene` (with `Scene.set()` module lifecycle), `moduleMesh`, `moduleTime`, `moduleRequire` (CommonJS-style `require()`/`module.exports`). Entry point is `scripts/init.js`, which does `require('./overworldscene.js')` + `Scene.set()`. Has unit tests (`test/script/`). |
+| entity     | Mature                             | Engine-level prefab lists are empty sentinels; all real prefabs live in `duskrpg`. |
+| scene      | Mature                             | Same prefab-delegation pattern as entity. No JSON serialize/deserialize (removed by design). |
+| save       | Mature, but undocumented           | Slot-based, yyjson + CRC32, platform stream hooks. Not covered in `CLAUDE.md`, no tests. |
+| network    | Connection-state layer only        | HTTP client + connection state machine; no multiplayer/replication protocol (expected -- that's roadmap items 8-17). Not covered in `CLAUDE.md`, has HTTP tests only. |
+| physics    | Mature, recently churned           | Recent revert/re-disable of "old ent code" suggests component wiring around physics isn't fully settled. Well tested. |
+| animation  | Early/mid-stage                    | Keyframes + easing only, no blend trees or state machines. Terse commit history ("ANIM") suggests still iterating. |
+| display    | Most mature/battle-tested          | Backbone of the engine; dominated by platform optimization commits. |
+| ui         | Actively churning, perf pass done  | Widget framework has had features added and ripped out repeatedly (story/battle UI added then removed). No JS bindings yet (from-scratch surface if that's picked up). Sprite-cache pass landed for slider/tab/frame/textbox (see roadmap item 4 below); still no scripted pointer/hit-testing. Has unit tests for the new caching logic (`test/ui/`), but nothing exercises actual draw calls -- see below. |
+| console    | Small, finished for its scope      | Fixed-size cached mesh (no more alloc/free churn), same pattern the rest of `ui/` now follows. |
+| event      | Clean, small, finished             | Pub/sub, rebuilt to replace the old input system. |
+| game       | Intentionally header-only          | Real implementation lives in `duskrpg/game/game.c`. |
+
+### UI rendering performance (roadmap item 4)
+First pass landed 2026-07-31: `uislider`/`uitab` now cache their non-text
+quads (track/fill/markers, tab background) relative to origin and only
+rebuild on state change, translating into position at draw time.
+`uiframe.c` grew `uiFrameDrawCached()`, which skips rebuilding its 9-slice
+sprites when x/y/width/height match the last call; wired into the
+confirm dialog, settings panel, and textbox (each owns its own
+`uiframecache_t`). `uitextbox` no longer does one `spriteBatchBuffer` call
+per visible glyph -- it builds a per-page glyph cache once and slices a
+prefix by scroll each frame. `uiconsole` dropped its alloc/free vertex
+buffer for a fixed 512-glyph array. `uifps` skips its label rebuild when
+the formatted FPS string hasn't changed.
+
+Still open: every widget still issues its own `spriteBatchBuffer` call
+per material/color, so a row of alternating highlighted/plain widgets
+still forces a GPU flush per widget (color is applied via material, not
+per-vertex) -- that's the next real win if PSP framerate is still an
+issue. No scripted pointer/hit-testing exists either; input is still
+100% gamepad/keyboard directional-focus (`ui/focus/`).
+
+Test coverage caveat: `test/ui/` and `test/display/test_spritebatchsprite.c`
+cover the new caching *logic* (geometry math, exercised by constructing
+widget structs directly) but cannot exercise `uiXxxDraw()`/`uiFrameDraw()`
+themselves -- those need `FONT_DEFAULT`/`UI_FRAME`'s GL texture, which
+needs a live GL context this test binary doesn't have (confirmed: calling
+`fontInitDefault()` in a test asserts in `texturegl.c`). This is true of
+the whole rendering layer, not something newly introduced -- there's no
+GL-backed test harness anywhere in the repo yet.
+
+## Game layer (`src/duskrpg/`)
+
+Actively maintained, not orphaned (despite an old "remove rpg" commit deep
+in history) -- last touched the same day as this survey.
+
+- **cutscene/** -- actively developed, matches `CLAUDE.md`'s documented
+  recipe exactly. 16 registered item types.
+- **entity/, scene/** -- overworld player/camera/interactable components
+  and prefabs, active.
+- **item/** -- `item.c`/`inventory.c`/`backpack.c` built via a working
+  `item.json` -> `itemdef.h` codegen pipeline. `itemgive.c/h` exist on
+  disk but are explicitly excluded from the CMake build pending textbox
+  UI restoration -- **that UI (`ui/textbox/`) is already restored**, so
+  this looks like an overdue follow-up, not a real blocker.
+- **input/** -- headers only, no implementation. Contains the one
+  genuine TODO found in the whole `duskrpg` tree: `// TODO: Wiimote, USB
+  Keyboard, probably more.`
+- **ui/** -- textbox restored and built; `uitestlabel.c/h` is an
+  intentional smoke-test scaffold, not dead code.
+
+## Platform layers
+
+| Platform     | Status |
+|--------------|--------|
+| duskgl / dusksdl2 | Complete, shared by Linux/Knulli/PSP, no gaps found. |
+| dusklinux    | Complete, well-trodden. |
+| duskpsp      | Complete for current design. The historical dialog/tearing bug (see memory `project_psp_dialog_tearing` etc.) was **not fixed -- the dialog-based connect UI was removed entirely** (commit `d7982599`, "Simplified PSP network") in favor of a silent profile-based connect. Revisit if the dialog UX is still wanted. |
+| duskdolphin (GameCube/Wii) | Functional, not a stub -- real GX-based display/mesh/shader/texture. Wii input uses only the GameCube `PAD_*` library; no WPAD/Wiimote support (`inputdolphin.h` has `#error "Wii not implemented"` gated behind macros that are never defined, so currently dormant, not a live build break). `networkdolphin.c` hardcodes a static IP as an explicit temporary workaround for a suspected DHCP-related memory-corruption bug in `if_config()` -- root cause still open. |
+| vita         | **Referenced by `scripts/build-vita.sh` and `docker/vita/` but no `cmake/targets/vita.cmake` exists** -- the build target is broken/unfinished at the CMake level. |
+
+### CI coverage gap
+`.github/workflows/test.yml` only builds+tests Linux, on PRs to `main`.
+`build.yml` builds all other platforms (PSP, Knulli, GameCube, Wii +
+ISO variants) but **only on tag push** (release time). Vita and Dolphin
+aren't in CI at all. Net effect: regressions on 4+ platforms can land
+silently until a release tag is cut.
+
+## Test coverage gaps
+
+Core `src/dusk/` subsystems with **zero** unit tests: `console`,
+`engine`, `event`, `game`, `input`, `log`, `save`, `script` (+ all JS
+module bindings), `system`, `ui` (entire widget framework).
+
+`src/duskrpg/` has almost no test coverage: `test/item/test_inventory.c`
+exists but **`add_subdirectory(item)` is commented out in
+`test/CMakeLists.txt`**, so even that one test never runs. `cutscene`,
+`entity`, `game`, `input`, `scene`, `ui` under `duskrpg` have no tests at
+all.
+
+No stale tests were found referencing deleted systems (old JSON
+serialize/deserialize, old event/cutscene modules) -- the test suite is
+internally consistent with current code, just incomplete in coverage.
+
+## Build/tooling gaps worth knowing about
+
+- `assetsraw/` -> `assets/` (chunk JSON -> `.dcf`) is a manual/editor-only
+  step (`tools.asset.chunk`), not part of the CMake build -- committed
+  `.dcf` files can silently drift from their raw source.
+- Several Python tool packages exist but aren't wired into any build:
+  `tools/color/csv/`, `tools/asset/chunk_json/`, `tools/asset/dmf/`,
+  `tools/asset/tiles/`, `tools/input/csv/`. Some may be superseded by
+  `tools/color.py`/`tools/item.py`; worth a pass to confirm which are
+  live vs leftover.
@@ -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,10 +0,0 @@
-# Copyright (c) 2026 Dominic Masters
-#
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Sources
-target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PUBLIC
-    camera.c
-)
@@ -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,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,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;
@@ -1,19 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "rpg/cutscene/cutscenesystem.h"
-
-bool_t cutsceneModeIsInputAllowed() {
-  switch(CUTSCENE_SYSTEM.mode) {
-    case CUTSCENE_MODE_FULL_FREEZE:
-    case CUTSCENE_MODE_INPUT_FREEZE:
-      return false;
-      
-    default:
-      return true;
-  }
-}
@@ -1,26 +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"
-
-typedef enum {
-  CUTSCENE_MODE_NONE,
-  CUTSCENE_MODE_FULL_FREEZE,
-  CUTSCENE_MODE_INPUT_FREEZE,
-  CUTSCENE_MODE_GAMEPLAY
-} cutscenemode_t;
-
-// Default mode for all cutscenes.
-#define CUTSCENE_MODE_INITIAL CUTSCENE_MODE_INPUT_FREEZE
-
-/**
- * Check if input is allowed in the current cutscene mode.
- * 
- * @return true if input is allowed, false otherwise.
- */
-bool_t cutsceneModeIsInputAllowed();
@@ -1,56 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "cutscenesystem.h"
-#include "util/memory.h"
-
-cutscenesystem_t CUTSCENE_SYSTEM;
-
-void cutsceneSystemInit() {
-  memoryZero(&CUTSCENE_SYSTEM, sizeof(cutscenesystem_t));
-}
-
-void cutsceneSystemStartCutscene(const cutscene_t *cutscene) {
-  CUTSCENE_SYSTEM.scene = cutscene;
-  CUTSCENE_SYSTEM.mode = CUTSCENE_MODE_INITIAL;
-  CUTSCENE_SYSTEM.currentItem = 0xFF;// Set to 0xFF so start wraps.
-  cutsceneSystemNext();
-}
-
-void cutsceneSystemUpdate() {
-  if(CUTSCENE_SYSTEM.scene == NULL) return;
-
-  const cutsceneitem_t *item = cutsceneSystemGetCurrentItem();
-  cutsceneItemUpdate(item, &CUTSCENE_SYSTEM.data);
-}
-
-void cutsceneSystemNext() {
-  if(CUTSCENE_SYSTEM.scene == NULL) return;
-
-  CUTSCENE_SYSTEM.currentItem++;
-
-  // End of the cutscene?
-  if(
-    CUTSCENE_SYSTEM.currentItem >= CUTSCENE_SYSTEM.scene->itemCount
-  ) {
-    CUTSCENE_SYSTEM.scene = NULL;
-    CUTSCENE_SYSTEM.currentItem = 0xFF;
-    CUTSCENE_SYSTEM.mode = CUTSCENE_MODE_NONE;
-    return;
-  }
-
-  // Start item.
-  const cutsceneitem_t *item = cutsceneSystemGetCurrentItem();
-  memset(&CUTSCENE_SYSTEM.data, 0, sizeof(CUTSCENE_SYSTEM.data));
-  cutsceneItemStart(item, &CUTSCENE_SYSTEM.data);
-}
-
-const cutsceneitem_t * cutsceneSystemGetCurrentItem() {
-  if(CUTSCENE_SYSTEM.scene == NULL) return NULL;
-
-  return &CUTSCENE_SYSTEM.scene->items[CUTSCENE_SYSTEM.currentItem];
-}
@@ -1,50 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "cutscene.h"
-#include "cutscenemode.h"
-
-typedef struct {
-  const cutscene_t *scene;
-  uint8_t currentItem;
-
-  // Data (used by the current item).
-  cutsceneitemdata_t data;
-  cutscenemode_t mode;
-} cutscenesystem_t;
-
-extern cutscenesystem_t CUTSCENE_SYSTEM;
-
-/**
- * Initialize the cutscene system.
- */
-void cutsceneSystemInit();
-
-/**
- * Start a cutscene.
- * 
- * @param cutscene Pointer to the cutscene to start.
- */
-void cutsceneSystemStartCutscene(const cutscene_t *cutscene);
-
-/**
- * Advance to the next item in the cutscene.
- */
-void cutsceneSystemNext();
-
-/**
- * Update the cutscene system for one frame.
- */
-void cutsceneSystemUpdate();
-
-/**
- * Get the current cutscene item.
- * 
- * @return Pointer to the current cutscene item.
- */
-const cutsceneitem_t * cutsceneSystemGetCurrentItem();
@@ -1,10 +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
-    cutsceneitem.c
-)
@@ -1,11 +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"
-
-typedef void (*cutscenecallback_t)(void);
@@ -1,54 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "rpg/cutscene/cutscenesystem.h"
-#include "input/input.h"
-#include "time/time.h"
-
-void cutsceneItemStart(const cutsceneitem_t *item, cutsceneitemdata_t *data) {
-  switch(item->type) {
-    case CUTSCENE_ITEM_TYPE_TEXT: {
-      rpgTextboxShow(
-        item->text.position,
-        item->text.text
-      );
-      break;
-    }
-
-    case CUTSCENE_ITEM_TYPE_WAIT:
-      data->wait = item->wait;
-      break;
-
-    case CUTSCENE_ITEM_TYPE_CALLBACK:
-      if(item->callback != NULL) item->callback();
-      break;
-
-    case CUTSCENE_ITEM_TYPE_CUTSCENE:
-      if(item->cutscene != NULL) cutsceneSystemStartCutscene(item->cutscene);
-      break;
-
-    default:
-      break;
-  }
-}
-
-void cutsceneItemUpdate(const cutsceneitem_t *item, cutsceneitemdata_t *data) {
-  switch(item->type) {
-    case CUTSCENE_ITEM_TYPE_TEXT:
-      if(rpgTextboxIsVisible()) return;
-      cutsceneSystemNext();
-      break;
-
-    case CUTSCENE_ITEM_TYPE_WAIT:
-      data->wait -= TIME.delta;
-      if(data->wait <= 0) cutsceneSystemNext();
-      break;
-
-    default:
-      break;
-  }
-}
@@ -1,53 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "cutscenewait.h"
-#include "cutscenecallback.h"
-#include "cutscenetext.h"
-
-typedef struct cutscene_s cutscene_t;
-
-typedef enum {
-  CUTSCENE_ITEM_TYPE_NULL,
-  CUTSCENE_ITEM_TYPE_TEXT,
-  CUTSCENE_ITEM_TYPE_CALLBACK,
-  CUTSCENE_ITEM_TYPE_WAIT,
-  CUTSCENE_ITEM_TYPE_CUTSCENE
-} cutsceneitemtype_t;
-
-typedef struct cutsceneitem_s {
-  cutsceneitemtype_t type;
-
-  // Arguments/Data that will be used when this item is invoked.
-  union {
-    cutscenetext_t text;
-    cutscenecallback_t callback;
-    cutscenewait_t wait;
-    const cutscene_t *cutscene;
-  };
-} cutsceneitem_t;
-
-typedef union {
-  cutscenewaitdata_t wait;
-} cutsceneitemdata_t;
-
-/**
- * Start the given cutscene item.
- * 
- * @param item The cutscene item to start.
- * @param data The cutscene item data storage.
- */
-void cutsceneItemStart(const cutsceneitem_t *item, cutsceneitemdata_t *data);
-
-/**
- * Tick the given cutscene item (one frame).
- * 
- * @param item The cutscene item to tick.
- * @param data The cutscene item data storage.
- */
-void cutsceneItemUpdate(const cutsceneitem_t *item, cutsceneitemdata_t *data);
@@ -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/rpgtextbox.h"
-
-typedef struct {
-  char_t text[RPG_TEXTBOX_MAX_CHARS];
-  rpgtextboxpos_t position;
-} cutscenetext_t;
@@ -1,12 +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"
-
-typedef float_t cutscenewait_t;
-typedef float_t cutscenewaitdata_t;
@@ -1,30 +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/cutscenesystem.h"
-
-static const cutsceneitem_t TEST_CUTSCENE_ONE_ITEMS[] = {
-  { .type = CUTSCENE_ITEM_TYPE_TEXT, .text = { .text = "This is a test cutscene.", .position = RPG_TEXTBOX_POS_BOTTOM } },
-  { .type = CUTSCENE_ITEM_TYPE_WAIT, .wait = 2.0f },
-  { .type = CUTSCENE_ITEM_TYPE_TEXT, .text = { .text = "It has multiple lines of text.\nAnd waits in between.", .position = RPG_TEXTBOX_POS_TOP } },
-};
-
-static const cutscene_t TEST_CUTSCENE_ONE = {
-  .items = TEST_CUTSCENE_ONE_ITEMS,
-  .itemCount = sizeof(TEST_CUTSCENE_ONE_ITEMS) / sizeof(cutsceneitem_t)
-};
-
-static const cutsceneitem_t TEST_CUTSCENE_TWO_ITEMS[] = {
-  { .type = CUTSCENE_ITEM_TYPE_WAIT, .wait = 1.0f },
-  { .type = CUTSCENE_ITEM_TYPE_CUTSCENE, .cutscene = &TEST_CUTSCENE_ONE },
-};
-
-static const cutscene_t TEST_CUTSCENE = {
-  .items = TEST_CUTSCENE_TWO_ITEMS,
-  .itemCount = sizeof(TEST_CUTSCENE_TWO_ITEMS) / sizeof(cutsceneitem_t)
-};
@@ -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
-    entity.c
-    entityanim.c
-    npc.c
-    player.c
-    entitydir.c
-)
@@ -1,200 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "entity.h"
-#include "assert/assert.h"
-#include "util/memory.h"
-#include "time/time.h"
-#include "util/math.h"
-#include "rpg/cutscene/cutscenemode.h"
-#include "rpg/overworld/map.h"
-
-entity_t ENTITIES[ENTITY_COUNT];
-
-void entityInit(entity_t *entity, const entitytype_t type) {
-  assertNotNull(entity, "Entity pointer cannot be NULL");
-  assertTrue(type < ENTITY_TYPE_COUNT, "Invalid entity type");
-  assertTrue(type != ENTITY_TYPE_NULL, "Cannot have NULL entity type");
-  assertTrue(
-    entity >= ENTITIES && entity < ENTITIES + ENTITY_COUNT,
-    "Entity pointer is out of bounds"
-  );
-
-  memoryZero(entity, sizeof(entity_t));
-  entity->id = (uint8_t)(entity - ENTITIES);
-  entity->type = type;
-
-  if(ENTITY_CALLBACKS[type].init != NULL) ENTITY_CALLBACKS[type].init(entity);
-}
-
-void entityUpdate(entity_t *entity) {
-  assertNotNull(entity, "Entity pointer cannot be NULL");
-  assertTrue(entity->type < ENTITY_TYPE_COUNT, "Invalid entity type");
-  assertTrue(entity->type != ENTITY_TYPE_NULL, "Cannot have NULL entity type");
-
-  // What state is the entity in?
-  if(entity->animation != ENTITY_ANIM_IDLE) {
-    // Entity is mid animation, tick it (down).
-    entity->animTime -= TIME.delta;
-    if(entity->animTime <= 0) {
-      entity->animation = ENTITY_ANIM_IDLE;
-      entity->animTime = 0;
-    }
-    return;
-  }
-
-  // Movement code.
-  if(
-    cutsceneModeIsInputAllowed() &&
-    ENTITY_CALLBACKS[entity->type].movement != NULL
-  ) {
-    ENTITY_CALLBACKS[entity->type].movement(entity);
-  }
-}
-
-void entityTurn(entity_t *entity, const entitydir_t direction) {
-  entity->direction = direction;
-  entity->animation = ENTITY_ANIM_TURN;
-  entity->animTime = ENTITY_ANIM_TURN_DURATION;
-}
-
-void entityWalk(entity_t *entity, const entitydir_t direction) {
-  // TODO: Animation, delay, etc.
-  entity->direction = direction;
-
-  // Where are we moving?
-  worldpos_t newPos = entity->position;
-  {
-    worldunits_t relX, relY;
-    entityDirGetRelative(direction, &relX, &relY);
-    newPos.x += relX;
-    newPos.y += relY;
-  }
-
-  // Get tile under foot
-  tile_t tileCurrent = mapGetTile(entity->position);
-  tile_t tileNew = mapGetTile(newPos);
-  bool_t fall = false;
-  bool_t raise = false;
-
-  // Are we walking up a ramp?
-  if(
-    tileIsRamp(tileCurrent) &&
-    (
-      // Can only walk UP the direction the ramp faces.
-      (direction+TILE_SHAPE_RAMP_SOUTH) == tileCurrent ||
-      // If diagonal ramp, can go up one of two ways only.
-      (
-        (
-          tileCurrent == TILE_SHAPE_RAMP_SOUTHEAST &&
-          (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_EAST)
-        ) ||
-        (
-          tileCurrent == TILE_SHAPE_RAMP_SOUTHWEST &&
-          (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_WEST)
-        ) ||
-        (
-          tileCurrent == TILE_SHAPE_RAMP_NORTHEAST &&
-          (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_EAST)
-        ) ||
-        (
-          tileCurrent == TILE_SHAPE_RAMP_NORTHWEST &&
-          (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_WEST)
-        )
-      )
-    // Must be able to walk up.
-    )
-  ) {
-    tileNew = TILE_SHAPE_NULL;// Force check for ramp above.
-    worldpos_t abovePos = newPos;
-    abovePos.z += 1;
-    tile_t tileAbove = mapGetTile(abovePos);
-
-    if(tileAbove != TILE_SHAPE_NULL && tileIsWalkable(tileAbove)) {
-      // We can go up the ramp.
-      raise = true;
-    }
-  } else if(tileNew == TILE_SHAPE_NULL && newPos.z > 0) {
-    // Falling down?
-    worldpos_t belowPos = newPos;
-    belowPos.z -= 1;
-    tile_t tileBelow = mapGetTile(belowPos);
-    if(
-      tileBelow != TILE_SHAPE_NULL &&
-      tileIsRamp(tileBelow) &&
-      (
-        // This handles regular cardinal ramps
-        (entityDirGetOpposite(direction)+TILE_SHAPE_RAMP_SOUTH) == tileBelow ||
-        // This handles diagonal ramps
-        (
-          (
-            tileBelow == TILE_SHAPE_RAMP_SOUTHEAST &&
-            (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_WEST)
-          ) ||
-          (
-            tileBelow == TILE_SHAPE_RAMP_SOUTHWEST &&
-            (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_EAST)
-          ) ||
-          (
-            tileBelow == TILE_SHAPE_RAMP_NORTHEAST &&
-            (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_WEST)
-          ) ||
-          (
-            tileBelow == TILE_SHAPE_RAMP_NORTHWEST &&
-            (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_EAST)
-          )
-        )
-      )
-    ) {
-      // We will fall to this tile.
-      fall = true;
-    }
-  }
-
-  // Can we walk here?
-  if(!raise && !fall && !tileIsWalkable(tileNew)) return;// Blocked
-
-  // Entity in way?
-  entity_t *other = ENTITIES;
-  do {
-    if(other == entity) continue;
-    if(other->type == ENTITY_TYPE_NULL) continue;
-    if(!worldPosIsEqual(other->position, newPos)) continue;
-    return;// Blocked
-  } while(++other, other < &ENTITIES[ENTITY_COUNT]);
-
-  entity->lastPosition = entity->position;
-  entity->position = newPos;
-  entity->animation = ENTITY_ANIM_WALK;
-  entity->animTime = ENTITY_ANIM_WALK_DURATION;// TODO: Running vs walking
-
-  if(raise) {
-    entity->position.z += 1;
-  } else if(fall) {
-    entity->position.z -= 1;
-  }
-}
-
-entity_t * entityGetAt(const worldpos_t position) {
-  entity_t *ent = ENTITIES;
-  do {
-    if(ent->type == ENTITY_TYPE_NULL) continue;
-    if(!worldPosIsEqual(ent->position, position)) continue;
-    return ent;
-  } while(++ent, ent < &ENTITIES[ENTITY_COUNT]);
-
-  return NULL;
-}
-
-uint8_t entityGetAvailable() {
-  entity_t *ent = ENTITIES;
-  do {
-    if(ent->type == ENTITY_TYPE_NULL) return ent - ENTITIES;
-  } while(++ent, ent < &ENTITIES[ENTITY_COUNT]);
-
-  return 0xFF;
-}
@@ -1,77 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "entitydir.h"
-#include "entityanim.h"
-#include "entitytype.h"
-#include "npc.h"
-
-typedef struct map_s map_t;
-
-typedef struct entity_s {
-  uint8_t id;
-  entitytype_t type;
-  entitytypedata_t data;
-
-  // Movement
-  entitydir_t direction;
-  worldpos_t position;
-  worldpos_t lastPosition;
-
-  entityanim_t animation;
-  float_t animTime;
-} entity_t;
-
-extern entity_t ENTITIES[ENTITY_COUNT];
-
-/**
- * Initializes an entity structure.
- * 
- * @param entity Pointer to the entity structure to initialize.
- * @param type The type of the entity.
- */
-void entityInit(entity_t *entity, const entitytype_t type);
-
-/**
- * Updates an entity.
- * 
- * @param entity Pointer to the entity structure to update.
- */
-void entityUpdate(entity_t *entity);
-
-/**
- * Turn an entity to face a new direction.
- * 
- * @param entity Pointer to the entity to turn.
- * @param direction The direction to face.
- */
-void entityTurn(entity_t *entity, const entitydir_t direction);
-
-/**
- * Make an entity walk in a direction.
- * 
- * @param entity Pointer to the entity to make walk.
- * @param direction The direction to walk in.
- */
-void entityWalk(entity_t *entity, const entitydir_t direction);
-
-/**
- * Gets the entity at a specific world position.
- * 
- * @param map Pointer to the map to check.
- * @param pos The world position to check.
- * @return Pointer to the entity at the position, or NULL if none.
- */
-entity_t *entityGetAt(const worldpos_t pos);
-
-/**
- * Gets an available entity index.
- * 
- * @return The index of an available entity, or 0xFF if none are available.
- */
-uint8_t entityGetAvailable();
--- a/Show More
+++ b/Show More
				`@@ -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": []}