Only update overworld entities while the overworld scene is active

Entities (and the player's pause-to-open-game-menu handling with them) previously kept updating every frame regardless of the active scene, matching an existing TODO in rpgUpdate(). Gating the entity loop itself means the game menu (and any other entity-driven input) naturally can't trigger mid-battle or before the initial scene hands off to the overworld, without needing a scene check at each individual call site. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Add initial boot scene to check/prompt for save data before overworld
2026-08-04 20:54:58 -05:00 · 2026-08-04 20:53:01 -05:00 · 2026-08-04 18:35:06 -05:00 · 2026-08-04 13:54:15 -05:00 · 2026-08-04 11:10:44 -05:00 · 2026-08-04 10:33:57 -05:00
324 changed files with 12916 additions and 4137 deletions
@@ -4,36 +4,6 @@ on:
    tags:
      - '*'
 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
  build-linux:
    runs-on: ubuntu-latest
    steps:
@@ -0,0 +1,35 @@
 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
@@ -1,455 +0,0 @@
 # Dusk — Claude Code rules
 ## File headers
 Every C, H, and JS file starts with:
 ```c
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 ```
 JS files use `//` comment style instead.
 ---
 ## C conventions
 ### Types
 Always use the project-defined aliases instead of bare C primitives:
 | Use       | Not          |
 |-----------|--------------|
 | `bool_t`  | `bool`       |
 | `int_t`   | `int`        |
 | `float_t` | `float`      |
 | `char_t`  | `char`       |
 Use `uint8_t`, `uint16_t`, `int32_t`, etc. for fixed-width integers.
 All struct and enum types end in `_t` (`animation_t`, `errorret_t`, …).
 ### Naming
 - **Functions** — snake_case, prefixed with their module:
  `assetLock()`, `entityPositionInit()`, `moduleAssetBatchCtor()`
 - **Struct fields** — camelCase: `keyframeCount`, `localPosition`
 - **Macros / constants** — UPPER_SNAKE_CASE:
  `ENTITY_ID_INVALID`, `ERROR_OK`, `COMPONENT_TYPE_COUNT`
 - **Files** — snake_case matching the primary type: `entityposition.c`,
  `moduleassetbatch.c`
 ### Header files (`.h`)
 - Use `#pragma once` — no include guards.
 - Declare every public function, `#define`, and `extern` global.
 - Write a JSDoc block (`/** … */`) above every declaration explaining
  purpose, `@param`s, and `@returns`.
 - Only include headers that the `.h` file itself strictly requires for
  the types it exposes. Move everything else to the `.c` file.
  Do not use forward declarations as a workaround — use the real
  include in the `.c` file instead.
 ### Implementation files (`.c`)
 - Contain function bodies only; no declarations.
 - Pull in whatever additional includes the implementation needs.
 - Do not use `static` or `inline` on **functions**. Every function,
  including internal helpers, must be declared in the matching `.h` and
  defined in the `.c` file. Internal helpers belong near the bottom of
  the `.c` file, not at the top with a `static` qualifier.
  `static` and `inline` on functions are only appropriate when the
  function body is written directly inside a `.h` file.
  `static` on **variables** (file-scope state) is fine and expected.
 ### Formatting
 - Hard-wrap all lines at **80 characters**.
 ### Error handling
 Return `errorret_t` from fallible functions. Use these macros:
 ```c
 errorOk();                    // return success
 errorThrow("msg %d", val);    // return failure with message
 errorChain(someCall());       // propagate failure, continue on success
 errorIsOk(ret) / errorIsNotOk(ret)  // test a result
 errorCatch(ret);              // handle + free an error
 ```
 Never return raw error codes or use `errno` for in-engine errors.
 ### Memory
 Use the project allocator — never raw `malloc`/`free`:
 ```c
 memoryAllocate(size)          // allocate
 memoryFree(ptr)               // free
 memoryZero(dest, size)        // zero a block
 memoryCopy(dest, src, size)   // copy
 ```
 ### Asserts
 Prefer specific assert macros over bare `assert()`:
 ```c
 assertNotNull(ptr, "msg");
 assertTrue(cond, "msg");
 assertFalse(cond, "msg");
 assertUnreachable("msg");
 assertIsMainThread("msg");
 ```
 ---
 ## Build system
 Each subdirectory has its own `CMakeLists.txt` that adds sources with:
 ```cmake
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
  PUBLIC
    myfile.c
 )
 ```
 Never add source files to the root `CMakeLists.txt` directly.
 ---
 ## Platform support
 ### Targets
 Set `DUSK_TARGET_SYSTEM` at CMake configure time to select a platform:
 | `DUSK_TARGET_SYSTEM` | Macro defined     | Platform         |
 |----------------------|-------------------|------------------|
 | `linux`              | `DUSK_LINUX`      | Linux desktop    |
 | `knulli`             | `DUSK_KNULLI`     | Knulli (handheld)|
 | `psp`                | `DUSK_PSP`        | Sony PSP         |
 | `vita`               | `DUSK_VITA`       | PlayStation Vita |
 | `gamecube`           | `DUSK_GAMECUBE`   | Nintendo GameCube|
 | `wii`                | `DUSK_WII`        | Nintendo Wii     |
 ### Layer structure
 ```
 src/dusk/          core, platform-agnostic game logic
 src/duskgl/        OpenGL abstraction (Linux, Knulli, PSP, Vita)
 src/dusksdl2/      SDL2 window + input (Linux, Knulli, PSP, Vita)
 src/dusklinux/     Linux + Knulli platform impl
 src/duskpsp/       PSP platform impl
 src/duskvita/      Vita platform impl
 src/duskdolphin/   GameCube / Wii platform impl (no SDL2/OpenGL)
 ```
 Dolphin is the only target that bypasses SDL2 and OpenGL entirely —
 it uses native GameCube/Wii rendering and input APIs.
 ### Platform guards
 Use the compile-time macros for platform-specific code:
 ```c
 #ifdef DUSK_PSP
  // PSP-only path
 #elif defined(DUSK_GAMECUBE) || defined(DUSK_WII)
  // GameCube / Wii path
 #else
  // Generic / Linux fallback
 #endif
 ```
 Additional capability macros set per-target:
 `DUSK_SDL2`, `DUSK_OPENGL`, `DUSK_OPENGL_ES`, `DUSK_OPENGL_LEGACY`,
 `DUSK_INPUT_GAMEPAD`, `DUSK_INPUT_KEYBOARD`, `DUSK_INPUT_POINTER`,
 `DUSK_PLATFORM_ENDIAN_BIG` / `DUSK_PLATFORM_ENDIAN_LITTLE`.
 ### Abstraction pattern
 Platform-specific implementations are wired in via `#define` macros in
 each platform's `displayplatform.h` / `inputplatform.h` etc., which
 the core calls through. Functions that a platform does not support are
 simply left undefined — the core guards calls with `#ifdef`.
 ### Adding platform-specific code
 - Put it under `src/dusk<platform>/` in the matching subsystem folder.
 - Gate any core call-site with the appropriate `#ifdef DUSK_<PLATFORM>`
  or capability macro.
 - Keep the `src/dusk/` core free of platform ifdefs — delegate through
  the platform header macros instead.
 ---
 ## Adding a new asset loader type
 1. Add an enum value to `assetloadertype_t` (before `_COUNT`) in
   `src/dusk/asset/loader/assetloader.h`.
 2. Add fields to the input/loading/output unions in `assetloader.h`.
 3. Implement `assetXxxLoaderSync`, `assetXxxLoaderAsync`, and
   `assetXxxDispose` in a new `src/dusk/asset/loader/xxx/` directory.
 4. Register the three callbacks in `ASSET_LOADER_CALLBACKS[]` in
   `src/dusk/asset/loader/assetloader.c`.
 5. If user-facing, create a JS module (see below) and a `.d.ts` file.
 ---
 ## Adding a new entity component
 1. Create `src/dusk/entity/component/<category>/entityMyComp.h/.c` with
   struct `entityMyComp_t`, `entityMyCompInit()`, and optionally
   `entityMyCompDispose()`.
 2. Add the include to `src/dusk/entity/componentlist.h` header block.
 3. Add a row to `src/dusk/entity/componentlist.h`:
   ```c
   X(MYCOMP, entityMyComp_t, myComp, entityMyCompInit, NULL, NULL)
   ```
   This auto-generates the enum, union field, and definition entry.
 4. If JS-facing, create the script module and `.d.ts` (see below).
 ---
 ## Adding a new script (JS) module
 1. Create `src/dusk/script/module/<category>/moduleMyMod.h/.c`.
   - Declare `extern scriptproto_t MODULE_MYMOD_PROTO;` in the header.
   - Use `moduleBaseFunction(name)` to define JS-callable functions.
   - Register props/funcs in `moduleMyModInit()` with
     `scriptProtoDefineProp` / `scriptProtoDefineFunc` /
     `scriptProtoDefineStaticFunc`.
 2. `#include` the header in
   `src/dusk/script/module/modulelist.c` and call
   `moduleMyModInit()` in `moduleListInit()` (and `Dispose` in
   `moduleListDispose()`).
 3. For component modules also register in
   `src/dusk/script/module/entity/component/modulecomponentlist.c`
   so `entity.add()` returns the typed wrapper.
 4. Create `types/<category>/mymod.d.ts` and add a
   `/// <reference path="..." />` line to `types/index.d.ts`.
 ---
 ## Script module type declarations
 Whenever a `src/dusk/script/module/**/*.c` file is created or modified,
 check whether the corresponding `types/**/*.d.ts` needs updating and
 apply any changes before finishing the task.
 ---
 ## JavaScript (asset scripts)
 - Use `var` for module-level state; `const` for values that never
  change.
 - Always use semicolons.
 - Scene objects are plain objects (`var scene = {}`) with assigned
  methods.
 - Export via `module.exports = scene`.
 - Async scene init should use `async function` and `await`.
 ---
 ## Coding style
 ### ASCII only
 Source files (`.c`, `.h`, `.js`) must contain only ASCII characters (U+0000–U+007F).
 Non-ASCII characters are banned even in comments and string literals.
 Use ASCII-only substitutes instead:
 - `--` or `-` instead of `—` (em dash)
 - `->` instead of `→` (arrow)
 - `x` or `*` instead of `×` (multiplication)
 Only non-script asset files (e.g. `.po` locale files) may contain non-ASCII text.
 ### Indentation
 2 spaces. No tabs.
 ### Keyword and operator spacing
 No space between a keyword or function name and its opening parenthesis:
 ```c
 if(!ptr) return;
 for(uint8_t i = 0; i < count; i++) {
 while(entry->state != DONE) {
 switch(type) {
 sizeof(assetbatch_t)
 memoryZero(ptr, size)
 ```
 Spaces around all binary operators and after every comma:
 ```c
 pos->flags |= ENTITY_POSITION_FLAG_WORLD_DIRTY;
 (size_t)end - (size_t)start
 foo(a, b, c)
 ```
 ### Braces
 Opening brace on the **same line** as the statement (K&R style) for all
 constructs — functions, `if`, `else`, `for`, `while`, `switch`:
 ```c
 void assetEntryLock(assetentry_t *entry) {
  ...
 }
 if(dirty) {
  ...
 } else {
  ...
 }
 ```
 ### Guard returns
 Short guards go on one line with no braces:
 ```c
 if(!ptr) return;
 if(!b || !b->batch) return jerry_undefined();
 if(!(flags & DIRTY)) return;
 ```
 ### Blank lines
 - One blank line between functions; no blank line at the start or end of
  a function body.
 - One blank line between logical blocks inside a function body.
 - No trailing blank lines at the end of a file.
 ### Pointer placement
 `*` is attached to the variable name, not the type:
 ```c
 assetentry_t *entry
 const char_t *name
 void *ptr
 uint8_t *d = (uint8_t *)dest;
 ```
 ### Casts
 Space between cast and operand:
 ```c
 (assetbatch_t *)user
 (uint8_t *)dest
 (textureformat_t)v
 ```
 ### Return
 No parentheses around the return value:
 ```c
 return ptr;
 return MEMORY_POINTERS_IN_USE;
 ```
 ### switch / case
 `case` indented 2 spaces from `switch`; body indented 2 more from `case`:
 ```c
 switch(type) {
  case ASSET_LOADER_TYPE_TEXTURE:
    descs[i].input.texture = (textureformat_t)v;
    break;
  default:
    break;
 }
 ```
 ### Multi-line function signatures
 When parameters don't fit on one line, put each on its own line indented
 2 spaces; the closing `) {` (definition) or `);` (declaration) goes on
 its own line at column 0:
 ```c
 void assetEntryInit(
  assetentry_t *entry,
  const char_t *name,
  const assetloadertype_t type,
  assetloaderinput_t *input
 ) {
 errorret_t memoryCompare(
  const void *a,
  const void *b,
  const size_t size
 );
 ```
 ### Structs and enums
 Anonymous inner struct or enum with a `typedef`, `_t` suffix, closing
 brace and name on the same line:
 ```c
 typedef struct {
  errorcode_t code;
  char_t *message;
 } errorstate_t;
 typedef enum {
  ASSET_LOADER_TYPE_NULL,
  ASSET_LOADER_TYPE_COUNT
 } assetloadertype_t;
 ```
 ### Designated initialisers
 Spaces inside braces; `.field = value`:
 ```c
 jsassetentry_t e = { .entry = entry };
 assetbatchloadedpend_t init = { .batch = batch };
 ```
 ### Ternary operator
 Spaces around `?` and `:`:
 ```c
 const float val = psx > 0.0f ? pt[0][0] / psx : 0.0f;
 ```
 ### const placement
 `const` before the type, `*` attached to the variable:
 ```c
 const char_t *name
 const void *src
 const size_t size
 ```
 ### Comments in `.c` files
 - Do not use section dividers (`/* ---- ... ---- */`). Just let the
  functions follow one another with a single blank line between them.
 - Multi-line explanatory comments inside function bodies use `//` lines:
  ```c
  // Script modules are freed; orphaned JS wrapper objects now get GC'd
  // so their finalizers fire before assetDispose() checks ref counts.
  jerry_heap_gc(JERRY_GC_PRESSURE_HIGH);
  ```
 - Do not use `/* */` for inline or inline-block comments inside `.c`
  function bodies.
 ### Comments in `.h` files
 Every public declaration gets a Javadoc block (`/** … */`) with
 `@param` and `@returns` where relevant. Keep it on the lines immediately
 above the declaration with no blank line in between.
 ---
 ## 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`.
 - Test functions: `static void test_something(void **state)`.
 - After each test, assert `memoryGetAllocatedCount() == 0` to catch
  leaks.
 - Build with `-DDUSK_BUILD_TESTS=ON`.
@@ -1,21 +0,0 @@
 // Copyright (c) 2026 Dominic Masters
 //
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 const platformNames = {
  [System.PLATFORM_LINUX]:    'Linux',
  [System.PLATFORM_KNULLI]:   'Knulli',
  [System.PLATFORM_PSP]:      'PSP',
  [System.PLATFORM_GAMECUBE]: 'GameCube',
  [System.PLATFORM_WII]:      'Wii',
 };
 Console.print('Platform: ' + (platformNames[System.platform] || 'Unknown'));
 UIFullboxOver.setColor(Color.BLACK);
 requireAsync('testscene.js').then(Scene.set).catch(err => {
  Console.print('Error loading scene: ' + err);
  Engine.exit();
 });
@@ -10,51 +10,61 @@ msgid "ui.title"
 msgstr ""
 "Welcome"
-#: ui/user.c:22
+#: src/dusk/ui/frame/settings/uisettings.c
-msgid "ui.greeting"
+msgid "ui.settings.tabs.general"
-msgstr "Hello, %s!"
+msgstr "General"
-#: ui/files.c:40
+#: src/dusk/ui/frame/settings/uisettings.c
-msgid "ui.file_status"
+msgid "ui.settings.tabs.input"
-msgstr "%s has %d files."
+msgstr "Input"
-#: ui/cart.c:55
+#: src/dusk/ui/frame/settings/uisettings.c
-msgid "cart.item_count"
+msgid "ui.settings.tabs.display"
-msgid_plural "cart.item_count"
+msgstr "Display"
 msgstr[0] "%d item"
 msgstr[1] "%d items (dual)"
 msgstr[2] "%d items (few)"
 msgstr[3] "%d items (many)"
-#: ui/notifications.c:71
+#: src/dusk/ui/frame/settings/uisettings.c
-msgid ""
+msgid "ui.settings.tabs.audio"
-"ui.multiline_help"
+msgstr "Audio"
 msgstr ""
 "Line one of the help text.\n"
 "Line two continues here.\n"
 "Line three ends here."
-#: ui/errors.c:90
+msgid "ui.settings.input.deadzone"
-msgid ""
+msgstr "Deadzone"
 "error.upload_failed.long"
 msgstr ""
 "Upload failed for file \"%s\".\n"
 "Please try again later or contact support."
-#: ui/messages.c:110
+#: src/dusk/ui/frame/settings/uisettingsgeneral.c
-msgid ""
+msgid "ui.settings.general.language"
-"user.invite_status"
+msgstr "Language"
-msgid_plural ""
+
-"user.invite_status"
+msgid "ui.settings.general.language_detail"
-msgstr[0] ""
+msgstr "Takes effect after restarting the application."
-"%s invited %d user.\n"
+
-"Please review the request."
+#: src/dusk/ui/frame/settings/uisettings.c
-msgstr[1] ""
+msgid "ui.settings.apply"
-"%s invited %d users (dual).\n"
+msgstr "Apply"
-"Please review the requests."
+
-msgstr[2] ""
+#: src/dusk/ui/frame/uiconfirm.c
-"%s invited %d users (few).\n"
+msgid "ui.confirm.discard_changes"
-"Please review the requests."
+msgstr "Discard unsaved changes?"
-msgstr[3] ""
+
-"%s invited %d users (many).\n"
+#: src/dusk/ui/frame/game/uigamemenu.c
-"Please review the requests."
+msgid "ui.game_menu.characters"
 msgstr "Characters"
 #: src/dusk/ui/frame/game/uigamemenu.c
 msgid "ui.game_menu.items"
 msgstr "Items"
 #: src/dusk/ui/frame/game/uigamemenu.c
 msgid "ui.game_menu.settings"
 msgstr "Settings"
 #: src/dusk/ui/frame/game/uigamemenu.c
 msgid "ui.game_menu.save"
 msgstr "Save"
 msgid "item.potion.name"
 msgstr "Potion"
 msgid "item.potato.name"
 msgstr "Potato"
 msgid "item.apple.name"
 msgstr "Apple"
@@ -0,0 +1,74 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: ExampleApp 1.0\n"
 "Language: es\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Plural-Forms: nplurals=2; plural=(n==1 ? 0 : 1);\n"
 #: ui/menu.c:10
 msgid "ui.title"
 msgstr ""
 "Bienvenido"
 #: src/dusk/ui/frame/settings/uisettings.c
 msgid "ui.settings.tabs.general"
 msgstr "General"
 #: src/dusk/ui/frame/settings/uisettings.c
 msgid "ui.settings.tabs.input"
 msgstr "Entrada"
 #: src/dusk/ui/frame/settings/uisettings.c
 msgid "ui.settings.tabs.display"
 msgstr "Pantalla"
 #: src/dusk/ui/frame/settings/uisettings.c
 msgid "ui.settings.tabs.audio"
 msgstr "Audio"
 msgid "ui.settings.input.deadzone"
 msgstr "Deadzone"
 #: src/dusk/ui/frame/settings/uisettingsgeneral.c
 msgid "ui.settings.general.language"
 msgstr "Idioma"
 #: src/dusk/ui/frame/settings/uisettingsgeneral.c
 msgid "ui.settings.general.language_detail"
 msgstr "Se aplica después de reiniciar la aplicación."
 #: src/dusk/ui/frame/settings/uisettings.c
 msgid "ui.settings.apply"
 msgstr "Aplicar"
 #: src/dusk/ui/frame/uiconfirm.c
 msgid "ui.confirm.discard_changes"
 msgstr "¿Descartar los cambios no guardados?"
 #: src/dusk/ui/frame/game/uigamemenu.c
 msgid "ui.game_menu.characters"
 msgstr "Personajes"
 #: src/dusk/ui/frame/game/uigamemenu.c
 msgid "ui.game_menu.items"
 msgstr "Objetos"
 #: src/dusk/ui/frame/game/uigamemenu.c
 msgid "ui.game_menu.settings"
 msgstr "Configuración"
 #: src/dusk/ui/frame/game/uigamemenu.c
 msgid "ui.game_menu.save"
 msgstr "Guardar"
 #: src/dusk/rpg/item/item.json
 msgid "item.potion.name"
 msgstr "Poción"
 #: src/dusk/rpg/item/item.json
 msgid "item.potato.name"
 msgstr "Papa"
 #: src/dusk/rpg/item/item.json
 msgid "item.apple.name"
 msgstr "Manzana"
@@ -0,0 +1,74 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: ExampleApp 1.0\n"
 "Language: ja\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Plural-Forms: nplurals=1; plural=(0);\n"
 #: ui/menu.c:10
 msgid "ui.title"
 msgstr ""
 "歓迎"
 #: src/dusk/ui/frame/settings/uisettings.c
 msgid "ui.settings.tabs.general"
 msgstr "一般"
 #: src/dusk/ui/frame/settings/uisettings.c
 msgid "ui.settings.tabs.input"
 msgstr "入力"
 #: src/dusk/ui/frame/settings/uisettings.c
 msgid "ui.settings.tabs.display"
 msgstr "表示"
 #: src/dusk/ui/frame/settings/uisettings.c
 msgid "ui.settings.tabs.audio"
 msgstr "オーディオ"
 msgid "ui.settings.input.deadzone"
 msgstr "デッドゾーン"
 #: src/dusk/ui/frame/settings/uisettingsgeneral.c
 msgid "ui.settings.general.language"
 msgstr "言語"
 #: src/dusk/ui/frame/settings/uisettingsgeneral.c
 msgid "ui.settings.general.language_detail"
 msgstr "アプリケーションを再起動すると適用されます。"
 #: src/dusk/ui/frame/settings/uisettings.c
 msgid "ui.settings.apply"
 msgstr "適用"
 #: src/dusk/ui/frame/uiconfirm.c
 msgid "ui.confirm.discard_changes"
 msgstr "未保存の変更を破棄しますか？"
 #: src/dusk/ui/frame/game/uigamemenu.c
 msgid "ui.game_menu.characters"
 msgstr "キャラクター"
 #: src/dusk/ui/frame/game/uigamemenu.c
 msgid "ui.game_menu.items"
 msgstr "アイテム"
 #: src/dusk/ui/frame/game/uigamemenu.c
 msgid "ui.game_menu.settings"
 msgstr "設定"
 #: src/dusk/ui/frame/game/uigamemenu.c
 msgid "ui.game_menu.save"
 msgstr "セーブ"
 #: src/dusk/rpg/item/item.json
 msgid "item.potion.name"
 msgstr "ポーション"
 #: src/dusk/rpg/item/item.json
 msgid "item.potato.name"
 msgstr "ジャガイモ"
 #: src/dusk/rpg/item/item.json
 msgid "item.apple.name"
 msgstr "リンゴ"
@@ -1,63 +0,0 @@
 // Copyright (c) 2026 Dominic Masters
 //
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 const PLAYER_SPEED = 5.0;
 // 1 world unit = 16 pixels.
 const PIXEL_SCALE = 1.0 / 16.0;
 // Player sprite is 32x32 px (test.png dimensions).
 const PLAYER_W = 32 * PIXEL_SCALE;
 const PLAYER_H = 32 * PIXEL_SCALE;
 var player = {};
 player.getAssets = () => {
  return [
    { path: 'test.png', type: Asset.TYPE_TEXTURE, format: Texture.FORMAT_RGBA }
  ];
 }
 player.init = function(scene) {
  var texture = scene.assets.getAssetByPath('test.png');
  Console.print('Player init: got texture ' + texture);
  _entity   = Entity.create();
  _position = _entity.add(Component.POSITION);
  _physics  = _entity.add(Component.PHYSICS);
  _physics.bodyType   = Physics.DYNAMIC;
  _physics.shape      = Physics.SHAPE_CUBE;
  _physics.gravityScale = 1.0;
  var r       = _entity.add(Component.RENDERABLE);
  r.texture   = texture.texture;
  r.type      = Renderable.SPRITEBATCH;
  r.color     = new Color(220, 80, 80);
  // Upright quad centered on X, bottom-aligned on Y.
  r.sprites = [[-PLAYER_W/2, 0, 0, PLAYER_W/2, PLAYER_H, 0, 0, 1, 1, 0]];
  _position.localPosition = new Vec3(0, PLAYER_H, 0);
 };
 player.getPosition = function() {
  return _position;
 };
 player.update = function() {
  if(!_physics) return;
  var vx = Input.axis(INPUT_ACTION_LEFT, INPUT_ACTION_RIGHT) * PLAYER_SPEED;
  var vz = Input.axis(INPUT_ACTION_DOWN, INPUT_ACTION_UP) * PLAYER_SPEED;
  // Preserve vertical velocity so gravity and landing work correctly.
  var vy = _physics.velocity.y;
  _physics.velocity = new Vec3(vx, vy, vz);
 };
 player.dispose = function() {
  Entity.dispose(_entity);
  _entity   = null;
  _position = null;
  _physics  = null;
 };
 module.exports = player;
@@ -1,42 +0,0 @@
 // Copyright (c) 2026 Dominic Masters
 //
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 var scene  = {};
 // Pokemon DS-style camera: ~34 degrees elevation (atan(6/9)).
 // CAM_HEIGHT / CAM_DIST ratio controls the tilt - keep it under 0.7 for
 // the characteristically shallow DS angle.
 const CAM_HEIGHT = 6;
 const CAM_DIST   = 9;
 scene.init = async function() {
  // Camera
  scene.cam = Entity.create();
  var camPos = scene.cam.add(Component.POSITION);
  var cam = scene.cam.add(Component.CAMERA);
  camPos.localPosition = new Vec3(3, 3, 3);
  camPos.lookAt(new Vec3(0, 0, 0));
  // Floor - large flat slab, no texture needed.
  scene.floor = Entity.create();
  var floorPos = scene.floor.add(Component.POSITION);
  var floorR = scene.floor.add(Component.RENDERABLE);
  floorR.type  = Renderable.SHADER_MATERIAL;
  floorR.color = Color.BLUE;
  // floorPos.localScale = new Vec3(16, 0.2, 16);
  // floorPos.localPosition = new Vec3(0, -0.1, 0);
  await UIFullboxOver.transition(Color.BLACK, Color.TRANSPARENT, 1.0);
 };
 scene.update = function() {
 };
 scene.dispose = function() {
  Entity.dispose(scene.floor);
  Entity.dispose(scene.cam);
 };
 module.exports = scene;
@@ -1,6 +0,0 @@
 module = {
  render() {
    Text.draw(0, 0, "Hello World");
    SpriteBatch.flush();
  }
 };
@@ -2179,5 +2179,27 @@
        0
      ]
    }
  ],
  "entities": [
    {
      "type": "global",
      "globalId": 3,
      "pos": [8, 8, 1]
    },
    {
      "type": "item",
      "itemId": 1,
      "quantity": 1,
      "pos": [12, 2, 0]
    }
  ],
  "areas": [
    {
      "min": [11, 3, 0],
      "max": [16, 9, 10],
      "callbackId": 1,
      "notify": 3,
      "trigger": 6
    }
  ]
 }
@@ -1464,7 +1464,7 @@
        10,
        0
      ],
-      "type": 1,
+      "type": 4,
      "tile": 0
    },
    {
@@ -1473,7 +1473,7 @@
        10,
        0
      ],
-      "type": 1,
+      "type": 4,
      "tile": 0
    },
    {
@@ -1482,7 +1482,7 @@
        10,
        0
      ],
-      "type": 1,
+      "type": 4,
      "tile": 0
    },
    {
@@ -1491,7 +1491,7 @@
        10,
        0
      ],
-      "type": 1,
+      "type": 4,
      "tile": 0
    },
    {
@@ -1500,7 +1500,7 @@
        10,
        0
      ],
-      "type": 1,
+      "type": 4,
      "tile": 0
    },
    {
@@ -1509,7 +1509,7 @@
        10,
        0
      ],
-      "type": 1,
+      "type": 4,
      "tile": 0
    },
    {
@@ -2267,6 +2267,276 @@
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        6,
        9,
        1
      ],
      "type": 4,
      "tile": 0
    },
    {
      "pos": [
        7,
        9,
        1
      ],
      "type": 4,
      "tile": 0
    },
    {
      "pos": [
        8,
        9,
        1
      ],
      "type": 4,
      "tile": 0
    },
    {
      "pos": [
        9,
        9,
        1
      ],
      "type": 4,
      "tile": 0
    },
    {
      "pos": [
        10,
        9,
        1
      ],
      "type": 4,
      "tile": 0
    },
    {
      "pos": [
        11,
        9,
        1
      ],
      "type": 4,
      "tile": 0
    },
    {
      "pos": [
        6,
        8,
        2
      ],
      "type": 4,
      "tile": 0
    },
    {
      "pos": [
        7,
        8,
        2
      ],
      "type": 4,
      "tile": 0
    },
    {
      "pos": [
        8,
        8,
        2
      ],
      "type": 4,
      "tile": 0
    },
    {
      "pos": [
        9,
        8,
        2
      ],
      "type": 4,
      "tile": 0
    },
    {
      "pos": [
        10,
        8,
        2
      ],
      "type": 4,
      "tile": 0
    },
    {
      "pos": [
        11,
        8,
        2
      ],
      "type": 4,
      "tile": 0
    },
    {
      "pos": [
        6,
        5,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        7,
        5,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        8,
        5,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        9,
        5,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        10,
        5,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        11,
        5,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        6,
        6,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        7,
        6,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        8,
        6,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        9,
        6,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        10,
        6,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        11,
        6,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        6,
        7,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        7,
        7,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        8,
        7,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        9,
        7,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        10,
        7,
        3
      ],
      "type": 1,
      "tile": 0
    },
    {
      "pos": [
        11,
        7,
        3
      ],
      "type": 1,
      "tile": 0
    }
  ],
  "meshes": []
@@ -16,6 +16,9 @@ target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
  DOL=1
  ISO=2
  DUSK_DOLPHIN_BUILD_TYPE=${DUSK_DOLPHIN_BUILD_TYPE}
  # GameCube/Wii PowerPC is always big-endian; declare it at compile time
  # like every other target instead of relying on endian.h's runtime probe.
  DUSK_PLATFORM_ENDIAN_BIG
 )
 # Custom compiler flags
@@ -36,7 +36,7 @@ target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
  # DUSK_OPENGL_LEGACY
  DUSK_LINUX
  DUSK_DISPLAY_SIZE_DYNAMIC
-  DUSK_DISPLAY_WIDTH_DEFAULT=640
+  DUSK_DISPLAY_WIDTH_DEFAULT=854
  DUSK_DISPLAY_HEIGHT_DEFAULT=480
  DUSK_DISPLAY_SCREEN_HEIGHT=240
  DUSK_INPUT_KEYBOARD
@@ -56,6 +56,7 @@ target_compile_definitions(${DUSK_BINARY_TARGET_NAME} PUBLIC
  DUSK_DISPLAY_HEIGHT=272
  DUSK_THREAD_PTHREAD
  DUSK_TIME_DYNAMIC
  DUSK_DISPLAY_OVERSCAN=6
 )
 if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -17,6 +17,10 @@ const ChunkTerrain = (() => {
  const CHUNK_DEPTH  = 4;
  const TILE_COUNT   = CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH;
  // World-space Z distance of one Z-layer/story, in world-float space.
  // Must match WORLD_LAYER_HEIGHT in src/dusk/rpg/overworld/worldpos.h.
  const WORLD_LAYER_HEIGHT = Math.SQRT1_2;
  const TILE_SHAPE_NULL           = 0;
  const TILE_SHAPE_GROUND         = 1;
  const TILE_SHAPE_RAMP_NORTH     = 2;
@@ -88,7 +92,53 @@ const ChunkTerrain = (() => {
          const v1 = (y + 1) / CHUNK_HEIGHT;
          const [sw, se, ne, nw] = corners;
-          pushTileQuad(out, u0, u1, v0, v1, x, y, z + sw, z + se, z + ne, z + nw);
+          pushTileQuad(
            out, u0, u1, v0, v1, x, y,
            (z + sw) * WORLD_LAYER_HEIGHT,
            (z + se) * WORLD_LAYER_HEIGHT,
            (z + ne) * WORLD_LAYER_HEIGHT,
            (z + nw) * WORLD_LAYER_HEIGHT
          );
        }
      }
    }
    return new Float32Array(out);
  }
  // Four edges (SW-SE, SE-NE, NE-NW, NW-SW) of a tile's quad as line
  // segments, lifted slightly above the terrain surface to avoid
  // z-fighting - same corner-height convention as pushTileQuad().
  function pushTileGridLines(out, fx, fy, swZ, seZ, neZ, nwZ) {
    const eps = 0.01;
    const sw = [fx,     fy,     swZ + eps];
    const se = [fx + 1, fy,     seZ + eps];
    const ne = [fx + 1, fy + 1, neZ + eps];
    const nw = [fx,     fy + 1, nwZ + eps];
    const edges = [sw, se, se, ne, ne, nw, nw, sw];
    for(const [x, y, z] of edges) out.push(0, 0, x, y, z);
  }
  // Generate grid-outline line segments for every non-null tile, following
  // the same per-corner heights as buildTerrainVerts() so lines hug ramps
  // instead of cutting through them. Returns a Float32Array of interleaved
  // [u, v, x, y, z] vertices meant to be drawn with gl.LINES (pairs).
  function buildGridLines(tiles) {
    const out = [];
    for(let z = 0; z < CHUNK_DEPTH; z++) {
      for(let y = 0; y < CHUNK_HEIGHT; y++) {
        for(let x = 0; x < CHUNK_WIDTH; x++) {
          const type = tiles[tileIndex(x, y, z)] || TILE_SHAPE_NULL;
          const corners = RAMP_CORNERS[type];
          if(!corners) continue;
          const [sw, se, ne, nw] = corners;
          pushTileGridLines(
            out, x, y,
            (z + sw) * WORLD_LAYER_HEIGHT,
            (z + se) * WORLD_LAYER_HEIGHT,
            (z + ne) * WORLD_LAYER_HEIGHT,
            (z + nw) * WORLD_LAYER_HEIGHT
          );
        }
      }
    }
@@ -96,7 +146,7 @@ const ChunkTerrain = (() => {
  }
  return Object.freeze({
-    CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_COUNT,
+    CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_COUNT, WORLD_LAYER_HEIGHT,
    TILE_SHAPE_NULL, TILE_SHAPE_GROUND,
    TILE_SHAPE_RAMP_NORTH, TILE_SHAPE_RAMP_EAST,
    TILE_SHAPE_RAMP_SOUTH, TILE_SHAPE_RAMP_WEST,
@@ -104,6 +154,6 @@ const ChunkTerrain = (() => {
    TILE_SHAPE_RAMP_SOUTHEAST, TILE_SHAPE_RAMP_SOUTHWEST,
    TILE_SHAPE_RAMP_NORTHEAST_INNER, TILE_SHAPE_RAMP_NORTHWEST_INNER,
    TILE_SHAPE_RAMP_SOUTHEAST_INNER, TILE_SHAPE_RAMP_SOUTHWEST_INNER,
-    RAMP_CORNERS, tileIndex, buildTerrainVerts,
+    RAMP_CORNERS, tileIndex, buildTerrainVerts, buildGridLines,
  });
 })();
@@ -9,7 +9,7 @@
  flex-direction: column;
  flex-wrap: wrap;
  gap: 6px;
-  max-height: 512px;
+  max-height: 600px;
 }
 .tile-swatch {
@@ -41,16 +41,15 @@
    [ChunkTerrain.TILE_SHAPE_RAMP_SOUTHWEST_INNER]: { dx: -1, dy: 1 },
  };
-  // Draws an arrow centered at (cx, cy) pointing toward the ramp's high
+  const INNER_CORNER_SHAPES = new Set([
-  // side, so ramp direction is visible at a glance on both the palette
+    ChunkTerrain.TILE_SHAPE_RAMP_NORTHEAST_INNER,
-  // swatches and the tile grid.
+    ChunkTerrain.TILE_SHAPE_RAMP_NORTHWEST_INNER,
-  function drawArrow(ctx, cx, cy, size, dx, dy) {
+    ChunkTerrain.TILE_SHAPE_RAMP_SOUTHEAST_INNER,
-    const mag = Math.hypot(dx, dy) || 1;
+    ChunkTerrain.TILE_SHAPE_RAMP_SOUTHWEST_INNER,
-    const ux = dx / mag, uy = dy / mag;
+  ]);
    const len = size * 0.32;
    const tipX = cx + ux * len, tipY = cy + uy * len;
    const tailX = cx - ux * len, tailY = cy - uy * len;
  // Draws a single-headed arrow from (tailX, tailY) to (tipX, tipY).
  function drawArrowSegment(ctx, tailX, tailY, tipX, tipY, size) {
    ctx.strokeStyle = "#ffffff";
    ctx.fillStyle = "#ffffff";
    ctx.lineWidth = Math.max(1, size * 0.08);
@@ -62,7 +61,7 @@
    ctx.stroke();
    const headLen = size * 0.18;
-    const angle = Math.atan2(uy, ux);
+    const angle = Math.atan2(tipY - tailY, tipX - tailX);
    const leftAngle = angle + Math.PI * 0.8;
    const rightAngle = angle - Math.PI * 0.8;
    ctx.beginPath();
@@ -73,6 +72,54 @@
    ctx.fill();
  }
  // Draws an arrow centered at (cx, cy) pointing toward the ramp's high
  // side, so ramp direction is visible at a glance on both the palette
  // swatches and the tile grid. Used for cardinal ramps and outer-corner
  // ramps (a single raised corner).
  function drawArrow(ctx, cx, cy, size, dx, dy) {
    const mag = Math.hypot(dx, dy) || 1;
    const ux = dx / mag, uy = dy / mag;
    const len = size * 0.32;
    drawArrowSegment(ctx, cx - ux * len, cy - uy * len, cx + ux * len, cy + uy * len, size);
  }
  // Draws a plain right-angle bracket - two line segments meeting at 90
  // degrees at the tile's corner, one running along each of the two edges
  // adjacent to it - so inner-corner ramps (three corners raised, one
  // dropped) read as "the adjacent sides meeting in a 90-degree corner",
  // distinct from the single diagonal arrow used for outer-corner ramps.
  function drawCornerBracket(ctx, cx, cy, size, dx, dy) {
    const cornerDist = size * 0.42;
    const armLen = size * 0.34;
    const cornerX = cx + dx * cornerDist;
    const cornerY = cy + dy * cornerDist;
    ctx.strokeStyle = "#ffffff";
    ctx.lineWidth = Math.max(1, size * 0.08);
    ctx.lineCap = "round";
    ctx.lineJoin = "round";
    ctx.beginPath();
    ctx.moveTo(cornerX - dx * armLen, cornerY);
    ctx.lineTo(cornerX, cornerY);
    ctx.lineTo(cornerX, cornerY - dy * armLen);
    ctx.stroke();
  }
  // Draws the direction icon for a ramp tile `type` in a `size`x`size` area
  // centered at (cx, cy): a diagonal arrow for cardinal/outer-corner ramps,
  // or a right-angle bracket for inner-corner ramps. No-op for shapes with
  // no direction (ground, erase).
  function drawShapeIcon(ctx, cx, cy, size, type) {
    const dir = SHAPE_DIRECTIONS[type];
    if(!dir) return;
    if(INNER_CORNER_SHAPES.has(type)) {
      drawCornerBracket(ctx, cx, cy, size, dir.dx, dir.dy);
    } else {
      drawArrow(ctx, cx, cy, size, dir.dx, dir.dy);
    }
  }
  // Draws a small pencil icon centered in a `size`x`size` canvas.
  function drawPencilIcon(ctx, size) {
    ctx.save();
@@ -146,6 +193,7 @@
  let mapRenderer = null;
  let terrainMesh = null;
  let gridLinesMesh = null;
  let terrainTexturePromise = null;
  let modelIndex = null;
  let neighborChunks = [];
@@ -262,6 +310,13 @@
    return modelIndex;
  }
  // Scales a mesh's stored [x, y, z] offset for preview, matching the
  // Z scaling mapChunkLoaded() applies at runtime (chunk.meshOffsets[m][2]
  // * WORLD_LAYER_HEIGHT) - x/y stay 1:1 since only Z is height-scaled.
  function scaledMeshOffset(pos) {
    return [pos[0], pos[1], pos[2] * ChunkTerrain.WORLD_LAYER_HEIGHT];
  }
  // Resolves a chunk mesh entry's bare filename (e.g. "house_5_3.dmf") to
  // its model JSON by basename, mirroring find_model() in
  // tools/asset/chunk/__main__.py - the chunk JSON only ever stores a bare
@@ -330,7 +385,7 @@
      for(const m of neighborMeshes) {
        try {
          const resolved = await resolveModelForMeshFile(m.file);
-          if(resolved) models.push({ ...resolved, offset: m.pos });
+          if(resolved) models.push({ ...resolved, offset: scaledMeshOffset(m.pos) });
        } catch(e) {
          console.warn("Failed to load neighbor mesh preview", m.file, e);
        }
@@ -426,13 +481,12 @@
        buildPalette();
      });
-      const dir = SHAPE_DIRECTIONS[s.type];
+      if(SHAPE_DIRECTIONS[s.type]) {
      if(dir) {
        const icon = document.createElement("canvas");
        icon.width = 32;
        icon.height = 32;
        icon.className = "tile-swatch-icon";
-        drawArrow(icon.getContext("2d"), 16, 16, 32, dir.dx, dir.dy);
+        drawShapeIcon(icon.getContext("2d"), 16, 16, 32, s.type);
        btn.appendChild(icon);
      }
@@ -489,11 +543,10 @@
        const sy = (ChunkTerrain.CHUNK_HEIGHT - 1 - y) * cell;
        ctx.fillStyle = SHAPE_COLORS[type] || "#15171b";
        ctx.fillRect(x * cell, sy, cell, cell);
-        ctx.strokeStyle = "rgba(255, 255, 255, 0.08)";
+        ctx.strokeStyle = "rgba(255, 255, 255, 0.25)";
        ctx.strokeRect(x * cell, sy, cell, cell);
-        const dir = SHAPE_DIRECTIONS[type];
+        drawShapeIcon(ctx, x * cell + cell / 2, sy + cell / 2, cell, type);
        if(dir) drawArrow(ctx, x * cell + cell / 2, sy + cell / 2, cell, dir.dx, dir.dy);
      }
    }
@@ -592,6 +645,9 @@
  function rebuildTerrainMesh() {
    const floats = ChunkTerrain.buildTerrainVerts(tiles);
    terrainMesh = floats.length ? mapRenderer.createMesh(floats) : null;
    const lineFloats = ChunkTerrain.buildGridLines(tiles);
    gridLinesMesh = lineFloats.length ? mapRenderer.createMesh(lineFloats) : null;
  }
  // Keeps the preview canvas's backing-store resolution matched to its
@@ -619,7 +675,7 @@
    for(const m of meshes) {
      try {
        const resolved = await resolveModelForMeshFile(m.file);
-        if(resolved) models.push({ ...resolved, offset: m.pos });
+        if(resolved) models.push({ ...resolved, offset: scaledMeshOffset(m.pos) });
      } catch(e) {
        console.warn("Failed to load mesh preview", m.file, e);
      }
@@ -637,13 +693,15 @@
      models: n.models,
    }));
    const zLevelHeight = currentZLevel * ChunkTerrain.WORLD_LAYER_HEIGHT;
    mapRenderer.render({
-      target: [ChunkTerrain.CHUNK_WIDTH / 2, ChunkTerrain.CHUNK_HEIGHT / 2, currentZLevel],
+      target: [ChunkTerrain.CHUNK_WIDTH / 2, ChunkTerrain.CHUNK_HEIGHT / 2, zLevelHeight],
      worldH: zoomWorldH,
      terrain: terrainMesh ? { mesh: terrainMesh, texture: terrainTexture } : null,
      gridLines: gridLinesMesh ? { mesh: gridLinesMesh } : null,
      models,
      neighbors,
-      highlight: hoverTile ? { x: hoverTile.x, y: hoverTile.y, z: currentZLevel } : null,
+      highlight: hoverTile ? { x: hoverTile.x, y: hoverTile.y, z: zLevelHeight } : null,
    });
  }
@@ -221,6 +221,7 @@ const MapRenderer = (() => {
    // scene = {
    //   target: [x, y, z], worldH: number,
    //   terrain: { mesh, texture } | null,
    //   gridLines: { mesh } | null,
    //   models: [{ mesh, texture, color: [r,g,b,a in 0..1], offset: [x,y,z] }],
    //   neighbors: [{
    //     offset: [x,y,z],
@@ -248,6 +249,10 @@ const MapRenderer = (() => {
        drawMesh(scene.terrain.mesh, identity, scene.terrain.texture, [1, 1, 1, 1], true);
      }
      if(scene.gridLines) {
        drawMesh(scene.gridLines.mesh, identity, null, [0, 0, 0, 0.35], false, gl.LINES);
      }
      for(const model of scene.models) {
        const modelMatrix = mat4Translation(new Float32Array(16), model.offset);
        drawMesh(model.mesh, modelMatrix, model.texture, model.color, true);
@@ -59,7 +59,10 @@ assetentry_t * assetGetEntry(
    entry++;
  } while(entry < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
-  // We did not find one existing, Find first available slot.
+  // We did not find one existing. Find first available slot, reaping
  // zero-ref entries to make room if none are immediately available.
  bool_t reaped = false;
  for(;;) {
    entry = ASSET.entries;
    do {
      if(entry->type != ASSET_LOADER_TYPE_NULL) {
@@ -74,6 +77,11 @@ assetentry_t * assetGetEntry(
      entry++;
    } while(entry < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
    if(reaped) break;
    reaped = true;
    errorCatch(assetReapUnused());
  }
  assertUnreachable("No available asset entry slots.");
  return NULL;
 }
@@ -191,6 +199,32 @@ void assetUnlockEntry(assetentry_t *entry) {
  assetEntryUnlock(entry);
 }
 errorret_t assetReapUnused(void) {
  assertIsMainThread("assetReapUnused must be called from the main thread.");
  // Repeatedly find and dispose zero-ref LOADED entries until none remain.
  // This handles dependency chains where an entry (e.g. a model) holds refs
  // on child entries (mesh, texture): dispose parents first so child ref
  // counts drop to zero, then pick up the children on the next pass. Without
  // this, a forward-only scan fails when a shared child entry appears before
  // a parent that still holds a ref to it.
  bool_t any;
  do {
    any = false;
    assetentry_t *entry = ASSET.entries;
    do {
      if(entry->type == ASSET_LOADER_TYPE_NULL) { entry++; continue; }
      if(entry->state != ASSET_ENTRY_STATE_LOADED) { entry++; continue; }
      if(entry->refs.count > 0) { entry++; continue; }
      errorChain(assetEntryDispose(entry));
      any = true;
      entry++;
    } while(entry < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
  } while(any);
  errorOk();
 }
 errorret_t assetUpdate(void) {
  assertIsMainThread("assetUpdate must be called from the main thread.");
@@ -324,30 +358,6 @@ errorret_t assetUpdate(void) {
    }
  } while(loading < ASSET.loading + ASSET_LOADING_COUNT_MAX);
  // Reap unused entries.
  entry = ASSET.entries;
  do {
    if(entry->state != ASSET_ENTRY_STATE_LOADED) {
      entry++;
      continue;
    }
    if(entry->type == ASSET_LOADER_TYPE_NULL) {
      entry++;
      continue;
    }
    if(entry->refs.count > 0) {
      entry++;
      continue;
    }
    // consolePrint("Reaping asset %s", entry->name);
    errorChain(assetEntryDispose(entry));
    entry++;
  } while(entry < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
  errorOk();
 }
@@ -413,26 +423,7 @@ errorret_t assetDispose(void) {
  assertIsMainThread("Must be called from the main thread.");
  threadStop(&ASSET.loadThread);
-  // Drain-dispose: repeatedly find and dispose zero-ref LOADED entries
+  errorChain(assetReapUnused());
  // until none remain. This handles dependency chains where an entry
  // (e.g. a model) holds refs on child entries (mesh, texture): dispose
  // parents first so child ref counts drop to zero, then pick up the
  // children on the next pass. Without this, a forward-only scan fails
  // when a shared child entry appears before a parent that still holds a
  // ref to it.
  bool_t any;
  do {
    any = false;
    assetentry_t *e = ASSET.entries;
    do {
      if(e->type == ASSET_LOADER_TYPE_NULL) { e++; continue; }
      if(e->state != ASSET_ENTRY_STATE_LOADED) { e++; continue; }
      if(e->refs.count > 0) { e++; continue; }
      errorChain(assetEntryDispose(e));
      any = true;
      e++;
    } while(e < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
  } while(any);
  // Cleanup zip file.
  if(ASSET.zip != NULL) {
@@ -23,8 +23,8 @@
 #define ASSET_FILE_NAME "dusk.dsk"
 #define ASSET_HEADER_SIZE 3
-#define ASSET_LOADING_COUNT_MAX 20
+#define ASSET_LOADING_COUNT_MAX 10
-#define ASSET_ENTRY_COUNT_MAX 128
+#define ASSET_ENTRY_COUNT_MAX 64
 typedef struct asset_s {
  zip_t *zip;
@@ -112,6 +112,16 @@ void assetUnlock(const char_t *name);
 */
 void assetUnlockEntry(assetentry_t *entry);
 /**
 * Frees every currently unreferenced (zero-ref) loaded asset entry. Repeats
 * until a full pass frees nothing further, since disposing a parent entry
 * (e.g. a model) may drop a child entry's (e.g. a mesh) ref count to zero,
 * making it eligible for reaping too.
 *
 * @return An error code if any entry could not be disposed properly.
 */
 errorret_t assetReapUnused(void);
 /**
 * Requires an asset entry to be loaded. This will block until the asset entry
 * is fully loaded.
@@ -14,6 +14,26 @@
 #include "asset/loader/assetloader.h"
 #include "asset/asset.h"
 // Reads a little-endian int16 from a potentially-unaligned offset into a
 // worldunit_t, advancing *offset past it.
 static worldunit_t assetChunkReadWorldUnit(
  const uint8_t *data,
  size_t *offset
 ) {
  int16_t value;
  memoryCopy(&value, data + *offset, sizeof(int16_t));
  *offset += sizeof(int16_t);
  return (worldunit_t)endianLittleToHost16((uint16_t)value);
 }
 static worldpos_t assetChunkReadWorldPos(const uint8_t *data, size_t *offset) {
  worldpos_t pos;
  pos.x = assetChunkReadWorldUnit(data, offset);
  pos.y = assetChunkReadWorldUnit(data, offset);
  pos.z = assetChunkReadWorldUnit(data, offset);
  return pos;
 }
 errorret_t assetChunkLoaderAsync(assetloading_t *loading) {
  assertNotNull(loading, "Loading cannot be NULL");
  assertNotMainThread("Should be called from an async thread.");
@@ -111,9 +131,15 @@ errorret_t assetChunkLoaderSync(assetloading_t *loading) {
  size_t offset = 8;
  size_t tileSize = CHUNK_TILE_COUNT * sizeof(tile_t);
  out->tiles = memoryAllocate(tileSize);
  memoryCopy(out->tiles, data + offset, tileSize);
  offset += tileSize;
  for(size_t t = 0; t < CHUNK_TILE_COUNT; t++) {
    uint32_t *shape = (uint32_t *)&out->tiles[t].shape;
    *shape = endianLittleToHost32(*shape);
  }
  out->meshCount = data[offset];
  offset += sizeof(uint8_t);
  assertTrue(
@@ -135,6 +161,65 @@ errorret_t assetChunkLoaderSync(assetloading_t *loading) {
    memoryCopy(out->meshOffsets[m], data + offset, sizeof(vec3));
    offset += sizeof(vec3);
    out->meshOffsets[m][0] = endianLittleToHostFloat(out->meshOffsets[m][0]);
    out->meshOffsets[m][1] = endianLittleToHostFloat(out->meshOffsets[m][1]);
    out->meshOffsets[m][2] = endianLittleToHostFloat(out->meshOffsets[m][2]);
  }
  out->entitySpawnCount = data[offset];
  offset += sizeof(uint8_t);
  assertTrue(
    out->entitySpawnCount <= CHUNK_ENTITY_SPAWN_COUNT_MAX,
    "Chunk entity spawn count exceeds maximum."
  );
  for(uint8_t s = 0; s < out->entitySpawnCount; s++) {
    chunkentityspawn_t *spawn = &out->entitySpawns[s];
    spawn->kind = (chunkentityspawnkind_t)data[offset];
    offset += sizeof(uint8_t);
    uint16_t a;
    memoryCopy(&a, data + offset, sizeof(uint16_t));
    a = endianLittleToHost16(a);
    offset += sizeof(uint16_t);
    uint8_t b = data[offset];
    offset += sizeof(uint8_t);
    if(spawn->kind == CHUNK_ENTITY_SPAWN_KIND_ITEM) {
      spawn->globalId = 0;
      spawn->itemId = a;
      spawn->itemQuantity = b;
    } else {
      spawn->globalId = a;
      spawn->itemId = 0;
      spawn->itemQuantity = 0;
    }
    spawn->position = assetChunkReadWorldPos(data, &offset);
  }
  out->areaSpawnCount = data[offset];
  offset += sizeof(uint8_t);
  assertTrue(
    out->areaSpawnCount <= CHUNK_AREA_COUNT_MAX,
    "Chunk area spawn count exceeds maximum."
  );
  for(uint8_t s = 0; s < out->areaSpawnCount; s++) {
    chunkareaspawn_t *area = &out->areaSpawns[s];
    area->min = assetChunkReadWorldPos(data, &offset);
    area->max = assetChunkReadWorldPos(data, &offset);
    uint16_t callbackId;
    memoryCopy(&callbackId, data + offset, sizeof(uint16_t));
    area->callbackId = endianLittleToHost16(callbackId);
    offset += sizeof(uint16_t);
    area->notify = data[offset];
    offset += sizeof(uint8_t);
    area->trigger = data[offset];
    offset += sizeof(uint8_t);
  }
  memoryFree(data);
@@ -157,6 +242,12 @@ errorret_t assetChunkDispose(assetentry_t *entry) {
  assertIsMainThread("Must be called from the main thread.");
  assetchunkoutput_t *out = &entry->data.chunk;
  if(out->tiles != NULL) {
    memoryFree(out->tiles);
    out->tiles = NULL;
  }
  for(uint8_t m = 0; m < out->meshCount; m++) {
    if(out->modelEntries[m] == NULL) continue;
    assetUnlockEntry(out->modelEntries[m]);
@@ -9,7 +9,7 @@
 #include "asset/assetfile.h"
 #include "rpg/overworld/chunk.h"
-#define ASSET_CHUNK_FILE_VERSION 3
+#define ASSET_CHUNK_FILE_VERSION 5
 typedef struct assetloading_s assetloading_t;
 typedef struct assetentry_s assetentry_t;
@@ -33,12 +33,39 @@ typedef struct {
  uint8_t modelIndex;
 } assetchunkloaderloading_t;
 typedef enum {
  CHUNK_ENTITY_SPAWN_KIND_GLOBAL,
  CHUNK_ENTITY_SPAWN_KIND_ITEM
 } chunkentityspawnkind_t;
 typedef struct {
-  tile_t tiles[CHUNK_TILE_COUNT];
+  chunkentityspawnkind_t kind;
  uint16_t globalId;    // Valid when kind == CHUNK_ENTITY_SPAWN_KIND_GLOBAL.
  uint16_t itemId;      // Valid when kind == CHUNK_ENTITY_SPAWN_KIND_ITEM.
  uint8_t itemQuantity; // Valid when kind == CHUNK_ENTITY_SPAWN_KIND_ITEM.
  worldpos_t position;
 } chunkentityspawn_t;
 typedef struct {
  worldpos_t min;
  worldpos_t max;
  uint16_t callbackId; // Index into MAP_AREA_CALLBACK_LIST.
  uint8_t notify;
  uint8_t trigger;
 } chunkareaspawn_t;
 typedef struct {
  tile_t *tiles;
  uint8_t meshCount;
  char_t modelNames[CHUNK_MESH_COUNT_MAX][CHUNK_MESH_NAME_MAX];
  vec3 meshOffsets[CHUNK_MESH_COUNT_MAX];
  assetentry_t *modelEntries[CHUNK_MESH_COUNT_MAX];
  uint8_t entitySpawnCount;
  chunkentityspawn_t entitySpawns[CHUNK_ENTITY_SPAWN_COUNT_MAX];
  uint8_t areaSpawnCount;
  chunkareaspawn_t areaSpawns[CHUNK_AREA_COUNT_MAX];
 } assetchunkoutput_t;
 /**
@@ -48,8 +48,20 @@ errorret_t assetMeshLoaderAsync(assetloading_t *loading) {
  uint32_t vertCount = endianLittleToHost32(*(uint32_t *)(raw + 8));
  meshvertex_t *vertices = NULL;
  if(vertCount > 0) {
-    vertices = memoryAllocate(vertCount * sizeof(meshvertex_t));
+    // 32-byte (cache-line) aligned: GX_SetArray + DCFlushRange on Dolphin
    // require this for the DMA'd vertex data to actually reach the GPU
    // coherently. Static compiled-in vertex arrays happen to get this from
    // the linker; a plain memoryAllocate here would not.
    vertices = memoryAlign(32, vertCount * sizeof(meshvertex_t));
    memoryCopy(vertices, raw + 12, vertCount * sizeof(meshvertex_t));
    for(uint32_t v = 0; v < vertCount; v++) {
      vertices[v].uv[0] = endianLittleToHostFloat(vertices[v].uv[0]);
      vertices[v].uv[1] = endianLittleToHostFloat(vertices[v].uv[1]);
      vertices[v].pos[0] = endianLittleToHostFloat(vertices[v].pos[0]);
      vertices[v].pos[1] = endianLittleToHostFloat(vertices[v].pos[1]);
      vertices[v].pos[2] = endianLittleToHostFloat(vertices[v].pos[2]);
    }
  }
  memoryFree(raw);
@@ -103,18 +115,22 @@ errorret_t assetMeshLoaderSync(assetloading_t *loading) {
    out->vertices = NULL;
    errorChain(ret);
  }
  out->meshInitialized = true;
  ret = meshFlush(&out->mesh, 0, (int32_t)vertCount);
  if(errorIsNotOk(ret)) {
    loading->entry->state = ASSET_ENTRY_STATE_ERROR;
    meshDispose(&out->mesh);
    out->meshInitialized = false;
    memoryFree(out->vertices);
    out->vertices = NULL;
    errorChain(ret);
  }
-  #ifndef DUSK_OPENGL_LEGACY
+  #if defined(DUSK_OPENGL) && !defined(DUSK_OPENGL_LEGACY)
-    // VBO owns the data now; CPU copy is no longer needed.
+    // VBO owns the data now; CPU copy is no longer needed. The platform
    // mesh object itself still needs meshDispose later - tracked via
    // out->meshInitialized, independent of the CPU buffer's lifetime.
    memoryFree(out->vertices);
    out->vertices = NULL;
  #endif
@@ -129,8 +145,11 @@ errorret_t assetMeshDispose(assetentry_t *entry) {
  assertIsMainThread("Must be called from the main thread.");
  assetmeshoutput_t *out = &entry->data.mesh;
-  if(out->vertices != NULL) {
+  if(out->meshInitialized) {
    errorChain(meshDispose(&out->mesh));
    out->meshInitialized = false;
  }
  if(out->vertices != NULL) {
    memoryFree(out->vertices);
    out->vertices = NULL;
  }
@@ -30,6 +30,7 @@ typedef struct {
 typedef struct {
  mesh_t mesh;
  bool_t meshInitialized;
  meshvertex_t *vertices;
 } assetmeshoutput_t;
@@ -506,12 +506,17 @@ errorret_t assetLocaleGetString(
    sizeof(lineBuffer)
  );
  // Prime the reader with the first line before scanning; outBuffer holds
  // uninitialized memory until the first Next() call fills it.
  errorChain(assetFileLineReaderNext(&reader));
  // Skip blanks, comments, etc and start looking for msgid's
  errorChain(assetLocaleLineSkipBlanks(&reader, lineBuffer));
-  while(!reader.eof) {
+  while(true) {
    // Is this msgid?
    if(memoryCompare(lineBuffer, "msgid", 5) != 0) {
      if(reader.eof) break;
      errorChain(assetFileLineReaderNext(&reader));
      msgidBuffer[0] = '\0';
      continue;
@@ -535,7 +540,7 @@ errorret_t assetLocaleGetString(
  }
  // We are either going to see a msgstr or a msgid_plural
-  while(!reader.eof) {
+  while(true) {
    errorChain(assetLocaleLineSkipBlanks(&reader, lineBuffer));
    // Is msgid_plural?
@@ -17,7 +17,7 @@ console_t CONSOLE;
 void consoleInit(void) {
  memoryZero(&CONSOLE, sizeof(console_t));
-  CONSOLE.visible = true;
+  CONSOLE.visible = false;
  #ifdef DUSK_CONSOLE_POSIX
    threadMutexInit(&CONSOLE.printMutex);
@@ -37,7 +37,7 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
  errorChain(systemInit());
  errorChain(inputInit());
  errorChain(assetInit());
-  // errorChain(saveInit());
+  errorChain(saveInit());
  errorChain(localeManagerInit());
  errorChain(displayInit());
  errorChain(uiInit());
@@ -53,7 +53,7 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
    consolePrint("Assertions real");
  #endif
-  sceneSet(SCENE_TYPE_OVERWORLD);
+  sceneSet(SCENE_TYPE_INITIAL);
  errorOk();
@@ -62,6 +62,7 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
 errorret_t engineUpdate(void) {
  // Order here is important.
  errorChain(networkUpdate());
  errorChain(saveUpdate());
  timeUpdate();
  inputUpdate();
  consoleUpdate();
@@ -88,7 +89,7 @@ errorret_t engineDispose(void) {
  errorChain(uiDispose());
  consoleDispose();
  errorChain(displayDispose());
-  // errorChain(saveDispose());
+  errorChain(saveDispose());
  errorChain(assetDispose());
  errorOk();
@@ -17,3 +17,13 @@ static const localeinfo_t LOCALE_EN_US = {
  .name = "en-US",
  .file = "locale/en_US.po",
 };
 static const localeinfo_t LOCALE_JP_JP = {
  .name = "ja-JP",
  .file = "locale/jp_JP.po",
 };
 static const localeinfo_t LOCALE_ES_MX = {
  .name = "es-MX",
  .file = "locale/es_MX.po",
 };
@@ -8,10 +8,10 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
  PUBLIC
    rpg.c
    rpgcamera.c
    rpgtextbox.c
 )
 # Subdirs
 add_subdirectory(battle)
 add_subdirectory(cutscene)
 add_subdirectory(entity)
 add_subdirectory(overworld)
@@ -0,0 +1,12 @@
 # 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
    battle.c
    battlefighter.c
    party.c
 )
@@ -0,0 +1,223 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "battle.h"
 #include "assert/assert.h"
 #include "util/memory.h"
 battle_t BATTLE;
 void battleInit(void) {
  memoryZero(&BATTLE, sizeof(battle_t));
  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
    BATTLE.fighters[i].id = i;
  }
 }
 uint8_t battleGetAvailableFighter(void) {
  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
    if(BATTLE.fighters[i].status == BATTLE_FIGHTER_STATUS_NULL) return i;
  }
  return 0xFF;
 }
 battlefighter_t *battleAddFighter(
  const battlefighterteam_t team,
  const battlefightercontroller_t controller,
  const battlefighterstats_t stats,
  const uint16_t healthMax,
  const uint16_t mpMax
 ) {
  const uint8_t index = battleGetAvailableFighter();
  if(index == 0xFF) return NULL;
  battlefighter_t *fighter = &BATTLE.fighters[index];
  battleFighterInit(fighter, team, controller, stats, healthMax, mpMax);
  return fighter;
 }
 void battleStart(
  const battleencountertype_t encounterType,
  const bool_t fleeAvailable
 ) {
  assertTrue(encounterType < BATTLE_ENCOUNTER_COUNT, "Invalid encounter type");
  BATTLE.encounterType = encounterType;
  BATTLE.fleeAvailable = fleeAvailable;
  BATTLE.result = BATTLE_RESULT_NONE;
  BATTLE.round = 1;
  BATTLE.turnIndex = 0;
  battleBuildTurnOrder(true);
  BATTLE.active = true;
 }
 void battleDispose(void) {
  battleInit();
 }
 battlefighter_t *battleGetCurrentFighter(void) {
  if(!BATTLE.active) return NULL;
  if(BATTLE.turnIndex >= BATTLE.turnCount) return NULL;
  return &BATTLE.fighters[BATTLE.turnOrder[BATTLE.turnIndex]];
 }
 uint8_t battleGetAliveCount(const battlefighterteam_t team) {
  uint8_t count = 0;
  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
    if(BATTLE.fighters[i].team != team) continue;
    if(!battleFighterIsAlive(&BATTLE.fighters[i])) continue;
    count++;
  }
  return count;
 }
 void battleResolveAttack(
  battlefighter_t *attacker,
  battlefighter_t *defender
 ) {
  assertNotNull(attacker, "Attacker cannot be NULL");
  assertNotNull(defender, "Defender cannot be NULL");
  const int32_t rawDamage =
    (int32_t)attacker->stats.attack - (int32_t)defender->stats.defense;
  const uint16_t damage = rawDamage > 0 ? (uint16_t)rawDamage : 1;
  defender->health = damage >= defender->health ? 0 : defender->health - damage;
  if(defender->health == 0) defender->status = BATTLE_FIGHTER_STATUS_DEAD;
 }
 void battleNextTurn(void) {
  BATTLE.turnIndex++;
  if(BATTLE.turnIndex < BATTLE.turnCount) return;
  BATTLE.round++;
  BATTLE.turnIndex = 0;
  battleBuildTurnOrder(false);
 }
 battleresult_t battleCheckResult(void) {
  if(BATTLE.result != BATTLE_RESULT_NONE) return BATTLE.result;
  if(battleGetAliveCount(BATTLE_FIGHTER_TEAM_ALLY) == 0) {
    BATTLE.result = BATTLE_RESULT_LOSS;
  } else if(battleGetAliveCount(BATTLE_FIGHTER_TEAM_ENEMY) == 0) {
    BATTLE.result = BATTLE_RESULT_WIN;
  }
  return BATTLE.result;
 }
 void battlePlayerAttack(const uint8_t targetIndex) {
  battlefighter_t *attacker = battleGetCurrentFighter();
  if(attacker == NULL) return;
  if(attacker->controller != BATTLE_FIGHTER_CONTROLLER_PLAYER) return;
  if(targetIndex >= BATTLE_FIGHTER_COUNT_MAX) return;
  battlefighter_t *defender = &BATTLE.fighters[targetIndex];
  if(!battleFighterIsAlive(defender)) return;
  battleResolveAttack(attacker, defender);
  battleCheckResult();
  if(BATTLE.result == BATTLE_RESULT_NONE) battleNextTurn();
 }
 void battlePlayerFlee(void) {
  battlefighter_t *fighter = battleGetCurrentFighter();
  if(fighter == NULL) return;
  if(fighter->controller != BATTLE_FIGHTER_CONTROLLER_PLAYER) return;
  if(!BATTLE.fleeAvailable) return;
  BATTLE.result = BATTLE_RESULT_FLED;
 }
 void battleUpdate(void) {
  if(!BATTLE.active) return;
  if(BATTLE.result != BATTLE_RESULT_NONE) return;
  battlefighter_t *current = battleGetCurrentFighter();
  if(current == NULL) return;
  if(!battleFighterIsAlive(current)) {
    battleNextTurn();
    return;
  }
  if(current->controller != BATTLE_FIGHTER_CONTROLLER_AI) return;
  battlefighter_t *target = battleAIChooseTarget(current);
  if(target != NULL) battleResolveAttack(current, target);
  battleCheckResult();
  if(BATTLE.result == BATTLE_RESULT_NONE) battleNextTurn();
 }
 void battleBuildTurnOrder(const bool_t applyEncounterBias) {
  BATTLE.turnCount = 0;
  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
    if(!battleFighterIsAlive(&BATTLE.fighters[i])) continue;
    BATTLE.turnOrder[BATTLE.turnCount++] = i;
  }
  // Insertion sort by speed descending -- fine for BATTLE_FIGHTER_COUNT_MAX.
  for(uint8_t i = 1; i < BATTLE.turnCount; i++) {
    const uint8_t key = BATTLE.turnOrder[i];
    const uint16_t keySpeed = BATTLE.fighters[key].stats.speed;
    int8_t j = (int8_t)i - 1;
    while(
      j >= 0 && BATTLE.fighters[BATTLE.turnOrder[j]].stats.speed < keySpeed
    ) {
      BATTLE.turnOrder[j + 1] = BATTLE.turnOrder[j];
      j--;
    }
    BATTLE.turnOrder[j + 1] = key;
  }
  if(!applyEncounterBias) return;
  if(BATTLE.encounterType == BATTLE_ENCOUNTER_PLAYER_ADVANTAGE) {
    battleMoveTeamFirst(BATTLE_FIGHTER_TEAM_ALLY);
  } else if(BATTLE.encounterType == BATTLE_ENCOUNTER_BACK_ATTACK) {
    battleMoveTeamFirst(BATTLE_FIGHTER_TEAM_ENEMY);
  }
 }
 void battleMoveTeamFirst(const battlefighterteam_t team) {
  uint8_t sorted[BATTLE_FIGHTER_COUNT_MAX];
  uint8_t count = 0;
  for(uint8_t i = 0; i < BATTLE.turnCount; i++) {
    if(BATTLE.fighters[BATTLE.turnOrder[i]].team != team) continue;
    sorted[count++] = BATTLE.turnOrder[i];
  }
  for(uint8_t i = 0; i < BATTLE.turnCount; i++) {
    if(BATTLE.fighters[BATTLE.turnOrder[i]].team == team) continue;
    sorted[count++] = BATTLE.turnOrder[i];
  }
  memoryCopy(BATTLE.turnOrder, sorted, sizeof(uint8_t) * BATTLE.turnCount);
 }
 battlefighter_t *battleAIChooseTarget(const battlefighter_t *fighter) {
  const battlefighterteam_t enemyTeam =
    fighter->team == BATTLE_FIGHTER_TEAM_ALLY ?
      BATTLE_FIGHTER_TEAM_ENEMY : BATTLE_FIGHTER_TEAM_ALLY;
  battlefighter_t *weakest = NULL;
  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
    battlefighter_t *candidate = &BATTLE.fighters[i];
    if(candidate->team != enemyTeam) continue;
    if(!battleFighterIsAlive(candidate)) continue;
    if(weakest == NULL || candidate->health < weakest->health) {
      weakest = candidate;
    }
  }
  return weakest;
 }
@@ -0,0 +1,194 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "battlefighter.h"
 #define BATTLE_FIGHTER_COUNT_MAX 8
 typedef enum {
  BATTLE_ENCOUNTER_REGULAR,
  BATTLE_ENCOUNTER_PLAYER_ADVANTAGE,
  BATTLE_ENCOUNTER_BACK_ATTACK,
  BATTLE_ENCOUNTER_COUNT
 } battleencountertype_t;
 typedef enum {
  BATTLE_RESULT_NONE,
  BATTLE_RESULT_WIN,
  BATTLE_RESULT_LOSS,
  BATTLE_RESULT_FLED,
  BATTLE_RESULT_COUNT
 } battleresult_t;
 typedef struct {
  bool_t active;
  battlefighter_t fighters[BATTLE_FIGHTER_COUNT_MAX];
  battleencountertype_t encounterType;
  bool_t fleeAvailable;
  battleresult_t result;
  // Fighter indices (into fighters[]), sorted for the current round.
  uint8_t turnOrder[BATTLE_FIGHTER_COUNT_MAX];
  uint8_t turnCount;
  uint8_t turnIndex;
  uint16_t round;
 } battle_t;
 extern battle_t BATTLE;
 /**
 * Initializes the battle system. Marks it as inactive with no fighters.
 */
 void battleInit(void);
 /**
 * Gets an available (unused) fighter slot index.
 *
 * @return The index of an available fighter slot, or 0xFF if none are
 *         available.
 */
 uint8_t battleGetAvailableFighter(void);
 /**
 * Adds a fighter to the battle in the next available slot.
 *
 * @param team The team the fighter belongs to.
 * @param controller Who makes decisions for the fighter.
 * @param stats The fighter's base combat stats.
 * @param healthMax The fighter's maximum health.
 * @param mpMax The fighter's maximum mp.
 * @return Pointer to the newly added fighter, or NULL if the battle is
 *         already full.
 */
 battlefighter_t *battleAddFighter(
  const battlefighterteam_t team,
  const battlefightercontroller_t controller,
  const battlefighterstats_t stats,
  const uint16_t healthMax,
  const uint16_t mpMax
 );
 /**
 * Starts the battle: builds the opening turn order (biased by
 * encounterType for the first round only) and marks the battle active.
 * Call once every fighter has been added via battleAddFighter.
 *
 * @param encounterType Determines the opening round's turn order.
 * @param fleeAvailable Whether the party may attempt to flee this battle.
 */
 void battleStart(
  const battleencountertype_t encounterType,
  const bool_t fleeAvailable
 );
 /**
 * Disposes of the battle, clearing all fighters and marking it inactive.
 */
 void battleDispose(void);
 /**
 * Returns the fighter whose turn it currently is.
 *
 * @return Pointer to the active fighter, or NULL if the battle isn't
 *         active or has no living fighters left to act.
 */
 battlefighter_t *battleGetCurrentFighter(void);
 /**
 * Returns the number of living fighters on a team.
 *
 * @param team The team to count.
 * @return Count of living fighters on that team.
 */
 uint8_t battleGetAliveCount(const battlefighterteam_t team);
 /**
 * Resolves a physical attack from attacker onto defender: damage is the
 * attacker's attack stat minus the defender's defense stat (minimum 1),
 * subtracted from the defender's health. The defender is marked dead
 * once health reaches 0.
 *
 * @param attacker The attacking fighter.
 * @param defender The defending fighter.
 */
 void battleResolveAttack(
  battlefighter_t *attacker,
  battlefighter_t *defender
 );
 /**
 * Ends the current fighter's turn and advances to the next fighter in
 * the turn order, starting a new round (rebuilding turn order purely by
 * speed) once every fighter in the current round has acted.
 */
 void battleNextTurn(void);
 /**
 * Checks whether the battle has been won or lost, updating and
 * returning BATTLE.result. Does nothing if a result has already been
 * set (e.g. by a successful flee).
 *
 * @return The battle's current result.
 */
 battleresult_t battleCheckResult(void);
 /**
 * Submits the current fighter's attack against a target, if it is
 * currently a player-controlled fighter's turn. Resolves the attack,
 * checks for a battle result, and advances the turn.
 *
 * @param targetIndex Index into BATTLE.fighters of the target.
 */
 void battlePlayerAttack(const uint8_t targetIndex);
 /**
 * Submits a flee attempt for the current fighter's turn, if it is
 * currently a player-controlled fighter's turn and fleeing is
 * available for this battle. Always succeeds, ending the battle with
 * BATTLE_RESULT_FLED.
 */
 void battlePlayerFlee(void);
 /**
 * Updates the battle simulation for one frame: resolves the current
 * fighter's turn automatically if AI-controlled, otherwise waits for a
 * player action via battlePlayerAttack/battlePlayerFlee. No-op if the
 * battle isn't active or already has a result.
 */
 void battleUpdate(void);
 /**
 * Rebuilds BATTLE.turnOrder/turnCount from every currently living
 * fighter, sorted by speed descending.
 *
 * @param applyEncounterBias If true, reorders the freshly speed-sorted
 * queue so BATTLE.encounterType's favoured team goes first (used only
 * for the opening round).
 */
 void battleBuildTurnOrder(const bool_t applyEncounterBias);
 /**
 * Stably partitions BATTLE.turnOrder so every fighter on the given team
 * comes first, preserving each side's relative (speed-sorted) order.
 *
 * @param team The team to move to the front of the turn order.
 */
 void battleMoveTeamFirst(const battlefighterteam_t team);
 /**
 * Picks an AI target for fighter: the lowest-health living fighter on
 * the opposing team.
 *
 * @param fighter The AI-controlled fighter choosing a target.
 * @return The chosen target, or NULL if the opposing team has no
 *         living fighters.
 */
 battlefighter_t *battleAIChooseTarget(const battlefighter_t *fighter);
@@ -0,0 +1,43 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "battlefighter.h"
 #include "assert/assert.h"
 #include "util/memory.h"
 void battleFighterInit(
  battlefighter_t *fighter,
  const battlefighterteam_t team,
  const battlefightercontroller_t controller,
  const battlefighterstats_t stats,
  const uint16_t healthMax,
  const uint16_t mpMax
 ) {
  assertNotNull(fighter, "Fighter pointer cannot be NULL");
  assertTrue(team < BATTLE_FIGHTER_TEAM_COUNT, "Invalid fighter team");
  assertTrue(
    controller < BATTLE_FIGHTER_CONTROLLER_COUNT,
    "Invalid fighter controller"
  );
  const uint8_t id = fighter->id;
  memoryZero(fighter, sizeof(battlefighter_t));
  fighter->id = id;
  fighter->status = BATTLE_FIGHTER_STATUS_NORMAL;
  fighter->team = team;
  fighter->controller = controller;
  fighter->stats = stats;
  fighter->healthMax = healthMax;
  fighter->health = healthMax;
  fighter->mpMax = mpMax;
  fighter->mp = mpMax;
 }
 bool_t battleFighterIsAlive(const battlefighter_t *fighter) {
  assertNotNull(fighter, "Fighter pointer cannot be NULL");
  return fighter->status == BATTLE_FIGHTER_STATUS_NORMAL;
 }
@@ -0,0 +1,87 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "error/error.h"
 // An empty status means the slot in BATTLE.fighters is unused.
 typedef enum {
  BATTLE_FIGHTER_STATUS_NULL,
  BATTLE_FIGHTER_STATUS_NORMAL,
  BATTLE_FIGHTER_STATUS_DEAD,
  BATTLE_FIGHTER_STATUS_COUNT
 } battlefighterstatus_t;
 typedef enum {
  BATTLE_FIGHTER_TEAM_ALLY,
  BATTLE_FIGHTER_TEAM_ENEMY,
  BATTLE_FIGHTER_TEAM_COUNT
 } battlefighterteam_t;
 typedef enum {
  BATTLE_FIGHTER_CONTROLLER_PLAYER,
  BATTLE_FIGHTER_CONTROLLER_AI,
  BATTLE_FIGHTER_CONTROLLER_COUNT
 } battlefightercontroller_t;
 // Base combat stats, kept separate from the resource pools (health/mp) on
 // battlefighter_t so that equipment/buffs can later modify them without
 // touching current health/mp state.
 typedef struct {
  uint16_t attack;
  uint16_t defense;
  uint16_t magic;
  uint16_t speed;
  uint16_t luck;
 } battlefighterstats_t;
 typedef struct {
  uint8_t id;
  battlefighterstatus_t status;
  battlefighterteam_t team;
  battlefightercontroller_t controller;
  uint16_t health;
  uint16_t healthMax;
  uint16_t mp;
  uint16_t mpMax;
  battlefighterstats_t stats;
 } battlefighter_t;
 /**
 * Initializes a battle fighter in place, filling health/mp to their maximum
 * values and setting its status to normal.
 *
 * @param fighter Pointer to the fighter to initialize.
 * @param team The team the fighter belongs to.
 * @param controller Who makes decisions for the fighter.
 * @param stats The fighter's base combat stats.
 * @param healthMax The fighter's maximum health.
 * @param mpMax The fighter's maximum mp.
 */
 void battleFighterInit(
  battlefighter_t *fighter,
  const battlefighterteam_t team,
  const battlefightercontroller_t controller,
  const battlefighterstats_t stats,
  const uint16_t healthMax,
  const uint16_t mpMax
 );
 /**
 * Returns true if the fighter is in a state where it can still act (i.e.
 * is not dead).
 *
 * @param fighter Pointer to the fighter to check.
 * @returns True if the fighter can act.
 */
 bool_t battleFighterIsAlive(const battlefighter_t *fighter);
@@ -0,0 +1,71 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "party.h"
 #include "assert/assert.h"
 #include "util/memory.h"
 party_t PARTY;
 void partyInit(void) {
  memoryZero(&PARTY, sizeof(party_t));
  for(uint8_t i = 0; i < PARTY_MEMBER_COUNT_MAX; i++) {
    PARTY.members[i].id = i;
  }
  for(uint8_t i = 0; i < PARTY_ACTIVE_SIZE_MAX; i++) {
    PARTY.order[i] = PARTY_ORDER_EMPTY;
  }
 }
 uint8_t partyGetAvailableMember(void) {
  for(uint8_t i = 0; i < PARTY_MEMBER_COUNT_MAX; i++) {
    if(PARTY.members[i].status == BATTLE_FIGHTER_STATUS_NULL) return i;
  }
  return 0xFF;
 }
 battlefighter_t *partyAddMember(
  const battlefighterstats_t stats,
  const uint16_t healthMax,
  const uint16_t mpMax
 ) {
  const uint8_t index = partyGetAvailableMember();
  if(index == 0xFF) return NULL;
  battlefighter_t *member = &PARTY.members[index];
  battleFighterInit(
    member, BATTLE_FIGHTER_TEAM_ALLY, BATTLE_FIGHTER_CONTROLLER_PLAYER,
    stats, healthMax, mpMax
  );
  for(uint8_t i = 0; i < PARTY_ACTIVE_SIZE_MAX; i++) {
    if(PARTY.order[i] != PARTY_ORDER_EMPTY) continue;
    PARTY.order[i] = index;
    break;
  }
  return member;
 }
 battlefighter_t *partyGetOrderMember(const uint8_t slot) {
  assertTrue(slot < PARTY_ACTIVE_SIZE_MAX, "Invalid party order slot");
  const uint8_t index = PARTY.order[slot];
  if(index == PARTY_ORDER_EMPTY) return NULL;
  return &PARTY.members[index];
 }
 void partySetOrder(const uint8_t slot, const uint8_t memberIndex) {
  assertTrue(slot < PARTY_ACTIVE_SIZE_MAX, "Invalid party order slot");
  assertTrue(
    memberIndex == PARTY_ORDER_EMPTY || memberIndex < PARTY_MEMBER_COUNT_MAX,
    "Invalid party member index"
  );
  PARTY.order[slot] = memberIndex;
 }
@@ -0,0 +1,73 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "battlefighter.h"
 #define PARTY_MEMBER_COUNT_MAX 4
 #define PARTY_ACTIVE_SIZE_MAX 3
 #define PARTY_ORDER_EMPTY 0xFF
 typedef struct {
  battlefighter_t members[PARTY_MEMBER_COUNT_MAX];
  // Maps an active battle slot to the roster member filling it, or
  // PARTY_ORDER_EMPTY if the slot is unfilled. Only the first
  // PARTY_ACTIVE_SIZE_MAX of the PARTY_MEMBER_COUNT_MAX roster members
  // can be in the active lineup at once.
  uint8_t order[PARTY_ACTIVE_SIZE_MAX];
 } party_t;
 extern party_t PARTY;
 /**
 * Initializes the party system with an empty roster and order.
 */
 void partyInit(void);
 /**
 * Gets an available (unused) party member slot index.
 *
 * @return The index of an available slot, or 0xFF if the party is full.
 */
 uint8_t partyGetAvailableMember(void);
 /**
 * Adds a member to the party roster in the next available slot. Party
 * members are always allies controlled by the player. If there is a
 * free active order slot, the new member is placed into it.
 *
 * @param stats The member's base combat stats.
 * @param healthMax The member's maximum health.
 * @param mpMax The member's maximum mp.
 * @return Pointer to the newly added party member, or NULL if the party is
 *         already full.
 */
 battlefighter_t *partyAddMember(
  const battlefighterstats_t stats,
  const uint16_t healthMax,
  const uint16_t mpMax
 );
 /**
 * Gets the roster member currently occupying an active order slot.
 *
 * @param slot The active order slot to query.
 * @return Pointer to the member in that slot, or NULL if the slot is
 *         empty.
 */
 battlefighter_t *partyGetOrderMember(const uint8_t slot);
 /**
 * Assigns a roster member to an active order slot, replacing whatever
 * was there. Use PARTY_ORDER_EMPTY to clear a slot.
 *
 * @param slot The active order slot to assign.
 * @param memberIndex The roster member index to place there, or
 *        PARTY_ORDER_EMPTY to clear the slot.
 */
 void partySetOrder(const uint8_t slot, const uint8_t memberIndex);
@@ -7,7 +7,6 @@
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
  PUBLIC
    cutscenesystem.c
    cutscenemode.c
 )
 # Subdirs
@@ -7,8 +7,226 @@
 #pragma once
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/cutscene/cutscenepause.h"
 typedef struct cutscene_s {
  const cutsceneitem_t *items;
  uint8_t itemCount;
  cutscenepause_t pause;
  // Size in bytes of this cutscene's custom user data, carved out of
  // CUTSCENE_SYSTEM.data while the cutscene is running.
  size_t dataSize;
 } cutscene_t;
 #define CUTSCENE(NAME, SIZE, PAUSE_TYPE, ...) \
  static const cutsceneitem_t CUTSCENE_##NAME##_ITEMS[] = { __VA_ARGS__ }; \
  static const cutscene_t CUTSCENE_##NAME = { \
    .items = CUTSCENE_##NAME##_ITEMS, \
    .itemCount = sizeof(CUTSCENE_##NAME##_ITEMS) / sizeof(cutsceneitem_t), \
    .pause = CUTSCENE_PAUSE_##PAUSE_TYPE, \
    .dataSize = SIZE \
  };
 #define CUTSCENE_REFERENCE(CUTSCENE) \
  &CUTSCENE_##CUTSCENE
 #define CUTSCENE_TEXT(TEXT) \
  { .type = CUTSCENE_ITEM_TYPE_TEXT, .text = { .text = TEXT } }
 #define CUTSCENE_TEXT_MINI(TEXT, X, Y, Z, DURATION) \
  { \
    .type = CUTSCENE_ITEM_TYPE_TEXT_MINI, \
    .textMini = { \
      .text = TEXT, \
      .position = { X, Y, Z }, \
      .duration = DURATION \
    } \
  }
 #define CUTSCENE_TEXT_MINI_HIDE(INDEX) \
  { \
    .type = CUTSCENE_ITEM_TYPE_TEXT_MINI_HIDE, \
    .textMiniHide = { .index = INDEX } \
  }
 #define CUTSCENE_WAIT(WAIT) \
  { .type = CUTSCENE_ITEM_TYPE_WAIT, .wait = WAIT }
 #define CUTSCENE_CUTSCENE(CUTSCENE) \
  { \
    .type = CUTSCENE_ITEM_TYPE_CUTSCENE, \
    .cutscene = CUTSCENE_REFERENCE(CUTSCENE) \
  }
 #define CUTSCENE_CALLBACK(CALLBACK) \
  { .type = CUTSCENE_ITEM_TYPE_CALLBACK, .callback = CALLBACK }
 #define CUTSCENE_ENTITY_WALK_TO(ENTITY_INDEX, X, Y, Z) \
  { \
    .type = CUTSCENE_ITEM_TYPE_ENTITY_WALK_TO, \
    .entityWalkTo = { \
      .entityIndex = ENTITY_INDEX, \
      .positions = (const worldpos_t[]){ { X, Y, Z } }, \
      .count = 1, \
      .walkAround = true \
    } \
  }
 #define CUTSCENE_ENTITY_WALK_PATH(NAME, ENTITY_INDEX, ...) \
  static const worldpos_t CUTSCENE_##NAME##_POSITIONS[] = { __VA_ARGS__ }; \
  static const cutsceneitem_t CUTSCENE_##NAME = { \
    .type = CUTSCENE_ITEM_TYPE_ENTITY_WALK_TO, \
    .entityWalkTo = { \
      .entityIndex = ENTITY_INDEX, \
      .positions = CUTSCENE_##NAME##_POSITIONS, \
      .count = sizeof(CUTSCENE_##NAME##_POSITIONS) / sizeof(worldpos_t), \
      .walkAround = true \
    } \
  }
 #define CUTSCENE_ENTITY_REMOVE(ENTITY_INDEX) \
  { \
    .type = CUTSCENE_ITEM_TYPE_ENTITY_REMOVE, \
    .entityRemove = { .entityIndex = ENTITY_INDEX } \
  }
 #define CUTSCENE_ENTITY_ADD(TYPE, X, Y, Z) \
  { \
    .type = CUTSCENE_ITEM_TYPE_ENTITY_ADD, \
    .entityAdd = { .entityType = TYPE, .position = { X, Y, Z } } \
  }
 #define CUTSCENE_ENTITY_TURN(ENTITY_INDEX, DIRECTION) \
  { \
    .type = CUTSCENE_ITEM_TYPE_ENTITY_TURN, \
    .entityTurn = { .entityIndex = ENTITY_INDEX, .direction = DIRECTION } \
  }
 // Walks ENTITY_INDEX to stand beside TARGET_ENTITY_INDEX, offset by
 // (OFFSET_X, OFFSET_Y) on the 2D plane. The destination Z is resolved
 // from nearby terrain each frame, so ramps between the two entities are
 // accounted for automatically.
 #define CUTSCENE_ENTITY_WALK_TO_ENTITY( \
  ENTITY_INDEX, TARGET_ENTITY_INDEX, OFFSET_X, OFFSET_Y \
 ) \
  { \
    .type = CUTSCENE_ITEM_TYPE_ENTITY_WALK_TO_ENTITY, \
    .entityWalkToEntity = { \
      .entityIndex = ENTITY_INDEX, \
      .targetEntityIndex = TARGET_ENTITY_INDEX, \
      .offsetX = OFFSET_X, \
      .offsetY = OFFSET_Y \
    } \
  }
 #define CUTSCENE_ENTITY_TELEPORT(ENTITY_INDEX, X, Y, Z) \
  { \
    .type = CUTSCENE_ITEM_TYPE_ENTITY_TELEPORT, \
    .entityTeleport = { .entityIndex = ENTITY_INDEX, .target = { X, Y, Z } } \
  }
 #define CUTSCENE_FADE(FROM, TO, DURATION, EASING) \
  { \
    .type = CUTSCENE_ITEM_TYPE_FADE, \
    .fade = { .from = FROM, .to = TO, .duration = DURATION, .easing = EASING } \
  }
 #define CUTSCENE_FADE_TO_BLACK(DURATION) \
  CUTSCENE_FADE(COLOR_TRANSPARENT_BLACK, COLOR_BLACK, DURATION, EASING_LINEAR)
 #define CUTSCENE_FADE_FROM_BLACK(DURATION) \
  CUTSCENE_FADE(COLOR_BLACK, COLOR_TRANSPARENT_BLACK, DURATION, EASING_LINEAR)
 #define CUTSCENE_FADE_TO_WHITE(DURATION) \
  CUTSCENE_FADE(COLOR_TRANSPARENT_WHITE, COLOR_WHITE, DURATION, EASING_LINEAR)
 #define CUTSCENE_FADE_FROM_WHITE(DURATION) \
  CUTSCENE_FADE(COLOR_WHITE, COLOR_TRANSPARENT_WHITE, DURATION, EASING_LINEAR)
 #define CUTSCENE_EMOJI(ENTITY_INDEX, EMOJI_TYPE, DURATION) \
  { \
    .type = CUTSCENE_ITEM_TYPE_EMOJI, \
    .emoji = { \
      .entityIndex = ENTITY_INDEX, \
      .emojiType = EMOJI_TYPE, \
      .duration = DURATION \
    } \
  }
 // AMOUNT ranges 0 (no shake) to 4 (three tiles): 1 is half a tile, 2 is
 // a full tile, 3 is two tiles, and 4 is three tiles.
 #define CUTSCENE_SHAKE(AMOUNT, DURATION) \
  { \
    .type = CUTSCENE_ITEM_TYPE_SHAKE, \
    .shake = { .amount = AMOUNT, .duration = DURATION } \
  }
 #define CUTSCENE_SET_PAUSE(FLAGS) \
  { .type = CUTSCENE_ITEM_TYPE_SET_PAUSE, .setPause = (FLAGS) }
 #define CUTSCENE_ITEM_GIVE(ITEM_ID, QUANTITY) \
  { \
    .type = CUTSCENE_ITEM_TYPE_ITEM_GIVE, \
    .itemGive = { .item = ITEM_ID, .quantity = QUANTITY } \
  }
 // Runs all listed items simultaneously and waits until all are done.
 // Concurrent items cannot be nested inside another CUTSCENE_CONCURRENT.
 #define CUTSCENE_CONCURRENT(...) \
  { \
    .type = CUTSCENE_ITEM_TYPE_CONCURRENT, \
    .concurrent = { \
      .items = (const cutsceneitem_t[]){ __VA_ARGS__ }, \
      .count = (uint8_t)( \
        sizeof((cutsceneitem_t[]){ __VA_ARGS__ }) / \
        sizeof(cutsceneitem_t) \
      ) \
    } \
  }
 #define CUTSCENE_MAP_AREA_ADD( \
  MIN_X, MIN_Y, MIN_Z, MAX_X, MAX_Y, MAX_Z, CALLBACK, NOTIFY, TRIGGER \
 ) \
  { \
    .type = CUTSCENE_ITEM_TYPE_MAP_AREA_ADD, \
    .mapAreaAdd = { \
      .min = { MIN_X, MIN_Y, MIN_Z }, \
      .max = { MAX_X, MAX_Y, MAX_Z }, \
      .callback = CALLBACK, \
      .notify = NOTIFY, \
      .trigger = TRIGGER \
    } \
  }
 #define CUTSCENE_MAP_AREA_REMOVE(AREA_ID) \
  { \
    .type = CUTSCENE_ITEM_TYPE_MAP_AREA_REMOVE, \
    .mapAreaRemove = { .areaId = AREA_ID } \
  }
 // Waits until any one of the given map area IDs has its callback invoked.
 // Accepts CUTSCENE_AREA_LAST_CREATED in place of a literal area ID.
 #define CUTSCENE_MAP_AREA_WAIT(...) \
  { \
    .type = CUTSCENE_ITEM_TYPE_MAP_AREA_WAIT, \
    .mapAreaWait = { \
      .areaIds = (const uint8_t[]){ __VA_ARGS__ }, \
      .count = (uint8_t)( \
        sizeof((const uint8_t[]){ __VA_ARGS__ }) / sizeof(uint8_t) \
      ) \
    } \
  }
 // Adds a map area, waits for it to be triggered once, then removes it
 // before the cutscene continues. Uses a no-op callback since the wait is
 // driven by the area's trigger count rather than callback logic.
 #define CUTSCENE_MAP_AREA_TRIGGER_ONCE( \
  MIN_X, MIN_Y, MIN_Z, MAX_X, MAX_Y, MAX_Z, NOTIFY, TRIGGER \
 ) \
  CUTSCENE_MAP_AREA_ADD( \
    MIN_X, MIN_Y, MIN_Z, MAX_X, MAX_Y, MAX_Z, \
    mapAreaNoopCallback, NOTIFY, TRIGGER \
  ), \
  CUTSCENE_MAP_AREA_WAIT(CUTSCENE_AREA_LAST_CREATED), \
  CUTSCENE_MAP_AREA_REMOVE(CUTSCENE_AREA_LAST_CREATED)
@@ -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();
@@ -0,0 +1,24 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "dusk.h"
 typedef uint8_t cutscenepause_t;
 #define CUTSCENE_PAUSE_NONE    ((cutscenepause_t)0)
 #define CUTSCENE_PAUSE_NPC     ((cutscenepause_t)(1 << 0))
 #define CUTSCENE_PAUSE_PLAYER  ((cutscenepause_t)(1 << 1))
 #define CUTSCENE_PAUSE_WORLD   ((cutscenepause_t)(1 << 2))
 #define CUTSCENE_PAUSE_DEFAULT ((cutscenepause_t)( \
  CUTSCENE_PAUSE_NPC | CUTSCENE_PAUSE_PLAYER \
 ))
 #define CUTSCENE_PAUSE_ALL ((cutscenepause_t)( \
  CUTSCENE_PAUSE_NPC | CUTSCENE_PAUSE_PLAYER | CUTSCENE_PAUSE_WORLD \
 ))
@@ -6,7 +6,9 @@
 */
 #include "cutscenesystem.h"
 #include "rpg/entity/entity.h"
 #include "util/memory.h"
 #include "assert/assert.h"
 cutscenesystem_t CUTSCENE_SYSTEM;
@@ -15,9 +17,28 @@ void cutsceneSystemInit() {
 }
 void cutsceneSystemStartCutscene(const cutscene_t *cutscene) {
  cutsceneSystemStartCutsceneWith(cutscene, NULL, NULL);
 }
 void cutsceneSystemStartCutsceneWith(
  const cutscene_t *cutscene,
  entity_t *interact,
  entity_t *interacted
 ) {
  assertTrue(
    cutscene->dataSize < CUTSCENE_SYSTEM_SIZE_MAX,
    "Cutscene data size exceeds CUTSCENE_SYSTEM_SIZE_MAX"
  );
  CUTSCENE_SYSTEM.scene = cutscene;
-  CUTSCENE_SYSTEM.mode = CUTSCENE_MODE_INITIAL;
+  CUTSCENE_SYSTEM.pause = cutscene->pause;
-  CUTSCENE_SYSTEM.currentItem = 0xFF;// Set to 0xFF so start wraps.
+  CUTSCENE_SYSTEM.entityInteract = interact;
  CUTSCENE_SYSTEM.entityInteracted = interacted;
  CUTSCENE_SYSTEM.entityLastCreated = NULL;
  CUTSCENE_SYSTEM.entityLastRef = NULL;
  CUTSCENE_SYSTEM.areaLastCreated = CUTSCENE_AREA_LAST_CREATED;
  CUTSCENE_SYSTEM.textMiniLastCreated = CUTSCENE_TEXT_MINI_LAST_CREATED;
  CUTSCENE_SYSTEM.currentItem = 0xFF;// Set to 0xFF so Next wraps to 0.
  cutsceneSystemNext();
 }
@@ -25,7 +46,7 @@ void cutsceneSystemUpdate() {
  if(CUTSCENE_SYSTEM.scene == NULL) return;
  const cutsceneitem_t *item = cutsceneSystemGetCurrentItem();
-  cutsceneItemUpdate(item, &CUTSCENE_SYSTEM.data);
+  if(cutsceneItemUpdate(item, &CUTSCENE_SYSTEM.data)) cutsceneSystemNext();
 }
 void cutsceneSystemNext() {
@@ -39,7 +60,13 @@ void cutsceneSystemNext() {
  ) {
    CUTSCENE_SYSTEM.scene = NULL;
    CUTSCENE_SYSTEM.currentItem = 0xFF;
-    CUTSCENE_SYSTEM.mode = CUTSCENE_MODE_NONE;
+    CUTSCENE_SYSTEM.pause = CUTSCENE_PAUSE_NONE;
    CUTSCENE_SYSTEM.entityInteract = NULL;
    CUTSCENE_SYSTEM.entityInteracted = NULL;
    CUTSCENE_SYSTEM.entityLastCreated = NULL;
    CUTSCENE_SYSTEM.entityLastRef = NULL;
    CUTSCENE_SYSTEM.areaLastCreated = CUTSCENE_AREA_LAST_CREATED;
  CUTSCENE_SYSTEM.textMiniLastCreated = CUTSCENE_TEXT_MINI_LAST_CREATED;
    return;
  }
@@ -55,8 +82,76 @@ const cutsceneitem_t * cutsceneSystemGetCurrentItem() {
  return &CUTSCENE_SYSTEM.scene->items[CUTSCENE_SYSTEM.currentItem];
 }
 entity_t * cutsceneSystemGetEntity(const uint8_t entityIndex) {
  entity_t *entity;
  if(entityIndex == CUTSCENE_ENTITY_INTERACT) {
    assertNotNull(
      CUTSCENE_SYSTEM.entityInteract,
      "CUTSCENE_ENTITY_INTERACT used but no interact entity is set"
    );
    entity = CUTSCENE_SYSTEM.entityInteract;
  } else if(entityIndex == CUTSCENE_ENTITY_INTERACTED) {
    assertNotNull(
      CUTSCENE_SYSTEM.entityInteracted,
      "CUTSCENE_ENTITY_INTERACTED used but no interacted entity is set"
    );
    entity = CUTSCENE_SYSTEM.entityInteracted;
  } else if(entityIndex == CUTSCENE_ENTITY_LAST_CREATED) {
    assertNotNull(
      CUTSCENE_SYSTEM.entityLastCreated,
      "CUTSCENE_ENTITY_LAST_CREATED used but no entity has been created"
    );
    entity = CUTSCENE_SYSTEM.entityLastCreated;
  } else if(entityIndex == CUTSCENE_ENTITY_LAST_REF) {
    assertNotNull(
      CUTSCENE_SYSTEM.entityLastRef,
      "CUTSCENE_ENTITY_LAST_REF used but no entity has been referenced"
    );
    entity = CUTSCENE_SYSTEM.entityLastRef;
  } else {
    assertTrue(
      entityIndex < ENTITY_COUNT,
      "Entity index is out of range"
    );
    entity = &ENTITIES[entityIndex];
  }
  CUTSCENE_SYSTEM.entityLastRef = entity;
  return entity;
 }
 uint8_t cutsceneSystemGetAreaId(const uint8_t areaId) {
  if(areaId == CUTSCENE_AREA_LAST_CREATED) {
    assertTrue(
      CUTSCENE_SYSTEM.areaLastCreated != CUTSCENE_AREA_LAST_CREATED,
      "CUTSCENE_AREA_LAST_CREATED used but no map area has been created"
    );
    return CUTSCENE_SYSTEM.areaLastCreated;
  }
  return areaId;
 }
 uint8_t cutsceneSystemGetTextMiniId(const uint8_t index) {
  if(index == CUTSCENE_TEXT_MINI_LAST_CREATED) {
    assertTrue(
      CUTSCENE_SYSTEM.textMiniLastCreated != CUTSCENE_TEXT_MINI_LAST_CREATED,
      "CUTSCENE_TEXT_MINI_LAST_CREATED used but no mini textbox has been "
      "shown"
    );
    return CUTSCENE_SYSTEM.textMiniLastCreated;
  }
  return index;
 }
 void cutsceneSystemDispose() {
  CUTSCENE_SYSTEM.scene = NULL;
  CUTSCENE_SYSTEM.currentItem = 0xFF;
-  CUTSCENE_SYSTEM.mode = CUTSCENE_MODE_NONE;
+  CUTSCENE_SYSTEM.pause = CUTSCENE_PAUSE_NONE;
  CUTSCENE_SYSTEM.entityInteract = NULL;
  CUTSCENE_SYSTEM.entityInteracted = NULL;
  CUTSCENE_SYSTEM.entityLastCreated = NULL;
  CUTSCENE_SYSTEM.entityLastRef = NULL;
  CUTSCENE_SYSTEM.areaLastCreated = CUTSCENE_AREA_LAST_CREATED;
  CUTSCENE_SYSTEM.textMiniLastCreated = CUTSCENE_TEXT_MINI_LAST_CREATED;
 }
@@ -7,15 +7,37 @@
 #pragma once
 #include "cutscene.h"
-#include "cutscenemode.h"
+
 typedef struct entity_s entity_t;
 #define CUTSCENE_ENTITY_INTERACT      ((uint8_t)0xFE)
 #define CUTSCENE_ENTITY_INTERACTED    ((uint8_t)0xFD)
 #define CUTSCENE_ENTITY_LAST_CREATED  ((uint8_t)0xFC)
 #define CUTSCENE_ENTITY_LAST_REF      ((uint8_t)0xFB)
 #define CUTSCENE_AREA_LAST_CREATED    ((uint8_t)0xFF)
 #define CUTSCENE_TEXT_MINI_LAST_CREATED ((uint8_t)0xFA)
 // Maximum number of bytes a running cutscene may request via
 // cutscene_t.dataSize.
 #define CUTSCENE_SYSTEM_SIZE_MAX 8192
 typedef struct {
  const cutscene_t *scene;
  uint8_t currentItem;
  cutscenepause_t pause;
  entity_t *entityInteract;
  entity_t *entityInteracted;
  entity_t *entityLastCreated;
  entity_t *entityLastRef;
  uint8_t areaLastCreated;
  uint8_t textMiniLastCreated;
  // Data (used by the current item).
  cutsceneitemdata_t data;
-  cutscenemode_t mode;
+
  // Custom user data for the running cutscene, sized per-scene by
  // cutscene_t.dataSize.
  uint8_t userData[CUTSCENE_SYSTEM_SIZE_MAX];
 } cutscenesystem_t;
 extern cutscenesystem_t CUTSCENE_SYSTEM;
@@ -26,12 +48,55 @@ extern cutscenesystem_t CUTSCENE_SYSTEM;
 void cutsceneSystemInit();
 /**
- * Start a cutscene.
+ * Start a cutscene with no bound entities.
 *
 * @param cutscene Pointer to the cutscene to start.
 */
 void cutsceneSystemStartCutscene(const cutscene_t *cutscene);
 /**
 * Start a cutscene with the two entities that triggered it.
 *
 * @param cutscene    Pointer to the cutscene to start.
 * @param interact    The entity that initiated the interaction (player).
 * @param interacted  The entity that was interacted with (NPC).
 */
 void cutsceneSystemStartCutsceneWith(
  const cutscene_t *cutscene,
  entity_t *interact,
  entity_t *interacted
 );
 /**
 * Resolves a raw entity index (or sentinel) to an entity pointer.
 * Handles CUTSCENE_ENTITY_INTERACT, CUTSCENE_ENTITY_INTERACTED,
 * CUTSCENE_ENTITY_LAST_CREATED and CUTSCENE_ENTITY_LAST_REF.
 * Updates CUTSCENE_SYSTEM.entityLastRef to the resolved entity.
 * Asserts the resolved entity is within bounds.
 *
 * @param entityIndex Raw entity index or sentinel value.
 * @returns Pointer to the resolved entity.
 */
 entity_t * cutsceneSystemGetEntity(const uint8_t entityIndex);
 /**
 * Resolves a raw map area ID (or CUTSCENE_AREA_LAST_CREATED sentinel) to
 * a concrete map area ID.
 *
 * @param areaId Raw map area ID or sentinel value.
 * @returns The resolved map area ID.
 */
 uint8_t cutsceneSystemGetAreaId(const uint8_t areaId);
 /**
 * Resolves a raw mini textbox slot index (or CUTSCENE_TEXT_MINI_LAST_CREATED
 * sentinel) to a concrete UI_TEXTBOX_MINI_LIST slot index.
 *
 * @param index Raw slot index or sentinel value.
 * @returns The resolved slot index.
 */
 uint8_t cutsceneSystemGetTextMiniId(const uint8_t index);
 /**
 * Advance to the next item in the cutscene.
 */
@@ -3,9 +3,15 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 # Sources
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
  PUBLIC
    cutsceneitem.c
-    cutsceneentitymove.c
+    cutscenecallback.c
 )
 add_subdirectory(control)
 add_subdirectory(entity)
 add_subdirectory(item)
 add_subdirectory(maparea)
 add_subdirectory(ui)
 add_subdirectory(battle)
@@ -0,0 +1,9 @@
 # Copyright (c) 2026 Dominic Masters
 #
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
  PUBLIC
    cutscenestartbattle.c
 )
@@ -0,0 +1,71 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/battle/party.h"
 #include "scene/scene.h"
 void cutsceneStartBattleStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  const cutscenestartbattle_t *config = &item->startBattle;
  battleInit();
  for(uint8_t i = 0; i < PARTY_ACTIVE_SIZE_MAX; i++) {
    battlefighter_t *member = partyGetOrderMember(i);
    if(member == NULL) continue;
    battlefighter_t *fighter = battleAddFighter(
      BATTLE_FIGHTER_TEAM_ALLY, BATTLE_FIGHTER_CONTROLLER_PLAYER,
      member->stats, member->healthMax, member->mpMax
    );
    if(fighter == NULL) continue;
    fighter->health = member->health;
    fighter->mp = member->mp;
    fighter->status = member->status;
  }
  for(uint8_t i = 0; i < config->enemyCount; i++) {
    const cutscenestartbattleenemy_t *enemy = &config->enemies[i];
    battleAddFighter(
      BATTLE_FIGHTER_TEAM_ENEMY, BATTLE_FIGHTER_CONTROLLER_AI,
      enemy->stats, enemy->healthMax, enemy->mpMax
    );
  }
  battleStart(config->encounterType, config->fleeAvailable);
  sceneSet(SCENE_TYPE_BATTLE);
 }
 bool_t cutsceneStartBattleUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  if(BATTLE.result == BATTLE_RESULT_NONE) return false;
  // Sync ally HP/MP back to the persistent party roster. Relies on
  // ally fighters having been added to BATTLE.fighters in the same
  // order partyGetOrderMember() iterates, starting at index 0 (see
  // cutsceneStartBattleStart).
  uint8_t allySlot = 0;
  for(uint8_t i = 0; i < PARTY_ACTIVE_SIZE_MAX; i++) {
    battlefighter_t *member = partyGetOrderMember(i);
    if(member == NULL) continue;
    battlefighter_t *fighter = &BATTLE.fighters[allySlot++];
    member->health = fighter->health;
    member->mp = fighter->mp;
    member->status = fighter->status;
  }
  sceneSet(SCENE_TYPE_OVERWORLD);
  battleDispose();
  return true;
 }
@@ -0,0 +1,53 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "rpg/battle/battle.h"
 #define CUTSCENE_START_BATTLE_ENEMY_COUNT_MAX 4
 typedef struct {
  battlefighterstats_t stats;
  uint16_t healthMax;
  uint16_t mpMax;
 } cutscenestartbattleenemy_t;
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef struct {
  battleencountertype_t encounterType;
  bool_t fleeAvailable;
  uint8_t enemyCount;
  cutscenestartbattleenemy_t enemies[CUTSCENE_START_BATTLE_ENEMY_COUNT_MAX];
 } cutscenestartbattle_t;
 /**
 * Starts a battle: seeds BATTLE with the party's active order members
 * and the item's configured enemies, then switches to the battle
 * scene.
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneStartBattleStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Waits for the battle to produce a result, syncs ally HP/MP back to
 * the party roster, then returns to the overworld scene.
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true once the battle has ended.
 */
 bool_t cutsceneStartBattleUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,11 @@
 # Copyright (c) 2026 Dominic Masters
 #
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
  PUBLIC
    cutscenewait.c
    cutscenesetpause.c
    cutsceneconcurrent.c
 )
@@ -0,0 +1,46 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "assert/assert.h"
 void cutsceneConcurrentStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  assertTrue(
    item->concurrent.count <= CUTSCENE_CONCURRENT_MAX,
    "Too many items in CUTSCENE_CONCURRENT"
  );
  for(uint8_t i = 0; i < item->concurrent.count; i++) {
    assertTrue(
      item->concurrent.items[i].type != CUTSCENE_ITEM_TYPE_CONCURRENT,
      "Concurrent items cannot be nested"
    );
    cutsceneItemStart(
      &item->concurrent.items[i],
      (cutsceneitemdata_t *)&data->concurrent.childData[i]
    );
  }
 }
 bool_t cutsceneConcurrentUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  for(uint8_t i = 0; i < item->concurrent.count; i++) {
    if(data->concurrent.doneMask & (1u << i)) continue;
    if(cutsceneItemUpdate(
      &item->concurrent.items[i],
      (cutsceneitemdata_t *)&data->concurrent.childData[i]
    )) {
      data->concurrent.doneMask |= (uint8_t)(1u << i);
    }
  }
  uint8_t allDone = (uint8_t)((1u << item->concurrent.count) - 1u);
  return data->concurrent.doneMask == allDone;
 }
@@ -0,0 +1,62 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "cutscenewait.h"
 #include "rpg/cutscene/item/entity/cutsceneentitywalkto.h"
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 /** Maximum number of items that may run inside a CUTSCENE_CONCURRENT. */
 #define CUTSCENE_CONCURRENT_MAX 8
 /**
 * Static (const) data for a concurrent cutscene item.
 */
 typedef struct {
  const cutsceneitem_t *items;
  uint8_t count;
 } cutsceneconcurrent_t;
 /**
 * Runtime data for one non-concurrent child item.
 * Concurrent items cannot be nested.
 */
 typedef union {
  cutscenewaitdata_t wait;
  cutsceneentitywalktodata_t entityWalkTo;
 } cutsceneconcurrentchilddata_t;
 /** Runtime data for a running concurrent item. */
 typedef struct {
  cutsceneconcurrentchilddata_t childData[CUTSCENE_CONCURRENT_MAX];
  uint8_t doneMask;
 } cutsceneconcurrentdata_t;
 /**
 * Starts a concurrent item (starts all child items simultaneously).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneConcurrentStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates a concurrent item (ticks all unfinished children).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true once every child has completed.
 */
 bool_t cutsceneConcurrentUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,23 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/cutscene/cutscenesystem.h"
 void cutsceneSetPauseStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  CUTSCENE_SYSTEM.pause = item->setPause;
 }
 bool_t cutsceneSetPauseUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  return true;
 }
@@ -0,0 +1,35 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "rpg/cutscene/cutscenepause.h"
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 /**
 * Starts a set-pause item (applies the new pause flags immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneSetPauseStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates a set-pause item (always completes immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true always.
 */
 bool_t cutsceneSetPauseUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,24 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "time/time.h"
 void cutsceneWaitStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  data->wait = item->wait;
 }
 bool_t cutsceneWaitUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  data->wait -= TIME.delta;
  return data->wait <= 0;
 }
@@ -0,0 +1,38 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "dusk.h"
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef float_t cutscenewait_t;
 typedef float_t cutscenewaitdata_t;
 /**
 * Starts a wait item (stores the duration in data).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneWaitStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates a wait item.
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true when the wait has elapsed.
 */
 bool_t cutsceneWaitUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,23 @@
 /**
 * Copyright (c) 2025 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "cutsceneitem.h"
 #include "rpg/cutscene/cutscenesystem.h"
 void cutsceneCallbackStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  if(item->callback != NULL) item->callback(CUTSCENE_SYSTEM.userData);
 }
 bool_t cutsceneCallbackUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  return true;
 }
@@ -8,4 +8,30 @@
 #pragma once
 #include "dusk.h"
-typedef void (*cutscenecallback_t)(void);
+typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef void (*cutscenecallback_t)(void *userData);
 /**
 * Starts a callback item (invokes the callback immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneCallbackStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates a callback item (always completes immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true always.
 */
 bool_t cutsceneCallbackUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -1,39 +0,0 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "cutsceneentitymove.h"
 #include "rpg/cutscene/cutscenesystem.h"
 #include "rpg/entity/entity.h"
 void cutsceneEntityMoveStart(const cutsceneitem_t *item) {
 }
 void cutsceneEntityMoveUpdate(const cutsceneitem_t *item) {
  entity_t *entity = &ENTITIES[item->entityMove.entityIndex];
  if(worldPosIsEqual(entity->position, item->entityMove.target)) {
    cutsceneSystemNext();
    return;
  }
  entitydir_t dir;
  if(entity->position.x != item->entityMove.target.x) {
    dir = entity->position.x < item->entityMove.target.x
      ? ENTITY_DIR_EAST : ENTITY_DIR_WEST;
  } else {
    dir = entity->position.y < item->entityMove.target.y
      ? ENTITY_DIR_SOUTH : ENTITY_DIR_NORTH;
  }
  if(entityCanTurn(entity)) entityTurn(entity, dir);
  if(item->entityMove.run) {
    if(entityCanRun(entity)) entityRun(entity, dir);
  } else {
    if(entityCanWalk(entity)) entityWalk(entity, dir);
  }
 }
@@ -1,24 +0,0 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "cutsceneitem.h"
 /**
 * Handles the start of an entity move cutscene item.
 *
 * @param item The cutscene item.
 */
 void cutsceneEntityMoveStart(const cutsceneitem_t *item);
 /**
 * Updates an entity move cutscene item, steering the entity one step
 * per frame toward the target and advancing the cutscene on arrival.
 *
 * @param item The cutscene item.
 */
 void cutsceneEntityMoveUpdate(const cutsceneitem_t *item);
@@ -6,58 +6,147 @@
 */
 #include "rpg/cutscene/cutscenesystem.h"
-#include "cutsceneentitymove.h"
+
-#include "input/input.h"
+cutsceneitemcallbacks_t CUTSCENE_ITEM_CALLBACKS[CUTSCENE_ITEM_TYPE_COUNT] = {
-#include "time/time.h"
+  [CUTSCENE_ITEM_TYPE_NULL] = { 0 },
  [CUTSCENE_ITEM_TYPE_TEXT] = {
    .init = cutsceneTextStart,
    .update = cutsceneTextUpdate
  },
  [CUTSCENE_ITEM_TYPE_TEXT_MINI] = {
    .init = cutsceneTextMiniStart,
    .update = cutsceneTextMiniUpdate
  },
  [CUTSCENE_ITEM_TYPE_TEXT_MINI_HIDE] = {
    .init = cutsceneTextMiniHideStart,
    .update = cutsceneTextMiniHideUpdate
  },
  [CUTSCENE_ITEM_TYPE_CALLBACK] = {
    .init = cutsceneCallbackStart,
    .update = cutsceneCallbackUpdate
  },
  [CUTSCENE_ITEM_TYPE_WAIT] = {
    .init = cutsceneWaitStart,
    .update = cutsceneWaitUpdate
  },
  [CUTSCENE_ITEM_TYPE_CUTSCENE] = {
    .init = cutsceneCutsceneStart,
    .update = cutsceneCutsceneUpdate
  },
  [CUTSCENE_ITEM_TYPE_ENTITY_TELEPORT] = {
    .init = cutsceneEntityTeleportStart,
    .update = cutsceneEntityTeleportUpdate
  },
  [CUTSCENE_ITEM_TYPE_ENTITY_WALK_TO] = {
    .init = cutsceneEntityWalkToStart,
    .update = cutsceneEntityWalkToUpdate
  },
  [CUTSCENE_ITEM_TYPE_FADE] = {
    .init = cutsceneFadeStart,
    .update = cutsceneFadeUpdate
  },
  [CUTSCENE_ITEM_TYPE_SET_PAUSE] = {
    .init = cutsceneSetPauseStart,
    .update = cutsceneSetPauseUpdate
  },
  [CUTSCENE_ITEM_TYPE_CONCURRENT] = {
    .init = cutsceneConcurrentStart,
    .update = cutsceneConcurrentUpdate
  },
  [CUTSCENE_ITEM_TYPE_ITEM_GIVE] = {
    .init = cutsceneItemGiveStart,
    .update = cutsceneItemGiveUpdate
  },
  [CUTSCENE_ITEM_TYPE_ENTITY_REMOVE] = {
    .init = cutsceneEntityRemoveStart,
    .update = cutsceneEntityRemoveUpdate
  },
  [CUTSCENE_ITEM_TYPE_ENTITY_ADD] = {
    .init = cutsceneEntityAddStart,
    .update = cutsceneEntityAddUpdate
  },
  [CUTSCENE_ITEM_TYPE_ENTITY_TURN] = {
    .init = cutsceneEntityTurnStart,
    .update = cutsceneEntityTurnUpdate
  },
  [CUTSCENE_ITEM_TYPE_ENTITY_WALK_TO_ENTITY] = {
    .init = cutsceneEntityWalkToEntityStart,
    .update = cutsceneEntityWalkToEntityUpdate
  },
  [CUTSCENE_ITEM_TYPE_MAP_AREA_ADD] = {
    .init = cutsceneMapAreaAddStart,
    .update = cutsceneMapAreaAddUpdate
  },
  [CUTSCENE_ITEM_TYPE_MAP_AREA_REMOVE] = {
    .init = cutsceneMapAreaRemoveStart,
    .update = cutsceneMapAreaRemoveUpdate
  },
  [CUTSCENE_ITEM_TYPE_MAP_AREA_WAIT] = {
    .init = cutsceneMapAreaWaitStart,
    .update = cutsceneMapAreaWaitUpdate
  },
  [CUTSCENE_ITEM_TYPE_START_BATTLE] = {
    .init = cutsceneStartBattleStart,
    .update = cutsceneStartBattleUpdate
  },
  [CUTSCENE_ITEM_TYPE_EMOJI] = {
    .init = cutsceneEmojiStart,
    .update = cutsceneEmojiUpdate
  },
  [CUTSCENE_ITEM_TYPE_SHAKE] = {
    .init = cutsceneShakeStart,
    .update = cutsceneShakeUpdate
  }
 };
 void cutsceneItemStart(const cutsceneitem_t *item, cutsceneitemdata_t *data) {
-  switch(item->type) {
+  cutsceneiteminitcallback_t *init = CUTSCENE_ITEM_CALLBACKS[item->type].init;
-    case CUTSCENE_ITEM_TYPE_TEXT: {
+  if(init != NULL) init(item, data);
-      rpgTextboxShow(
+}
        item->text.position,
        item->text.text
      );
      break;
    }
-    case CUTSCENE_ITEM_TYPE_WAIT:
+bool_t cutsceneItemUpdate(
-      data->wait = item->wait;
+  const cutsceneitem_t *item,
-      break;
+  cutsceneitemdata_t *data
 ) {
  cutsceneitemupdatecallback_t *update =
    CUTSCENE_ITEM_CALLBACKS[item->type].update;
  if(update == NULL) return false;
-    case CUTSCENE_ITEM_TYPE_CALLBACK:
+  return update(item, data);
-      if(item->callback != NULL) item->callback();
+}
      break;
-    case CUTSCENE_ITEM_TYPE_CUTSCENE:
+void cutsceneCutsceneStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  if(item->cutscene != NULL) cutsceneSystemStartCutscene(item->cutscene);
      break;
    case CUTSCENE_ITEM_TYPE_ENTITY_MOVE:
      cutsceneEntityMoveStart(item);
      break;
    default:
      break;
  }
 }
-void cutsceneItemUpdate(const cutsceneitem_t *item, cutsceneitemdata_t *data) {
+bool_t cutsceneCutsceneUpdate(
-  switch(item->type) {
+  const cutsceneitem_t *item,
-    case CUTSCENE_ITEM_TYPE_TEXT:
+  cutsceneitemdata_t *data
-      if(rpgTextboxIsVisible()) return;
+) {
-      cutsceneSystemNext();
+  return false;
      break;
    case CUTSCENE_ITEM_TYPE_WAIT:
      data->wait -= TIME.delta;
      if(data->wait <= 0) cutsceneSystemNext();
      break;
    case CUTSCENE_ITEM_TYPE_ENTITY_MOVE:
      cutsceneEntityMoveUpdate(item);
      break;
    default:
      break;
  }
 }
@@ -6,55 +6,158 @@
 */
 #pragma once
 #include "cutscenewait.h"
 #include "cutscenecallback.h"
-#include "cutscenetext.h"
+#include "control/cutscenewait.h"
-#include "rpg/overworld/worldpos.h"
+#include "control/cutscenesetpause.h"
 #include "control/cutsceneconcurrent.h"
 #include "entity/cutsceneentityteleport.h"
 #include "entity/cutsceneentitywalkto.h"
 #include "entity/cutsceneentityremove.h"
 #include "entity/cutsceneentityadd.h"
 #include "entity/cutsceneentityturn.h"
 #include "entity/cutsceneentitywalktoentity.h"
 #include "ui/cutscenetext.h"
 #include "ui/cutscenetextmini.h"
 #include "ui/cutscenetextminihide.h"
 #include "ui/cutscenefade.h"
 #include "ui/cutsceneemoji.h"
 #include "ui/cutsceneshake.h"
 #include "item/cutsceneitemgive.h"
 #include "maparea/cutscenemapareaadd.h"
 #include "maparea/cutscenemaparearemove.h"
 #include "maparea/cutscenemapareawait.h"
 #include "battle/cutscenestartbattle.h"
 typedef struct cutscene_s cutscene_t;
 typedef enum {
  CUTSCENE_ITEM_TYPE_NULL,
  CUTSCENE_ITEM_TYPE_TEXT,
  CUTSCENE_ITEM_TYPE_TEXT_MINI,
  CUTSCENE_ITEM_TYPE_TEXT_MINI_HIDE,
  CUTSCENE_ITEM_TYPE_CALLBACK,
  CUTSCENE_ITEM_TYPE_WAIT,
  CUTSCENE_ITEM_TYPE_CUTSCENE,
-  CUTSCENE_ITEM_TYPE_ENTITY_MOVE
+  CUTSCENE_ITEM_TYPE_ENTITY_TELEPORT,
  CUTSCENE_ITEM_TYPE_ENTITY_WALK_TO,
  CUTSCENE_ITEM_TYPE_FADE,
  CUTSCENE_ITEM_TYPE_SET_PAUSE,
  CUTSCENE_ITEM_TYPE_CONCURRENT,
  CUTSCENE_ITEM_TYPE_ITEM_GIVE,
  CUTSCENE_ITEM_TYPE_ENTITY_REMOVE,
  CUTSCENE_ITEM_TYPE_ENTITY_ADD,
  CUTSCENE_ITEM_TYPE_ENTITY_TURN,
  CUTSCENE_ITEM_TYPE_ENTITY_WALK_TO_ENTITY,
  CUTSCENE_ITEM_TYPE_MAP_AREA_ADD,
  CUTSCENE_ITEM_TYPE_MAP_AREA_REMOVE,
  CUTSCENE_ITEM_TYPE_MAP_AREA_WAIT,
  CUTSCENE_ITEM_TYPE_START_BATTLE,
  CUTSCENE_ITEM_TYPE_EMOJI,
  CUTSCENE_ITEM_TYPE_SHAKE,
  CUTSCENE_ITEM_TYPE_COUNT
 } cutsceneitemtype_t;
-typedef struct cutsceneitem_s {
+struct cutsceneitem_s {
  cutsceneitemtype_t type;
  // Arguments/Data that will be used when this item is invoked.
  union {
    cutscenetext_t text;
    cutscenetextmini_t textMini;
    cutscenetextminihide_t textMiniHide;
    cutscenecallback_t callback;
    cutscenewait_t wait;
    const cutscene_t *cutscene;
-    struct {
+    cutsceneentityteleport_t entityTeleport;
-      uint8_t entityIndex;
+    cutsceneentitywalkto_t entityWalkTo;
-      worldpos_t target;
+    cutscenefade_t fade;
-      bool_t run;
+    cutscenepause_t setPause;
-    } entityMove;
+    cutsceneconcurrent_t concurrent;
    cutsceneitemgive_t itemGive;
    cutsceneentityremove_t entityRemove;
    cutsceneentityadd_t entityAdd;
    cutsceneentityturn_t entityTurn;
    cutsceneentitywalktoentity_t entityWalkToEntity;
    cutscenemapareaadd_t mapAreaAdd;
    cutscenemaparearemove_t mapAreaRemove;
    cutscenemapareawait_t mapAreaWait;
    cutscenestartbattle_t startBattle;
    cutsceneemoji_t emoji;
    cutsceneshake_t shake;
  };
-} cutsceneitem_t;
+};
-typedef union {
+typedef union cutsceneitemdata_u {
  cutscenewaitdata_t wait;
  cutsceneentitywalktodata_t entityWalkTo;
  cutsceneconcurrentdata_t concurrent;
  cutscenemapareawaitdata_t mapAreaWait;
 } cutsceneitemdata_t;
 typedef void (cutsceneiteminitcallback_t)(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 typedef bool_t (cutsceneitemupdatecallback_t)(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 typedef struct {
  cutsceneiteminitcallback_t *init;
  cutsceneitemupdatecallback_t *update;
 } cutsceneitemcallbacks_t;
 extern cutsceneitemcallbacks_t
 CUTSCENE_ITEM_CALLBACKS[CUTSCENE_ITEM_TYPE_COUNT];
 /**
 * Start the given cutscene item.
 *
 * @param item The cutscene item to start.
- * @param data The cutscene item data storage.
+ * @param data Runtime data storage (pre-zeroed by caller).
 */
-void cutsceneItemStart(const cutsceneitem_t *item, cutsceneitemdata_t *data);
+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.
+ * @param data Runtime data storage.
 * @returns true if the item is complete and the cutscene should advance.
 */
-void cutsceneItemUpdate(const cutsceneitem_t *item, cutsceneitemdata_t *data);
+bool_t cutsceneItemUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Starts a nested-cutscene item, handing control over to the
 * referenced cutscene.
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneCutsceneStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates a nested-cutscene item. By the time this would run, control
 * has already moved on to the referenced cutscene, so this always
 * reports incomplete.
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns false always.
 */
 bool_t cutsceneCutsceneUpdate(
  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;
@@ -0,0 +1,14 @@
 # Copyright (c) 2026 Dominic Masters
 #
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
  PUBLIC
    cutsceneentityteleport.c
    cutsceneentitywalkto.c
    cutsceneentityremove.c
    cutsceneentityadd.c
    cutsceneentityturn.c
    cutsceneentitywalktoentity.c
 )
@@ -0,0 +1,33 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/cutscene/cutscenesystem.h"
 #include "rpg/entity/entity.h"
 #include "assert/assert.h"
 void cutsceneEntityAddStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  uint8_t entIndex = entityGetAvailable();
  assertTrue(entIndex != 0xFF, "No available entity slots for CUTSCENE_ENTITY_ADD");
  entity_t *entity = &ENTITIES[entIndex];
  entityInit(entity, item->entityAdd.entityType);
  entityPositionSet(entity, item->entityAdd.position);// Also assigns chunk.
  CUTSCENE_SYSTEM.entityLastCreated = entity;
  CUTSCENE_SYSTEM.entityLastRef = entity;
 }
 bool_t cutsceneEntityAddUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  return true;
 }
@@ -0,0 +1,41 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "rpg/entity/entitytype.h"
 #include "rpg/overworld/worldpos.h"
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef struct {
  entitytype_t entityType;
  worldpos_t position;
 } cutsceneentityadd_t;
 /**
 * Starts an entity add step (spawns the entity into the world immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneEntityAddStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates an entity add step (always completes immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true always.
 */
 bool_t cutsceneEntityAddUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,25 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/cutscene/cutscenesystem.h"
 #include "rpg/entity/entity.h"
 void cutsceneEntityRemoveStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  cutsceneSystemGetEntity(item->entityRemove.entityIndex)->type = \
    ENTITY_TYPE_NULL;
 }
 bool_t cutsceneEntityRemoveUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  return true;
 }
@@ -0,0 +1,39 @@
 /**
 * 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 cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef struct {
  uint8_t entityIndex;
 } cutsceneentityremove_t;
 /**
 * Starts an entity remove step (removes the entity from the world immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneEntityRemoveStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates an entity remove step (always completes immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true always.
 */
 bool_t cutsceneEntityRemoveUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,27 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/cutscene/cutscenesystem.h"
 #include "rpg/entity/entity.h"
 void cutsceneEntityTeleportStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  entityPositionSet(
    cutsceneSystemGetEntity(item->entityTeleport.entityIndex),
    item->entityTeleport.target
  );
 }
 bool_t cutsceneEntityTeleportUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  return true;
 }
@@ -0,0 +1,40 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "rpg/overworld/worldpos.h"
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef struct {
  uint8_t entityIndex;
  worldpos_t target;
 } cutsceneentityteleport_t;
 /**
 * Starts an entity teleport item (teleports the entity immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneEntityTeleportStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates an entity teleport item (always completes immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true always.
 */
 bool_t cutsceneEntityTeleportUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,30 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/cutscene/cutscenesystem.h"
 #include "rpg/entity/entity.h"
 void cutsceneEntityTurnStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
 }
 bool_t cutsceneEntityTurnUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  entity_t *entity = cutsceneSystemGetEntity(item->entityTurn.entityIndex);
  if(
    entity->direction == item->entityTurn.direction &&
    entity->animation == ENTITY_ANIM_IDLE
  ) return true;
  entityTurn(entity, item->entityTurn.direction);
  return false;
 }
@@ -0,0 +1,42 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "rpg/entity/entitydir.h"
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef struct {
  uint8_t entityIndex;
  entitydir_t direction;
 } cutsceneentityturn_t;
 /**
 * Starts an entity turn step. The turn itself is driven from Update, since
 * the entity may still be finishing a previous action.
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneEntityTurnStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates an entity turn step, retrying entityTurn until it takes effect
 * and its animation completes.
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true once the entity is idle and facing the target direction.
 */
 bool_t cutsceneEntityTurnUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,36 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/cutscene/cutscenesystem.h"
 #include "rpg/entity/entitypathstep.h"
 void cutsceneEntityWalkToStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  data->entityWalkTo.currentIndex = 0;
 }
 bool_t cutsceneEntityWalkToUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  uint8_t i = data->entityWalkTo.currentIndex;
  entity_t *e = cutsceneSystemGetEntity(item->entityWalkTo.entityIndex);
  if(!entityPathStep(
    e,
    item->entityWalkTo.positions[i],
    item->entityWalkTo.walkAround
  )) return false;
  i++;
  if(i < item->entityWalkTo.count) {
    data->entityWalkTo.currentIndex = i;
    return false;
  }
  return true;
 }
@@ -0,0 +1,46 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "rpg/overworld/worldpos.h"
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef struct {
  uint8_t entityIndex;
  const worldpos_t *positions;
  uint8_t count;
  bool_t walkAround;
 } cutsceneentitywalkto_t;
 typedef struct {
  uint8_t currentIndex;
 } cutsceneentitywalktodata_t;
 /**
 * Starts an entity walk-to item (resets the waypoint index).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneEntityWalkToStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates an entity walk-to item (steps the entity toward the next waypoint).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true once all waypoints have been reached.
 */
 bool_t cutsceneEntityWalkToUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,41 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/cutscene/cutscenesystem.h"
 #include "rpg/entity/entity.h"
 #include "rpg/entity/entitypathstep.h"
 #include "rpg/overworld/map.h"
 void cutsceneEntityWalkToEntityStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
 }
 bool_t cutsceneEntityWalkToEntityUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  entity_t *entity = cutsceneSystemGetEntity(
    item->entityWalkToEntity.entityIndex
  );
  entity_t *target = cutsceneSystemGetEntity(
    item->entityWalkToEntity.targetEntityIndex
  );
  worldpos_t dest = {
    .x = (worldunit_t)(target->position.x + item->entityWalkToEntity.offsetX),
    .y = (worldunit_t)(target->position.y + item->entityWalkToEntity.offsetY),
    .z = target->position.z
  };
  worldunit_t z;
  if(mapGetWalkableZNear(dest.x, dest.y, target->position.z, &z)) dest.z = z;
  return entityPathStep(entity, dest, true);
 }
@@ -0,0 +1,46 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "rpg/overworld/worldpos.h"
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef struct {
  uint8_t entityIndex;
  uint8_t targetEntityIndex;
  worldunit_t offsetX;
  worldunit_t offsetY;
 } cutsceneentitywalktoentity_t;
 /**
 * Starts an entity walk-to-entity item. No setup is needed, the destination
 * is recomputed from the target's live position every Update.
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneEntityWalkToEntityStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates an entity walk-to-entity item. Re-reads the target entity's
 * current position each frame, applies the X/Y offset, resolves the
 * destination Z from nearby terrain (to account for ramps), and steps
 * the entity toward it.
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true once the entity has reached the target's side.
 */
 bool_t cutsceneEntityWalkToEntityUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,9 @@
 # Copyright (c) 2026 Dominic Masters
 #
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
  PUBLIC
    cutsceneitemgive.c
 )
@@ -0,0 +1,24 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/item/itemgive.h"
 #include "ui/rpg/textbox/uitextboxmain.h"
 void cutsceneItemGiveStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  itemGive(item->itemGive.item, item->itemGive.quantity);
 }
 bool_t cutsceneItemGiveUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  return !uiTextboxMainIsActive();
 }
@@ -0,0 +1,40 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "rpg/item/item.h"
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef struct {
  itemid_t item;
  uint8_t quantity;
 } cutsceneitemgive_t;
 /**
 * Starts a give-item step (adds the item to the player's backpack immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneItemGiveStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates a give-item step (always completes immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true always.
 */
 bool_t cutsceneItemGiveUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,11 @@
 # Copyright (c) 2026 Dominic Masters
 #
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
  PUBLIC
    cutscenemapareaadd.c
    cutscenemaparearemove.c
    cutscenemapareawait.c
 )
@@ -0,0 +1,29 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/cutscene/cutscenesystem.h"
 void cutsceneMapAreaAddStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  CUTSCENE_SYSTEM.areaLastCreated = mapAreaAdd(
    item->mapAreaAdd.min,
    item->mapAreaAdd.max,
    item->mapAreaAdd.callback,
    item->mapAreaAdd.notify,
    item->mapAreaAdd.trigger
  );
 }
 bool_t cutsceneMapAreaAddUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  return true;
 }
@@ -0,0 +1,44 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "rpg/overworld/maparea.h"
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef struct {
  worldpos_t min;
  worldpos_t max;
  mapareacallback_t callback;
  uint8_t notify;
  uint8_t trigger;
 } cutscenemapareaadd_t;
 /**
 * Starts a map area add step (adds the area immediately, storing its ID
 * in CUTSCENE_SYSTEM.areaLastCreated).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneMapAreaAddStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates a map area add step (always completes immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true always.
 */
 bool_t cutsceneMapAreaAddUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,24 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/cutscene/cutscenesystem.h"
 #include "rpg/overworld/maparea.h"
 void cutsceneMapAreaRemoveStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  mapAreaRemove(cutsceneSystemGetAreaId(item->mapAreaRemove.areaId));
 }
 bool_t cutsceneMapAreaRemoveUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  return true;
 }
@@ -0,0 +1,40 @@
 /**
 * 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 cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef struct {
  uint8_t areaId;
 } cutscenemaparearemove_t;
 /**
 * Starts a map area remove step (removes the area immediately). Accepts
 * CUTSCENE_AREA_LAST_CREATED in place of a literal area ID.
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneMapAreaRemoveStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates a map area remove step (always completes immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true always.
 */
 bool_t cutsceneMapAreaRemoveUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,40 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/cutscene/cutscenesystem.h"
 #include "rpg/overworld/maparea.h"
 #include "assert/assert.h"
 void cutsceneMapAreaWaitStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  assertTrue(
    item->mapAreaWait.count <= CUTSCENE_MAP_AREA_WAIT_MAX,
    "Too many areas in CUTSCENE_MAP_AREA_WAIT"
  );
  for(uint8_t i = 0; i < item->mapAreaWait.count; i++) {
    uint8_t areaId = cutsceneSystemGetAreaId(item->mapAreaWait.areaIds[i]);
    data->mapAreaWait.baseline[i] = MAP_AREAS[areaId].triggerCount;
  }
 }
 bool_t cutsceneMapAreaWaitUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  for(uint8_t i = 0; i < item->mapAreaWait.count; i++) {
    uint8_t areaId = cutsceneSystemGetAreaId(item->mapAreaWait.areaIds[i]);
    if(MAP_AREAS[areaId].triggerCount != data->mapAreaWait.baseline[i]) {
      return true;
    }
  }
  return false;
 }
@@ -0,0 +1,49 @@
 /**
 * 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 cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 /** Maximum number of areas a single CUTSCENE_MAP_AREA_WAIT may watch. */
 #define CUTSCENE_MAP_AREA_WAIT_MAX 4
 typedef struct {
  const uint8_t *areaIds;
  uint8_t count;
 } cutscenemapareawait_t;
 typedef struct {
  uint32_t baseline[CUTSCENE_MAP_AREA_WAIT_MAX];
 } cutscenemapareawaitdata_t;
 /**
 * Starts a map area wait step, snapshotting each watched area's current
 * trigger count.
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneMapAreaWaitStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates a map area wait step, completing once any watched area's
 * trigger count has changed since Start (i.e. its callback fired).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true once any watched area has been triggered.
 */
 bool_t cutsceneMapAreaWaitUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,14 @@
 # Copyright (c) 2026 Dominic Masters
 #
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
  PUBLIC
    cutscenetext.c
    cutscenetextmini.c
    cutscenetextminihide.c
    cutscenefade.c
    cutsceneemoji.c
    cutsceneshake.c
 )
@@ -0,0 +1,25 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/cutscene/cutscenesystem.h"
 #include "rpg/entity/entity.h"
 void cutsceneEmojiStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  entity_t *entity = cutsceneSystemGetEntity(item->emoji.entityIndex);
  uiEmojiAdd(entity->id, item->emoji.duration, item->emoji.emojiType);
 }
 bool_t cutsceneEmojiUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  return true;
 }
@@ -0,0 +1,43 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "dusk.h"
 #include "ui/rpg/uiemoji.h"
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef struct {
  uint8_t entityIndex;
  float_t duration;
  uiemojitype_t emojiType;
 } cutsceneemoji_t;
 /**
 * Starts an emoji step (shows an emoji above the entity for the given
 * duration, then completes immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneEmojiStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates an emoji step (always completes immediately).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true always.
 */
 bool_t cutsceneEmojiUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,32 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "ui/overlay/uifullbox.h"
 void cutsceneFadeStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  uiFullboxTransition(
    &UI_FULLBOX_OVER,
    item->fade.from,
    item->fade.to,
    item->fade.duration,
    item->fade.easing
  );
 }
 bool_t cutsceneFadeUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  return !(
    UI_FULLBOX_OVER.duration > 0.0f &&
    UI_FULLBOX_OVER.time < UI_FULLBOX_OVER.duration
  );
 }
@@ -0,0 +1,43 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #pragma once
 #include "display/color.h"
 #include "animation/easing.h"
 typedef struct cutsceneitem_s cutsceneitem_t;
 typedef union cutsceneitemdata_u cutsceneitemdata_t;
 typedef struct {
  color_t from;
  color_t to;
  float_t duration;
  easingtype_t easing;
 } cutscenefade_t;
 /**
 * Starts a fade item (begins the overlay transition).
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 */
 void cutsceneFadeStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
 /**
 * Updates a fade item.
 *
 * @param item The cutscene item.
 * @param data Runtime data storage.
 * @returns true once the overlay transition has completed.
 */
 bool_t cutsceneFadeUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 );
@@ -0,0 +1,23 @@
 /**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
 #include "rpg/cutscene/item/cutsceneitem.h"
 #include "rpg/rpgcamera.h"
 void cutsceneShakeStart(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  rpgCameraShake(item->shake.amount, item->shake.duration);
 }
 bool_t cutsceneShakeUpdate(
  const cutsceneitem_t *item,
  cutsceneitemdata_t *data
 ) {
  return true;
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
YourWishes	1ddc298a74	Only update overworld entities while the overworld scene is active Entities (and the player's pause-to-open-game-menu handling with them) previously kept updating every frame regardless of the active scene, matching an existing TODO in rpgUpdate(). Gating the entity loop itself means the game menu (and any other entity-driven input) naturally can't trigger mid-battle or before the initial scene hands off to the overworld, without needing a scene check at each individual call site. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-04 20:54:58 -05:00
YourWishes	e2a9442aa6	Add initial boot scene to check/prompt for save data before overworld A new SCENE_TYPE_INITIAL now runs before the overworld: it checks save-device availability and existing save data, then shows one of two new dedicated modals - "no save device found" (Retry / Continue Anyway) or "no save data found, create one?" (Yes / No) - before handing off to the overworld. Both modals are self-contained UI elements mirroring uiconfirm.h's shape, registered like any other global UI element. Choosing "Continue Anyway" marks the session temporary (SAVE.temporary, folded into saveIsAvailable()) so saving stays disabled for the rest of the session instead of silently retrying, and the game menu's Save action now reports that distinctly instead of the generic "no device" message. Also removes rpg.c's leftover TEST block (unconditional player-name stamp + save write on every boot) now that this real flow owns save creation. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-04 20:53:01 -05:00
YourWishes	aa0180571e	Unify save system into one save.h/.c; diverge storage format per platform Renames savefile_t to saveslot_t and folds last session's standalone settings.h/.c module back in as savemeta_t, so there's one save system (SAVE.slots[] + SAVE.meta) instead of two parallel ones - while letting each platform pick its own physical format for the two concepts: - Linux now writes human-editable JSON (slot0.json, settings.json, ...) via yyjson's mutable writer API, so players can hand-fix a bad setting. - PSP folds meta into the same sceUtilitySavedata binary payload as its one save slot (SAVE_SLOT_COUNT_MAX=1 there - a future save picker will let players manage multiple named saves via the OS's own browser). - GameCube consolidates the 3 per-slot memory card files and the separate settings file into one combined card file. Also fixes two bugs surfaced while building this: the CRC finalize step seeked to a hardcoded offset (only safe for one section per file, breaks once meta+slots share a buffer), and save.c's async/sync dispatch left an unconditional fallback call that doesn't exist on PSP-only platforms. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-04 18:35:06 -05:00
YourWishes	7f7be39230	Split device settings out of the per-slot save file Deadzone (and future prefs like locale) now live in their own settingsfile_t/settings.c, loaded eagerly at boot and saved immediately on Apply, instead of inside savefile_t - a setting shouldn't reset or diverge just because the player is on a different save slot, and this also fixes settings changes not actually reaching disk until the next full game Save. PSP settings use a new plain sceIo path rather than sceUtilitySavedata, since that dialog would flash its native icon on every settings tweak. GameCube reuses the save system's existing memory card mount rather than mounting it twice (settingsInit() now runs after saveInit()). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-04 13:54:15 -05:00
YourWishes	4d95415232	Move global item collected-state, deadzone, and story flags into save file Adds three new pieces of save-file state, all following the same shape: the save file is the single source of truth, not a separate live runtime copy that gets synced in/out. - globalitemstore.h/.c: per-global-entity-ID "collected" flags (savefile_t.globalItemCollected), so a global item entity's init callback can check whether it was already picked up in a prior session without needing to keep the entity itself alive to remember that. - Gamepad deadzone: removed input_t.deadzone entirely. The setting UI and every platform's actual deadzone-applying code (inputGetDeadzoneDolphin/ SDL2, previously hardcoded per-platform literals that the settings menu didn't actually affect) now read savefile_t.deadzone directly via saveGet(SAVE_ACTIVE_SLOT). Default lives in savefile.h (SAVE_DEADZONE_DEFAULT), stamped onto every slot in saveInit(). - Story flags: STORY_FLAG_VALUES (a live, codegen-initialized array) is replaced by savefile_t.storyFlags, read/written via the existing storyFlagGet()/storyFlagSet() call sites (now macros/functions over the active save file instead of a separate array). tools/story.py now generates STORY_FLAG_DEFAULTS (const) instead; storyFlagInitDefaults() stamps those onto a save the first time it's used (file->exists false), called from rpgInit(). Added SAVE_ACTIVE_SLOT (0) to savefile.h as the one shared "which slot is actually being played" constant, replacing three different local/implicit 0s (uigamemenu.c, rpg.c, and now the settings/input call sites). Verified round-trip on Linux (all three together in one save/load cycle); both Linux and PSP build clean.	2026-08-04 11:10:44 -05:00
YourWishes	2cbd80a004	Check for existing save data before saving, confirm before creating new uiGameMenuSave() now attempts a real load first (via the existing generic saveLoad()/saveExists() primitives) instead of writing blind. If a save already exists, it saves straight over it as before. If not, it prompts via the existing uiConfirm dialog ("No save data found. Create a new save?") before writing - this is exactly the flow GameCube needs (no native OS save browser to lean on, unlike PSP), but implemented generically so it also applies correctly on every other platform without any platform-specific UI code: saveIsAvailable()/saveExists() already reflect each platform's real state (e.g. Dolphin's memory-card presence and existing-file checks), so the same logic just does the right thing everywhere. Verified the two branches directly on Linux (temporarily wiring the same saveLoad -> check -> uiConfirmOpen sequence into rpgInit): with no save file, saveExists() is false and the confirm dialog opens; with one already written, it's true and the confirm dialog is correctly skipped. Not verified via actual menu navigation (no input-injection tooling available here) or on Dolphin (no devkitPPC toolchain in this environment).	2026-08-04 10:33:57 -05:00
YourWishes	9abf8101da	PSP: save through the real sceUtilitySavedata API, not raw file I/O Rewrote savepsp.c/savestreampsp.c to use sceUtilitySavedataInitStart/ Update/GetStatus/ShutdownStart instead of sceIoOpen/Read/Write, so PSP saves get a proper OS-generated PARAM.SFO (title/savedataTitle/detail) and show up correctly in the native save browser. This dialog spans multiple frames and, per this project's prior experience with the network config dialog, must be pumped non-blocking one step per real engine frame rather than blocked on synchronously - a raw-sceGu blocking loop already froze the app on real hardware for that dialog, since pspGL owns the GU context. So save.h's saveWrite()/saveLoad() are now callback-based (savecallback_t onComplete) instead of returning a result directly, mirroring networkRequestConnection()'s shape, with a new saveUpdate() (wired into engineUpdate()) pumping the active op each frame. Linux/Dolphin behavior is unchanged - their fallback path in save.c still completes synchronously, just via an immediate callback call instead of a direct return. Two real bugs found via PPSSPP testing (not just code review): SAVE/LOAD modes show a confirm screen even for brand-new data, which blocks forever headlessly - switched to AUTOSAVE/AUTOLOAD, which write/read silently and generate the identical PARAM.SFO. And PPSSPP's dialog status goes straight from QUIT to NONE without a separately observable FINISHED in between, which the first version misread as "disappeared without a result" even on a successful save - fixed by tracking whether QUIT was already seen. Confirmed end-to-end in PPSSPP: write, dialog completes, PARAM.SFO + encrypted save.bin appear on the virtual memory stick, and a subsequent load decrypts/deserializes back to the exact original data. Not tested on real PSP hardware.	2026-08-04 09:54:45 -05:00
YourWishes	24badd06a5	Add player name field to save file, save it out as a round-trip test Adds savefile_t.playerName (SAVE_PLAYER_NAME_MAX) serialized via the existing saveFileReadString/WriteString helpers, and stamps + saves it in rpgInit() as a test that the save system now persists actual game data, not just the header/version. Verified manually: written bytes end in "Dusk\0" immediately after the version field, and loading it back returns the same string.	2026-08-04 08:59:29 -05:00
YourWishes	7a03ef8eaf	Re-enable save system, fix header/version stamping, handle missing media - Fixed the actual reason saving never worked on any platform: saveWrite() never stamped file->header/file->version before serializing, so every written save file had a zeroed magic header and failed its own validation on the next load. Confirmed via a manual write/load round trip that this alone fully explains "saving doesn't work." - Re-enabled saveInit()/saveDispose() in engine.c (previously commented out under "Temporarily disable save code"). - Added SAVE.available + saveIsAvailable(), refreshed by every real save/load/delete attempt. saveInit() no longer treats an unreachable save medium as fatal to booting - it logs and continues, since a missing memory card/stick shouldn't prevent playing. - Hardened PSP's saveInitPSP() to actually detect a missing memory stick (sceIoGetstat on ms0:/) instead of assuming success, and fixed single-level sceIoMkdir to build the full PSP/SAVEDATA directory chain. - Added busy-retry (CARD_ERROR_BUSY) and a not-mounted guard to Dolphin's live savestreamdolphin.c path, extending the same handling already backported into savedolphin.c. - Added a "Save" entry to the game menu wired to saveWrite(0), showing a clear message on success, on failure, and when saveIsAvailable() is false.	2026-08-04 08:30:24 -05:00
YourWishes	f3ea507313	Fixed save crash Backported from branch ac2 (commit `85b61097`) - CARD_Mount was being called without CARD_Init first, leaving per-channel control blocks and the DSP unlock sequence unset. On real Dolphin/hardware this surfaced as a hard MMIO crash instead of a clean CARD_ERROR_* failure. Co-Authored-By: Dominic Masters <dominic@domsplace.com>	2026-08-04 08:12:57 -05:00
YourWishes	4b0388a0e1	Chunk streaming concurrency, entity slot fix, and map-data-driven spawns - Allow 2 chunks to be mid-load concurrently instead of 1 (MAP_CHUNK_LOAD_CONCURRENCY). - Fix entitySetChunk silently losing track of an entity when its target chunk's entity slots are full - it now stays detached (and retries later) instead of claiming a chunk that never actually registered it. - DCF format bumped to v5: chunks can now declare entity spawns (global/NPC via the existing entityglobal registry, or one-shot item pickups) and map area triggers, resolved via a new callback-ID registry (mapareagloballist.h) mirroring the entity one. rpg.c's hardcoded TEST entity/item/area spawns are gone - chunk_0_0_0.json now carries that data instead. The player is still bootstrapped in code since it isn't map-authored content.	2026-08-04 07:37:48 -05:00
YourWishes	a84137b5ff	del md	2026-08-04 06:58:03 -05:00
YourWishes	ca02ee0352	Add camera shake	2026-07-11 11:02:09 -05:00
YourWishes	fbaa54145e	Fixed dolphin rendering.	2026-07-10 20:15:26 -05:00
YourWishes	28754ffbf2	Removed old scripted types	2026-07-10 13:24:21 -05:00
YourWishes	470c0eba7a	Whatever, some minor map chunking improvements	2026-07-10 12:57:31 -05:00
YourWishes	7098dcec43	Cleaned some log	2026-07-09 23:25:43 -05:00
YourWishes	07137f57af	Assets are slightly optimized	2026-07-09 23:25:26 -05:00
YourWishes	8b7491a3d3	Emoji support to characters	2026-07-09 13:18:48 -05:00
YourWishes	8cfa8ddfeb	Weaather baseline	2026-07-08 12:57:13 -05:00
YourWishes	ef284a15a1	pre-cache shader matrices	2026-07-08 12:36:40 -05:00
YourWishes	3723921573	Render culling on sceneoverworld.h	2026-07-08 12:02:41 -05:00
YourWishes	195399635e	Updating mini textbox	2026-07-08 11:45:10 -05:00
YourWishes	46e2a924d3	Mini textboxes	2026-07-08 10:53:53 -05:00
YourWishes	b693ea4102	Starting item and battle stuff	2026-07-08 10:05:21 -05:00
YourWishes	a73f55beb0	Battle stuff Build Dusk / build-linux (push) Successful in 7m5s Details Build Dusk / build-psp (push) Successful in 1m33s Details Build Dusk / build-knulli (push) Successful in 4m0s Details Build Dusk / build-gamecube (push) Successful in 3m31s Details Build Dusk / build-gamecube-iso (push) Successful in 3m39s Details Build Dusk / build-wii (push) Successful in 3m5s Details Build Dusk / build-wii-iso (push) Successful in 3m25s Details	2026-07-08 07:55:15 -05:00
YourWishes	0bd2491ab7	Dropdown test.	2026-07-07 15:18:33 -05:00
YourWishes	860c797c9c	Last round of cleanup for settings for now.	2026-07-07 14:56:08 -05:00
YourWishes	38c5080f9f	Collapsing more ui settings code	2026-07-07 14:36:19 -05:00
YourWishes	fae191d8fe	Settings improvements	2026-07-07 14:00:37 -05:00
YourWishes	d83a953e2d	First pass of language	2026-07-07 11:14:02 -05:00
YourWishes	2dcf0d0f0d	UI Confirm	2026-07-07 10:12:22 -05:00
YourWishes	6dee37d8c1	Slider widget and some cleanup	2026-07-07 09:58:10 -05:00
YourWishes	3bad03afb3	Item entity	2026-07-07 07:52:22 -05:00
YourWishes	6a6d8448f7	Area cutscene controls	2026-07-07 07:28:12 -05:00
YourWishes	189babd2cf	Trigger types on areas	2026-07-07 07:07:32 -05:00
YourWishes	988a0f2294	Area basics	2026-07-06 23:19:05 -05:00
YourWishes	85bf455731	entity pos sets chunk now	2026-07-04 18:43:09 -05:00
YourWishes	589e4224f3	Example global ent	2026-07-04 13:03:24 -05:00
YourWishes	bd7fa154b4	Add user data to callbacks	2026-07-04 09:13:37 -05:00
YourWishes	a292f1992b	Change to use the Z tile system	2026-07-04 08:40:53 -05:00
YourWishes	88ddf429b7	add some entity management in prep for global entities.	2026-07-03 12:25:24 -05:00
YourWishes	7a1f6662df	More cutscene tools	2026-07-03 09:17:49 -05:00
YourWishes	afc68bccc6	Update test runner Build Dusk / build-linux (push) Successful in 5m36s Details Build Dusk / build-psp (push) Successful in 1m15s Details Build Dusk / build-knulli (push) Successful in 4m53s Details Build Dusk / build-gamecube (push) Successful in 3m51s Details Build Dusk / build-gamecube-iso (push) Successful in 3m52s Details Build Dusk / build-wii (push) Successful in 3m17s Details Build Dusk / build-wii-iso (push) Successful in 4m54s Details	2026-07-02 19:20:17 -05:00
YourWishes	b4cdc4a64f	Add remove event Build Dusk / run-tests (push) Failing after 5m7s Details Build Dusk / build-linux (push) Successful in 5m41s Details Build Dusk / build-psp (push) Successful in 1m17s Details Build Dusk / build-knulli (push) Successful in 4m22s Details Build Dusk / build-gamecube (push) Successful in 3m43s Details Build Dusk / build-gamecube-iso (push) Successful in 3m36s Details Build Dusk / build-wii (push) Successful in 3m36s Details Build Dusk / build-wii-iso (push) Successful in 3m22s Details	2026-07-02 16:10:47 -05:00
YourWishes	3ad5afb81c	Fix item crash	2026-07-02 16:04:41 -05:00
YourWishes	bed3f20118	Lot of cutscene cleanup	2026-07-02 15:53:02 -05:00
YourWishes	de67315178	Cutscene cleanup	2026-07-02 14:59:41 -05:00
YourWishes	8d5c0c7cad	Path finding (first pass)	2026-07-02 14:08:59 -05:00
YourWishes	a8271e01bd	Fade cutscene items	2026-07-02 13:26:41 -05:00
YourWishes	900b3f8558	More cutscene stuff	2026-07-02 12:54:12 -05:00
YourWishes	fdc4e056f9	Cutscene defs	2026-07-02 11:32:31 -05:00
YourWishes	7b98e40ccf	Cutscene tests	2026-07-02 11:18:36 -05:00
YourWishes	01d89cf22c	Map tweaks	2026-07-01 21:07:24 -05:00
YourWishes	503a3c799a	Grid to editor	2026-07-01 20:51:46 -05:00
YourWishes	0b21388844	Fixing bugs, one at a time	2026-07-01 20:23:44 -05:00
YourWishes	117bdf0c00	Fov tweaks	2026-07-01 20:18:32 -05:00
YourWishes	172dc5d37b	Tile Z is now hypotenused to 1 rather than stretching to have Z of 1.	2026-07-01 16:27:59 -05:00