Remove event for input

Splits the platform-agnostic network core out of dusk into a top-level
dusknetwork module, mirroring the duskgl/dusksdl2 pattern. Adds a
DUSK_NETWORK cmake option (default ON) so builds can exclude all
networking code, including the per-platform implementations.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

CLAUDE.md

@@ -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`.

CMakeLists.txt

@@ -13,6 +13,7 @@ cmake_policy(SET CMP0079 NEW)
 # set(FETCHCONTENT_UPDATES_DISCONNECTED ON)
 
 option(DUSK_BUILD_TESTS "Enable tests" OFF)
+option(DUSK_NETWORK "Enable network support" ON)
 
 set(DUSK_GAME_NAME "Dusk" CACHE STRING "Game display name")
 set(DUSK_GAME_AUTHOR "YourWishes" CACHE STRING "Game author / coder")
@@ -90,6 +91,12 @@ target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME}
     DUSK_VERSION="${DUSK_VERSION}"
 )
 
+if(DUSK_NETWORK)
+  target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
+    DUSK_NETWORK
+  )
+endif()
+
 # Toolchains
 include(cmake/targets/${DUSK_TARGET_SYSTEM}.cmake)
 

assets/locale/en_US.po

@@ -56,6 +56,62 @@ msgstr "Items"
 msgid "ui.game_menu.settings"
 msgstr "Settings"
 
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save"
+msgstr "Save"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_success"
+msgstr "Game saved."
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_cancelled"
+msgstr "Save cancelled."
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_unavailable"
+msgstr "Can't save - no save device found."
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_temporary"
+msgstr "This session is temporary - no save device was found, so saving is disabled."
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_create_confirm"
+msgstr "No save data found. Create a new save?"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_failed_format"
+msgstr "Save failed: %s"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_check_failed_format"
+msgstr "Can't save: %s"
+
+#: src/dusk/ui/frame/initial/uiinitialnocard.c
+msgid "ui.initial.no_card.message"
+msgstr "No save device found. You can continue, but\nprogress will not be saved."
+
+#: src/dusk/ui/frame/initial/uiinitialnocard.c
+msgid "ui.initial.no_card.retry"
+msgstr "Retry"
+
+#: src/dusk/ui/frame/initial/uiinitialnocard.c
+msgid "ui.initial.no_card.continue"
+msgstr "Continue Anyway"
+
+#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
+msgid "ui.initial.create_save.message"
+msgstr "No save data found. Create a new save?"
+
+#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
+msgid "ui.initial.create_save.yes"
+msgstr "Yes"
+
+#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
+msgid "ui.initial.create_save.no"
+msgstr "No"
+
 msgid "item.potion.name"
 msgstr "Potion"
 

assets/locale/es_MX.po

@@ -57,6 +57,62 @@ msgstr "Objetos"
 msgid "ui.game_menu.settings"
 msgstr "Configuración"
 
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save"
+msgstr "Guardar"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_success"
+msgstr "Partida guardada."
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_cancelled"
+msgstr "Guardado cancelado."
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_unavailable"
+msgstr "No se puede guardar: no se encontró ningún dispositivo de guardado."
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_temporary"
+msgstr "Esta sesión es temporal - no se encontró ningún dispositivo de guardado, por lo que guardar está deshabilitado."
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_create_confirm"
+msgstr "No se encontraron datos guardados. ¿Crear una partida nueva?"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_failed_format"
+msgstr "Error al guardar: %s"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_check_failed_format"
+msgstr "No se puede guardar: %s"
+
+#: src/dusk/ui/frame/initial/uiinitialnocard.c
+msgid "ui.initial.no_card.message"
+msgstr "No se encontró ningún dispositivo de guardado. Puedes continuar, pero\nel progreso no se guardará."
+
+#: src/dusk/ui/frame/initial/uiinitialnocard.c
+msgid "ui.initial.no_card.retry"
+msgstr "Reintentar"
+
+#: src/dusk/ui/frame/initial/uiinitialnocard.c
+msgid "ui.initial.no_card.continue"
+msgstr "Continuar de todos modos"
+
+#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
+msgid "ui.initial.create_save.message"
+msgstr "No se encontraron datos guardados. ¿Crear una partida nueva?"
+
+#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
+msgid "ui.initial.create_save.yes"
+msgstr "Sí"
+
+#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
+msgid "ui.initial.create_save.no"
+msgstr "No"
+
 #: src/dusk/rpg/item/item.json
 msgid "item.potion.name"
 msgstr "Poción"

assets/locale/jp_JP.po

@@ -57,6 +57,62 @@ msgstr "アイテム"
 msgid "ui.game_menu.settings"
 msgstr "設定"
 
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save"
+msgstr "セーブ"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_success"
+msgstr "セーブしました。"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_cancelled"
+msgstr "セーブをキャンセルしました。"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_unavailable"
+msgstr "セーブできません - セーブデバイスが見つかりません。"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_temporary"
+msgstr "このセッションは一時的です - セーブデバイスが見つからなかったため、セーブは無効になっています。"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_create_confirm"
+msgstr "セーブデータが見つかりません。新しいセーブを作成しますか？"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_failed_format"
+msgstr "セーブに失敗しました: %s"
+
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save_check_failed_format"
+msgstr "セーブできません: %s"
+
+#: src/dusk/ui/frame/initial/uiinitialnocard.c
+msgid "ui.initial.no_card.message"
+msgstr "セーブデバイスが見つかりません。続行できますが、\n進行状況は保存されません。"
+
+#: src/dusk/ui/frame/initial/uiinitialnocard.c
+msgid "ui.initial.no_card.retry"
+msgstr "再試行"
+
+#: src/dusk/ui/frame/initial/uiinitialnocard.c
+msgid "ui.initial.no_card.continue"
+msgstr "続行する"
+
+#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
+msgid "ui.initial.create_save.message"
+msgstr "セーブデータが見つかりません。新しいセーブを作成しますか？"
+
+#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
+msgid "ui.initial.create_save.yes"
+msgstr "はい"
+
+#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
+msgid "ui.initial.create_save.no"
+msgstr "いいえ"
+
 #: src/dusk/rpg/item/item.json
 msgid "item.potion.name"
 msgstr "ポーション"

assetsraw/chunks/chunk_0_0_0.json

@@ -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
+    }
   ]
 }

src/CMakeLists.txt

@@ -5,6 +5,10 @@
 
 add_subdirectory(dusk)
 
+if(DUSK_NETWORK)
+  add_subdirectory(dusknetwork)
+endif()
+
 if(DUSK_TARGET_SYSTEM STREQUAL "linux" OR DUSK_TARGET_SYSTEM STREQUAL "knulli")
   add_subdirectory(dusklinux)
   add_subdirectory(dusksdl2)

src/dusk/CMakeLists.txt

@@ -68,7 +68,6 @@ add_subdirectory(scene)
 add_subdirectory(system)
 add_subdirectory(time)
 add_subdirectory(ui)
-add_subdirectory(network)
 add_subdirectory(save)
 add_subdirectory(util)
 add_subdirectory(thread)

src/dusk/animation/CMakeLists.txt

@@ -7,4 +7,5 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     easing.c
     animation.c
+    keyframe.c
 )

src/dusk/animation/animation.c

@@ -11,42 +11,122 @@
 void animationInit(
   animation_t *anim,
   keyframe_t *keyframes,
-  uint16_t keyframeCount
+  uint16_t *keyframeCounts,
+  const uint16_t layerCount
 ) {
   assertNotNull(anim, "Animation pointer cannot be null.");
   assertNotNull(keyframes, "Keyframes pointer cannot be null.");
-  assertTrue(keyframeCount > 0, "Keyframe count must be more than 0.");
+  assertNotNull(keyframeCounts, "Keyframe counts pointer cannot be null.");
+  assertTrue(layerCount > 0, "Layer count must be greater than zero.");
 
+  memoryZero(anim, sizeof(animation_t));
   anim->keyframes = keyframes;
-  anim->keyframeCount = keyframeCount;
+  anim->keyframeCounts = keyframeCounts;
+  anim->layerCount = layerCount;
+
+  // Determine duration
+  float_t duration = 0.0f;
+  for(uint16_t layer = 0; layer < layerCount; layer++) {
+    uint16_t keyframeCount = keyframeCounts[layer];
+    assertTrue(keyframeCount > 0, "Keyframe count invalid.");
+    keyframe_t *layerKeyframes = keyframes + layer * keyframeCount;
+
+    #ifdef DUSK_ASSERTIONS
+      // Check that the keyframes are sorted by time.
+      for(uint16_t i = 1; i < keyframeCount; i++) {
+        assertTrue(
+          layerKeyframes[i].time >= layerKeyframes[i - 1].time,
+          "Keyframes must be sorted by time."
+        );
+      }
+    #endif
+
+    keyframe_t *lastKeyframe = layerKeyframes + keyframeCount - 1;
+    duration = mathMax(duration, lastKeyframe->time);
+  }
+  assertTrue(duration > 0, "Animation duration must be greater than 0.");
+  anim->duration = duration;
 }
 
-float_t animationGetValue(animation_t *anim, const float_t time) {
+float_t animationGetLayerValue(const animation_t *anim, const uint16_t layer) {
   assertNotNull(anim, "Animation pointer cannot be null.");
-  assertNotNull(anim->keyframes, "Keyframes pointer cannot be null.");
-  assertTrue(anim->keyframeCount > 0, "Keyframe count invalid.");
-  assertTrue(time >= 0, "Time must be non-negative.");
+  assertTrue(layer < anim->layerCount, "Layer index out of bounds.");
 
-  keyframe_t *start;
-  keyframe_t *end;
-  keyframe_t *last = anim->keyframes + anim->keyframeCount - 1;
-  keyframe_t *current = anim->keyframes;
-  start = current;
-
-  do {
-    if(current->time > time) {
-      end = current;
-      break;
-    }
-    start = current;
-    current++;
-
-    if(current > last) {
-      end = start;
-      break;
-    }
-  } while(true);
-
-  float_t t = (time - start->time) / (end->time - start->time);
-  return mathLerp(start->value, end->value, easingApply(start->easing, t));
+  uint16_t keyframeCount = anim->keyframeCounts[layer];
+  keyframe_t *layerKeyframes = anim->keyframes + layer * keyframeCount;
+  return keyframeGetValue(layerKeyframes, keyframeCount, anim->time);
+}
+
+void animationUpdate(
+  animation_t *anim,
+  const float_t deltaTime
+) {
+  assertNotNull(anim, "Animation pointer cannot be null.");
+  assertTrue(deltaTime >= 0, "Delta time must be non-negative.");
+
+  bool_t justCompleted = false;
+
+  if(!(anim->flags & ANIMATION_FLAG_INTERNAL_COMPLETED)) {
+    bool_t loop = (anim->flags & ANIMATION_FLAG_LOOP) != 0;
+    bool_t pingpong = (anim->flags & ANIMATION_FLAG_PINGPONG) != 0;
+    assertFalse(
+      loop && pingpong,
+      "Cannot set both ANIMATION_FLAG_LOOP and ANIMATION_FLAG_PINGPONG."
+    );
+    
+    bool_t backward;
+    if(pingpong) {
+      backward = (anim->flags & ANIMATION_FLAG_INTERNAL_PINGPONG_BACKWARD) != 0;
+    } else {
+      backward = (anim->flags & ANIMATION_FLAG_REVERSE) != 0;
+    }
+
+    // Resolve boundary crossings one at a time, so a single large deltaTime
+    // can correctly loop/pingpong across multiple boundaries in one call.
+    float_t remaining = deltaTime;
+    while(remaining > 0.0f) {
+      float_t toBoundary = (
+        backward ? anim->time : (anim->duration - anim->time)
+      );
+      if(remaining < toBoundary) {
+        anim->time += backward ? -remaining : remaining;
+        break;
+      }
+
+      remaining -= toBoundary;
+      anim->time = backward ? 0.0f : anim->duration;
+
+      bool_t stopHere;
+      if(backward) {
+        stopHere = (anim->flags & ANIMATION_FLAG_STOP_BEGINNING) != 0;
+      } else {
+        stopHere = (anim->flags & ANIMATION_FLAG_STOP_END) != 0;
+      }
+
+      if(stopHere) {
+        justCompleted = true;
+        break;
+      } else if(pingpong) {
+        backward = !backward;
+        if(backward) anim->flags |= ANIMATION_FLAG_INTERNAL_PINGPONG_BACKWARD;
+        else anim->flags &= ~ANIMATION_FLAG_INTERNAL_PINGPONG_BACKWARD;
+      } else if(loop) {
+        anim->time = backward ? anim->duration : 0.0f;
+        if(anim->onLoop) anim->onLoop(anim->user);
+      } else {
+        justCompleted = true;
+        break;
+      }
+    }
+
+    if(justCompleted) anim->flags |= ANIMATION_FLAG_INTERNAL_COMPLETED;
+  }
+
+  // Call onUpdate for each layer.
+  for(uint16_t layer = 0; layer < anim->layerCount; layer++) {
+    float_t value = animationGetLayerValue(anim, layer);
+    if(anim->onUpdate) anim->onUpdate(layer, value, anim->user);
+  }
+
+  if(justCompleted && anim->onComplete) anim->onComplete(anim->user);
 }

src/dusk/animation/animation.h

@@ -6,29 +6,89 @@
 #pragma once
 #include "keyframe.h"
 
+#define ANIMATION_FLAG_LOOP (1 << 0)
+#define ANIMATION_FLAG_REVERSE (1 << 1)
+#define ANIMATION_FLAG_PINGPONG (1 << 2)
+#define ANIMATION_FLAG_STOP_BEGINNING (1 << 3)
+#define ANIMATION_FLAG_STOP_END (1 << 4)
+
+// Internal - tracks which direction a pingponging animation is currently
+// travelling. Do not set this manually, it is managed by animationUpdate().
+#define ANIMATION_FLAG_INTERNAL_PINGPONG_BACKWARD (1 << 7)
+
+// Internal - set once the animation has stopped advancing (see
+// animationUpdate()). Do not set this manually. There is currently no way to
+// restart a completed animation short of clearing this bit and resetting
+// anim->time by hand.
+#define ANIMATION_FLAG_INTERNAL_COMPLETED (1 << 6)
+
 typedef struct {
   keyframe_t *keyframes;
-  uint16_t keyframeCount;
+  uint16_t *keyframeCounts;
+  uint16_t layerCount;
+  float_t time;
+  float_t duration;
+  uint8_t flags;
+
+  void *user;
+  void (*onUpdate)(const uint16_t layer, const float_t value, void *user);
+  void (*onComplete)(void *user);
+  void (*onLoop)(void *user);
 } animation_t;
 
 /**
- * Initializes an animation.
+ * Initializes an animation with the given keyframes and layer count.
  *
- * @param anim The animation to initialize.
- * @param keyframes The keyframes to use for the animation.
- * @param keyframeCount The number of keyframes in the animation.
+ * @param anim Pointer to the animation to initialize.
+ * @param keyframes Pointer to the array of keyframes for each layer.
+ * @param keyframeCount Number of keyframes in each layer.
+ * @param layerCount Number of layers in the animation.
  */
 void animationInit(
   animation_t *anim,
   keyframe_t *keyframes,
-  uint16_t keyframeCount
+  uint16_t *keyframeCounts,
+  const uint16_t layerCount
 );
 
 /**
- * Gets the value of the animation at a given time.
+ * Sets the current time of the animation, clamping it to the valid range.
+ * This will call the onUpdate callback but none of the other callbacks.
  * 
- * @param anim The animation to get the value from.
- * @param time The time at which to get the value, in seconds.
- * @return The value of the animation at the given time.
+ * @param anim Pointer to the animation to set the time for.
+ * @param time The new time to set for the animation.
  */
-float_t animationGetValue(animation_t *anim, const float_t time);
+void animationSetTime(animation_t *anim, const float_t time);
+
+/**
+ * Gets the current value of a specific layer in the animation based on the
+ * current animation time.
+ */
+float_t animationGetLayerValue(const animation_t *anim, const uint16_t layer);
+
+/**
+ * Updates the animation state based on the elapsed time. Advances anim->time
+ * by deltaTime (or against it, if ANIMATION_FLAG_REVERSE is set), then
+ * resolves whatever happens when it reaches the 0 or duration boundary:
+ *
+ * - ANIMATION_FLAG_PINGPONG: reflects off the boundary and continues playing
+ *   in the opposite direction, forever, unless stopped (see below).
+ * - ANIMATION_FLAG_LOOP: wraps back around to the other boundary and keeps
+ *   playing in the same direction, forever, unless stopped (see below).
+ * - ANIMATION_FLAG_STOP_BEGINNING / ANIMATION_FLAG_STOP_END: when the
+ *   animation reaches that specific boundary, it clamps there and stops
+ *   (firing onComplete) instead of looping/pingponging past it.
+ * - If none of the above apply at a boundary, the animation clamps there and
+ *   stops, firing onComplete.
+ *
+ * onUpdate is called for every layer on every call. onLoop is called each
+ * time a loop wraps around. onComplete is called at most once, the moment
+ * the animation stops advancing.
+ *
+ * @param anim Pointer to the animation to update.
+ * @param deltaTime Time elapsed since the last update (in seconds).
+ */
+void animationUpdate(
+  animation_t *anim,
+  const float_t deltaTime
+);

src/dusk/animation/keyframe.c

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "keyframe.h"
+#include "assert/assert.h"
+#include "util/math.h"
+
+float_t keyframeGetValue(
+  const keyframe_t *keyframes,
+  const uint32_t keyframeCount,
+  const float_t time
+) {
+  assertNotNull(keyframes, "Keyframes pointer cannot be null.");
+  assertTrue(keyframeCount > 0, "Keyframe count must be more than 0.");
+  assertTrue(time >= 0, "Time must be non-negative.");
+  #ifdef DUSK_ASSERTIONS
+    // Checks that the keyframes are sorted by time.
+    for(uint32_t i = 1; i < keyframeCount; i++) {
+      assertTrue(
+        keyframes[i].time >= keyframes[i - 1].time,
+        "Keyframes must be sorted by time."
+      );
+    }
+  #endif
+
+  keyframe_t *last = (keyframe_t *)(keyframes + keyframeCount - 1);
+  if(time >= last->time) return last->value;
+
+  // Since time < last->time (checked above), current is guaranteed to stop
+  // at or before reaching last, so no separate end-of-array check is needed.
+  keyframe_t *current = (keyframe_t *)keyframes;
+  keyframe_t *start = current;
+  while(current->time <= time) {
+    start = current;
+    current++;
+  }
+  keyframe_t *end = current;
+
+  float_t t = (time - start->time) / (end->time - start->time);
+  return mathLerp(start->value, end->value, easingApply(start->easing, t));
+}

src/dusk/animation/keyframe.h

@@ -11,3 +11,17 @@ typedef struct {
   float_t value;
   easingtype_t easing;
 } keyframe_t;
+
+/**
+ * Gets the value of a keyframe at a given time.
+ * 
+ * @param keyframes The keyframes to get the value from.
+ * @param keyframeCount The number of keyframes in the array.
+ * @param time The time at which to get the value, in seconds.
+ * @return The value of the keyframe at the given time.
+ */
+float_t keyframeGetValue(
+  const keyframe_t *keyframes,
+  const uint32_t keyframeCount,
+  const float_t time
+);

src/dusk/assert/assert.h

@@ -22,6 +22,8 @@
 #endif
 
 #ifndef DUSK_ASSERTIONS_FAKED
+  #define DUSK_ASSERTIONS 1
+
   /**
    * Initializes the assert system. Must be the very first call in engine
    * startup.

src/dusk/asset/loader/chunk/assetchunkloader.c

@@ -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.");
@@ -146,6 +166,62 @@ errorret_t assetChunkLoaderSync(assetloading_t *loading) {
     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);
   loading->loading.chunk.data = NULL;
 

src/dusk/asset/loader/chunk/assetchunkloader.h

@@ -9,7 +9,7 @@
 #include "asset/assetfile.h"
 #include "rpg/overworld/chunk.h"
 
-#define ASSET_CHUNK_FILE_VERSION 4
+#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 {
+  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;
 
 /**

src/dusk/console/console.c

@@ -18,10 +18,7 @@ console_t CONSOLE;
 void consoleInit(void) {
   memoryZero(&CONSOLE, sizeof(console_t));
   CONSOLE.visible = false;
-
-  #ifdef DUSK_CONSOLE_POSIX
   threadMutexInit(&CONSOLE.printMutex);
-  #endif
 }
 
 void consolePrint(const char_t *message, ...) {
@@ -32,20 +29,14 @@ void consolePrint(const char_t *message, ...) {
   int32_t len = stringFormatVA(buffer, CONSOLE_LINE_MAX, message, args);
   va_end(args);
 
-  #ifdef DUSK_CONSOLE_POSIX
   threadMutexLock(&CONSOLE.printMutex);
-  #endif
-
   memoryMove(
     CONSOLE.line[0],
     CONSOLE.line[1],
     (CONSOLE_HISTORY_MAX - 1) * CONSOLE_LINE_MAX
   );
   memoryCopy(CONSOLE.line[CONSOLE_HISTORY_MAX - 1], buffer, len + 1);
-
-  #ifdef DUSK_CONSOLE_POSIX
   threadMutexUnlock(&CONSOLE.printMutex);
-  #endif
 
   logDebug("%s\n", buffer);
 }
@@ -61,7 +52,5 @@ void consoleUpdate(void) {
 }
 
 void consoleDispose(void) {
-  #ifdef DUSK_CONSOLE_POSIX
   threadMutexDispose(&CONSOLE.printMutex);
-  #endif
 }

src/dusk/console/console.h

@@ -6,24 +6,18 @@
  */
 
 #pragma once
-#include "consoledefs.h"
 #include "error/error.h"
 #include "dusk.h"
+#include "thread/thread.h"
 
-#ifdef DUSK_CONSOLE_POSIX
-  #include "thread/thread.h"
-  #include <poll.h>
-  #include <unistd.h>
-  #define CONSOLE_POSIX_POLL_RATE 75
-#endif
+#define CONSOLE_LINE_MAX 512
+#define CONSOLE_HISTORY_MAX 16
+#define CONSOLE_EXEC_BUFFER_MAX 32
 
 typedef struct {
   char_t line[CONSOLE_HISTORY_MAX][CONSOLE_LINE_MAX];
   bool_t visible;
-
-  #ifdef DUSK_CONSOLE_POSIX
   threadmutex_t printMutex;
-  #endif
 } console_t;
 
 extern console_t CONSOLE;

src/dusk/console/consoledefs.h

@@ -1,12 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-
-#define CONSOLE_LINE_MAX 512
-#define CONSOLE_HISTORY_MAX 16
-#define CONSOLE_EXEC_BUFFER_MAX 32

src/dusk/display/display.c

@@ -33,13 +33,17 @@ errorret_t displayInit(void) {
   #ifdef displayPlatformInit
     errorChain(displayPlatformInit());
   #endif
+
+  // Set initial state
   errorChain(displaySetState((displaystate_t){ .flags = 0 }));
+
+  // Init the fixed textures
   errorChain(textureInit(
-    &TEXTURE_WHITE, 4, 4,
+    &TEXTURE_WHITE, TEXTURE_FIXED_WIDTH, TEXTURE_FIXED_HEIGHT,
     TEXTURE_FORMAT_RGBA, (texturedata_t){ .rgbaColors = TEXTURE_WHITE_PIXELS }
   ));
   errorChain(textureInit(
-    &TEXTURE_TEST, 4, 4,
+    &TEXTURE_TEST, TEXTURE_FIXED_WIDTH, TEXTURE_FIXED_HEIGHT,
     TEXTURE_FORMAT_RGBA, (texturedata_t){ .rgbaColors = TEXTURE_TEST_PIXELS }
   ));
 
@@ -51,13 +55,13 @@ errorret_t displayInit(void) {
   errorChain(capsuleInit());
   errorChain(triPrismInit());
 
+  // Init the subsystems
   errorChain(frameBufferInitBackBuffer());
   errorChain(spriteBatchInit());
   errorChain(textInit());
   errorChain(screenInit());
 
   // Setup initial shader with default values
-
   errorChain(shaderListInit());
 
   errorOk();

src/dusk/display/text/CMakeLists.txt

@@ -7,4 +7,5 @@
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     text.c
+    font.c
 )

src/dusk/display/text/font.c

@@ -0,0 +1,168 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "font.h"
+#include "util/memory.h"
+#include "util/math.h"
+#include "display/color.h"
+
+font_t FONT_DEFAULT;
+static texture_t FONT_DEFAULT_TEXTURE;
+static tileset_t FONT_DEFAULT_TILESET;
+
+const uint8_t FONT_DEFAULT_GLYPHS[FONT_DEFAULT_TILE_COUNT][
+  FONT_DEFAULT_TILE_HEIGHT
+] = {
+  { 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x10, 0x00, 0x00 }, // !
+  { 0x00, 0x14, 0x14, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // "
+  { 0x00, 0x14, 0x14, 0x3E, 0x14, 0x3E, 0x14, 0x14, 0x00, 0x00 }, // #
+  { 0x00, 0x08, 0x1E, 0x28, 0x1C, 0x0A, 0x3C, 0x08, 0x00, 0x00 }, // $
+  { 0x00, 0x00, 0x22, 0x24, 0x08, 0x12, 0x22, 0x00, 0x00, 0x00 }, // %
+  { 0x00, 0x08, 0x14, 0x14, 0x1A, 0x24, 0x24, 0x1A, 0x00, 0x00 }, // &
+  { 0x00, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // '
+  { 0x00, 0x04, 0x08, 0x08, 0x08, 0x08, 0x08, 0x04, 0x00, 0x00 }, // (
+  { 0x00, 0x10, 0x08, 0x08, 0x08, 0x08, 0x08, 0x10, 0x00, 0x00 }, // )
+  { 0x00, 0x00, 0x08, 0x2A, 0x1C, 0x2A, 0x08, 0x00, 0x00, 0x00 }, // *
+  { 0x00, 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 0x00, 0x00 }, // +
+  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x20, 0x00 }, // ,
+  { 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00 }, // -
+  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00 }, // .
+  { 0x00, 0x04, 0x04, 0x08, 0x08, 0x08, 0x10, 0x10, 0x00, 0x00 }, // /
+  { 0x00, 0x1C, 0x22, 0x26, 0x2A, 0x32, 0x22, 0x1C, 0x00, 0x00 }, // 0
+  { 0x00, 0x08, 0x18, 0x08, 0x08, 0x08, 0x08, 0x3E, 0x00, 0x00 }, // 1
+  { 0x00, 0x1C, 0x22, 0x02, 0x04, 0x08, 0x10, 0x3E, 0x00, 0x00 }, // 2
+  { 0x00, 0x1C, 0x22, 0x02, 0x0C, 0x02, 0x22, 0x1C, 0x00, 0x00 }, // 3
+  { 0x00, 0x22, 0x22, 0x22, 0x3E, 0x02, 0x02, 0x02, 0x00, 0x00 }, // 4
+  { 0x00, 0x3E, 0x20, 0x20, 0x3C, 0x02, 0x22, 0x1C, 0x00, 0x00 }, // 5
+  { 0x00, 0x1C, 0x20, 0x20, 0x3C, 0x22, 0x22, 0x1C, 0x00, 0x00 }, // 6
+  { 0x00, 0x3E, 0x02, 0x02, 0x04, 0x08, 0x08, 0x08, 0x00, 0x00 }, // 7
+  { 0x00, 0x1C, 0x22, 0x22, 0x1C, 0x22, 0x22, 0x1C, 0x00, 0x00 }, // 8
+  { 0x00, 0x1C, 0x22, 0x22, 0x1E, 0x02, 0x22, 0x1C, 0x00, 0x00 }, // 9
+  { 0x00, 0x00, 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00 }, // :
+  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // ;
+  { 0x00, 0x04, 0x08, 0x10, 0x20, 0x10, 0x08, 0x04, 0x00, 0x00 }, // <
+  { 0x00, 0x00, 0x00, 0x3E, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00 }, // =
+  { 0x00, 0x10, 0x08, 0x04, 0x02, 0x04, 0x08, 0x10, 0x00, 0x00 }, // >
+  { 0x00, 0x1C, 0x22, 0x02, 0x04, 0x08, 0x00, 0x08, 0x00, 0x00 }, // ?
+  { 0x00, 0x1C, 0x26, 0x2A, 0x2A, 0x26, 0x20, 0x1C, 0x00, 0x00 }, // @
+  { 0x00, 0x1C, 0x22, 0x22, 0x22, 0x3E, 0x22, 0x22, 0x00, 0x00 }, // A
+  { 0x00, 0x3C, 0x22, 0x22, 0x3C, 0x22, 0x22, 0x3C, 0x00, 0x00 }, // B
+  { 0x00, 0x1C, 0x22, 0x20, 0x20, 0x20, 0x22, 0x1C, 0x00, 0x00 }, // C
+  { 0x00, 0x3C, 0x22, 0x22, 0x22, 0x22, 0x22, 0x3C, 0x00, 0x00 }, // D
+  { 0x00, 0x3E, 0x20, 0x20, 0x3C, 0x20, 0x20, 0x3E, 0x00, 0x00 }, // E
+  { 0x00, 0x3E, 0x20, 0x20, 0x3C, 0x20, 0x20, 0x20, 0x00, 0x00 }, // F
+  { 0x00, 0x1C, 0x22, 0x20, 0x2E, 0x22, 0x22, 0x1C, 0x00, 0x00 }, // G
+  { 0x00, 0x22, 0x22, 0x22, 0x3E, 0x22, 0x22, 0x22, 0x00, 0x00 }, // H
+  { 0x00, 0x3E, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3E, 0x00, 0x00 }, // I
+  { 0x00, 0x02, 0x02, 0x02, 0x02, 0x22, 0x22, 0x1C, 0x00, 0x00 }, // J
+  { 0x00, 0x22, 0x24, 0x28, 0x30, 0x28, 0x24, 0x22, 0x00, 0x00 }, // K
+  { 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3E, 0x00, 0x00 }, // L
+  { 0x00, 0x22, 0x36, 0x2A, 0x22, 0x22, 0x22, 0x22, 0x00, 0x00 }, // M
+  { 0x00, 0x22, 0x22, 0x32, 0x2A, 0x26, 0x22, 0x22, 0x00, 0x00 }, // N
+  { 0x00, 0x1C, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1C, 0x00, 0x00 }, // O
+  { 0x00, 0x3C, 0x22, 0x22, 0x3C, 0x20, 0x20, 0x20, 0x00, 0x00 }, // P
+  { 0x00, 0x1C, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1C, 0x06, 0x00 }, // Q
+  { 0x00, 0x3C, 0x22, 0x22, 0x3C, 0x22, 0x22, 0x22, 0x00, 0x00 }, // R
+  { 0x00, 0x1C, 0x22, 0x20, 0x1C, 0x02, 0x22, 0x1C, 0x00, 0x00 }, // S
+  { 0x00, 0x3E, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00 }, // T
+  { 0x00, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x1C, 0x00, 0x00 }, // U
+  { 0x00, 0x22, 0x22, 0x22, 0x22, 0x14, 0x14, 0x08, 0x00, 0x00 }, // V
+  { 0x00, 0x22, 0x22, 0x22, 0x22, 0x2A, 0x36, 0x22, 0x00, 0x00 }, // W
+  { 0x00, 0x22, 0x22, 0x14, 0x08, 0x14, 0x22, 0x22, 0x00, 0x00 }, // X
+  { 0x00, 0x22, 0x22, 0x14, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00 }, // Y
+  { 0x00, 0x3E, 0x02, 0x04, 0x08, 0x10, 0x20, 0x3E, 0x00, 0x00 }, // Z
+  { 0x00, 0x0C, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0C, 0x00, 0x00 }, // [
+  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // backslash (not drawn in source font)
+  { 0x00, 0x18, 0x08, 0x08, 0x08, 0x08, 0x08, 0x18, 0x00, 0x00 }, // ]
+  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // ^ (not drawn in source font)
+  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // _ (not drawn in source font)
+  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // ` (not drawn in source font)
+  { 0x00, 0x00, 0x00, 0x1E, 0x22, 0x22, 0x22, 0x1E, 0x00, 0x00 }, // a
+  { 0x00, 0x20, 0x20, 0x3C, 0x22, 0x22, 0x22, 0x3C, 0x00, 0x00 }, // b
+  { 0x00, 0x00, 0x00, 0x1C, 0x22, 0x20, 0x22, 0x1C, 0x00, 0x00 }, // c
+  { 0x00, 0x02, 0x02, 0x1E, 0x22, 0x22, 0x22, 0x1E, 0x00, 0x00 }, // d
+  { 0x00, 0x00, 0x00, 0x1C, 0x22, 0x3E, 0x20, 0x1C, 0x00, 0x00 }, // e
+  { 0x00, 0x0C, 0x12, 0x10, 0x3C, 0x10, 0x10, 0x10, 0x00, 0x00 }, // f
+  { 0x00, 0x00, 0x00, 0x1E, 0x22, 0x22, 0x22, 0x1E, 0x02, 0x1C }, // g
+  { 0x00, 0x20, 0x20, 0x3C, 0x22, 0x22, 0x22, 0x22, 0x00, 0x00 }, // h
+  { 0x00, 0x08, 0x00, 0x18, 0x08, 0x08, 0x08, 0x3E, 0x00, 0x00 }, // i
+  { 0x00, 0x02, 0x00, 0x06, 0x02, 0x02, 0x02, 0x02, 0x22, 0x1C }, // j
+  { 0x00, 0x20, 0x20, 0x22, 0x24, 0x38, 0x24, 0x22, 0x00, 0x00 }, // k
+  { 0x00, 0x30, 0x10, 0x10, 0x10, 0x10, 0x10, 0x0E, 0x00, 0x00 }, // l
+  { 0x00, 0x00, 0x00, 0x3C, 0x2A, 0x2A, 0x2A, 0x2A, 0x00, 0x00 }, // m
+  { 0x00, 0x00, 0x00, 0x3C, 0x22, 0x22, 0x22, 0x22, 0x00, 0x00 }, // n
+  { 0x00, 0x00, 0x00, 0x1C, 0x22, 0x22, 0x22, 0x1C, 0x00, 0x00 }, // o
+  { 0x00, 0x00, 0x00, 0x3C, 0x22, 0x22, 0x22, 0x3C, 0x20, 0x20 }, // p
+  { 0x00, 0x00, 0x00, 0x1E, 0x22, 0x22, 0x22, 0x1E, 0x02, 0x02 }, // q
+  { 0x00, 0x00, 0x00, 0x2C, 0x32, 0x20, 0x20, 0x20, 0x00, 0x00 }, // r
+  { 0x00, 0x00, 0x00, 0x1E, 0x20, 0x1C, 0x02, 0x3C, 0x00, 0x00 }, // s
+  { 0x00, 0x10, 0x10, 0x3C, 0x10, 0x10, 0x10, 0x0E, 0x00, 0x00 }, // t
+  { 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x22, 0x1E, 0x00, 0x00 }, // u
+  { 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x14, 0x08, 0x00, 0x00 }, // v
+  { 0x00, 0x00, 0x00, 0x22, 0x22, 0x2A, 0x2A, 0x14, 0x00, 0x00 }, // w
+  { 0x00, 0x00, 0x00, 0x22, 0x14, 0x08, 0x14, 0x22, 0x00, 0x00 }, // x
+  { 0x00, 0x00, 0x00, 0x22, 0x22, 0x22, 0x22, 0x1E, 0x02, 0x1C }, // y
+  { 0x00, 0x00, 0x00, 0x3E, 0x04, 0x08, 0x10, 0x3E, 0x00, 0x00 }, // z
+  { 0x00, 0x04, 0x08, 0x08, 0x10, 0x08, 0x08, 0x04, 0x00, 0x00 }, // {
+  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // | (not drawn in source font)
+  { 0x00, 0x10, 0x08, 0x08, 0x04, 0x08, 0x08, 0x10, 0x00, 0x00 }, // }
+  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // ~ (not drawn in source font)
+  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // unused trailing tile
+  { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // unused trailing tile
+};
+
+errorret_t fontDefaultInit(void) {
+  const int32_t width = (int32_t)mathNextPowTwo(
+    FONT_DEFAULT_COLUMNS * FONT_DEFAULT_TILE_WIDTH
+  );
+  const int32_t height = (int32_t)mathNextPowTwo(
+    FONT_DEFAULT_ROWS * FONT_DEFAULT_TILE_HEIGHT
+  );
+
+  color_t *pixels = memoryAllocate(sizeof(color_t) * width * height);
+  memoryZero(pixels, sizeof(color_t) * width * height);
+
+  for(uint16_t i = 0; i < FONT_DEFAULT_TILE_COUNT; i++) {
+    const uint16_t tileX = (i % FONT_DEFAULT_COLUMNS) * FONT_DEFAULT_TILE_WIDTH;
+    const uint16_t tileY = (i / FONT_DEFAULT_COLUMNS) * FONT_DEFAULT_TILE_HEIGHT;
+
+    for(uint8_t row = 0; row < FONT_DEFAULT_TILE_HEIGHT; row++) {
+      const uint8_t bits = FONT_DEFAULT_GLYPHS[i][row];
+
+      for(uint8_t col = 0; col < FONT_DEFAULT_TILE_WIDTH; col++) {
+        if(!((bits >> (FONT_DEFAULT_TILE_WIDTH - 1 - col)) & 1)) continue;
+        pixels[((tileY + row) * width) + (tileX + col)] = COLOR_WHITE;
+      }
+    }
+  }
+
+  FONT_DEFAULT_TILESET.tileWidth = FONT_DEFAULT_TILE_WIDTH;
+  FONT_DEFAULT_TILESET.tileHeight = FONT_DEFAULT_TILE_HEIGHT;
+  FONT_DEFAULT_TILESET.columns = FONT_DEFAULT_COLUMNS;
+  FONT_DEFAULT_TILESET.rows = FONT_DEFAULT_ROWS;
+  FONT_DEFAULT_TILESET.tileCount = FONT_DEFAULT_TILE_COUNT;
+  FONT_DEFAULT_TILESET.uv[0] = (float_t)FONT_DEFAULT_TILE_WIDTH / (float_t)width;
+  FONT_DEFAULT_TILESET.uv[1] = (float_t)FONT_DEFAULT_TILE_HEIGHT / (float_t)height;
+
+  const texturedata_t data = { .rgbaColors = pixels };
+  errorret_t textureResult = textureInit(
+    &FONT_DEFAULT_TEXTURE, width, height, TEXTURE_FORMAT_RGBA, data
+  );
+  memoryFree(pixels);
+  errorChain(textureResult);
+
+  FONT_DEFAULT.texture = &FONT_DEFAULT_TEXTURE;
+  FONT_DEFAULT.tileset = &FONT_DEFAULT_TILESET;
+  errorOk();
+}
+
+errorret_t fontDefaultDispose(void) {
+  errorChain(textureDispose(&FONT_DEFAULT_TEXTURE));
+  FONT_DEFAULT.texture = NULL;
+  FONT_DEFAULT.tileset = NULL;
+  errorOk();
+}

src/dusk/display/text/font.h

@@ -6,6 +6,7 @@
  */
 
 #pragma once
+#include "error/error.h"
 #include "display/texture/texture.h"
 #include "display/texture/tileset.h"
 
@@ -13,3 +14,51 @@ typedef struct {
   texture_t *texture;
   tileset_t *tileset;
 } font_t;
+
+/**
+ * Pixel width/height of a single default-font glyph tile.
+ */
+#define FONT_DEFAULT_TILE_WIDTH 6
+#define FONT_DEFAULT_TILE_HEIGHT 10
+
+/** Grid layout of the generated default-font texture, in tiles. */
+#define FONT_DEFAULT_COLUMNS 16
+#define FONT_DEFAULT_ROWS 6
+
+/**
+ * Number of glyphs defined in FONT_DEFAULT_GLYPHS (FONT_DEFAULT_COLUMNS *
+ * FONT_DEFAULT_ROWS), covering the printable ASCII range starting at
+ * TEXT_CHAR_START ('!') plus a couple of unused trailing tiles.
+ */
+#define FONT_DEFAULT_TILE_COUNT (FONT_DEFAULT_COLUMNS * FONT_DEFAULT_ROWS)
+
+extern font_t FONT_DEFAULT;
+
+/**
+ * Hard coded bitmap data for the built-in default font. Indexed
+ * [glyph][row], where glyph 0 corresponds to TEXT_CHAR_START ('!') and
+ * glyphs run consecutively through the printable ASCII range. Each row
+ * byte holds FONT_DEFAULT_TILE_WIDTH bit flags, one per pixel column:
+ * bit (FONT_DEFAULT_TILE_WIDTH - 1) is the leftmost pixel and bit 0 is
+ * the rightmost; 1 means the pixel is set, 0 means it is not.
+ */
+extern const uint8_t FONT_DEFAULT_GLYPHS[FONT_DEFAULT_TILE_COUNT][
+  FONT_DEFAULT_TILE_HEIGHT
+];
+
+/**
+ * Builds the default font's texture + tileset directly from
+ * FONT_DEFAULT_GLYPHS, without going through the asset system - so the
+ * engine always has a usable font to render with regardless of whether
+ * asset loading (e.g. the packed .dsk archive) succeeds.
+ *
+ * @return Either an error or success result.
+ */
+errorret_t fontDefaultInit(void);
+
+/**
+ * Disposes of the default font created by fontDefaultInit().
+ *
+ * @return Either an error or success result.
+ */
+errorret_t fontDefaultDispose(void);

src/dusk/display/text/text.c

@@ -9,34 +9,15 @@
 #include "assert/assert.h"
 #include "util/memory.h"
 #include "display/spritebatch/spritebatch.h"
-#include "asset/asset.h"
-#include "asset/loader/display/assettextureloader.h"
-#include "asset/loader/display/assettilesetloader.h"
 #include "display/shader/shaderunlit.h"
 
-font_t FONT_DEFAULT;
-
 errorret_t textInit(void) {
-  assetloaderinput_t input = { .texture = TEXTURE_FORMAT_RGBA };
-  assetentry_t *entryTexture = assetLock(
-    "ui/minogram.png", ASSET_LOADER_TYPE_TEXTURE, &input
-  );
-  assetentry_t *entryTileset = assetLock(
-    "ui/minogram.dtf", ASSET_LOADER_TYPE_TILESET, NULL
-  );
-  errorChain(assetRequireLoaded(entryTexture));
-  errorChain(assetRequireLoaded(entryTileset));
-
-  FONT_DEFAULT.texture = &entryTexture->data.texture;
-  FONT_DEFAULT.tileset = &entryTileset->data.tileset;
+  errorChain(fontDefaultInit());
   errorOk();
 }
 
 errorret_t textDispose(void) {
-  FONT_DEFAULT.texture = NULL;
-  FONT_DEFAULT.tileset = NULL;
-  assetUnlock("ui/minogram.png");
-  assetUnlock("ui/minogram.dtf");
+  errorChain(fontDefaultDispose());
   errorOk();
 }
 

src/dusk/display/text/text.h

@@ -12,8 +12,6 @@
 
 #define TEXT_CHAR_START '!'
 
-extern font_t FONT_DEFAULT;
-
 /**
  * Initializes the text system.
  *

src/dusk/display/texture/texture.c

@@ -12,7 +12,7 @@
 #include "display/display.h"
 
 texture_t TEXTURE_WHITE;
-color_t TEXTURE_WHITE_PIXELS[4*4] = {
+color_t TEXTURE_WHITE_PIXELS[TEXTURE_FIXED_WIDTH * TEXTURE_FIXED_HEIGHT] = {
   COLOR_WHITE, COLOR_WHITE, COLOR_WHITE, COLOR_WHITE,
   COLOR_WHITE, COLOR_WHITE, COLOR_WHITE, COLOR_WHITE,
   COLOR_WHITE, COLOR_WHITE, COLOR_WHITE, COLOR_WHITE,
@@ -20,7 +20,7 @@ color_t TEXTURE_WHITE_PIXELS[4*4] = {
 };
 
 texture_t TEXTURE_TEST;
-color_t TEXTURE_TEST_PIXELS[4*4] = {
+color_t TEXTURE_TEST_PIXELS[TEXTURE_FIXED_WIDTH * TEXTURE_FIXED_HEIGHT] = {
   COLOR_BLACK, COLOR_MAGENTA, COLOR_BLACK, COLOR_MAGENTA,
   COLOR_MAGENTA, COLOR_BLACK, COLOR_MAGENTA, COLOR_BLACK,
   COLOR_BLACK, COLOR_MAGENTA, COLOR_BLACK, COLOR_MAGENTA,

src/dusk/display/texture/texture.h

@@ -17,6 +17,9 @@
   #error "textureDisposePlatform should not be defined."
 #endif
 
+#define TEXTURE_FIXED_WIDTH 4
+#define TEXTURE_FIXED_HEIGHT 4
+
 typedef textureformatplatform_t textureformat_t;
 typedef textureplatform_t texture_t;
 
@@ -29,9 +32,9 @@ typedef union texturedata_u {
 } texturedata_t;
 
 extern texture_t TEXTURE_WHITE;
-extern color_t TEXTURE_WHITE_PIXELS[4*4];
+extern color_t TEXTURE_WHITE_PIXELS[TEXTURE_FIXED_WIDTH * TEXTURE_FIXED_HEIGHT];
 extern texture_t TEXTURE_TEST;
-extern color_t TEXTURE_TEST_PIXELS[4*4];
+extern color_t TEXTURE_TEST_PIXELS[TEXTURE_FIXED_WIDTH * TEXTURE_FIXED_HEIGHT];
 
 /**
  * Initializes a texture.

src/dusk/engine/engine.c

@@ -16,10 +16,13 @@
 #include "asset/asset.h"
 #include "ui/ui.h"
 #include "assert/assert.h"
-#include "network/network.h"
+#ifdef DUSK_NETWORK
+  #include "network/network.h"
+#endif
 #include "system/system.h"
 #include "console/console.h"
 #include "save/save.h"
+#include "save/autosave.h"
 
 engine_t ENGINE;
 
@@ -37,12 +40,14 @@ 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());
   errorChain(rpgInit());
+  #ifdef DUSK_NETWORK
     errorChain(networkInit());
+  #endif
   errorChain(sceneInit());
 
   consolePrint("Engine initialized");
@@ -53,15 +58,18 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
     consolePrint("Assertions real");
   #endif
 
-  sceneSet(SCENE_TYPE_OVERWORLD);
-  
+  sceneSet(SCENE_TYPE_INITIAL);
 
   errorOk();
 }
 
 errorret_t engineUpdate(void) {
   // Order here is important.
+  #ifdef DUSK_NETWORK
     errorChain(networkUpdate());
+  #endif
+  errorChain(saveUpdate());
+  autoSaveUpdate();
   timeUpdate();
   inputUpdate();
   consoleUpdate();
@@ -82,13 +90,15 @@ void engineExit(void) {
 
 errorret_t engineDispose(void) {
   errorChain(sceneDispose());
+  #ifdef DUSK_NETWORK
     errorChain(networkDispose());
+  #endif
   errorChain(rpgDispose());
   localeManagerDispose();
   errorChain(uiDispose());
   consoleDispose();
   errorChain(displayDispose());
-  // errorChain(saveDispose());
+  errorChain(saveDispose());
   errorChain(assetDispose());
 
   errorOk();

src/dusk/input/input.c

@@ -17,26 +17,11 @@ input_t INPUT;
 
 errorret_t inputInit(void) {
   memoryZero(&INPUT, sizeof(input_t));
-  INPUT.deadzone = INPUT_DEADZONE_DEFAULT;
 
   for(uint8_t i = 0; i < INPUT_ACTION_COUNT; i++) {
     INPUT.actions[i].action = (inputaction_t)i;
     INPUT.actions[i].lastValue = 0.0f;
     INPUT.actions[i].currentValue = 0.0f;
-
-    eventInit(
-      &INPUT.actions[i].onPressed,
-      INPUT.actions[i].onPressedCallbacks,
-      INPUT.actions[i].onPressedUsers,
-      INPUT_ACTION_CALLBACK_COUNT_MAX
-    );
-    
-    eventInit(
-      &INPUT.actions[i].onReleased,
-      INPUT.actions[i].onReleasedCallbacks,
-      INPUT.actions[i].onReleasedUsers,
-      INPUT_ACTION_CALLBACK_COUNT_MAX
-    );
   }
 
   #ifdef inputInitPlatform
@@ -107,8 +92,6 @@ void inputUpdate(void) {
     inputactiondata_t *act = &INPUT.actions[i];
     bool_t isDown = act->currentValue > 0.0f;
     bool_t wasDown = act->lastValue > 0.0f;
-    if(isDown && !wasDown) eventInvoke(&act->onPressed, act);
-    if(!isDown && wasDown) eventInvoke(&act->onReleased, act);
   }
 }
 

src/dusk/input/input.h

@@ -10,17 +10,9 @@
 #include "inputbutton.h"
 #include "inputaction.h"
 
-#define INPUT_LISTENER_PRESSED_MAX 16
-#define INPUT_LISTENER_RELEASED_MAX INPUT_LISTENER_PRESSED_MAX
-#define INPUT_DEADZONE_DEFAULT 0.1f
-
 typedef struct {
   inputactiondata_t actions[INPUT_ACTION_COUNT];
-
   inputplatform_t platform;
-
-  /** User-configured gamepad axis deadzone (0.0f to 1.0f). */
-  float_t deadzone;
 } input_t;
 
 extern input_t INPUT;

src/dusk/input/inputaction.h

@@ -8,7 +8,6 @@
 #pragma once
 #include "time/time.h"
 #include "input/inputactiondefs.h"
-#include "event/event.h"
 
 #define INPUT_ACTION_CALLBACK_COUNT_MAX 4
 
@@ -21,13 +20,6 @@ typedef struct {
     float_t lastDynamicValue;
     float_t currentDynamicValue;
   #endif
-
-  eventcallback_t onPressedCallbacks[INPUT_ACTION_CALLBACK_COUNT_MAX];
-  void *onPressedUsers[INPUT_ACTION_CALLBACK_COUNT_MAX];
-  event_t onPressed;
-  eventcallback_t onReleasedCallbacks[INPUT_ACTION_CALLBACK_COUNT_MAX];
-  void *onReleasedUsers[INPUT_ACTION_CALLBACK_COUNT_MAX];
-  event_t onReleased;
 } inputactiondata_t;
 
 /**

src/dusk/locale/localemanager.c

@@ -7,16 +7,42 @@
 
 #include "localemanager.h"
 #include "util/memory.h"
+#include "util/string.h"
 #include "assert/assert.h"
+#include "save/save.h"
 
 localemanager_t LOCALE;
 
+const localeinfo_t * const LOCALE_LIST[LOCALE_LIST_COUNT] = {
+  &LOCALE_EN_US,
+  &LOCALE_JP_JP,
+  &LOCALE_ES_MX
+};
+
 errorret_t localeManagerInit() {
   memoryZero(&LOCALE, sizeof(localemanager_t));
-  errorChain(localeManagerSetLocale(&LOCALE_EN_US));
+  // saveInit() runs before this (see engine.c) and, on most platforms,
+  // has already loaded a persisted language choice into savemeta_t by
+  // this point - see localeManagerGetByIndex().
+  errorChain(localeManagerSetLocale(
+    localeManagerGetByIndex(saveGetMeta()->language)
+  ));
   errorOk();
 }
 
+uint8_t localeManagerGetIndex(const localeinfo_t *locale) {
+  assertNotNull(locale, "Locale cannot be NULL");
+  for(uint8_t i = 0; i < LOCALE_LIST_COUNT; i++) {
+    if(stringCompare(LOCALE_LIST[i]->file, locale->file) == 0) return i;
+  }
+  return 0;
+}
+
+const localeinfo_t * localeManagerGetByIndex(const uint8_t index) {
+  if(index >= LOCALE_LIST_COUNT) return LOCALE_LIST[0];
+  return LOCALE_LIST[index];
+}
+
 errorret_t localeManagerSetLocale(const localeinfo_t *locale) {
   assertNotNull(locale, "Locale cannot be NULL");
 

src/dusk/locale/localemanager.h

@@ -18,6 +18,15 @@ typedef struct {
 
 extern localemanager_t LOCALE;
 
+/**
+ * Every locale the game supports, in a fixed, stable order - index into
+ * this array is what gets persisted as savemeta_t.language (see
+ * save/savemeta.h), so the order here must never change once shipped
+ * (only append new locales at the end).
+ */
+#define LOCALE_LIST_COUNT 3
+extern const localeinfo_t * const LOCALE_LIST[LOCALE_LIST_COUNT];
+
 /**
  * Initialize the locale system.
  *
@@ -33,6 +42,27 @@ errorret_t localeManagerInit();
  */
 errorret_t localeManagerSetLocale(const localeinfo_t *locale);
 
+/**
+ * Finds the LOCALE_LIST index matching the given locale's file, by
+ * content rather than pointer identity (localeinfo_t instances are
+ * declared `static const` in a header, so the same locale gets a
+ * distinct pointer in every translation unit that references it).
+ *
+ * @param locale The locale to find.
+ * @return The matching index in LOCALE_LIST, or 0 if not found.
+ */
+uint8_t localeManagerGetIndex(const localeinfo_t *locale);
+
+/**
+ * Gets the locale at the given LOCALE_LIST index, clamping to index 0
+ * (LOCALE_EN_US) if out of range - e.g. a save file's persisted language
+ * index from a future build with more locales than this one supports.
+ *
+ * @param index The index to look up.
+ * @return The locale at that index, or LOCALE_LIST[0] if out of range.
+ */
+const localeinfo_t * localeManagerGetByIndex(const uint8_t index);
+
 /**
  * Get a localized string for the given message ID.
  * 

src/dusk/rpg/battle/battle.c

@@ -8,6 +8,7 @@
 #include "battle.h"
 #include "assert/assert.h"
 #include "util/memory.h"
+#include "rpg/cutscene/cutscenesystem.h"
 
 battle_t BATTLE;
 
@@ -51,10 +52,8 @@ void battleStart(
   BATTLE.fleeAvailable = fleeAvailable;
   BATTLE.result = BATTLE_RESULT_NONE;
   BATTLE.round = 1;
-  BATTLE.turnIndex = 0;
-  battleBuildTurnOrder(true);
 
-  BATTLE.active = true;
+  battleSetState(BATTLE_STATE_OPENING);
 }
 
 void battleDispose(void) {
@@ -62,9 +61,9 @@ void battleDispose(void) {
 }
 
 battlefighter_t *battleGetCurrentFighter(void) {
-  if(!BATTLE.active) return NULL;
-  if(BATTLE.turnIndex >= BATTLE.turnCount) return NULL;
-  return &BATTLE.fighters[BATTLE.turnOrder[BATTLE.turnIndex]];
+  if(BATTLE.state != BATTLE_STATE_PLAYER_SELECTION) return NULL;
+  if(BATTLE.selectionIndex >= BATTLE.executionCount) return NULL;
+  return &BATTLE.fighters[BATTLE.executionOrder[BATTLE.selectionIndex]];
 }
 
 uint8_t battleGetAliveCount(const battlefighterteam_t team) {
@@ -92,91 +91,105 @@ void battleResolveAttack(
   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;
+    battleSetResult(BATTLE_RESULT_LOSS);
   } else if(battleGetAliveCount(BATTLE_FIGHTER_TEAM_ENEMY) == 0) {
-    BATTLE.result = BATTLE_RESULT_WIN;
+    battleSetResult(BATTLE_RESULT_WIN);
   }
 
   return BATTLE.result;
 }
 
+void battleQueueAction(
+  const uint8_t fighterIndex,
+  const battleactiontype_t type,
+  const uint8_t targetIndex
+) {
+  battleaction_t *action = &BATTLE.actions[fighterIndex];
+  action->type = type;
+  action->targetIndex = targetIndex;
+
+  if(BATTLE.onActionDecided != NULL) {
+    BATTLE.onActionDecided(&BATTLE.fighters[fighterIndex], action);
+  }
+}
+
 void battlePlayerAttack(const uint8_t targetIndex) {
-  battlefighter_t *attacker = battleGetCurrentFighter();
-  if(attacker == NULL) return;
-  if(attacker->controller != BATTLE_FIGHTER_CONTROLLER_PLAYER) return;
+  battlefighter_t *fighter = battleGetCurrentFighter();
+  if(fighter == NULL) return;
   if(targetIndex >= BATTLE_FIGHTER_COUNT_MAX) return;
+  if(!battleFighterIsAlive(&BATTLE.fighters[targetIndex])) return;
 
-  battlefighter_t *defender = &BATTLE.fighters[targetIndex];
-  if(!battleFighterIsAlive(defender)) return;
-
-  battleResolveAttack(attacker, defender);
-  battleCheckResult();
-  if(BATTLE.result == BATTLE_RESULT_NONE) battleNextTurn();
+  battleQueueAction(fighter->id, BATTLE_ACTION_ATTACK, targetIndex);
+  BATTLE.selectionIndex++;
+  battleAdvanceSelection();
 }
 
 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;
+  battleSetResult(BATTLE_RESULT_FLED);
 }
 
 void battleUpdate(void) {
-  if(!BATTLE.active) return;
-  if(BATTLE.result != BATTLE_RESULT_NONE) return;
+  if(BATTLE.state == BATTLE_STATE_NONE) return;
+  if(BATTLE.state == BATTLE_STATE_ENDED) return;
+  if(CUTSCENE_SYSTEM.pause & CUTSCENE_PAUSE_BATTLE) return;
 
-  battlefighter_t *current = battleGetCurrentFighter();
-  if(current == NULL) return;
+  switch(BATTLE.state) {
+    case BATTLE_STATE_OPENING:
+      battleSetState(BATTLE_STATE_PRE_ROUND);
+      break;
 
-  if(!battleFighterIsAlive(current)) {
-    battleNextTurn();
-    return;
+    case BATTLE_STATE_PRE_ROUND:
+      battleUpdatePreRound();
+      break;
+
+    case BATTLE_STATE_AI_SELECTION:
+      battleUpdateAiSelection();
+      break;
+
+    case BATTLE_STATE_MOVES_EXECUTING:
+      battleUpdateMovesExecuting();
+      break;
+
+    case BATTLE_STATE_POST_ROUND:
+      battleUpdatePostRound();
+      break;
+
+    default:
+      // BATTLE_STATE_PLAYER_SELECTION: waits on battlePlayerAttack/Flee.
+      // BATTLE_STATE_NONE/ENDED: handled above.
+      break;
   }
-
-  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;
+void battleBuildExecutionOrder(const bool_t applyEncounterBias) {
+  BATTLE.executionCount = 0;
   for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
     if(!battleFighterIsAlive(&BATTLE.fighters[i])) continue;
-    BATTLE.turnOrder[BATTLE.turnCount++] = i;
+    BATTLE.executionOrder[BATTLE.executionCount++] = 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];
+  for(uint8_t i = 1; i < BATTLE.executionCount; i++) {
+    const uint8_t key = BATTLE.executionOrder[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
+      j >= 0 &&
+      BATTLE.fighters[BATTLE.executionOrder[j]].stats.speed < keySpeed
     ) {
-      BATTLE.turnOrder[j + 1] = BATTLE.turnOrder[j];
+      BATTLE.executionOrder[j + 1] = BATTLE.executionOrder[j];
       j--;
     }
-    BATTLE.turnOrder[j + 1] = key;
+    BATTLE.executionOrder[j + 1] = key;
   }
 
   if(!applyEncounterBias) return;
@@ -192,16 +205,16 @@ 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.executionCount; i++) {
+    if(BATTLE.fighters[BATTLE.executionOrder[i]].team != team) continue;
+    sorted[count++] = BATTLE.executionOrder[i];
   }
-  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.executionCount; i++) {
+    if(BATTLE.fighters[BATTLE.executionOrder[i]].team == team) continue;
+    sorted[count++] = BATTLE.executionOrder[i];
   }
 
-  memoryCopy(BATTLE.turnOrder, sorted, sizeof(uint8_t) * BATTLE.turnCount);
+  memoryCopy(BATTLE.executionOrder, sorted, sizeof(uint8_t) * BATTLE.executionCount);
 }
 
 battlefighter_t *battleAIChooseTarget(const battlefighter_t *fighter) {
@@ -221,3 +234,93 @@ battlefighter_t *battleAIChooseTarget(const battlefighter_t *fighter) {
 
   return weakest;
 }
+
+void battleSetState(const battlestate_t next) {
+  const battlestate_t previous = BATTLE.state;
+  BATTLE.state = next;
+  if(BATTLE.onStateChanged != NULL) BATTLE.onStateChanged(previous, next);
+}
+
+void battleSetResult(const battleresult_t result) {
+  BATTLE.result = result;
+  battleSetState(BATTLE_STATE_ENDED);
+}
+
+bool_t battleFighterNeedsDecision(
+  const uint8_t fighterIndex,
+  const battlefightercontroller_t controller
+) {
+  return battleFighterIsAlive(&BATTLE.fighters[fighterIndex])
+    && BATTLE.fighters[fighterIndex].controller == controller
+    && BATTLE.actions[fighterIndex].type == BATTLE_ACTION_NONE;
+}
+
+void battleAdvanceSelection(void) {
+  while(BATTLE.selectionIndex < BATTLE.executionCount) {
+    const uint8_t fighterIndex = BATTLE.executionOrder[BATTLE.selectionIndex];
+    if(
+      battleFighterNeedsDecision(fighterIndex, BATTLE_FIGHTER_CONTROLLER_PLAYER)
+    ) {
+      return;
+    }
+    BATTLE.selectionIndex++;
+  }
+
+  battleSetState(BATTLE_STATE_AI_SELECTION);
+}
+
+void battleUpdatePreRound(void) {
+  // No need to clear BATTLE.actions here: every living fighter's action is
+  // unconditionally reset to BATTLE_ACTION_NONE as it's processed in
+  // battleUpdateMovesExecuting, and round 1 starts pre-zeroed by
+  // battleInit(). Clearing it here would also wipe out any action a
+  // cutscene force-queued while parked at BATTLE_STATE_PRE_ROUND.
+  battleBuildExecutionOrder(BATTLE.round == 1);
+
+  BATTLE.selectionIndex = 0;
+  battleSetState(BATTLE_STATE_PLAYER_SELECTION);
+  battleAdvanceSelection();
+}
+
+void battleUpdateAiSelection(void) {
+  for(uint8_t i = 0; i < BATTLE.executionCount; i++) {
+    const uint8_t fighterIndex = BATTLE.executionOrder[i];
+    if(
+      !battleFighterNeedsDecision(fighterIndex, BATTLE_FIGHTER_CONTROLLER_AI)
+    ) continue;
+
+    battlefighter_t *target =
+      battleAIChooseTarget(&BATTLE.fighters[fighterIndex]);
+    if(target == NULL) continue;
+
+    battleQueueAction(fighterIndex, BATTLE_ACTION_ATTACK, target->id);
+  }
+
+  BATTLE.executionIndex = 0;
+  battleSetState(BATTLE_STATE_MOVES_EXECUTING);
+}
+
+void battleUpdateMovesExecuting(void) {
+  if(BATTLE.executionIndex >= BATTLE.executionCount) {
+    battleSetState(BATTLE_STATE_POST_ROUND);
+    return;
+  }
+
+  const uint8_t fighterIndex = BATTLE.executionOrder[BATTLE.executionIndex++];
+  battlefighter_t *fighter = &BATTLE.fighters[fighterIndex];
+  if(!battleFighterIsAlive(fighter)) return;
+
+  battleaction_t *action = &BATTLE.actions[fighterIndex];
+  if(action->type == BATTLE_ACTION_ATTACK) {
+    battlefighter_t *target = &BATTLE.fighters[action->targetIndex];
+    if(battleFighterIsAlive(target)) battleResolveAttack(fighter, target);
+  }
+  action->type = BATTLE_ACTION_NONE;
+
+  battleCheckResult();
+}
+
+void battleUpdatePostRound(void) {
+  BATTLE.round++;
+  battleSetState(BATTLE_STATE_PRE_ROUND);
+}

src/dusk/rpg/battle/battle.h

@@ -27,19 +27,68 @@ typedef enum {
   BATTLE_RESULT_COUNT
 } battleresult_t;
 
+// Where BATTLE currently is within a round. A cutscene can pause progression
+// (CUTSCENE_PAUSE_BATTLE) and use CUTSCENE_BATTLE_WAIT_STATE to synchronize
+// with any of these, or CUTSCENE_BATTLE_FORCE_ACTION to decide a fighter's
+// action ahead of PLAYER_SELECTION/AI_SELECTION reaching them.
+typedef enum {
+  BATTLE_STATE_NONE, // Battle inactive.
+
+  BATTLE_STATE_OPENING, // Entered once by battleStart().
+  BATTLE_STATE_PRE_ROUND, // Rebuilds execution order, clears the action queue.
+  BATTLE_STATE_PLAYER_SELECTION, // Waits on battlePlayerAttack/Flee.
+  BATTLE_STATE_AI_SELECTION, // Auto-queues every undecided AI fighter.
+  BATTLE_STATE_MOVES_EXECUTING, // Resolves one queued action per update.
+  BATTLE_STATE_POST_ROUND, // Round wrap-up; loops back to PRE_ROUND.
+
+  BATTLE_STATE_ENDED, // Terminal for WIN/LOSS/FLED alike -- see BATTLE.result.
+
+  BATTLE_STATE_COUNT
+} battlestate_t;
+
+typedef enum {
+  BATTLE_ACTION_NONE, // No action decided yet for this fighter this round.
+  BATTLE_ACTION_ATTACK,
+
+  BATTLE_ACTION_COUNT
+} battleactiontype_t;
+
 typedef struct {
-  bool_t active;
+  battleactiontype_t type;
+  uint8_t targetIndex; // Meaningful for BATTLE_ACTION_ATTACK.
+} battleaction_t;
+
+typedef void (*battlestatechangedcallback_t)(
+  const battlestate_t previous,
+  const battlestate_t next
+);
+
+typedef void (*battleactiondecidedcallback_t)(
+  const battlefighter_t *fighter,
+  const battleaction_t *action
+);
+
+typedef struct {
+  battlestate_t state;
   battlefighter_t fighters[BATTLE_FIGHTER_COUNT_MAX];
+  battleaction_t actions[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;
+  uint8_t executionOrder[BATTLE_FIGHTER_COUNT_MAX];
+  uint8_t executionCount;
+  uint8_t executionIndex;
   uint16_t round;
+
+  // Cursor into executionOrder used by BATTLE_STATE_PLAYER_SELECTION to find
+  // the next player-controlled fighter that still needs a decision.
+  uint8_t selectionIndex;
+
+  battlestatechangedcallback_t onStateChanged;
+  battleactiondecidedcallback_t onActionDecided;
 } battle_t;
 
 extern battle_t BATTLE;
@@ -77,11 +126,10 @@ battlefighter_t *battleAddFighter(
 );
 
 /**
- * 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.
+ * Starts the battle: enters BATTLE_STATE_OPENING and marks the battle
+ * active. Call once every fighter has been added via battleAddFighter.
  *
- * @param encounterType Determines the opening round's turn order.
+ * @param encounterType Determines the opening round's execution order.
  * @param fleeAvailable Whether the party may attempt to flee this battle.
  */
 void battleStart(
@@ -95,10 +143,11 @@ void battleStart(
 void battleDispose(void);
 
 /**
- * Returns the fighter whose turn it currently is.
+ * Returns the fighter currently awaiting a player decision.
  *
- * @return Pointer to the active fighter, or NULL if the battle isn't
- *         active or has no living fighters left to act.
+ * @return Pointer to the fighter awaiting a decision, or NULL if the battle
+ *         isn't in BATTLE_STATE_PLAYER_SELECTION or every player-controlled
+ *         fighter has already decided.
  */
 battlefighter_t *battleGetCurrentFighter(void);
 
@@ -125,61 +174,68 @@ void battleResolveAttack(
 );
 
 /**
- * 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).
+ * Checks whether the battle has been won or lost, transitioning to
+ * BATTLE_STATE_ENDED and updating BATTLE.result if so. 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.
+ * Queues an action for a fighter to perform once BATTLE_STATE_MOVES_EXECUTING
+ * reaches them this round, overwriting any action already queued for that
+ * fighter. Fires BATTLE.onActionDecided.
+ *
+ * @param fighterIndex Index into BATTLE.fighters of the deciding fighter.
+ * @param type The type of action to perform.
+ * @param targetIndex Index into BATTLE.fighters of the target, meaningful
+ *        for BATTLE_ACTION_ATTACK.
+ */
+void battleQueueAction(
+  const uint8_t fighterIndex,
+  const battleactiontype_t type,
+  const uint8_t targetIndex
+);
+
+/**
+ * Submits the currently-selecting fighter's attack against a target, if the
+ * battle is in BATTLE_STATE_PLAYER_SELECTION and awaiting a decision.
+ * Queues the action and advances the selection cursor.
  *
  * @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.
+ * Submits a flee attempt for the currently-selecting fighter, if the battle
+ * is in BATTLE_STATE_PLAYER_SELECTION 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.
+ * Updates the battle simulation for one frame, dispatching on BATTLE.state.
+ * No-op if the battle isn't active, has already ended, or
+ * CUTSCENE_PAUSE_BATTLE is set.
  */
 void battleUpdate(void);
 
 /**
- * Rebuilds BATTLE.turnOrder/turnCount from every currently living
+ * Rebuilds BATTLE.executionOrder/executionCount 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);
+void battleBuildExecutionOrder(const bool_t applyEncounterBias);
 
 /**
- * Stably partitions BATTLE.turnOrder so every fighter on the given team
+ * Stably partitions BATTLE.executionOrder 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.
+ * @param team The team to move to the front of the execution order.
  */
 void battleMoveTeamFirst(const battlefighterteam_t team);
 
@@ -192,3 +248,66 @@ void battleMoveTeamFirst(const battlefighterteam_t team);
  *         living fighters.
  */
 battlefighter_t *battleAIChooseTarget(const battlefighter_t *fighter);
+
+/**
+ * Sets BATTLE.state and fires BATTLE.onStateChanged with the previous and
+ * new state.
+ *
+ * @param next The state to transition to.
+ */
+void battleSetState(const battlestate_t next);
+
+/**
+ * Sets BATTLE.result and transitions to BATTLE_STATE_ENDED.
+ *
+ * @param result The result to end the battle with.
+ */
+void battleSetResult(const battleresult_t result);
+
+/**
+ * Checks whether a fighter is a live, undecided candidate for the given
+ * controller -- i.e. whether PLAYER_SELECTION or AI_SELECTION should still
+ * be deciding an action for it this round.
+ *
+ * @param fighterIndex Index into BATTLE.fighters to check.
+ * @param controller The controller PLAYER_SELECTION/AI_SELECTION is
+ *        currently deciding for.
+ * @return True if the fighter is alive, matches controller, and has no
+ *         action queued yet.
+ */
+bool_t battleFighterNeedsDecision(
+  const uint8_t fighterIndex,
+  const battlefightercontroller_t controller
+);
+
+/**
+ * Advances BATTLE.selectionIndex to the next player-controlled fighter that
+ * still needs a decision, or transitions to BATTLE_STATE_AI_SELECTION once
+ * none remain.
+ */
+void battleAdvanceSelection(void);
+
+/**
+ * Handles BATTLE_STATE_PRE_ROUND: rebuilds the execution order and moves on
+ * to BATTLE_STATE_PLAYER_SELECTION, positioning the selection cursor.
+ */
+void battleUpdatePreRound(void);
+
+/**
+ * Handles BATTLE_STATE_AI_SELECTION: queues an attack for every undecided
+ * AI-controlled fighter, then moves on to BATTLE_STATE_MOVES_EXECUTING.
+ */
+void battleUpdateAiSelection(void);
+
+/**
+ * Handles BATTLE_STATE_MOVES_EXECUTING: resolves one queued action from
+ * BATTLE.executionOrder per call, or transitions to BATTLE_STATE_POST_ROUND
+ * once every fighter this round has been processed.
+ */
+void battleUpdateMovesExecuting(void);
+
+/**
+ * Handles BATTLE_STATE_POST_ROUND: advances BATTLE.round and transitions
+ * back to BATTLE_STATE_PRE_ROUND.
+ */
+void battleUpdatePostRound(void);

src/dusk/rpg/cutscene/cutscene.h

@@ -162,6 +162,28 @@ typedef struct cutscene_s {
     .shake = { .amount = AMOUNT, .duration = DURATION } \
   }
 
+// Waits until BATTLE.state reaches STATE. Put this BEFORE
+// CUTSCENE_SET_PAUSE(CUTSCENE_PAUSE_BATTLE), not after -- pausing first
+// freezes BATTLE.state wherever it already is, so it would never reach
+// STATE on its own to satisfy the wait. Waiting unpaused, then pausing the
+// moment it's satisfied, catches the battle right at STATE before it can
+// advance further.
+#define CUTSCENE_BATTLE_WAIT_STATE(STATE) \
+  { \
+    .type = CUTSCENE_ITEM_TYPE_BATTLE_WAIT_STATE, \
+    .battleWaitState = { .state = STATE } \
+  }
+
+// Immediately queues an attack for FIGHTER_INDEX against TARGET_INDEX,
+// bypassing normal player/AI selection for that fighter this round.
+#define CUTSCENE_BATTLE_FORCE_ACTION(FIGHTER_INDEX, TARGET_INDEX) \
+  { \
+    .type = CUTSCENE_ITEM_TYPE_BATTLE_FORCE_ACTION, \
+    .battleForceAction = { \
+      .fighterIndex = FIGHTER_INDEX, .targetIndex = TARGET_INDEX \
+    } \
+  }
+
 #define CUTSCENE_SET_PAUSE(FLAGS) \
   { .type = CUTSCENE_ITEM_TYPE_SET_PAUSE, .setPause = (FLAGS) }
 

src/dusk/rpg/cutscene/cutscenepause.h

@@ -14,11 +14,13 @@ typedef uint8_t cutscenepause_t;
 #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_BATTLE  ((cutscenepause_t)(1 << 3))
 
 #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 \
+  CUTSCENE_PAUSE_NPC | CUTSCENE_PAUSE_PLAYER | CUTSCENE_PAUSE_WORLD | \
+  CUTSCENE_PAUSE_BATTLE \
 ))

src/dusk/rpg/cutscene/item/battle/CMakeLists.txt

@@ -6,4 +6,6 @@
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     cutscenestartbattle.c
+    cutscenebattlewaitstate.c
+    cutscenebattleforceaction.c
 )

src/dusk/rpg/cutscene/item/battle/cutscenebattleforceaction.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"
+
+void cutsceneBattleForceActionStart(
+  const cutsceneitem_t *item,
+  cutsceneitemdata_t *data
+) {
+  battleQueueAction(
+    item->battleForceAction.fighterIndex, BATTLE_ACTION_ATTACK,
+    item->battleForceAction.targetIndex
+  );
+}
+
+bool_t cutsceneBattleForceActionUpdate(
+  const cutsceneitem_t *item,
+  cutsceneitemdata_t *data
+) {
+  return true;
+}

src/dusk/rpg/cutscene/item/battle/cutscenebattleforceaction.h

@@ -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/battle/battle.h"
+
+typedef struct {
+  uint8_t fighterIndex;
+  uint8_t targetIndex;
+} cutscenebattleforceaction_t;
+
+typedef struct cutsceneitem_s cutsceneitem_t;
+typedef union cutsceneitemdata_u cutsceneitemdata_t;
+
+/**
+ * Starts a battle force-action step: immediately queues an attack for the
+ * given fighter against the given target, bypassing normal player/AI
+ * selection for that fighter this round.
+ *
+ * @param item The cutscene item.
+ * @param data Runtime data storage.
+ */
+void cutsceneBattleForceActionStart(
+  const cutsceneitem_t *item,
+  cutsceneitemdata_t *data
+);
+
+/**
+ * Updates a battle force-action step (always completes immediately).
+ *
+ * @param item The cutscene item.
+ * @param data Runtime data storage.
+ * @returns true always.
+ */
+bool_t cutsceneBattleForceActionUpdate(
+  const cutsceneitem_t *item,
+  cutsceneitemdata_t *data
+);

src/dusk/rpg/cutscene/item/battle/cutscenebattlewaitstate.c

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "rpg/cutscene/item/cutsceneitem.h"
+
+bool_t cutsceneBattleWaitStateUpdate(
+  const cutsceneitem_t *item,
+  cutsceneitemdata_t *data
+) {
+  return BATTLE.state == item->battleWaitState.state;
+}

src/dusk/rpg/cutscene/item/battle/cutscenebattlewaitstate.h

@@ -0,0 +1,30 @@
+/**
+ * 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"
+
+typedef struct {
+  battlestate_t state;
+} cutscenebattlewaitstate_t;
+
+typedef struct cutsceneitem_s cutsceneitem_t;
+typedef union cutsceneitemdata_u cutsceneitemdata_t;
+
+/**
+ * Updates a battle wait-state step, completing once BATTLE.state reaches
+ * the watched state. Has no Start callback -- there's nothing to do until
+ * the state is actually reached.
+ *
+ * @param item The cutscene item.
+ * @param data Runtime data storage.
+ * @returns true once BATTLE.state equals the watched state.
+ */
+bool_t cutsceneBattleWaitStateUpdate(
+  const cutsceneitem_t *item,
+  cutsceneitemdata_t *data
+);

src/dusk/rpg/cutscene/item/cutsceneitem.c

@@ -118,6 +118,15 @@ cutsceneitemcallbacks_t CUTSCENE_ITEM_CALLBACKS[CUTSCENE_ITEM_TYPE_COUNT] = {
   [CUTSCENE_ITEM_TYPE_SHAKE] = {
     .init = cutsceneShakeStart,
     .update = cutsceneShakeUpdate
+  },
+
+  [CUTSCENE_ITEM_TYPE_BATTLE_WAIT_STATE] = {
+    .update = cutsceneBattleWaitStateUpdate
+  },
+
+  [CUTSCENE_ITEM_TYPE_BATTLE_FORCE_ACTION] = {
+    .init = cutsceneBattleForceActionStart,
+    .update = cutsceneBattleForceActionUpdate
   }
 };
 

src/dusk/rpg/cutscene/item/cutsceneitem.h

@@ -27,6 +27,8 @@
 #include "maparea/cutscenemaparearemove.h"
 #include "maparea/cutscenemapareawait.h"
 #include "battle/cutscenestartbattle.h"
+#include "battle/cutscenebattlewaitstate.h"
+#include "battle/cutscenebattleforceaction.h"
 
 typedef struct cutscene_s cutscene_t;
 
@@ -55,6 +57,8 @@ typedef enum {
   CUTSCENE_ITEM_TYPE_START_BATTLE,
   CUTSCENE_ITEM_TYPE_EMOJI,
   CUTSCENE_ITEM_TYPE_SHAKE,
+  CUTSCENE_ITEM_TYPE_BATTLE_WAIT_STATE,
+  CUTSCENE_ITEM_TYPE_BATTLE_FORCE_ACTION,
 
   CUTSCENE_ITEM_TYPE_COUNT
 } cutsceneitemtype_t;
@@ -85,6 +89,8 @@ struct cutsceneitem_s {
     cutscenestartbattle_t startBattle;
     cutsceneemoji_t emoji;
     cutsceneshake_t shake;
+    cutscenebattlewaitstate_t battleWaitState;
+    cutscenebattleforceaction_t battleForceAction;
   };
 };
 

src/dusk/rpg/entity/entity.c

@@ -10,6 +10,7 @@
 #include "util/memory.h"
 #include "time/time.h"
 #include "util/math.h"
+#include "console/console.h"
 #include "rpg/overworld/map.h"
 #include "rpg/overworld/maparea.h"
 #include "rpg/overworld/chunk.h"
@@ -292,7 +293,10 @@ void entitySetChunk(entity_t *entity, const uint8_t chunkIndex) {
     }
   }
 
-  entity->chunkIndex = chunkIndex;
+  // Only claim the new chunk once actually inserted into one of its slots -
+  // otherwise entity->chunkIndex would point at a chunk that doesn't know
+  // about this entity, so it would never be torn down on unload.
+  entity->chunkIndex = 0xFF;
 
   if(chunkIndex != 0xFF) {
     chunk_t *next = mapGetChunk(chunkIndex);
@@ -300,8 +304,16 @@ void entitySetChunk(entity_t *entity, const uint8_t chunkIndex) {
       for(uint8_t i = 0; i < CHUNK_ENTITY_COUNT_MAX; i++) {
         if(next->entities[i] != 0xFF) continue;
         next->entities[i] = entity->id;
+        entity->chunkIndex = chunkIndex;
         break;
       }
+      if(entity->chunkIndex != chunkIndex) {
+        consolePrint(
+          "entitySetChunk: chunk %u has no free entity slots, entity %u "
+          "left untracked",
+          chunkIndex, entity->id
+        );
+      }
     }
   }
 }

src/dusk/rpg/entity/entity.h

@@ -142,7 +142,10 @@ uint8_t entityGetAvailable();
 
 /**
  * Assigns an entity to a chunk, removing it from its current chunk first.
- * Pass 0xFF as chunkIndex to detach the entity from any chunk.
+ * Pass 0xFF as chunkIndex to detach the entity from any chunk. If the
+ * target chunk has no free entity slots, the entity is left detached
+ * (chunkIndex 0xFF) rather than assigned to a chunk that isn't actually
+ * tracking it - entityUpdateChunk will keep retrying on subsequent moves.
  *
  * @param entity Pointer to the entity.
  * @param chunkIndex Index of the chunk to assign to, or 0xFF for none.

src/dusk/rpg/entity/global/CMakeLists.txt

@@ -6,4 +6,5 @@
 # Sources
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
+    globalitemstore.c
 )

src/dusk/rpg/entity/global/globalitemstore.c

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "globalitemstore.h"
+#include "assert/assert.h"
+
+bool_t globalItemStoreIsCollected(
+  const saveslot_t *file, const entityglobalid_t id
+) {
+  assertNotNull(file, "Save slot cannot be NULL");
+  assertTrue(id < SAVE_GLOBAL_ITEM_COUNT_MAX, "Global item ID out of range");
+  return file->globalItemCollected[id];
+}
+
+void globalItemStoreSetCollected(
+  saveslot_t *file, const entityglobalid_t id, const bool_t collected
+) {
+  assertNotNull(file, "Save slot cannot be NULL");
+  assertTrue(id < SAVE_GLOBAL_ITEM_COUNT_MAX, "Global item ID out of range");
+  file->globalItemCollected[id] = collected;
+}

src/dusk/rpg/entity/global/globalitemstore.h

@@ -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 "error/error.h"
+#include "save/saveslot.h"
+#include "rpg/entity/entity.h"
+
+/**
+ * Checks whether the global entity with the given ID has already been
+ * marked collected in the given save slot's data - e.g. so a global item
+ * entity's init callback (see rpg/entity/global/entitygloballist.h) can
+ * skip spawning itself if the player already picked it up in a prior
+ * session, without needing to keep the entity itself alive to remember
+ * that (which would need render/collision special-casing - this doesn't).
+ *
+ * @param file The save slot to check.
+ * @param id The global entity ID to check.
+ * @return True if already marked collected.
+ */
+bool_t globalItemStoreIsCollected(
+  const saveslot_t *file, const entityglobalid_t id
+);
+
+/**
+ * Marks the global entity with the given ID as collected (or not) in the
+ * given save slot's data. Does not itself write the save to disk - call
+ * saveWriteSlot() separately once ready to persist it.
+ *
+ * @param file The save slot to write into.
+ * @param id The global entity ID to mark.
+ * @param collected The new collected state.
+ */
+void globalItemStoreSetCollected(
+  saveslot_t *file, const entityglobalid_t id, const bool_t collected
+);

src/dusk/rpg/overworld/CMakeLists.txt

@@ -14,3 +14,5 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
     tileshape.c
 )
 
+add_subdirectory(global)
+

src/dusk/rpg/overworld/chunk.h

@@ -12,6 +12,8 @@
 #define CHUNK_MESH_COUNT_MAX 10
 #define CHUNK_MESH_NAME_MAX 64
 #define CHUNK_ENTITY_COUNT_MAX 10
+#define CHUNK_ENTITY_SPAWN_COUNT_MAX 8
+#define CHUNK_AREA_COUNT_MAX 4
 
 typedef struct assetentry_s assetentry_t;
 
@@ -28,6 +30,13 @@ typedef struct chunk_s {
   assetentry_t *modelEntries[CHUNK_MESH_COUNT_MAX];
 
   uint8_t entities[CHUNK_ENTITY_COUNT_MAX];
+
+  // Map area IDs (into MAP_AREAS) spawned from this chunk's file data.
+  // Removed via mapAreaRemove when this chunk unloads, and re-added if it
+  // streams back in - unlike entities (tracked by current position via
+  // entities[] above), areas have no position-based ownership mechanism of
+  // their own, so the owning chunk must track and tear them down directly.
+  uint8_t areas[CHUNK_AREA_COUNT_MAX];
 } chunk_t;
 
 /**

src/dusk/rpg/overworld/global/CMakeLists.txt

@@ -0,0 +1,9 @@
+# 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
+)

src/dusk/rpg/overworld/global/mapareaglobal.h

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "mapareaglobaldefs.h"
+#include "mapareagloballist.h"
+
+#define MAP_AREA_CALLBACK_LIST_COUNT ( \
+  sizeof(MAP_AREA_CALLBACK_LIST) / \
+  sizeof(MAP_AREA_CALLBACK_LIST[0]) \
+)
+
+//EOF

src/dusk/rpg/overworld/global/mapareaglobaldefs.h

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "rpg/overworld/maparea.h"
+
+#define MAP_AREA_CALLBACK(id) \
+  static void MAP_AREA_CALLBACK_##id(entity_t *entity, const uint8_t trigger)
+
+#define MAP_AREA_CALLBACK_REF(id) \
+  MAP_AREA_CALLBACK_##id
+
+//EOF

src/dusk/rpg/overworld/global/mapareagloballist.h

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "mapareaglobaldefs.h"
+#include "console/console.h"
+
+MAP_AREA_CALLBACK(1) {
+  consolePrint("mapAreaGlobalCallback 1: trigger=%u", trigger);
+}
+
+// Index 0 is reserved (not a valid callback ID) - see mapAreaAddGlobal.
+static const mapareacallback_t MAP_AREA_CALLBACK_LIST[] = {
+  NULL,
+  MAP_AREA_CALLBACK_REF(1),
+};
+
+//EOF

src/dusk/rpg/overworld/map.c

@@ -14,9 +14,20 @@
 #include "event/event.h"
 #include "util/string.h"
 #include "rpg/entity/global/entityglobal.h"
+#include "rpg/entity/item/entityitem.h"
+#include "rpg/overworld/maparea.h"
 
 map_t MAP;
 
+// Clears chunk's mid-load slot, if it currently holds one.
+static void mapChunkLoadingSlotClear(chunk_t *chunk) {
+  for(uint32_t i = 0; i < MAP_CHUNK_LOAD_CONCURRENCY; i++) {
+    if(MAP.loadingChunks[i] != chunk) continue;
+    MAP.loadingChunks[i] = NULL;
+    return;
+  }
+}
+
 errorret_t mapInit() {
   memoryZero(&MAP, sizeof(map_t));
   MAP.loaded = true;
@@ -105,7 +116,7 @@ errorret_t mapDispose() {
 
 void mapChunkUnload(chunk_t *chunk) {
   mapChunkLoadQueueRemove(chunk);
-  if(MAP.loadingChunk == chunk) MAP.loadingChunk = NULL;
+  mapChunkLoadingSlotClear(chunk);
 
   for(uint8_t i = 0; i < CHUNK_ENTITY_COUNT_MAX; i++) {
     if(chunk->entities[i] == 0xFF) continue;
@@ -119,6 +130,12 @@ void mapChunkUnload(chunk_t *chunk) {
 
   memorySet(chunk->entities, 0xFF, sizeof(chunk->entities));
 
+  for(uint8_t i = 0; i < CHUNK_AREA_COUNT_MAX; i++) {
+    if(chunk->areas[i] == 0xFF) continue;
+    mapAreaRemove(chunk->areas[i]);
+  }
+  memorySet(chunk->areas, 0xFF, sizeof(chunk->areas));
+
   if(chunk->dcfEntry != NULL) {
     eventUnsubscribe(&chunk->dcfEntry->onLoaded, mapChunkLoaded);
     eventUnsubscribe(&chunk->dcfEntry->onError, mapChunkLoadError);
@@ -139,7 +156,7 @@ errorret_t mapChunkLoad(chunk_t *chunk) {
   if(!mapIsLoaded()) errorThrow("No map loaded");
 
   mapChunkLoadQueueRemove(chunk);
-  if(MAP.loadingChunk == chunk) MAP.loadingChunk = NULL;
+  mapChunkLoadingSlotClear(chunk);
 
   if(chunk->dcfEntry != NULL) {
     eventUnsubscribe(&chunk->dcfEntry->onLoaded, mapChunkLoaded);
@@ -149,6 +166,16 @@ errorret_t mapChunkLoad(chunk_t *chunk) {
   }
 
   memorySet(chunk->entities, 0xFF, sizeof(chunk->entities));
+
+  // Normally already empty (mapChunkUnload clears these before a chunk is
+  // handed back for reuse), but cleared defensively here too so a reload
+  // never leaks a MAP_AREAS slot referenced by a stale owned area ID.
+  for(uint8_t i = 0; i < CHUNK_AREA_COUNT_MAX; i++) {
+    if(chunk->areas[i] == 0xFF) continue;
+    mapAreaRemove(chunk->areas[i]);
+  }
+  memorySet(chunk->areas, 0xFF, sizeof(chunk->areas));
+
   chunk->meshCount = 0;
 
   char_t name[64];
@@ -178,7 +205,8 @@ errorret_t mapChunkLoad(chunk_t *chunk) {
 }
 
 void mapChunkLoadNext() {
-  if(MAP.loadingChunk != NULL) return;
+  for(uint32_t slot = 0; slot < MAP_CHUNK_LOAD_CONCURRENCY; slot++) {
+    if(MAP.loadingChunks[slot] != NULL) continue;
     if(MAP.loadQueueCount == 0) return;
 
     chunk_t *chunk = MAP.loadQueue[0];
@@ -186,7 +214,7 @@ void mapChunkLoadNext() {
       MAP.loadQueue[i - 1] = MAP.loadQueue[i];
     }
     MAP.loadQueueCount--;
-  MAP.loadingChunk = chunk;
+    MAP.loadingChunks[slot] = chunk;
 
     char_t name[64];
     stringFormat(
@@ -201,21 +229,24 @@ void mapChunkLoadNext() {
     assertNotNull(entry, "Failed to get chunk asset entry");
     chunk->dcfEntry = entry;
 
-  // The entry may already be resident from an earlier load that hasn't been
-  // reaped yet - in that case onLoaded/onError already fired once and never
-  // will again, so handle the terminal state directly instead of waiting on
-  // a subscription that would never trigger.
+    // The entry may already be resident from an earlier load that hasn't
+    // been reaped yet - in that case onLoaded/onError already fired once
+    // and never will again, so handle the terminal state directly instead
+    // of waiting on a subscription that would never trigger. Both of these
+    // recurse back into mapChunkLoadNext once they clear this slot, so the
+    // outer loop just continues on to try filling the next one.
     if(entry->state == ASSET_ENTRY_STATE_LOADED) {
       mapChunkLoaded(entry, chunk);
-    return;
+      continue;
     }
     if(entry->state == ASSET_ENTRY_STATE_ERROR) {
       mapChunkLoadError(entry, chunk);
-    return;
+      continue;
     }
 
     eventSubscribe(&entry->onLoaded, mapChunkLoaded, chunk);
     eventSubscribe(&entry->onError, mapChunkLoadError, chunk);
+  }
 }
 
 void mapChunkLoadQueueRemove(chunk_t *chunk) {
@@ -372,7 +403,7 @@ void mapChunkLoadError(void *params, void *user) {
   chunk->dcfEntry = NULL;
   memorySet(chunk->tiles, 0x00, sizeof(chunk->tiles));
 
-  if(MAP.loadingChunk == chunk) MAP.loadingChunk = NULL;
+  mapChunkLoadingSlotClear(chunk);
   mapChunkLoadNext();
 }
 
@@ -433,6 +464,47 @@ void mapChunkLoaded(void *params, void *user) {
   // this chunk_t is displaying it. Released in mapChunkUnload instead.
   chunk->meshCount = meshCount;
 
-  if(MAP.loadingChunk == chunk) MAP.loadingChunk = NULL;
+  // Spawn entities declared by this chunk's file. Global entities are
+  // deduped by mapSpawnEntity itself (a persistent NPC that streams back
+  // in won't be duplicated); item entities have no persistent identity, so
+  // each reload spawns a fresh one - picking an item up and then leaving
+  // and re-entering its chunk will currently respawn it, since nothing
+  // tracks "already collected" across a chunk unload/reload yet.
+  for(uint8_t s = 0; s < entry->data.chunk.entitySpawnCount; s++) {
+    chunkentityspawn_t *spawn = &entry->data.chunk.entitySpawns[s];
+    if(spawn->kind == CHUNK_ENTITY_SPAWN_KIND_GLOBAL) {
+      mapSpawnEntity((entityglobalid_t)spawn->globalId, spawn->position);
+      continue;
+    }
+
+    uint8_t index = entityGetAvailable();
+    assertTrue(index != 0xFF, "No available entity slots for chunk spawn");
+    entity_t *itemEntity = &ENTITIES[index];
+    entityInit(itemEntity, ENTITY_TYPE_ITEM);
+    entityItemSet(
+      itemEntity, (itemid_t)spawn->itemId, spawn->itemQuantity
+    );
+    entityPositionSet(itemEntity, spawn->position);
+  }
+
+  // Spawn map areas declared by this chunk's file, tracked as owned by
+  // this chunk so mapChunkUnload can tear them down again.
+  for(uint8_t s = 0; s < entry->data.chunk.areaSpawnCount; s++) {
+    chunkareaspawn_t *area = &entry->data.chunk.areaSpawns[s];
+    uint8_t areaId = mapAreaAddGlobal(
+      area->min, area->max, area->callbackId, area->notify, area->trigger
+    );
+
+    uint8_t slot = 0xFF;
+    for(uint8_t i = 0; i < CHUNK_AREA_COUNT_MAX; i++) {
+      if(chunk->areas[i] != 0xFF) continue;
+      slot = i;
+      break;
+    }
+    assertTrue(slot != 0xFF, "Chunk has no free owned-area slots");
+    chunk->areas[slot] = areaId;
+  }
+
+  mapChunkLoadingSlotClear(chunk);
   mapChunkLoadNext();
 }

src/dusk/rpg/overworld/map.h

@@ -12,6 +12,10 @@
 
 #define MAP_FILE_PATH_MAX 128
 
+// Number of chunks that may be mid-load (asset locked & awaiting onLoaded/
+// onError) at the same time - everything past this waits in loadQueue.
+#define MAP_CHUNK_LOAD_CONCURRENCY 2
+
 typedef struct map_s {
   bool_t loaded;
 
@@ -19,11 +23,9 @@ typedef struct map_s {
   chunk_t *chunkOrder[MAP_CHUNK_COUNT];
   chunkpos_t chunkPosition;
 
-  // Only one chunk may be mid-load (asset locked & awaiting onLoaded/
-  // onError) at any given time - everything else waits here in FIFO order.
   chunk_t *loadQueue[MAP_CHUNK_COUNT];
   uint32_t loadQueueCount;
-  chunk_t *loadingChunk;
+  chunk_t *loadingChunks[MAP_CHUNK_LOAD_CONCURRENCY];
 } map_t;
 
 extern map_t MAP;
@@ -80,9 +82,9 @@ void mapChunkUnload(chunk_t* chunk);
 errorret_t mapChunkLoad(chunk_t* chunk);
 
 /**
- * Starts loading the next queued chunk, if no chunk is currently mid-load.
- * Called after mapChunkLoad enqueues a chunk, and again after the
- * currently-loading chunk finishes (or is unloaded) to advance the queue.
+ * Starts loading queued chunks until MAP_CHUNK_LOAD_CONCURRENCY chunks are
+ * mid-load. Called after mapChunkLoad enqueues a chunk, and again after a
+ * mid-load chunk finishes (or is unloaded) to advance the queue.
  */
 void mapChunkLoadNext();
 

src/dusk/rpg/overworld/maparea.c

@@ -10,6 +10,7 @@
 #include "util/math.h"
 #include "util/memory.h"
 #include "rpg/overworld/map.h"
+#include "rpg/overworld/global/mapareaglobal.h"
 
 maparea_t MAP_AREAS[MAP_AREA_COUNT_MAX];
 
@@ -148,3 +149,20 @@ void mapAreaCheckEntity(entity_t *entity) {
 
 void mapAreaNoopCallback(entity_t *entity, const uint8_t trigger) {
 }
+
+uint8_t mapAreaAddGlobal(
+  const worldpos_t min,
+  const worldpos_t max,
+  const uint16_t callbackId,
+  const uint8_t notify,
+  const uint8_t trigger
+) {
+  assertTrue(callbackId > 0, "Map area callback ID 0 is reserved");
+  assertTrue(
+    callbackId < MAP_AREA_CALLBACK_LIST_COUNT,
+    "Map area callback ID is out of range"
+  );
+  return mapAreaAdd(
+    min, max, MAP_AREA_CALLBACK_LIST[callbackId], notify, trigger
+  );
+}

src/dusk/rpg/overworld/maparea.h

@@ -159,3 +159,28 @@ void mapAreaCheckEntity(entity_t *entity);
  * @param trigger Which MAP_TRIGGER_* condition invoked the callback.
  */
 void mapAreaNoopCallback(entity_t *entity, const uint8_t trigger);
+
+/**
+ * Adds a map area using a compiled-in callback referenced by ID (see
+ * MAP_AREA_CALLBACK_LIST in rpg/overworld/global/mapareagloballist.h),
+ * rather than a direct function pointer. This is what lets chunk file
+ * data - which can only reference compiled code by a small integer ID,
+ * not a function pointer - declare map areas.
+ *
+ * @param min The minimum world position of the area.
+ * @param max The maximum world position of the area.
+ * @param callbackId Index into MAP_AREA_CALLBACK_LIST. Must be greater
+ *   than 0 (0 is reserved) and within range.
+ * @param notify Bitwise MAP_AREA_NOTIFY_* flags for which entity types
+ *   should trigger the callback.
+ * @param trigger Bitwise MAP_TRIGGER_* flags for which conditions should
+ *   invoke the callback.
+ * @returns The ID of the newly added map area.
+ */
+uint8_t mapAreaAddGlobal(
+  const worldpos_t min,
+  const worldpos_t max,
+  const uint16_t callbackId,
+  const uint8_t notify,
+  const uint8_t trigger
+);

src/dusk/rpg/rpg.c

@@ -7,32 +7,41 @@
 
 #include "rpg.h"
 #include "entity/entity.h"
-#include "rpg/entity/npc/npcpath.h"
-#include "rpg/entity/item/entityitem.h"
 #include "rpg/overworld/map.h"
 #include "rpg/overworld/maparea.h"
 #include "rpg/cutscene/cutscenesystem.h"
-#include "rpg/cutscene/scene/testcutscene.h"
 #include "rpg/item/backpack.h"
 #include "rpg/battle/party.h"
 #include "ui/rpg/textbox/uitextboxminilist.h"
 #include "time/time.h"
 #include "rpgcamera.h"
 #include "util/memory.h"
-#include "util/string.h"
 #include "assert/assert.h"
-#include "console/console.h"
+#include "save/save.h"
+#include "save/autosave.h"
+#include "error/error.h"
+#include "scene/scene.h"
 
 #include "ui/rpg/uiemoji.h"
-
-void rpgTestAreaCallback(entity_t *entity, const uint8_t trigger) {
-  consolePrint("rpgTestAreaCallback: trigger=%u", trigger);
-}
+#include "rpg/story/storyflag.h"
 
 errorret_t rpgInit(void) {
   memoryZero(ENTITIES, sizeof(ENTITIES));
   memoryZero(MAP_AREAS, sizeof(MAP_AREAS));
 
+  saveslot_t *saveSlot = saveGetSlot(SAVE_ACTIVE_SLOT);
+  // saveInit() eagerly loads every slot from disk, but there's no
+  // continue-game flow yet - every boot is a fresh game regardless of
+  // what was found on disk, so force this false rather than let a stale
+  // "exists" from a real save skip storyFlagInitDefaults() below while
+  // everything else here still hardcodes new-game state.
+  saveSlot->exists = false;
+
+  // Must run before any code reads a story flag - stamps CSV-defined
+  // defaults onto the active save slot since it's now forced to look
+  // unloaded.
+  storyFlagInitDefaults(saveSlot);
+
   backpackInit();
   partyInit();
   cutsceneSystemInit();
@@ -43,7 +52,9 @@ errorret_t rpgInit(void) {
   // Init world
   errorChain(mapPositionSet((chunkpos_t){ 0, 0, 0 }));
 
-  // TEST: Create some entities.
+  // The player is the one entity that isn't sourced from map/chunk data -
+  // every other entity (NPCs, items) and map area comes from the loaded
+  // chunks' own spawn data (see rpg/overworld/map.c mapChunkLoaded).
   uint8_t entIndex = entityGetAvailable();
   assertTrue(entIndex != 0xFF, "No available entity slots!.");
   entity_t *ent = &ENTITIES[entIndex];
@@ -52,31 +63,11 @@ errorret_t rpgInit(void) {
   RPG_CAMERA.mode = RPG_CAMERA_MODE_FOLLOW_ENTITY;
   RPG_CAMERA.followEntity.followEntityId = ent->id;
 
-  mapSpawnEntity(3, (worldpos_t){ 8, 8, 1 });
-
-  // TEST: Place an item entity.
-  uint8_t itemEntIndex = entityGetAvailable();
-  assertTrue(itemEntIndex != 0xFF, "No available entity slots!.");
-  entity_t *itemEnt = &ENTITIES[itemEntIndex];
-  entityInit(itemEnt, ENTITY_TYPE_ITEM);
-  entityItemSet(itemEnt, ITEM_ID_POTION, 1);
-  entityPositionSet(itemEnt, (worldpos_t){ 12, 2, 0 });
-
-  // TEST: Give the player a starting assortment of items.
+  // Starting inventory.
   backpackAdd(ITEM_ID_POTION, 5);
   backpackAdd(ITEM_ID_POTATO, 3);
   backpackAdd(ITEM_ID_APPLE, 8);
 
-  // TEST: Create a test map area.
-  uint8_t areaIndex = mapAreaAdd(
-    (worldpos_t){ 11, 3, 0 },
-    (worldpos_t){ 16, 9, 10 },
-    rpgTestAreaCallback,
-    MAP_AREA_NOTIFY_ALL,
-    MAP_TRIGGER_ENTER | MAP_TRIGGER_EXIT
-  );
-  assertTrue(areaIndex != 0xFF, "No available map area slots!.");
-
   // All Good!
   errorOk();
 }
@@ -88,15 +79,26 @@ errorret_t rpgUpdate(void) {
     }
   #endif
 
+  // A failed autosave forces a no-save-device prompt (see autosave.h) -
+  // freeze the world entirely until the player resolves it, rather than
+  // letting NPCs/cutscenes/camera keep running behind a modal that's
+  // supposed to be blocking.
+  if(autoSaveIsBlocking()) errorOk();
+
   // TODO: Do not update if the scene is not the map scene?
   errorChain(mapUpdate());
 
-  // Update overworld ents.
+  // Update overworld ents - only while actually in the overworld. Entities
+  // (the player among them) keep existing across scene changes, but their
+  // input/movement/animation logic doesn't make sense to run mid-battle or
+  // before the initial scene has handed off to the overworld.
+  if(SCENE.current == SCENE_TYPE_OVERWORLD) {
     entity_t *ent = &ENTITIES[0];
     do {
       if(ent->type == ENTITY_TYPE_NULL) continue;
       entityUpdate(ent);
     } while(++ent < &ENTITIES[ENTITY_COUNT]);
+  }
 
   cutsceneSystemUpdate();
   errorChain(rpgCameraUpdate());

src/dusk/rpg/story/storyflag.c

@@ -10,5 +10,17 @@
 
 void storyFlagSet(const storyflag_t flag, const storyflagvalue_t value) {
   assertTrue(flag > STORY_FLAG_NULL && flag < STORY_FLAG_COUNT, "Bad Flag");
-  STORY_FLAG_VALUES[flag] = value;
+  saveGetSlot(SAVE_ACTIVE_SLOT)->storyFlags[flag] = value;
+}
+
+void storyFlagInitDefaults(saveslot_t *file) {
+  assertNotNull(file, "Save slot cannot be NULL");
+  if(file->exists) return;
+  assertTrue(
+    STORY_FLAG_COUNT <= SAVE_STORY_FLAG_COUNT_MAX,
+    "Too many story flags for the save format - bump SAVE_STORY_FLAG_COUNT_MAX"
+  );
+  for(storyflag_t i = 0; i < STORY_FLAG_COUNT; i++) {
+    file->storyFlags[i] = STORY_FLAG_DEFAULTS[i];
+  }
 }

src/dusk/rpg/story/storyflag.h

@@ -7,19 +7,34 @@
 
 #pragma once
 #include "rpg/story/storyflagvalue.h"
+#include "save/save.h"
 
 /**
- * Gets the value of a story flag.
+ * Gets the value of a story flag. Reads directly from the active save
+ * slot (see SAVE_ACTIVE_SLOT) - flag values have no separate live copy.
  *
  * @param flag The story flag to get.
  * @return The value of the story flag.
  */
-#define storyFlagGet(flag) (STORY_FLAG_VALUES[(flag)])
+#define storyFlagGet(flag) (saveGetSlot(SAVE_ACTIVE_SLOT)->storyFlags[(flag)])
 
 /**
- * Sets the value of a story flag.
+ * Sets the value of a story flag, directly in the active save slot (see
+ * SAVE_ACTIVE_SLOT). Does not itself write the save to disk - call
+ * saveWriteSlot() separately once ready to persist it.
  *
  * @param flag The story flag to set.
  * @param value The value to set the story flag to.
  */
 void storyFlagSet(const storyflag_t flag, const storyflagvalue_t value);
+
+/**
+ * Stamps each story flag's CSV-defined default (STORY_FLAG_DEFAULTS) onto
+ * the given save slot, but only if it hasn't actually been loaded from
+ * disk yet (file->exists is false) - otherwise leaves already-played
+ * progress alone. Call once, e.g. during rpgInit(), before any gameplay
+ * code reads a story flag.
+ *
+ * @param file The save slot to stamp defaults onto.
+ */
+void storyFlagInitDefaults(saveslot_t *file);

src/dusk/save/CMakeLists.txt

@@ -8,4 +8,5 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     save.c
     savestream.c
+    autosave.c
 )

src/dusk/save/autosave.c

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "autosave.h"
+#include "save.h"
+#include "error/error.h"
+#include "ui/frame/initial/uiinitialnocard.h"
+
+autosave_t AUTO_SAVE;
+
+static void autoSaveNoCardResult(const bool_t retry, void *user) {
+  AUTO_SAVE.blocking = false;
+
+  // "Retry" just re-queues the write for the next tick - there's no way
+  // to force a re-probe of the hardware mid-session (see saveInit()'s doc
+  // comment), so this only actually helps for a transient failure.
+  if(retry) {
+    AUTO_SAVE.pending = true;
+    return;
+  }
+
+  // The player explicitly acknowledged there's no save device and chose
+  // to proceed anyway - sticks for the rest of the session, so future
+  // autoSaveUpdate() calls silently skip instead of prompting again.
+  saveMarkTemporary();
+}
+
+static void autoSaveWriteComplete(errorret_t result, void *user) {
+  AUTO_SAVE.saving = false;
+  if(errorIsOk(result)) return;
+
+  errorCatch(errorPrint(result));
+
+  // The write failed - most likely no save medium is present right now
+  // (a GameCube with no memory card inserted, for example). Pause world
+  // simulation and force the same prompt the initial boot scene uses so
+  // the player can insert a card and retry, or explicitly accept a
+  // temporary, unsaved session.
+  AUTO_SAVE.blocking = true;
+  uiInitialNoCardOpen(autoSaveNoCardResult, NULL);
+}
+
+void autoSaveQueue(void) {
+  AUTO_SAVE.pending = true;
+}
+
+void autoSaveUpdate(void) {
+  if(AUTO_SAVE.blocking) return;
+  if(!AUTO_SAVE.pending) return;
+  if(saveIsBusy()) return;
+
+  AUTO_SAVE.pending = false;
+
+  // Already opted out of saving for this session - nothing to do, and
+  // definitely don't reprompt every time an autosave is queued.
+  if(saveIsTemporary()) return;
+
+  AUTO_SAVE.saving = true;
+  saveWriteSlot(SAVE_ACTIVE_SLOT, autoSaveWriteComplete, NULL);
+}
+
+bool_t autoSaveIsSaving(void) {
+  return AUTO_SAVE.saving;
+}
+
+bool_t autoSaveIsBlocking(void) {
+  return AUTO_SAVE.blocking;
+}

src/dusk/save/autosave.h

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+
+typedef struct {
+  /** True from autoSaveQueue() until the queued write starts. */
+  bool_t pending;
+  /** True while the queued write is actually in flight. */
+  bool_t saving;
+  /**
+   * True while the forced no-save-device prompt is up after a queued
+   * write failed - see autoSaveUpdate(). World simulation must pause
+   * while this is true (see rpgUpdate()).
+   */
+  bool_t blocking;
+} autosave_t;
+
+extern autosave_t AUTO_SAVE;
+
+/**
+ * Queues an autosave to run on a future engine tick. Safe to call as
+ * often as needed (e.g. after every map transition or story event) -
+ * repeated calls before the queued save starts just collapse into one.
+ */
+void autoSaveQueue(void);
+
+/**
+ * Pumps the queued autosave: starts the write once nothing else is
+ * using the save system, and if that write fails (e.g. a GameCube with
+ * no memory card inserted), forces the same no-save-device prompt the
+ * initial boot scene uses and pauses world simulation until the player
+ * resolves it. Must be called every engine frame, after saveUpdate().
+ */
+void autoSaveUpdate(void);
+
+/**
+ * True while a queued autosave's write is actually in progress. Intended
+ * for UI to show a "Saving" indicator.
+ *
+ * @return true if an autosave write is currently in flight.
+ */
+bool_t autoSaveIsSaving(void);
+
+/**
+ * True while a failed autosave is forcing the no-save-device prompt and
+ * waiting on the player's decision. Intended for the world simulation to
+ * pause while this is true.
+ *
+ * @return true if an autosave is currently blocking on player input.
+ */
+bool_t autoSaveIsBlocking(void);

src/dusk/save/save.c

@@ -9,19 +9,70 @@
 #include "save/savestream.h"
 #include "util/memory.h"
 #include "assert/assert.h"
+#include "error/error.h"
 
 save_t SAVE;
 
+const saveslot_t SAVE_DEFAULT = {
+  .header = {
+    SAVE_SLOT_HEADER[0], SAVE_SLOT_HEADER[1], SAVE_SLOT_HEADER[2]
+  },
+  .version = SAVE_SLOT_VERSION,
+  .exists = true,
+  .playerName = "Player"
+  // globalItemCollected/storyFlags are left at their zero default.
+};
+
+static void _saveEagerLoadComplete(errorret_t result, void *user) {
+  if(errorIsNotOk(result)) errorCatch(errorPrint(result));
+}
+
 errorret_t saveInit(void) {
   memoryZero(&SAVE, sizeof(save_t));
+  SAVE.meta.deadzone = SAVE_META_DEADZONE_DEFAULT;
+  SAVE.meta.language = SAVE_META_LANGUAGE_DEFAULT;
 
   #ifdef saveInitPlatform
-    errorChain(saveInitPlatform());
+    // A missing/unreachable save medium is expected, recoverable state,
+    // not a reason to fail booting the whole game - log it and carry on
+    // with SAVE.available false instead of chaining the error upward.
+    errorret_t result = saveInitPlatform();
+    SAVE.available = errorIsOk(result);
+    if(!SAVE.available) errorCatch(errorPrint(result));
+  #else
+    SAVE.available = false;
+  #endif
+
+  // Eagerly pull meta + every slot into memory up front - cheap and
+  // harmless (nothing consumes loaded slot data automatically; there's no
+  // continue-game flow yet). PSP opts out entirely (see
+  // saveSkipEagerLoadPlatform) since its only read path is now the native
+  // savedata dialog, and running that on every boot would defeat the whole
+  // point of folding meta into it instead of a separate instant-write file.
+  #ifndef saveSkipEagerLoadPlatform
+    if(SAVE.available) {
+      saveLoadMeta(_saveEagerLoadComplete, NULL);
+      for(uint8_t i = 0; i < SAVE_SLOT_COUNT_MAX; i++) {
+        saveLoadSlot(i, _saveEagerLoadComplete, NULL);
+      }
+    }
   #endif
 
   errorOk();
 }
 
+bool_t saveIsAvailable(void) {
+  return SAVE.available && !SAVE.temporary;
+}
+
+void saveMarkTemporary(void) {
+  SAVE.temporary = true;
+}
+
+bool_t saveIsTemporary(void) {
+  return SAVE.temporary;
+}
+
 errorret_t saveDispose(void) {
   #ifdef saveDisposePlatform
     errorChain(saveDisposePlatform());
@@ -29,80 +80,109 @@ errorret_t saveDispose(void) {
   errorOk();
 }
 
-errorret_t saveLoad(const uint8_t slot) {
-  assertTrue(slot < SAVE_FILE_COUNT_MAX, "slot exceeds SAVE_FILE_COUNT_MAX");
-
-  savefile_t *file = &SAVE.files[slot];
-  file->exists = false;
-
-  savestream_t stream;
-  memoryZero(&stream, sizeof(savestream_t));
-
-  #ifdef saveStreamOpenReadPlatform
-    errorChain(saveStreamOpenReadPlatform(&stream, slot));
+errorret_t saveUpdate(void) {
+  #ifdef savePlatformUpdate
+    errorChain(savePlatformUpdate());
   #endif
-
-  if(!stream.found) errorOk();
-
-  errorret_t ret = saveFileLoad(&stream, file);
-
-  #ifdef saveStreamClosePlatform
-    saveStreamClosePlatform(&stream);
-  #endif
-
-  if(errorIsNotOk(ret)) return ret;
-
-  errorChain(saveStreamVerifyChecksumImpl(&stream, slot));
-
-  file->exists = true;
   errorOk();
 }
 
-errorret_t saveWrite(const uint8_t slot) {
-  assertTrue(slot < SAVE_FILE_COUNT_MAX, "slot exceeds SAVE_FILE_COUNT_MAX");
+bool_t saveIsBusy(void) {
+  #ifdef saveIsBusyPlatform
+    return saveIsBusyPlatform();
+  #else
+    return false;
+  #endif
+}
 
-  savefile_t *file = &SAVE.files[slot];
+void saveLoadSlot(const uint8_t slot, savecallback_t onComplete, void *user) {
+  assertTrue(slot < SAVE_SLOT_COUNT_MAX, "slot exceeds SAVE_SLOT_COUNT_MAX");
+  assertNotNull(onComplete, "onComplete cannot be NULL");
 
-  savestream_t stream;
-  memoryZero(&stream, sizeof(savestream_t));
+  SAVE.slots[slot].exists = false;
 
-  #ifdef saveStreamOpenWritePlatform
-    errorChain(saveStreamOpenWritePlatform(&stream, slot));
+  // Some platforms (PSP's native save dialog) can't complete within this
+  // call - they take over entirely and invoke onComplete later, from
+  // saveUpdate(), once their own multi-frame flow finishes. Those
+  // platforms never define the sync saveSlotLoadPlatform() at all, so the
+  // fallback below must live in the #else, not just after an early return.
+  #ifdef saveSlotAsyncLoadPlatform
+    saveSlotAsyncLoadPlatform(slot, onComplete, user);
+  #else
+    errorret_t ret = saveSlotLoadPlatform(slot, &SAVE.slots[slot]);
+    SAVE.available = errorIsOk(ret);
+    onComplete(ret, user);
+  #endif
+}
+
+void saveLoadDefault(const uint8_t slot) {
+  assertTrue(slot < SAVE_SLOT_COUNT_MAX, "slot exceeds SAVE_SLOT_COUNT_MAX");
+  SAVE.slots[slot] = SAVE_DEFAULT;
+}
+
+void saveWriteSlot(const uint8_t slot, savecallback_t onComplete, void *user) {
+  assertTrue(slot < SAVE_SLOT_COUNT_MAX, "slot exceeds SAVE_SLOT_COUNT_MAX");
+  assertNotNull(onComplete, "onComplete cannot be NULL");
+
+  // See saveLoadSlot() - some platforms take over and complete later.
+  #ifdef saveSlotAsyncWritePlatform
+    saveSlotAsyncWritePlatform(slot, onComplete, user);
+  #else
+    errorret_t ret = saveSlotWritePlatform(slot, &SAVE.slots[slot]);
+    SAVE.available = errorIsOk(ret);
+    onComplete(ret, user);
+  #endif
+}
+
+errorret_t saveDeleteSlot(const uint8_t slot) {
+  assertTrue(slot < SAVE_SLOT_COUNT_MAX, "slot exceeds SAVE_SLOT_COUNT_MAX");
+
+  #ifdef saveSlotDeletePlatform
+    errorret_t deleteRet = saveSlotDeletePlatform(slot);
+    SAVE.available = errorIsOk(deleteRet);
+    errorChain(deleteRet);
   #endif
 
-  errorret_t ret = saveFileWrite(&stream, file);
-
-  if(errorIsOk(ret)) {
-    ret = saveStreamFinalizeWriteImpl(&stream);
-  }
-
-  #ifdef saveStreamClosePlatform
-    saveStreamClosePlatform(&stream);
-  #endif
-
-  if(errorIsNotOk(ret)) return ret;
-
-  file->exists = true;
+  SAVE.slots[slot].exists = false;
   errorOk();
 }
 
-errorret_t saveDelete(const uint8_t slot) {
-  assertTrue(slot < SAVE_FILE_COUNT_MAX, "slot exceeds SAVE_FILE_COUNT_MAX");
+bool_t saveSlotExists(const uint8_t slot) {
+  assertTrue(slot < SAVE_SLOT_COUNT_MAX, "slot exceeds SAVE_SLOT_COUNT_MAX");
+  return SAVE.slots[slot].exists;
+}
 
-  #ifdef saveDeletePlatform
-    errorChain(saveDeletePlatform(slot));
+saveslot_t * saveGetSlot(const uint8_t slot) {
+  assertTrue(slot < SAVE_SLOT_COUNT_MAX, "slot exceeds SAVE_SLOT_COUNT_MAX");
+  return &SAVE.slots[slot];
+}
+
+void saveLoadMeta(savecallback_t onComplete, void *user) {
+  assertNotNull(onComplete, "onComplete cannot be NULL");
+
+  SAVE.meta.exists = false;
+
+  #ifdef saveMetaAsyncLoadPlatform
+    saveMetaAsyncLoadPlatform(onComplete, user);
+  #else
+    errorret_t ret = saveMetaLoadPlatform(&SAVE.meta);
+    SAVE.available = errorIsOk(ret);
+    onComplete(ret, user);
   #endif
-
-  SAVE.files[slot].exists = false;
-  errorOk();
 }
 
-bool_t saveExists(const uint8_t slot) {
-  assertTrue(slot < SAVE_FILE_COUNT_MAX, "slot exceeds SAVE_FILE_COUNT_MAX");
-  return SAVE.files[slot].exists;
+void saveWriteMeta(savecallback_t onComplete, void *user) {
+  assertNotNull(onComplete, "onComplete cannot be NULL");
+
+  #ifdef saveMetaAsyncWritePlatform
+    saveMetaAsyncWritePlatform(onComplete, user);
+  #else
+    errorret_t ret = saveMetaWritePlatform(&SAVE.meta);
+    SAVE.available = errorIsOk(ret);
+    onComplete(ret, user);
+  #endif
 }
 
-savefile_t * saveGet(const uint8_t slot) {
-  assertTrue(slot < SAVE_FILE_COUNT_MAX, "slot exceeds SAVE_FILE_COUNT_MAX");
-  return &SAVE.files[slot];
+savemeta_t * saveGetMeta(void) {
+  return &SAVE.meta;
 }

src/dusk/save/save.h

@@ -7,25 +7,97 @@
 
 #pragma once
 #include "error/error.h"
-#include "savefile.h"
+#include "saveslot.h"
+#include "savemeta.h"
 #include "save/saveplatform.h"
 
 typedef struct {
-  /** Per-slot save file data; indexed 0 to SAVE_FILE_COUNT_MAX - 1. */
-  savefile_t files[SAVE_FILE_COUNT_MAX];
+  /** Per-slot save data; indexed 0 to SAVE_SLOT_COUNT_MAX - 1. */
+  saveslot_t slots[SAVE_SLOT_COUNT_MAX];
+  /** Device-wide preferences - see savemeta.h. */
+  savemeta_t meta;
   /** Platform-specific save system state (paths, card handles, etc.). */
   saveplatform_t platform;
+  /**
+   * True if the save medium (memory card/stick/disk) was reachable the
+   * last time it was checked - at saveInit(), and refreshed by every
+   * subsequent load/write attempt. Starting the game with no card/stick
+   * inserted, or one being removed mid-session, are both expected
+   * conditions here, not fatal errors - see saveIsAvailable().
+   */
+  bool_t available;
+  /**
+   * True once the player has explicitly acknowledged there's no save
+   * device and chosen to continue anyway (see the initial scene's "no
+   * card" prompt) - sticky for the rest of the session, folded into
+   * saveIsAvailable() so every existing/future call site that already
+   * gates on that automatically refuses to save/load from here on. See
+   * saveMarkTemporary()/saveIsTemporary().
+   */
+  bool_t temporary;
+  /**
+   * Scratch error state used by platforms whose save/load completes
+   * asynchronously (see saveIsBusy()) to construct a result to hand to a
+   * savecallback_t from inside saveUpdate(), rather than from a direct
+   * errorThrow() return - mirrors network_t.errorState for the same reason.
+   */
+  errorstate_t errorState;
 } save_t;
 
 extern save_t SAVE;
 
 /**
- * Initializes the save system.
+ * Initializes the save system. Never fails the way saveWriteSlot()/
+ * saveWriteMeta() can - if the platform's save medium isn't reachable
+ * (e.g. no memory card/stick inserted), that's logged and reflected in
+ * saveIsAvailable() rather than treated as fatal, since the game should
+ * still be playable without save support.
  *
- * @return An error code if initialization fails.
+ * On most platforms, this also eagerly loads meta and every slot from
+ * disk immediately - cheap and harmless, since nothing consumes the
+ * loaded slot data automatically (there's no "continue game" flow yet;
+ * rpgInit() always hardcodes a fresh game regardless of what's loaded).
+ * PSP skips this (see saveSkipEagerLoadPlatform) - its only read path is
+ * the native sceUtilitySavedata dialog now that meta lives inside the
+ * same payload as the save slot, and running that multi-frame dialog on
+ * every single boot would reintroduce the exact UX problem a lightweight
+ * settings-only file used to avoid.
+ *
+ * @return An error code only for unexpected platform failures.
  */
 errorret_t saveInit(void);
 
+/**
+ * Checks whether the save medium was reachable as of the last load/write
+ * attempt (or saveInit(), if none has been attempted yet), AND the
+ * session hasn't been marked temporary (see saveMarkTemporary()).
+ * Intended for UI to decide whether to offer saving/loading at all, or to
+ * explain why it isn't available right now - e.g. "No memory card
+ * inserted".
+ *
+ * @return true if saving/loading can be attempted right now.
+ */
+bool_t saveIsAvailable(void);
+
+/**
+ * Marks this session as temporary - the player explicitly acknowledged
+ * there's no save device and chose to continue anyway. One-way: nothing
+ * currently re-probes the save medium mid-session (see saveInit()'s doc
+ * comment), so there's no legitimate way to un-stick this once set short
+ * of restarting the game.
+ */
+void saveMarkTemporary(void);
+
+/**
+ * True once saveMarkTemporary() has been called this session. Distinct
+ * from saveIsAvailable() so UI can give a more specific message (e.g.
+ * "this session is temporary" rather than the generic "no save device
+ * found") once the player has already made that choice.
+ *
+ * @return true if this session has been marked temporary.
+ */
+bool_t saveIsTemporary(void);
+
 /**
  * Disposes of the save system.
  *
@@ -34,41 +106,105 @@ errorret_t saveInit(void);
 errorret_t saveDispose(void);
 
 /**
- * Loads the save file for a given slot from persistent storage.
+ * Updates the save manager, pumping any in-progress async save/load and
+ * dispatching its callback once complete. No-op on platforms where every
+ * operation always completes synchronously (see saveIsBusy()). Must be
+ * called every engine frame for platforms that need it (PSP's native save
+ * dialog spans multiple frames).
  *
- * @param slot The save slot index (0 to SAVE_FILE_COUNT_MAX - 1).
- * @return An error code if the load fails.
+ * @return An error code indicating success or failure.
  */
-errorret_t saveLoad(const uint8_t slot);
+errorret_t saveUpdate(void);
 
 /**
- * Writes the save file for a given slot to persistent storage.
+ * True while an async save/load is in progress (e.g. PSP's native save
+ * dialog is open). Calling any save/load function again while this is true
+ * is undefined behavior - wait for the previous call's callback first.
  *
- * @param slot The save slot index (0 to SAVE_FILE_COUNT_MAX - 1).
- * @return An error code if the write fails.
+ * @return True if a save/load request is currently in progress.
  */
-errorret_t saveWrite(const uint8_t slot);
+bool_t saveIsBusy(void);
 
 /**
- * Deletes the save file for a given slot from persistent storage.
+ * Loads the save slot for a given index from persistent storage. Slow/
+ * async on some platforms (PSP's native save dialog spans multiple
+ * frames) - on others (Linux, Dolphin) onComplete is invoked before this
+ * call returns. See saveIsBusy().
  *
- * @param slot The save slot index (0 to SAVE_FILE_COUNT_MAX - 1).
+ * @param slot The save slot index (0 to SAVE_SLOT_COUNT_MAX - 1).
+ * @param onComplete Callback invoked with the result once loading finishes.
+ * @param user User data passed through to onComplete.
+ */
+void saveLoadSlot(const uint8_t slot, savecallback_t onComplete, void *user);
+
+/**
+ * Resets a save slot in memory to SAVE_DEFAULT, for starting a new game
+ * without reading anything from persistent storage. Synchronous - no
+ * disk I/O is involved, so there's no callback to wait on.
+ *
+ * @param slot The save slot index (0 to SAVE_SLOT_COUNT_MAX - 1) to reset.
+ */
+void saveLoadDefault(const uint8_t slot);
+
+/**
+ * Writes the save slot for a given index to persistent storage. Slow/
+ * async on some platforms (PSP's native save dialog spans multiple
+ * frames) - on others (Linux, Dolphin) onComplete is invoked before this
+ * call returns. See saveIsBusy().
+ *
+ * @param slot The save slot index (0 to SAVE_SLOT_COUNT_MAX - 1).
+ * @param onComplete Callback invoked with the result once writing finishes.
+ * @param user User data passed through to onComplete.
+ */
+void saveWriteSlot(const uint8_t slot, savecallback_t onComplete, void *user);
+
+/**
+ * Deletes the save slot for a given index from persistent storage.
+ *
+ * @param slot The save slot index (0 to SAVE_SLOT_COUNT_MAX - 1).
  * @return An error code if the delete fails.
  */
-errorret_t saveDelete(const uint8_t slot);
+errorret_t saveDeleteSlot(const uint8_t slot);
 
 /**
- * Checks whether a save file exists for a given slot.
+ * Checks whether a save slot has data for a given index.
  *
- * @param slot The save slot index (0 to SAVE_FILE_COUNT_MAX - 1).
- * @return true if a save file exists for the slot, false otherwise.
+ * @param slot The save slot index (0 to SAVE_SLOT_COUNT_MAX - 1).
+ * @return true if the slot has data, false otherwise.
  */
-bool_t saveExists(const uint8_t slot);
+bool_t saveSlotExists(const uint8_t slot);
 
 /**
- * Gets a pointer to the save file data for a given slot.
+ * Gets a pointer to the save slot data for a given index.
  *
- * @param slot The save slot index (0 to SAVE_FILE_COUNT_MAX - 1).
- * @return A pointer to the savefile_t for the given slot.
+ * @param slot The save slot index (0 to SAVE_SLOT_COUNT_MAX - 1).
+ * @return A pointer to the saveslot_t for the given slot.
  */
-savefile_t * saveGet(const uint8_t slot);
+saveslot_t * saveGetSlot(const uint8_t slot);
+
+/**
+ * Loads device-wide meta (preferences) from persistent storage. Callback-
+ * based on every platform, same as saveLoadSlot() - on PSP specifically,
+ * loading meta means loading the same combined savedata payload as the
+ * active slot, which is unavoidably async there.
+ *
+ * @param onComplete Callback invoked with the result once loading finishes.
+ * @param user User data passed through to onComplete.
+ */
+void saveLoadMeta(savecallback_t onComplete, void *user);
+
+/**
+ * Writes device-wide meta (preferences) to persistent storage.
+ *
+ * @param onComplete Callback invoked with the result once writing finishes.
+ * @param user User data passed through to onComplete.
+ */
+void saveWriteMeta(savecallback_t onComplete, void *user);
+
+/**
+ * Gets a pointer to the live meta data. Modify fields directly, then call
+ * saveWriteMeta() to persist them.
+ *
+ * @return A pointer to the meta.
+ */
+savemeta_t * saveGetMeta(void);

src/dusk/save/savefile.h

@@ -1,30 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "dusk.h"
-
-/** Save file format version. Increment on breaking change. */
-#define SAVE_FILE_VERSION 1
-
-/** Magic bytes that identify a Dusk save file. */
-#define SAVE_FILE_HEADER "DSK"
-
-/** Byte length of the magic header (excludes the null terminator). */
-#define SAVE_FILE_HEADER_SIZE (sizeof(SAVE_FILE_HEADER) - 1)
-
-/** Maximum number of independent save slots supported. */
-#define SAVE_FILE_COUNT_MAX 3
-
-typedef struct {
-  /** Magic header bytes read from the file; must equal SAVE_FILE_HEADER. */
-  char_t header[SAVE_FILE_HEADER_SIZE];
-  /** Format version read from the file; used to branch on older layouts. */
-  uint32_t version;
-  /** Runtime flag - true if this slot was successfully loaded or written. */
-  bool_t exists;
-} savefile_t;

src/dusk/save/savemeta.h

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+
+/** Save meta format version. Increment on breaking change. */
+#define SAVE_META_VERSION 1
+
+/** Magic bytes that identify a Dusk save meta blob. */
+#define SAVE_META_HEADER "DSM"
+
+/** Byte length of the magic header (excludes the null terminator). */
+#define SAVE_META_HEADER_SIZE (sizeof(SAVE_META_HEADER) - 1)
+
+/**
+ * Default gamepad deadzone for meta that's never actually been loaded from
+ * disk yet (see saveInit(), which stamps this on first boot) - the save
+ * meta is the single source of truth for this value (see
+ * savemeta_t.deadzone); nothing else stores or defaults it.
+ */
+#define SAVE_META_DEADZONE_DEFAULT 0.1f
+
+/**
+ * Default language index for meta that's never actually been loaded from
+ * disk yet - index 0 into LOCALE_LIST (see locale/localemanager.h), i.e.
+ * LOCALE_EN_US.
+ */
+#define SAVE_META_LANGUAGE_DEFAULT 0
+
+/**
+ * Device/user-wide preferences, independent of any individual game save
+ * slot (see saveslot.h) - there's exactly one of these, not one per slot,
+ * since a setting like gamepad deadzone shouldn't reset or diverge just
+ * because the player started a new game in a different slot.
+ */
+typedef struct {
+  /** Magic header bytes read from the blob; must equal SAVE_META_HEADER. */
+  char_t header[SAVE_META_HEADER_SIZE];
+  /** Format version read from the blob; used to branch on older layouts. */
+  uint32_t version;
+  /** Runtime flag - true if meta was successfully loaded or written. */
+  bool_t exists;
+  /**
+   * User-configured gamepad deadzone (0.0f-1.0f) - the save meta is the
+   * only place this lives; read it directly via saveGetMeta()->deadzone
+   * rather than caching it anywhere else.
+   */
+  float_t deadzone;
+  /**
+   * Index into LOCALE_LIST (see locale/localemanager.h) for the player's
+   * preferred UI language - the save meta is the only place this lives;
+   * read it directly via saveGetMeta()->language rather than caching it
+   * anywhere else. Never reorder/remove entries from LOCALE_LIST, only
+   * append, since this index must keep meaning the same locale across
+   * versions.
+   */
+  uint8_t language;
+} savemeta_t;

src/dusk/save/saveslot.h

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+
+/** Save slot format version. Increment on breaking change. */
+#define SAVE_SLOT_VERSION 1
+
+/** Magic bytes that identify a Dusk save slot. */
+#define SAVE_SLOT_HEADER "DSK"
+
+/** Byte length of the magic header (excludes the null terminator). */
+#define SAVE_SLOT_HEADER_SIZE (sizeof(SAVE_SLOT_HEADER) - 1)
+
+/**
+ * Maximum number of independent save slots supported. Platform-overridable
+ * via a compiler define (not a header #ifndef alone, since this header is
+ * included before any platform header gets a chance to react) - see PSP's
+ * CMakeLists.txt, which overrides this to 1.
+ */
+#ifndef SAVE_SLOT_COUNT_MAX
+  #define SAVE_SLOT_COUNT_MAX 3
+#endif
+
+/**
+ * The save slot actually used for gameplay right now - there's no slot
+ * select/multi-save UX yet (SAVE_SLOT_COUNT_MAX > 1 exists for later), so
+ * every part of the game that needs "the" save slot (the game menu's Save
+ * button, etc.) reads/writes this one slot.
+ */
+#define SAVE_ACTIVE_SLOT 0
+
+/** Maximum length of a saved player name, including the null terminator. */
+#define SAVE_PLAYER_NAME_MAX 32
+
+/**
+ * Maximum number of global entities whose "collected" state can be
+ * tracked - see rpg/entity/global/globalitemstore.h. Bounded/fixed here
+ * rather than tied to ENTITY_GLOBAL_LIST_COUNT, since saveslot.h is a
+ * leaf header with no dependency on the entity system (and no reason to
+ * take one just for a size constant).
+ */
+#define SAVE_GLOBAL_ITEM_COUNT_MAX 64
+
+/**
+ * Maximum number of story flags the save format can hold - see
+ * rpg/story/storyflag.h. Bounded/fixed here (with real headroom over the
+ * current flag count) rather than tied to STORY_FLAG_COUNT, since
+ * saveslot.h is a leaf header with no dependency on generated story
+ * content, matching SAVE_GLOBAL_ITEM_COUNT_MAX's reasoning.
+ */
+#define SAVE_STORY_FLAG_COUNT_MAX 128
+
+/** Per-slot game progress - the state a "save file" traditionally means. */
+typedef struct {
+  /** Magic header bytes read from the slot; must equal SAVE_SLOT_HEADER. */
+  char_t header[SAVE_SLOT_HEADER_SIZE];
+  /** Format version read from the slot; used to branch on older layouts. */
+  uint32_t version;
+  /** Runtime flag - true if this slot was successfully loaded or written. */
+  bool_t exists;
+  /** The player's saved name. */
+  char_t playerName[SAVE_PLAYER_NAME_MAX];
+  /** Per-global-ID "already collected" flags - see globalitemstore.h. */
+  bool_t globalItemCollected[SAVE_GLOBAL_ITEM_COUNT_MAX];
+  /**
+   * Story flag values, indexed by storyflag_t - the save slot is the only
+   * place these live; read/write via storyFlagGet()/storyFlagSet() (see
+   * rpg/story/storyflag.h), not directly.
+   */
+  uint8_t storyFlags[SAVE_STORY_FLAG_COUNT_MAX];
+} saveslot_t;
+
+/**
+ * Callback invoked when an async saveWriteSlot()/saveLoadSlot()/
+ * saveWriteMeta()/saveLoadMeta() request completes. Declared here (rather
+ * than save.h) so platform save headers - which save.h's platform
+ * indirection pulls in before save.h finishes defining anything else - can
+ * reference it without a circular include.
+ *
+ * @param result Whether the request succeeded.
+ * @param user User data passed through from the original call.
+ */
+typedef void (*savecallback_t)(errorret_t result, void *user);
+
+/**
+ * The blank template used to (re)initialize a save slot for a brand new
+ * game via saveLoadDefault(), rather than reading one from persistent
+ * storage. Deliberately generic at this layer (empty collected-item
+ * flags, no story flags set) - anything that needs CSV-defined story flag
+ * defaults layers that on top afterward (see storyFlagInitDefaults()),
+ * since saveslot.h stays a leaf header with no dependency on generated
+ * story content (see SAVE_STORY_FLAG_COUNT_MAX's doc comment above).
+ */
+extern const saveslot_t SAVE_DEFAULT;

src/dusk/save/savestream.c

@@ -45,12 +45,23 @@ errorret_t saveStreamWriteBytesImpl(
   errorOk();
 }
 
-errorret_t saveStreamFinalizeWriteImpl(savestream_t *stream) {
+errorret_t saveStreamTellImpl(savestream_t *stream, size_t *out) {
+  #ifdef saveStreamTellPlatform
+    errorChain(saveStreamTellPlatform(stream, out));
+  #else
+    *out = 0;
+  #endif
+  errorOk();
+}
+
+errorret_t saveStreamFinalizeWriteImpl(
+  savestream_t *stream, const size_t headerPosition, const size_t headerSize
+) {
   uint32_t finalCRC = cryptCRC32End(stream->checksum);
   uint32_t leChecksum = endianLittleToHost32(finalCRC);
 
   #ifdef saveStreamSeekPlatform
-    errorChain(saveStreamSeekPlatform(stream, SAVE_FILE_HEADER_SIZE));
+    errorChain(saveStreamSeekPlatform(stream, headerPosition + headerSize));
   #endif
 
   errorChain(saveStreamWriteBytesRawImpl(
@@ -60,27 +71,25 @@ errorret_t saveStreamFinalizeWriteImpl(savestream_t *stream) {
 }
 
 errorret_t saveStreamVerifyChecksumImpl(
-  savestream_t *stream, const uint8_t slot
+  savestream_t *stream, const char_t *sectionLabel
 ) {
   uint32_t computed = cryptCRC32End(stream->checksum);
   if(computed != stream->expectedChecksum) {
-    errorThrow("Save slot %u has invalid checksum", (uint32_t)slot);
+    errorThrow("%s has invalid checksum", sectionLabel);
   }
   errorOk();
 }
 
-
 errorret_t saveStreamReadHeaderImpl(
-  savestream_t *stream, char_t header[SAVE_FILE_HEADER_SIZE]
+  savestream_t *stream, char_t *header, const char_t *expectedHeader,
+  const size_t headerSize
 ) {
-  errorChain(saveStreamReadBytesRawImpl(stream, header, SAVE_FILE_HEADER_SIZE));
+  errorChain(saveStreamReadBytesRawImpl(stream, header, headerSize));
 
-  if(
-    header[0] != SAVE_FILE_HEADER[0] ||
-    header[1] != SAVE_FILE_HEADER[1] ||
-    header[2] != SAVE_FILE_HEADER[2]
-  ) {
-    errorThrow("Save file has invalid header");
+  for(size_t i = 0; i < headerSize; i++) {
+    if(header[i] != expectedHeader[i]) {
+      errorThrow("Save data has invalid header");
+    }
   }
 
   uint32_t leChecksum;
@@ -91,11 +100,9 @@ errorret_t saveStreamReadHeaderImpl(
 }
 
 errorret_t saveStreamWriteHeaderImpl(
-  savestream_t *stream, const char_t header[SAVE_FILE_HEADER_SIZE]
+  savestream_t *stream, const char_t *header, const size_t headerSize
 ) {
-  errorChain(saveStreamWriteBytesRawImpl(
-    stream, header, SAVE_FILE_HEADER_SIZE
-  ));
+  errorChain(saveStreamWriteBytesRawImpl(stream, header, headerSize));
 
   uint32_t placeholder = 0;
   errorChain(saveStreamWriteBytesRawImpl(
@@ -327,14 +334,70 @@ errorret_t saveStreamWriteDateImpl(
   errorOk();
 }
 
-errorret_t saveFileLoad(savestream_t *stream, savefile_t *file) {
-  saveFileReadHeader(stream, file->header);
-  saveFileReadVersion(stream, &file->version);
+errorret_t saveMetaSerializeRead(savestream_t *stream, savemeta_t *meta) {
+  saveFileReadHeader(
+    stream, meta->header, SAVE_META_HEADER, SAVE_META_HEADER_SIZE
+  );
+  saveFileReadVersion(stream, &meta->version);
+  saveFileReadFloat(stream, &meta->deadzone);
+  saveFileReadUInt8(stream, &meta->language);
+  errorChain(saveStreamVerifyChecksumImpl(stream, "Save meta"));
+  meta->exists = true;
   errorOk();
 }
 
-errorret_t saveFileWrite(savestream_t *stream, savefile_t *file) {
-  saveFileWriteHeader(stream, file->header);
-  saveFileWriteVersion(stream, &file->version);
+errorret_t saveMetaSerializeWrite(savestream_t *stream, savemeta_t *meta) {
+  memoryCopy(meta->header, SAVE_META_HEADER, SAVE_META_HEADER_SIZE);
+  meta->version = SAVE_META_VERSION;
+
+  size_t headerPosition;
+  errorChain(saveStreamTellImpl(stream, &headerPosition));
+  saveFileWriteHeader(stream, meta->header, SAVE_META_HEADER_SIZE);
+  saveFileWriteVersion(stream, &meta->version);
+  saveFileWriteFloat(stream, &meta->deadzone);
+  saveFileWriteUInt8(stream, &meta->language);
+  errorChain(saveStreamFinalizeWriteImpl(
+    stream, headerPosition, SAVE_META_HEADER_SIZE
+  ));
+  meta->exists = true;
+  errorOk();
+}
+
+errorret_t saveSlotSerializeRead(savestream_t *stream, saveslot_t *slot) {
+  saveFileReadHeader(
+    stream, slot->header, SAVE_SLOT_HEADER, SAVE_SLOT_HEADER_SIZE
+  );
+  saveFileReadVersion(stream, &slot->version);
+  saveFileReadString(stream, slot->playerName, SAVE_PLAYER_NAME_MAX);
+  for(size_t i = 0; i < SAVE_GLOBAL_ITEM_COUNT_MAX; i++) {
+    saveFileReadBool(stream, &slot->globalItemCollected[i]);
+  }
+  for(size_t i = 0; i < SAVE_STORY_FLAG_COUNT_MAX; i++) {
+    saveFileReadUInt8(stream, &slot->storyFlags[i]);
+  }
+  errorChain(saveStreamVerifyChecksumImpl(stream, "Save slot"));
+  slot->exists = true;
+  errorOk();
+}
+
+errorret_t saveSlotSerializeWrite(savestream_t *stream, saveslot_t *slot) {
+  memoryCopy(slot->header, SAVE_SLOT_HEADER, SAVE_SLOT_HEADER_SIZE);
+  slot->version = SAVE_SLOT_VERSION;
+
+  size_t headerPosition;
+  errorChain(saveStreamTellImpl(stream, &headerPosition));
+  saveFileWriteHeader(stream, slot->header, SAVE_SLOT_HEADER_SIZE);
+  saveFileWriteVersion(stream, &slot->version);
+  saveFileWriteString(stream, slot->playerName, SAVE_PLAYER_NAME_MAX);
+  for(size_t i = 0; i < SAVE_GLOBAL_ITEM_COUNT_MAX; i++) {
+    saveFileWriteBool(stream, &slot->globalItemCollected[i]);
+  }
+  for(size_t i = 0; i < SAVE_STORY_FLAG_COUNT_MAX; i++) {
+    saveFileWriteUInt8(stream, &slot->storyFlags[i]);
+  }
+  errorChain(saveStreamFinalizeWriteImpl(
+    stream, headerPosition, SAVE_SLOT_HEADER_SIZE
+  ));
+  slot->exists = true;
   errorOk();
 }

src/dusk/save/savestream.h

@@ -7,7 +7,8 @@
 
 #pragma once
 #include "error/error.h"
-#include "savefile.h"
+#include "saveslot.h"
+#include "savemeta.h"
 #include "save/saveplatform.h"
 #include "time/timeepoch.h"
 
@@ -67,49 +68,72 @@ errorret_t saveStreamWriteBytesImpl(
 );
 
 /**
- * Finalizes a write stream: computes the final CRC32, seeks to the
- * checksum field in the header, and writes it in little-endian order.
+ * Gets the current read/write position within the stream. Used to capture
+ * a section's start position before writing its header, so its checksum
+ * can be backfilled at the right offset once the section's body is known -
+ * required now that a single stream can hold multiple self-contained
+ * sections back-to-back (meta + N save slots), not just one.
+ *
+ * @param stream Active stream.
+ * @param out    Receives the current position.
+ * @return An error if the platform can't report a position.
+ */
+errorret_t saveStreamTellImpl(savestream_t *stream, size_t *out);
+
+/**
+ * Finalizes a write stream: computes the final CRC32, seeks back to the
+ * checksum field just after this section's header, and writes it in
+ * little-endian order.
  *
  * @param stream Active write stream.
+ * @param headerPosition Byte offset where this section's header started
+ *   (see saveStreamTellImpl), captured before writing the header.
+ * @param headerSize Byte length of this section's magic header.
  * @return An error if the seek or write fails.
  */
-errorret_t saveStreamFinalizeWriteImpl(savestream_t *stream);
+errorret_t saveStreamFinalizeWriteImpl(
+  savestream_t *stream, const size_t headerPosition, const size_t headerSize
+);
 
 /**
  * Verifies that the CRC32 accumulated during loading matches the value
- * stored in the file header.
+ * stored in this section's header.
  *
  * @param stream Active read stream (loading must be complete).
- * @param slot   Slot index used in the error message on mismatch.
+ * @param sectionLabel Human-readable label used in the error message on
+ *   mismatch (e.g. "save meta", "save slot").
  * @return An error if the checksum does not match.
  */
 errorret_t saveStreamVerifyChecksumImpl(
-  savestream_t *stream, const uint8_t slot
+  savestream_t *stream, const char_t *sectionLabel
 );
 
 /**
- * Reads and validates the magic header, then reads the stored CRC32 and
- * resets the running accumulator.
+ * Reads and validates a section's magic header, then reads its stored
+ * CRC32 and resets the running accumulator.
  *
  * @param stream Active read stream.
- * @param header Buffer of SAVE_FILE_HEADER_SIZE bytes to receive the header.
+ * @param header Buffer of headerSize bytes to receive the header.
+ * @param expectedHeader The magic bytes this section must match.
+ * @param headerSize Byte length of the magic header.
  * @return An error if the header is missing or invalid.
  */
 errorret_t saveStreamReadHeaderImpl(
-  savestream_t *stream, char_t header[SAVE_FILE_HEADER_SIZE]
+  savestream_t *stream, char_t *header, const char_t *expectedHeader,
+  const size_t headerSize
 );
 
 /**
- * Writes the magic header and a zero CRC32 placeholder, then resets the
- * running accumulator.
+ * Writes a section's magic header and a zero CRC32 placeholder, then
+ * resets the running accumulator.
  *
  * @param stream Active write stream.
- * @param header Buffer of SAVE_FILE_HEADER_SIZE bytes to write.
+ * @param header Buffer of headerSize bytes to write.
+ * @param headerSize Byte length of the magic header.
  * @return An error if the write fails.
  */
 errorret_t saveStreamWriteHeaderImpl(
-  savestream_t *stream,
-  const char_t header[SAVE_FILE_HEADER_SIZE]
+  savestream_t *stream, const char_t *header, const size_t headerSize
 );
 
 /**
@@ -377,29 +401,49 @@ errorret_t saveStreamWriteDateImpl(
 );
 
 /**
- * Reads the contents of a save slot from the stream into the save file
- * struct. Use saveFileRead* macros to deserialize fields one at a time.
+ * Reads a self-contained save meta section (header, version, fields,
+ * checksum verification) from the stream.
  *
- * @param stream Active read stream for this slot.
- * @param file   Save file struct to populate.
+ * @param stream Active read stream, positioned at the section's start.
+ * @param meta   Meta struct to populate.
  * @return An error code if loading fails.
  */
-errorret_t saveFileLoad(savestream_t *stream, savefile_t *file);
+errorret_t saveMetaSerializeRead(savestream_t *stream, savemeta_t *meta);
 
 /**
- * Writes the contents of the save file struct into the stream.
- * Use saveFileWrite* macros to serialize fields one at a time.
+ * Writes a self-contained save meta section (header, version, fields,
+ * checksum) to the stream.
  *
- * @param stream Active write stream for this slot.
- * @param file   Save file struct to serialize.
+ * @param stream Active write stream, positioned at the section's start.
+ * @param meta   Meta struct to serialize.
  * @return An error code if writing fails.
  */
-errorret_t saveFileWrite(savestream_t *stream, savefile_t *file);
+errorret_t saveMetaSerializeWrite(savestream_t *stream, savemeta_t *meta);
 
-#define saveFileReadHeader(stream, header) \
-  errorChain(saveStreamReadHeaderImpl(stream, header))
-#define saveFileWriteHeader(stream, header) \
-  errorChain(saveStreamWriteHeaderImpl(stream, header))
+/**
+ * Reads a self-contained save slot section (header, version, fields,
+ * checksum verification) from the stream.
+ *
+ * @param stream Active read stream, positioned at the section's start.
+ * @param slot   Slot struct to populate.
+ * @return An error code if loading fails.
+ */
+errorret_t saveSlotSerializeRead(savestream_t *stream, saveslot_t *slot);
+
+/**
+ * Writes a self-contained save slot section (header, version, fields,
+ * checksum) to the stream.
+ *
+ * @param stream Active write stream, positioned at the section's start.
+ * @param slot   Slot struct to serialize.
+ * @return An error code if writing fails.
+ */
+errorret_t saveSlotSerializeWrite(savestream_t *stream, saveslot_t *slot);
+
+#define saveFileReadHeader(stream, header, expected, size) \
+  errorChain(saveStreamReadHeaderImpl(stream, header, expected, size))
+#define saveFileWriteHeader(stream, header, size) \
+  errorChain(saveStreamWriteHeaderImpl(stream, header, size))
 
 #define saveFileReadVersion(stream, out) \
   errorChain(saveStreamReadVersionImpl(stream, out))
@@ -465,4 +509,3 @@ errorret_t saveFileWrite(savestream_t *stream, savefile_t *file);
   errorChain(saveStreamReadDateImpl(stream, out))
 #define saveFileWriteDate(stream, input) \
   errorChain(saveStreamWriteDateImpl(stream, input))
-

src/dusk/scene/CMakeLists.txt

@@ -10,5 +10,7 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
 )
 
 # Subdirs
+add_subdirectory(initial)
+add_subdirectory(mainmenu)
 add_subdirectory(overworld)
 add_subdirectory(battle)

src/dusk/scene/battle/scenebattle.c

@@ -6,7 +6,14 @@
  */
 
 #include "scenebattle.h"
-#include "rpg/battle/battle.h"
+#include "display/display.h"
+#include "display/displaystate.h"
+#include "display/shader/shader.h"
+#include "display/shader/shaderunlit.h"
+#include "display/spritebatch/spritebatch.h"
+#include "display/screen/screen.h"
+#include "display/color.h"
+#include "scene/scene.h"
 
 errorret_t sceneBattleInit(scenedata_t *sceneData) {
   errorOk();
@@ -18,9 +25,127 @@ errorret_t sceneBattleUpdate(scenedata_t *sceneData) {
 }
 
 errorret_t sceneBattleRender(scenedata_t *sceneData) {
+  scenebattle_t *battle = &sceneData->battle;
+
+  sceneBattleCameraUpdateProjection(battle);
+  sceneBattleCameraUpdateEye(battle);
+
+  errorChain(shaderBind(&SHADER_UNLIT));
+  errorChain(shaderSetMatrix(
+    &SHADER_UNLIT, SHADER_UNLIT_MODEL, SCENE.screenIdentity
+  ));
+  errorChain(shaderSetMatrix(
+    &SHADER_UNLIT, SHADER_UNLIT_PROJECTION, battle->projection
+  ));
+  errorChain(shaderSetMatrix(
+    &SHADER_UNLIT, SHADER_UNLIT_VIEW, battle->eye
+  ));
+
+  errorChain(displaySetState((displaystate_t){
+    .flags = DISPLAY_STATE_FLAG_DEPTH_TEST | DISPLAY_STATE_FLAG_CULL
+  }));
+
+  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
+    errorChain(sceneBattleDrawFighter(i));
+  }
+
   errorOk();
 }
 
 errorret_t sceneBattleDispose(scenedata_t *sceneData) {
   errorOk();
 }
+
+void sceneBattleCameraUpdateProjection(scenebattle_t *battle) {
+  glm_perspective(
+    glm_rad(SCENE_BATTLE_CAMERA_FOV),
+    SCREEN.aspect,
+    SCENE_BATTLE_CAMERA_NEAR,
+    SCENE_BATTLE_CAMERA_FAR,
+    battle->projection
+  );
+}
+
+void sceneBattleCameraUpdateEye(scenebattle_t *battle) {
+  glm_lookat(
+    (vec3){ 0.0f, 4.0f, 7.0f },
+    (vec3){ 0.0f, 0.5f, 0.0f },
+    (vec3){ 0.0f, 1.0f, 0.0f },
+    battle->eye
+  );
+}
+
+void sceneBattleWorldToScreen(
+  scenebattle_t *battle,
+  vec3 renderPos,
+  vec2 out
+) {
+  mat4 viewProj;
+  glm_mat4_mul(battle->projection, battle->eye, viewProj);
+
+  vec4 viewport = {
+    0.0f, 0.0f, (float_t)SCREEN.width, (float_t)SCREEN.height
+  };
+  vec3 window;
+  glm_project(renderPos, viewProj, viewport, window);
+
+  out[0] = window[0];
+  out[1] = (float_t)SCREEN.height - window[1];
+}
+
+void sceneBattleGetFighterPosition(const uint8_t fighterIndex, vec3 out) {
+  const battlefighter_t *fighter = &BATTLE.fighters[fighterIndex];
+
+  // Ordinal (and count) of this fighter among its living-slot teammates,
+  // in slot order, so each team lays out as an evenly spaced row.
+  uint8_t ordinal = 0;
+  uint8_t teamCount = 0;
+  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
+    if(BATTLE.fighters[i].status == BATTLE_FIGHTER_STATUS_NULL) continue;
+    if(BATTLE.fighters[i].team != fighter->team) continue;
+    if(i < fighterIndex) ordinal++;
+    teamCount++;
+  }
+
+  const float_t x =
+    ((float_t)ordinal - ((float_t)(teamCount - 1) * 0.5f)) *
+    SCENE_BATTLE_FIGHTER_SPACING;
+  const float_t z = fighter->team == BATTLE_FIGHTER_TEAM_ALLY
+    ? SCENE_BATTLE_ALLY_Z : SCENE_BATTLE_ENEMY_Z;
+
+  out[0] = x;
+  out[1] = 0.0f;
+  out[2] = z;
+}
+
+errorret_t sceneBattleDrawFighter(const uint8_t fighterIndex) {
+  const battlefighter_t *fighter = &BATTLE.fighters[fighterIndex];
+  if(fighter->status == BATTLE_FIGHTER_STATUS_NULL) errorOk();
+
+  vec3 position;
+  sceneBattleGetFighterPosition(fighterIndex, position);
+
+  spritebatchsprite_t sprite;
+  glm_vec3_copy(position, sprite.min);
+  glm_vec3_copy(position, sprite.max);
+  glm_vec3_add(sprite.max, (vec3){ 1.0f, 1.0f, 0.0f }, sprite.max);
+  glm_vec2_copy((vec2){ 0.0f, 0.0f }, sprite.uvMin);
+  glm_vec2_copy((vec2){ 1.0f, 1.0f }, sprite.uvMax);
+
+  color_t color;
+  if(fighter->status == BATTLE_FIGHTER_STATUS_DEAD) {
+    color = color4b(96, 96, 96, 255);
+  } else if(fighter->team == BATTLE_FIGHTER_TEAM_ALLY) {
+    color = COLOR_BLUE;
+  } else {
+    color = COLOR_RED;
+  }
+
+  shadermaterial_t material = {
+    .unlit = { .color = color, .texture = NULL }
+  };
+  errorChain(spriteBatchBuffer(&sprite, 1, &SHADER_UNLIT, material));
+  errorChain(spriteBatchFlush());
+
+  errorOk();
+}

src/dusk/scene/battle/scenebattle.h

@@ -7,9 +7,24 @@
 
 #pragma once
 #include "scene/scenebase.h"
+#include "rpg/battle/battle.h"
+
+// Fixed mock camera, "to begin": looking down at the arena from above and
+// in front. Not yet driven by anything (no shake, no per-fighter framing).
+#define SCENE_BATTLE_CAMERA_FOV 45.0f
+#define SCENE_BATTLE_CAMERA_NEAR 0.1f
+#define SCENE_BATTLE_CAMERA_FAR 100.0f
+
+// Fighter row layout, in render-space units. Allies stand closer to the
+// camera (+Z), enemies further away (-Z); each team is spread evenly
+// along X, centered on the origin.
+#define SCENE_BATTLE_FIGHTER_SPACING 2.0f
+#define SCENE_BATTLE_ALLY_Z 2.5f
+#define SCENE_BATTLE_ENEMY_Z (-2.5f)
 
 typedef struct {
-
+  mat4 eye;
+  mat4 projection;
 } scenebattle_t;
 
 /**
@@ -44,3 +59,52 @@ errorret_t sceneBattleRender(scenedata_t *sceneData);
  * @return An error if the dispose failed, or errorOk() if it succeeded.
  */
 errorret_t sceneBattleDispose(scenedata_t *sceneData);
+
+/**
+ * Recomputes the battle camera's projection matrix from the current
+ * screen aspect ratio, storing it in battle->projection.
+ *
+ * @param battle The battle scene data to update.
+ */
+void sceneBattleCameraUpdateProjection(scenebattle_t *battle);
+
+/**
+ * Recomputes the battle camera's eye/view matrix, storing it in
+ * battle->eye. Fixed for now -- doesn't yet track anything.
+ *
+ * @param battle The battle scene data to update.
+ */
+void sceneBattleCameraUpdateEye(scenebattle_t *battle);
+
+/**
+ * Converts a render-space position to screen-space pixel coordinates,
+ * using the battle camera's current eye and projection matrices.
+ *
+ * @param battle The battle scene data holding the camera matrices.
+ * @param renderPos The render-space position to convert.
+ * @param out Output vec2 filled with the screen-space pixel position.
+ */
+void sceneBattleWorldToScreen(
+  scenebattle_t *battle,
+  vec3 renderPos,
+  vec2 out
+);
+
+/**
+ * Computes the render-space position of a fighter's feet, laying out
+ * each team as an evenly spaced row facing the camera.
+ *
+ * @param fighterIndex Index into BATTLE.fighters.
+ * @param out Output vec3 filled with the fighter's render-space position.
+ */
+void sceneBattleGetFighterPosition(const uint8_t fighterIndex, vec3 out);
+
+/**
+ * Draws a single fighter as a colored 1x1 quad, skipping empty slots.
+ * Color differentiates team (ally/enemy) and status (dead fighters are
+ * drawn dimmed).
+ *
+ * @param fighterIndex Index into BATTLE.fighters.
+ * @return An error if drawing failed, or errorOk() if it succeeded.
+ */
+errorret_t sceneBattleDrawFighter(const uint8_t fighterIndex);

src/dusk/scene/initial/CMakeLists.txt

@@ -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
+    sceneinitial.c
+)

src/dusk/scene/initial/sceneinitial.c

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "scene/scene.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "error/error.h"
+#include "save/save.h"
+#include "ui/frame/initial/uiinitialnocard.h"
+#include "ui/frame/initial/uiinitialcreatesave.h"
+
+static void sceneInitialCheckSave(void);
+
+static void sceneInitialCreateSaveWriteComplete(errorret_t result, void *user) {
+  if(errorIsNotOk(result)) errorCatch(errorPrint(result));
+  sceneSet(SCENE_TYPE_MAIN_MENU);
+}
+
+static void sceneInitialCreateSaveResult(const bool_t create, void *user) {
+  if(!create) {
+    sceneSet(SCENE_TYPE_MAIN_MENU);
+    return;
+  }
+
+  saveWriteSlot(SAVE_ACTIVE_SLOT, sceneInitialCreateSaveWriteComplete, NULL);
+}
+
+static void sceneInitialNoCardResult(const bool_t retry, void *user) {
+  if(retry) {
+    sceneInitialCheckSave();
+    return;
+  }
+
+  // The player explicitly acknowledged there's no save device and chose
+  // to proceed anyway - stick with that for the rest of the session (see
+  // saveMarkTemporary()'s doc comment for why this can't be un-set later).
+  saveMarkTemporary();
+  sceneSet(SCENE_TYPE_MAIN_MENU);
+}
+
+static void sceneInitialLoadComplete(errorret_t result, void *user) {
+  if(errorIsNotOk(result) || !saveIsAvailable()) {
+    errorCatch(result);
+    uiInitialNoCardOpen(sceneInitialNoCardResult, NULL);
+    return;
+  }
+
+  if(saveSlotExists(SAVE_ACTIVE_SLOT)) {
+    sceneSet(SCENE_TYPE_MAIN_MENU);
+    return;
+  }
+
+  uiInitialCreateSaveOpen(sceneInitialCreateSaveResult, NULL);
+}
+
+static void sceneInitialCheckSave(void) {
+  if(!saveIsAvailable()) {
+    uiInitialNoCardOpen(sceneInitialNoCardResult, NULL);
+    return;
+  }
+
+  if(saveIsBusy()) return;
+
+  saveLoadSlot(SAVE_ACTIVE_SLOT, sceneInitialLoadComplete, NULL);
+}
+
+errorret_t sceneInitialInit(scenedata_t *sceneData) {
+  assertNotNull(sceneData, "Scene data cannot be null");
+  memoryZero(&sceneData->initial, sizeof(sceneinitial_t));
+
+  sceneInitialCheckSave();
+
+  errorOk();
+}
+
+errorret_t sceneInitialUpdate(scenedata_t *sceneData) {
+  assertNotNull(sceneData, "Scene data cannot be null");
+  errorOk();
+}
+
+errorret_t sceneInitialRender(scenedata_t *sceneData) {
+  assertNotNull(sceneData, "Scene data cannot be null");
+  errorOk();
+}
+
+errorret_t sceneInitialDispose(scenedata_t *sceneData) {
+  assertNotNull(sceneData, "Scene data cannot be null");
+  errorOk();
+}

src/dusk/scene/initial/sceneinitial.h

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "scene/scenebase.h"
+
+// No per-scene state needed - the save globals and the two modal UI
+// elements (see ui/frame/initial/) carry everything this scene cares
+// about. A byte placeholder keeps the struct non-empty for portability.
+typedef struct {
+  uint8_t reserved;
+} sceneinitial_t;
+
+/**
+ * Initialises the initial (boot) scene - kicks off the save
+ * availability/existence check that decides which prompt, if any, to
+ * show before proceeding to the main menu.
+ *
+ * @param sceneData The scene data used for this scene.
+ * @return An error if the init failed, or errorOk() if it succeeded.
+ */
+errorret_t sceneInitialInit(scenedata_t *sceneData);
+
+/**
+ * Updates the initial scene. Currently a no-op - all the work happens in
+ * save callbacks and the two modal UI elements' own button handling.
+ *
+ * @param sceneData The scene data used for this scene.
+ * @return An error if the update failed, or errorOk() if it succeeded.
+ */
+errorret_t sceneInitialUpdate(scenedata_t *sceneData);
+
+/**
+ * Renders the initial scene. Currently a no-op - the modals draw
+ * themselves via the global UI element pipeline.
+ *
+ * @param sceneData The scene data used for this scene.
+ * @return An error if the render failed, or errorOk() if it succeeded.
+ */
+errorret_t sceneInitialRender(scenedata_t *sceneData);
+
+/**
+ * Disposes the initial scene.
+ *
+ * @param sceneData The scene data used for this scene.
+ * @return An error if the dispose failed, or errorOk() if it succeeded.
+ */
+errorret_t sceneInitialDispose(scenedata_t *sceneData);

src/dusk/scene/mainmenu/CMakeLists.txt

@@ -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
+    scenemainmenu.c
+)

src/dusk/scene/mainmenu/scenemainmenu.c

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "scenemainmenu.h"
+
+errorret_t sceneMainMenuInit(scenedata_t *sceneData) {
+  errorOk();
+}
+
+errorret_t sceneMainMenuUpdate(scenedata_t *sceneData) {
+  errorOk();
+}
+
+errorret_t sceneMainMenuRender(scenedata_t *sceneData) {
+  errorOk();
+}
+
+errorret_t sceneMainMenuDispose(scenedata_t *sceneData) {
+  errorOk();
+}

src/dusk/scene/mainmenu/scenemainmenu.h

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "scene/scenebase.h"
+
+// Empty for now -- the menu itself lives in ui/frame/mainmenu/uimainmenu.c,
+// driven by the global UI element pipeline (see uimainmenu.c's own
+// SCENE.current check for when it shows itself). A byte placeholder keeps
+// the struct non-empty for portability.
+typedef struct {
+  uint8_t reserved;
+} scenemainmenu_t;
+
+/**
+ * Initializes the main menu scene.
+ *
+ * @param sceneData The scene data used for this scene.
+ * @return An error if the init failed, or errorOk() if it succeeded.
+ */
+errorret_t sceneMainMenuInit(scenedata_t *sceneData);
+
+/**
+ * Updates the main menu scene. Currently a no-op -- the menu drives
+ * itself via the global UI element pipeline.
+ *
+ * @param sceneData The scene data used for this scene.
+ * @return An error if the update failed, or errorOk() if it succeeded.
+ */
+errorret_t sceneMainMenuUpdate(scenedata_t *sceneData);
+
+/**
+ * Renders the main menu scene. Currently a no-op -- the menu draws
+ * itself via the global UI element pipeline.
+ *
+ * @param sceneData The scene data used for this scene.
+ * @return An error if the render failed, or errorOk() if it succeeded.
+ */
+errorret_t sceneMainMenuRender(scenedata_t *sceneData);
+
+/**
+ * Disposes the main menu scene.
+ *
+ * @param sceneData The scene data used for this scene.
+ * @return An error if the dispose failed, or errorOk() if it succeeded.
+ */
+errorret_t sceneMainMenuDispose(scenedata_t *sceneData);

src/dusk/scene/scenetype.c

@@ -10,6 +10,20 @@
 scenecallbacks_t SCENE_TYPES[SCENE_TYPE_COUNT] = {
   [SCENE_TYPE_NULL] = { 0 },
 
+  [SCENE_TYPE_INITIAL] = {
+    .init = sceneInitialInit,
+    .update = sceneInitialUpdate,
+    .render = sceneInitialRender,
+    .dispose = sceneInitialDispose
+  },
+
+  [SCENE_TYPE_MAIN_MENU] = {
+    .init = sceneMainMenuInit,
+    .update = sceneMainMenuUpdate,
+    .render = sceneMainMenuRender,
+    .dispose = sceneMainMenuDispose
+  },
+
   [SCENE_TYPE_OVERWORLD] = {
     .init = sceneOverworldInit,
     .update = sceneOverworldUpdate,

src/dusk/scene/scenetype.h

@@ -7,10 +7,14 @@
 
 #pragma once
 #include "scene/scenebase.h"
+#include "scene/initial/sceneinitial.h"
+#include "scene/mainmenu/scenemainmenu.h"
 #include "scene/overworld/sceneoverworld.h"
 #include "scene/battle/scenebattle.h"
 
 typedef union scenedata_u {
+  sceneinitial_t initial;
+  scenemainmenu_t mainMenu;
   sceneoverworld_t overworld;
   scenebattle_t battle;
 } scenedata_t;
@@ -27,6 +31,8 @@ typedef struct {
 typedef enum {
   SCENE_TYPE_NULL,
 
+  SCENE_TYPE_INITIAL,
+  SCENE_TYPE_MAIN_MENU,
   SCENE_TYPE_OVERWORLD,
   SCENE_TYPE_BATTLE,
 

src/dusk/ui/frame/CMakeLists.txt

@@ -10,6 +10,8 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
 )
 
 add_subdirectory(game)
+add_subdirectory(mainmenu)
 add_subdirectory(settings)
 add_subdirectory(battle)
 add_subdirectory(backpack)
+add_subdirectory(initial)

src/dusk/ui/frame/battle/CMakeLists.txt

@@ -6,4 +6,5 @@
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     uibattlemenu.c
+    uibattlehud.c
 )

src/dusk/ui/frame/battle/uibattlehud.c

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "uibattlehud.h"
+#include "rpg/battle/battle.h"
+#include "scene/battle/scenebattle.h"
+#include "scene/scene.h"
+#include "display/text/text.h"
+#include "display/color.h"
+#include "display/spritebatch/spritebatch.h"
+#include "util/string.h"
+
+#define UI_BATTLE_HUD_TEXT_MAX 32
+#define UI_BATTLE_HUD_LINE_HEIGHT 12.0f
+
+errorret_t uiBattleHudDraw(void) {
+  if(BATTLE.state == BATTLE_STATE_NONE) errorOk();
+
+  scenebattle_t *battle = &SCENE.data.battle;
+
+  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
+    const battlefighter_t *fighter = &BATTLE.fighters[i];
+    if(fighter->status == BATTLE_FIGHTER_STATUS_NULL) continue;
+
+    vec3 position;
+    sceneBattleGetFighterPosition(i, position);
+    glm_vec3_add(position, (vec3){ 0.5f, 1.3f, 0.0f }, position);
+
+    vec2 screenPos;
+    sceneBattleWorldToScreen(battle, position, screenPos);
+
+    char_t hpText[UI_BATTLE_HUD_TEXT_MAX];
+    stringFormat(
+      hpText, UI_BATTLE_HUD_TEXT_MAX - 1, "HP %u/%u",
+      fighter->health, fighter->healthMax
+    );
+    errorChain(textDraw(screenPos[0], screenPos[1], hpText, COLOR_WHITE, NULL));
+
+    char_t mpText[UI_BATTLE_HUD_TEXT_MAX];
+    stringFormat(
+      mpText, UI_BATTLE_HUD_TEXT_MAX - 1, "MP %u/%u",
+      fighter->mp, fighter->mpMax
+    );
+    errorChain(textDraw(
+      screenPos[0], screenPos[1] + UI_BATTLE_HUD_LINE_HEIGHT,
+      mpText, COLOR_CYAN, NULL
+    ));
+  }
+
+  errorChain(spriteBatchFlush());
+  errorOk();
+}

src/dusk/ui/frame/battle/uibattlehud.h

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+
+/**
+ * Draws each living battle fighter's HP/MP as text above its position in
+ * the battle scene. No-op if no battle is active.
+ *
+ * @return An error if drawing failed, or errorOk() if it succeeded.
+ */
+errorret_t uiBattleHudDraw(void);

src/dusk/ui/frame/game/uigamemenu.c

@@ -7,18 +7,95 @@
 
 #include "uigamemenu.h"
 #include "ui/frame/uiframe.h"
+#include "ui/frame/uiconfirm.h"
 #include "ui/frame/settings/uisettings.h"
 #include "ui/frame/backpack/uibackpack.h"
+#include "ui/rpg/textbox/uitextboxmain.h"
 #include "util/memory.h"
 #include "display/spritebatch/spritebatch.h"
 #include "display/screen/screen.h"
 #include "assert/assert.h"
 #include "locale/localemanager.h"
 #include "asset/loader/locale/assetlocaleloader.h"
+#include "save/save.h"
+#include "error/error.h"
+#include "util/string.h"
 
 #define UI_GAME_MENU_INDEX_CHARACTERS 0
 #define UI_GAME_MENU_INDEX_ITEMS 1
 #define UI_GAME_MENU_INDEX_SETTINGS 2
+#define UI_GAME_MENU_INDEX_SAVE 3
+
+static void uiGameMenuSaveWriteComplete(errorret_t result, void *user) {
+  if(errorIsNotOk(result)) {
+    // Generously sized - stringFormat asserts (crashes) rather than
+    // truncating if the message doesn't fit, so this must comfortably fit
+    // the longest platform save-error message plus this prefix.
+    char_t msg[256];
+    stringFormat(
+      msg, sizeof(msg), UI_GAME_MENU.saveFailedFormat, result.state->message
+    );
+    errorCatch(result);
+    uiTextboxMainSetText(msg);
+    return;
+  }
+
+  uiTextboxMainSetText(UI_GAME_MENU.saveSuccessText);
+}
+
+static void uiGameMenuSaveCreateConfirmed(const bool_t confirmed, void *user) {
+  if(!confirmed) {
+    uiTextboxMainSetText(UI_GAME_MENU.saveCancelledText);
+    return;
+  }
+
+  saveWriteSlot(SAVE_ACTIVE_SLOT, uiGameMenuSaveWriteComplete, NULL);
+}
+
+// Determines whether there's actually save data to overwrite (not just
+// whether the medium is present) by attempting a real load first - this is
+// what lets a fresh memory card/stick, with no prior save on it yet, be
+// told apart from one that already has our data on it. Cheap either way
+// (a single sector/file read), and correct on every platform without any
+// platform-specific UI code - saveSlotExists() already reflects each
+// platform's own notion of "found something."
+static void uiGameMenuSaveCheckComplete(errorret_t result, void *user) {
+  if(errorIsNotOk(result)) {
+    char_t msg[256];
+    stringFormat(
+      msg, sizeof(msg), UI_GAME_MENU.saveCheckFailedFormat,
+      result.state->message
+    );
+    errorCatch(result);
+    uiTextboxMainSetText(msg);
+    return;
+  }
+
+  if(saveSlotExists(SAVE_ACTIVE_SLOT)) {
+    saveWriteSlot(SAVE_ACTIVE_SLOT, uiGameMenuSaveWriteComplete, NULL);
+    return;
+  }
+
+  uiConfirmOpen(
+    UI_GAME_MENU.saveCreateConfirmText,
+    uiGameMenuSaveCreateConfirmed,
+    NULL
+  );
+}
+
+static void uiGameMenuSave(void) {
+  if(saveIsTemporary()) {
+    uiTextboxMainSetText(UI_GAME_MENU.saveTemporaryText);
+    return;
+  }
+  if(!saveIsAvailable()) {
+    uiTextboxMainSetText(UI_GAME_MENU.saveUnavailableText);
+    return;
+  }
+  if(saveIsBusy()) return;// A save/load dialog (e.g. on PSP) is already up.
+
+  saveLoadSlot(SAVE_ACTIVE_SLOT, uiGameMenuSaveCheckComplete, NULL);
+}
 
 uigamemenu_t UI_GAME_MENU;
 
@@ -29,6 +106,7 @@ void uiGameMenuSelected(
 ) {
   if(index == UI_GAME_MENU_INDEX_ITEMS) uiBackpackOpen();
   if(index == UI_GAME_MENU_INDEX_SETTINGS) uiSettingsOpen();
+  if(index == UI_GAME_MENU_INDEX_SAVE) uiGameMenuSave();
 }
 
 errorret_t uiGameMenuInit(void) {
@@ -55,6 +133,62 @@ errorret_t uiGameMenuInit(void) {
     UI_GAME_MENU.settingsLabel,
     UI_GAME_MENU_LABEL_MAX
   ));
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.game_menu.save",
+    0,
+    UI_GAME_MENU.saveLabel,
+    UI_GAME_MENU_LABEL_MAX
+  ));
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.game_menu.save_success",
+    0,
+    UI_GAME_MENU.saveSuccessText,
+    UI_GAME_MENU_MESSAGE_MAX
+  ));
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.game_menu.save_cancelled",
+    0,
+    UI_GAME_MENU.saveCancelledText,
+    UI_GAME_MENU_MESSAGE_MAX
+  ));
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.game_menu.save_unavailable",
+    0,
+    UI_GAME_MENU.saveUnavailableText,
+    UI_GAME_MENU_MESSAGE_MAX
+  ));
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.game_menu.save_temporary",
+    0,
+    UI_GAME_MENU.saveTemporaryText,
+    UI_GAME_MENU_MESSAGE_MAX
+  ));
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.game_menu.save_create_confirm",
+    0,
+    UI_GAME_MENU.saveCreateConfirmText,
+    UI_GAME_MENU_MESSAGE_MAX
+  ));
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.game_menu.save_failed_format",
+    0,
+    UI_GAME_MENU.saveFailedFormat,
+    UI_GAME_MENU_MESSAGE_MAX
+  ));
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.game_menu.save_check_failed_format",
+    0,
+    UI_GAME_MENU.saveCheckFailedFormat,
+    UI_GAME_MENU_MESSAGE_MAX
+  ));
 
   MENU_BEGIN(
     &UI_GAME_MENU.menu, UI_GAME_MENU.items, uiGameMenuSelected, NULL, NULL
@@ -62,6 +196,7 @@ errorret_t uiGameMenuInit(void) {
   MENU_BUTTON(UI_GAME_MENU.charactersLabel);
   MENU_BUTTON(UI_GAME_MENU.itemsLabel);
   MENU_BUTTON(UI_GAME_MENU.settingsLabel);
+  MENU_BUTTON(UI_GAME_MENU.saveLabel);
 
   MENU_END(UI_GAME_MENU.items, 1);
 

src/dusk/ui/frame/game/uigamemenu.h

@@ -9,9 +9,10 @@
 #include "error/error.h"
 #include "ui/widget/uimenu.h"
 
-#define UI_GAME_MENU_ITEM_COUNT 3
+#define UI_GAME_MENU_ITEM_COUNT 4
 #define UI_GAME_MENU_WIDTH 150.0f
 #define UI_GAME_MENU_LABEL_MAX 32
+#define UI_GAME_MENU_MESSAGE_MAX 192
 
 typedef struct {
   uimenu_t menu;
@@ -19,6 +20,14 @@ typedef struct {
   char_t charactersLabel[UI_GAME_MENU_LABEL_MAX];
   char_t itemsLabel[UI_GAME_MENU_LABEL_MAX];
   char_t settingsLabel[UI_GAME_MENU_LABEL_MAX];
+  char_t saveLabel[UI_GAME_MENU_LABEL_MAX];
+  char_t saveSuccessText[UI_GAME_MENU_MESSAGE_MAX];
+  char_t saveCancelledText[UI_GAME_MENU_MESSAGE_MAX];
+  char_t saveUnavailableText[UI_GAME_MENU_MESSAGE_MAX];
+  char_t saveTemporaryText[UI_GAME_MENU_MESSAGE_MAX];
+  char_t saveCreateConfirmText[UI_GAME_MENU_MESSAGE_MAX];
+  char_t saveFailedFormat[UI_GAME_MENU_MESSAGE_MAX];
+  char_t saveCheckFailedFormat[UI_GAME_MENU_MESSAGE_MAX];
 } uigamemenu_t;
 
 extern uigamemenu_t UI_GAME_MENU;

src/dusk/ui/frame/initial/CMakeLists.txt

@@ -0,0 +1,10 @@
+# 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
+    uiinitialnocard.c
+    uiinitialcreatesave.c
+)

src/dusk/ui/frame/initial/uiinitialcreatesave.c

@@ -0,0 +1,150 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "uiinitialcreatesave.h"
+#include "ui/frame/uiframe.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "util/math.h"
+#include "display/screen/screen.h"
+#include "display/text/text.h"
+#include "display/color.h"
+#include "display/spritebatch/spritebatch.h"
+#include "display/texture/texture.h"
+#include "display/shader/shaderunlit.h"
+#include "locale/localemanager.h"
+#include "asset/loader/locale/assetlocaleloader.h"
+
+#define UI_INITIAL_CREATE_SAVE_BACKDROP_COLOR color4b(0, 0, 0, 160)
+
+uiinitialcreatesave_t UI_INITIAL_CREATE_SAVE;
+
+static void uiInitialCreateSaveSelected(
+  const uimenu_t *menu,
+  const uint8_t index,
+  const uimenuitem_t *item
+) {
+  UI_INITIAL_CREATE_SAVE.create = index == UI_INITIAL_CREATE_SAVE_INDEX_YES;
+  uiInitialCreateSaveClose();
+}
+
+static void uiInitialCreateSaveClosed(const uimenu_t *menu) {
+  if(UI_INITIAL_CREATE_SAVE.callback != NULL) {
+    UI_INITIAL_CREATE_SAVE.callback(
+      UI_INITIAL_CREATE_SAVE.create, UI_INITIAL_CREATE_SAVE.user
+    );
+  }
+}
+
+errorret_t uiInitialCreateSaveInit(void) {
+  memoryZero(&UI_INITIAL_CREATE_SAVE, sizeof(uiinitialcreatesave_t));
+
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.initial.create_save.message",
+    0,
+    UI_INITIAL_CREATE_SAVE.text,
+    UI_INITIAL_CREATE_SAVE_TEXT_MAX
+  ));
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.initial.create_save.yes",
+    0,
+    UI_INITIAL_CREATE_SAVE.yesLabel,
+    UI_INITIAL_CREATE_SAVE_LABEL_MAX
+  ));
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.initial.create_save.no",
+    0,
+    UI_INITIAL_CREATE_SAVE.noLabel,
+    UI_INITIAL_CREATE_SAVE_LABEL_MAX
+  ));
+
+  MENU_BEGIN(
+    &UI_INITIAL_CREATE_SAVE.menu, UI_INITIAL_CREATE_SAVE.items,
+    uiInitialCreateSaveSelected, uiInitialCreateSaveClosed, NULL
+  );
+  MENU_BUTTON(UI_INITIAL_CREATE_SAVE.yesLabel);
+  MENU_BUTTON(UI_INITIAL_CREATE_SAVE.noLabel);
+
+  MENU_END(UI_INITIAL_CREATE_SAVE.items, menuIndex);
+
+  errorOk();
+}
+
+errorret_t uiInitialCreateSaveDraw(void) {
+  if(!uiMenuIsActive(&UI_INITIAL_CREATE_SAVE.menu)) errorOk();
+
+  spritebatchsprite_t backdropSprite = {
+    .min = { 0.0f, 0.0f, 0.0f },
+    .max = { (float_t)SCREEN.width, (float_t)SCREEN.height, 0.0f },
+    .uvMin = { 0.0f, 0.0f },
+    .uvMax = { 1.0f, 1.0f }
+  };
+  shadermaterial_t backdropMaterial = {
+    .unlit = {
+      .color = UI_INITIAL_CREATE_SAVE_BACKDROP_COLOR,
+      .texture = &TEXTURE_WHITE
+    }
+  };
+  errorChain(
+    spriteBatchBuffer(&backdropSprite, 1, &SHADER_UNLIT, backdropMaterial)
+  );
+  errorChain(spriteBatchFlush());
+
+  int32_t textW, textH;
+  textMeasure(UI_INITIAL_CREATE_SAVE.text, &FONT_DEFAULT, &textW, &textH);
+
+  float_t rowHeight = (float_t)FONT_DEFAULT.tileset->tileHeight;
+  float_t width = mathMax(
+    (float_t)textW + (UI_FRAME_START_X * 2), UI_INITIAL_CREATE_SAVE_MIN_WIDTH
+  );
+  float_t height = (UI_FRAME_START_Y * 2) + rowHeight + UI_FRAME_PADDING_Y +
+    rowHeight;
+  float_t x = (float_t)SCREEN.scanX + ((float_t)SCREEN.scanWidth - width) * 0.5f;
+  float_t y = (float_t)SCREEN.scanY + ((float_t)SCREEN.scanHeight - height) * 0.5f;
+
+  errorChain(uiFrameDraw(x, y, width, height));
+
+  float_t contentX = x + UI_FRAME_START_X;
+  float_t contentY = y + UI_FRAME_START_Y;
+  float_t contentWidth = width - (UI_FRAME_START_X * 2);
+
+  errorChain(textDraw(
+    contentX, contentY, UI_INITIAL_CREATE_SAVE.text, COLOR_WHITE, &FONT_DEFAULT
+  ));
+
+  float_t buttonsY = contentY + rowHeight + UI_FRAME_PADDING_Y;
+  errorChain(uiMenuDraw(
+    &UI_INITIAL_CREATE_SAVE.menu, contentX, buttonsY, contentWidth, rowHeight
+  ));
+
+  errorChain(spriteBatchFlush());
+  errorOk();
+}
+
+bool_t uiInitialCreateSaveIsOpen(void) {
+  return uiMenuIsActive(&UI_INITIAL_CREATE_SAVE.menu);
+}
+
+void uiInitialCreateSaveOpen(
+  uiinitialcreatesavecallback_t callback, void *user
+) {
+  UI_INITIAL_CREATE_SAVE.callback = callback;
+  UI_INITIAL_CREATE_SAVE.user = user;
+  UI_INITIAL_CREATE_SAVE.create = false;
+  uiMenuOpen(&UI_INITIAL_CREATE_SAVE.menu);
+}
+
+void uiInitialCreateSaveClose(void) {
+  uiMenuClose(&UI_INITIAL_CREATE_SAVE.menu);
+}
+
+errorret_t uiInitialCreateSaveDispose(void) {
+  errorOk();
+}

src/dusk/ui/frame/initial/uiinitialcreatesave.h

@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "ui/widget/uimenu.h"
+
+#define UI_INITIAL_CREATE_SAVE_INDEX_YES 0
+#define UI_INITIAL_CREATE_SAVE_INDEX_NO 1
+#define UI_INITIAL_CREATE_SAVE_ITEM_COUNT 2
+#define UI_INITIAL_CREATE_SAVE_MIN_WIDTH 160.0f
+#define UI_INITIAL_CREATE_SAVE_TEXT_MAX 256
+#define UI_INITIAL_CREATE_SAVE_LABEL_MAX 32
+
+/**
+ * Callback invoked once the create-save modal is dismissed.
+ *
+ * @param create True if Yes was selected, false if No was selected or
+ *   the dialog was backed out of.
+ * @param user Arbitrary pointer passed to uiInitialCreateSaveOpen.
+ */
+typedef void (*uiinitialcreatesavecallback_t)(const bool_t create, void *user);
+
+typedef struct {
+  uimenu_t menu;
+  uimenuitem_t items[UI_INITIAL_CREATE_SAVE_ITEM_COUNT];
+  uiinitialcreatesavecallback_t callback;
+  void *user;
+  bool_t create;
+  char_t text[UI_INITIAL_CREATE_SAVE_TEXT_MAX];
+  char_t yesLabel[UI_INITIAL_CREATE_SAVE_LABEL_MAX];
+  char_t noLabel[UI_INITIAL_CREATE_SAVE_LABEL_MAX];
+} uiinitialcreatesave_t;
+
+extern uiinitialcreatesave_t UI_INITIAL_CREATE_SAVE;
+
+/**
+ * Initializes the create-save modal.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiInitialCreateSaveInit(void);
+
+/**
+ * Draws the create-save modal: a semi-transparent black backdrop covering
+ * the whole screen, then its own centered frame with a fixed message and
+ * Yes/No buttons. No-op when not open.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiInitialCreateSaveDraw(void);
+
+/**
+ * Returns true when the modal is currently open.
+ *
+ * @return True if open.
+ */
+bool_t uiInitialCreateSaveIsOpen(void);
+
+/**
+ * Opens the create-save modal. callback is invoked exactly once with the
+ * result, whether dismissed by selecting a button or backing out.
+ *
+ * @param callback Called with the result once the modal closes. May be
+ *   NULL.
+ * @param user Arbitrary pointer passed through to callback.
+ */
+void uiInitialCreateSaveOpen(uiinitialcreatesavecallback_t callback, void *user);
+
+/**
+ * Closes the modal. No-op when already closed.
+ */
+void uiInitialCreateSaveClose(void);
+
+/**
+ * Disposes of the modal.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiInitialCreateSaveDispose(void);