Only update overworld entities while the overworld scene is active

Entities (and the player's pause-to-open-game-menu handling with them)
previously kept updating every frame regardless of the active scene,
matching an existing TODO in rpgUpdate(). Gating the entity loop itself
means the game menu (and any other entity-driven input) naturally can't
trigger mid-battle or before the initial scene hands off to the
overworld, without needing a scene check at each individual call site.

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

CLAUDE.md

@@ -1,453 +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         |
-| `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)
-src/dusksdl2/      SDL2 window + input (Linux, Knulli, PSP)
-src/dusklinux/     Linux + Knulli platform impl
-src/duskpsp/       PSP 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`.

ROADMAP.md

@@ -1,55 +0,0 @@
-# Dusk Roadmap
-
-Tracking upcoming milestones for the engine.
-
-## Upcoming milestones
-
-1. Add a very basic physics engine, moving away from the current
-   tile-based movement.
-2. Give entities full freedom of movement (no longer locked to tile
-   grid positions).
-3. Update entity interaction, triggers, chunk management, and other
-   systems that currently assume tile-based positioning so they work
-   with the new 3D positioning/movement code.
-4. Investigate and fix poor UI rendering performance. Rendering the
-   console alone tanks framerate despite the existing mesh
-   optimizations, so there is likely more headroom to find in the
-   vertex/text rendering path.
-5. Create UI elements for displaying status indicators, e.g. network
-   connection state and save-in-progress.
-6. Fully test saving end-to-end on all supported platforms.
-7. Remove the tile system from chunks in favor of meshes, with
-   dynamic hitboxes per chunk loaded in from the chunk file data.
-8. Create UI elements for network status: a connecting modal, an
-   error state, and a connected flag. Retire the test HTTP request
-   once these are in place.
-9. Build the socket server and client implementation, including
-   handlers for the different packet types.
-10. Add a dedicated multiplayer entity type, `clientplayer`, alongside
-    the existing `npc` and `player` types. Limit to 8 (defined
-    constant) for now.
-11. Send and receive `clientplayer` position over the network.
-12. Create a UI menu for creating a server and joining a server. For
-    now, join IPs are hard-coded (testing against a fixed IP of
-    10.0.0.94).
-13. Create "handshake" packets. For now, just send the username,
-    enforced to be under 10 characters long.
-14. Server tracks all players' positions and broadcasts them to all
-    connected clients.
-15. Server sends disconnect packets for users who leave.
-16. Server assigns each client a UUID; all clients know every other
-    client's UUID (used to reference them across position updates,
-    disconnect packets, etc).
-17. Server notifies all clients (by UUID) when a user joins, leaves,
-    or is disconnected, so clients can spawn or remove the
-    corresponding `clientplayer` entity in the world.
-
-## Principles
-
-- Never trust the network implicitly. Neither side (server or client)
-  should assume the other's packets are well-formed or benign --
-  validate all incoming packet data defensively, since either side
-  may send garbage or malicious data. Use `errorret_t` /
-  `errorThrow()` for these runtime checks, not assert macros --
-  asserts are debug-only and won't guard release builds against
-  malformed or malicious packet data.

assets/locale/en_US.po

@@ -56,6 +56,10 @@ msgstr "Items"
 msgid "ui.game_menu.settings"
 msgstr "Settings"
 
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save"
+msgstr "Save"
+
 msgid "item.potion.name"
 msgstr "Potion"
 

assets/locale/es_MX.po

@@ -57,6 +57,10 @@ 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/rpg/item/item.json
 msgid "item.potion.name"
 msgstr "Poción"

assets/locale/jp_JP.po

@@ -57,6 +57,10 @@ msgstr "アイテム"
 msgid "ui.game_menu.settings"
 msgstr "設定"
 
+#: src/dusk/ui/frame/game/uigamemenu.c
+msgid "ui.game_menu.save"
+msgstr "セーブ"
+
 #: src/dusk/rpg/item/item.json
 msgid "item.potion.name"
 msgstr "ポーション"

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

cmake/targets/vita.cmake

@@ -0,0 +1,88 @@
+# Copyright (c) 2026 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+if(NOT DEFINED ENV{VITASDK})
+  message(FATAL_ERROR "VITASDK environment variable is not set.")
+endif()
+
+include("$ENV{VITASDK}/share/vita.cmake" REQUIRED)
+
+set(VITA_APP_NAME "Dusk")
+set(VITA_TITLEID "DUSK00001")
+set(VITA_VERSION "01.00")
+
+find_package(SDL2 REQUIRED)
+
+# Custom flags for cglm
+set(CGLM_SHARED OFF CACHE BOOL "Build cglm shared" FORCE)
+set(CGLM_STATIC ON  CACHE BOOL "Build cglm static" FORCE)
+find_package(cglm REQUIRED)
+
+# Link libraries
+target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
+  ${SDL2_LIBRARIES}
+  cglm
+  SDL2
+  SDL2main
+  zip
+  bz2
+  z
+  zstd
+  crypto
+  lzma
+  m
+  pthread
+  stdc++
+  vitaGL
+  mathneon
+  vitashark
+  kubridge_stub
+  SceAppMgr_stub
+  SceAudio_stub
+  SceCtrl_stub
+  SceCommonDialog_stub
+  SceDisplay_stub
+  SceKernelDmacMgr_stub
+  SceGxm_stub
+  SceShaccCg_stub
+  SceSysmodule_stub
+  ScePower_stub
+  SceTouch_stub
+  SceVshBridge_stub
+  SceIofilemgr_stub
+  SceShaccCgExt
+  libtaihen_stub.a
+
+
+  # SceKernel_stub
+  SceAppUtil_stub
+  SceHid_stub
+  SceRtc_stub
+)
+
+target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
+  ${SDL2_INCLUDE_DIRS}
+)
+
+target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
+  DUSK_SDL2
+  DUSK_OPENGL
+  DUSK_VITA
+  DUSK_INPUT_GAMEPAD
+  DUSK_PLATFORM_ENDIAN_LITTLE
+  DUSK_OPENGL_LEGACY
+  DUSK_DISPLAY_WIDTH=960
+  DUSK_DISPLAY_HEIGHT=544
+)
+
+# Post-build: create SELF from the ELF binary (UNSAFE = homebrew, no signing)
+vita_create_self(${DUSK_BINARY_TARGET_NAME}.self ${DUSK_BINARY_TARGET_NAME} UNSAFE)
+
+# Post-build: package SELF + assets into a .vpk installable on the Vita
+vita_create_vpk(${DUSK_BINARY_TARGET_NAME}.vpk ${VITA_TITLEID} ${DUSK_BINARY_TARGET_NAME}.self
+  VERSION ${VITA_VERSION}
+  NAME ${VITA_APP_NAME}
+  FILE ${DUSK_ASSETS_ZIP} dusk.dsk
+)

src/CMakeLists.txt

@@ -15,6 +15,11 @@ elseif(DUSK_TARGET_SYSTEM STREQUAL "psp")
   add_subdirectory(dusksdl2)
   add_subdirectory(duskgl)
 
+elseif(DUSK_TARGET_SYSTEM STREQUAL "vita")
+  add_subdirectory(duskvita)
+  add_subdirectory(dusksdl2)
+  add_subdirectory(duskgl)
+
 elseif(DUSK_TARGET_SYSTEM STREQUAL "wii" OR DUSK_TARGET_SYSTEM STREQUAL "gamecube")
   add_subdirectory(duskdolphin)
   

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

@@ -42,7 +42,6 @@ void consolePrint(const char_t *message, ...) {
     (CONSOLE_HISTORY_MAX - 1) * CONSOLE_LINE_MAX
   );
   memoryCopy(CONSOLE.line[CONSOLE_HISTORY_MAX - 1], buffer, len + 1);
-  CONSOLE.dirty = true;
 
   #ifdef DUSK_CONSOLE_POSIX
     threadMutexUnlock(&CONSOLE.printMutex);

src/dusk/console/console.h

@@ -21,11 +21,6 @@ typedef struct {
   char_t line[CONSOLE_HISTORY_MAX][CONSOLE_LINE_MAX];
   bool_t visible;
 
-  // Set whenever the history changes; consumers rendering the console
-  // (e.g. uiConsoleDraw) check and clear this to know when their own
-  // cached representation of the history needs rebuilding.
-  bool_t dirty;
-
   #ifdef DUSK_CONSOLE_POSIX
     threadmutex_t printMutex;
   #endif

src/dusk/display/shader/shader.c

@@ -21,7 +21,6 @@ errorret_t shaderInit(shader_t *shader, const shaderdefinition_t *def) {
 
 errorret_t shaderBind(shader_t *shader) {
   assertNotNull(shader, "Shader cannot be null");
-  if(bound == shader) errorOk();
   errorChain(shaderBindPlatform(shader));
   bound = shader;
   errorOk();

src/dusk/engine/engine.c

@@ -17,11 +17,9 @@
 #include "ui/ui.h"
 #include "assert/assert.h"
 #include "network/network.h"
-#include "network/http/networkhttprequest.h"
 #include "system/system.h"
 #include "console/console.h"
 #include "save/save.h"
-#include "save/savesettings.h"
 
 engine_t ENGINE;
 
@@ -40,7 +38,6 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
   errorChain(inputInit());
   errorChain(assetInit());
   errorChain(saveInit());
-  errorChain(saveSettingsLoad());
   errorChain(localeManagerInit());
   errorChain(displayInit());
   errorChain(uiInit());
@@ -48,13 +45,6 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
   errorChain(networkInit());
   errorChain(sceneInit());
 
-  networkRequestConnection(
-    engineNetworkOnConnected,
-    engineNetworkOnFailed,
-    engineNetworkOnDisconnect,
-    NULL
-  );
-
   consolePrint("Engine initialized");
 
   #ifdef DUSK_ASSERTIONS_FAKED
@@ -63,7 +53,8 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
     consolePrint("Assertions real");
   #endif
 
-  sceneSet(SCENE_TYPE_OVERWORLD);
+  sceneSet(SCENE_TYPE_INITIAL);
+  
 
   errorOk();
 }
@@ -71,34 +62,18 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
 errorret_t engineUpdate(void) {
   // Order here is important.
   errorChain(networkUpdate());
+  errorChain(saveUpdate());
   timeUpdate();
-
-  if(
-    ENGINE.networkDisconnectTestPending &&
-    TIME.time >= ENGINE.networkDisconnectTestAt
-  ) {
-    ENGINE.networkDisconnectTestPending = false;
-    networkRequestDisconnection(engineNetworkDisconnectTestOnComplete, NULL);
-  }
-
-  const systemdialogtype_t dialogType = systemGetActiveDialogType();
-  if(dialogType == SYSTEM_DIALOG_TYPE_NONE) {
   inputUpdate();
   consoleUpdate();
   errorChain(rpgUpdate());
   errorChain(sceneUpdate());
   errorChain(assetUpdate());
   errorChain(uiUpdate());
-  }
 
   // Render
   errorChain(displayUpdate());
-  if(
-    dialogType == SYSTEM_DIALOG_TYPE_NONE &&
-    inputPressed(INPUT_ACTION_RAGEQUIT)
-  ) {
-    ENGINE.running = false;
-  }
+  if(inputPressed(INPUT_ACTION_RAGEQUIT)) ENGINE.running = false;
   errorOk();
 }
 
@@ -119,63 +94,3 @@ errorret_t engineDispose(void) {
 
   errorOk();
 }
-
-void engineHttpTestOnComplete(void *params, void *user) {
-  networkhttprequest_t *request = (networkhttprequest_t *)params;
-  const networkhttpresponse_t *response = &request->response;
-
-  consolePrint("frogfind.com response status: %d", response->status);
-
-  for(uint32_t i = 0; i < response->headers.count; i++) {
-    const networkhttpheader_t *header = &response->headers.headers[i];
-    consolePrint("frogfind.com header: %s: %s", header->name, header->value);
-  }
-
-  consolePrint("frogfind.com body length: %d", (int32_t)response->bodyLength);
-
-  const size_t chunkMax = CONSOLE_LINE_MAX - 32;
-  for(size_t offset = 0; offset < response->bodyLength; offset += chunkMax) {
-    size_t chunkLength = response->bodyLength - offset;
-    if(chunkLength > chunkMax) chunkLength = chunkMax;
-
-    consolePrint("frogfind.com body: %.*s",
-      (int32_t)chunkLength, (const char_t *)response->body + offset);
-  }
-}
-
-void engineHttpTestOnError(void *params, void *user) {
-  consolePrint("frogfind.com request failed");
-}
-
-void engineNetworkOnConnected(void *user) {
-  consolePrint("Network connected");
-
-  errorret_t ret = networkHttpRequest(
-    NETWORK_HTTP_METHOD_GET,
-    "http://frogfind.com",
-    NULL, 0,
-    NULL, 0,
-    NULL, 0,
-    engineHttpTestOnComplete,
-    engineHttpTestOnError,
-    NULL
-  );
-  errorCatch(errorPrint(ret));
-
-  ENGINE.networkDisconnectTestAt = TIME.time + 10.0f;
-  ENGINE.networkDisconnectTestPending = true;
-}
-
-void engineNetworkOnFailed(errorret_t error, void *user) {
-  consolePrint("Network connection failed");
-  errorCatch(errorPrint(error));
-}
-
-void engineNetworkOnDisconnect(errorret_t error, void *user) {
-  consolePrint("Network disconnected");
-  errorCatch(errorPrint(error));
-}
-
-void engineNetworkDisconnectTestOnComplete(void *user) {
-  consolePrint("Network disconnect test complete");
-}

src/dusk/engine/engine.h

@@ -16,10 +16,6 @@ typedef struct {
   int32_t argc;
   const char_t **argv;
   const char_t *version;
-
-  // Test: disconnects the network 10 seconds after it connects.
-  bool_t networkDisconnectTestPending;
-  float_t networkDisconnectTestAt;
 } engine_t;
 
 extern engine_t ENGINE;
@@ -42,51 +38,3 @@ errorret_t engineUpdate(void);
  */
 errorret_t engineDispose(void);
 
-/**
- * Logs the response status, headers and body of the frogfind.com test
- * request to the console.
- *
- * @param params The completed networkhttprequest_t.
- * @param user Unused.
- */
-void engineHttpTestOnComplete(void *params, void *user);
-
-/**
- * Logs that the frogfind.com test request failed.
- *
- * @param params The failed networkhttprequest_t.
- * @param user Unused.
- */
-void engineHttpTestOnError(void *params, void *user);
-
-/**
- * Fires the frogfind.com test request once the network connection is
- * up (some platforms, such as PSP, only bring the network stack up
- * asynchronously after networkRequestConnection is called).
- *
- * @param user Unused.
- */
-void engineNetworkOnConnected(void *user);
-
-/**
- * Logs that the network connection could not be established.
- *
- * @param error The error describing why the connection failed.
- * @param user Unused.
- */
-void engineNetworkOnFailed(errorret_t error, void *user);
-
-/**
- * Logs that the network connection was lost after having connected.
- *
- * @param error The error describing why the connection was lost.
- * @param user Unused.
- */
-void engineNetworkOnDisconnect(errorret_t error, void *user);
-
-/**
- * Logs that the 10-second test disconnect completed.
- *
- * @param user Unused.
- */
-void engineNetworkDisconnectTestOnComplete(void *user);

src/dusk/input/input.c

@@ -11,17 +11,31 @@
 #include "util/string.h"
 #include "util/math.h"
 #include "time/time.h"
+#include "event/event.h"
 
 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
@@ -83,6 +97,18 @@ void inputUpdate(void) {
 
     cur++;
   }
+
+  #ifdef DUSK_TIME_DYNAMIC
+    if(TIME.dynamicUpdate) return;
+  #endif
+
+  for(uint8_t i = INPUT_ACTION_NULL + 1; i < INPUT_ACTION_COUNT; i++) {
+    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);
+  }
 }
 
 float_t inputGetCurrentValue(const inputaction_t action) {

src/dusk/input/input.h

@@ -12,15 +12,11 @@
 
 #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,6 +8,9 @@
 #pragma once
 #include "time/time.h"
 #include "input/inputactiondefs.h"
+#include "event/event.h"
+
+#define INPUT_ACTION_CALLBACK_COUNT_MAX 4
 
 typedef struct {
   inputaction_t action;
@@ -18,6 +21,13 @@ 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/network/CMakeLists.txt

@@ -8,6 +8,3 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
     network.c
     networkinfo.c
 )
-
-# Subdirs
-add_subdirectory(http)

src/dusk/network/http/networkhttp.c

@@ -1,48 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "networkhttp.h"
-#include "networkhttprequest.h"
-#include "networkhttpthread.h"
-
-networkhttp_t NETWORK_HTTP;
-
-errorret_t networkHttpInit(void) {
-  networkHttpRequestPoolInit();
-
-  threadInit(&NETWORK_HTTP.thread, networkHttpThreadRun);
-  threadStart(&NETWORK_HTTP.thread);
-
-  errorOk();
-}
-
-errorret_t networkHttpUpdate(void) {
-  for(uint32_t i = 0; i < NETWORK_HTTP_REQUEST_COUNT_MAX; i++) {
-    networkhttprequest_t *request = &NETWORK_HTTP_REQUESTS[i];
-
-    threadMutexLock(&request->mutex);
-    const networkhttprequeststate_t state = request->state;
-    threadMutexUnlock(&request->mutex);
-
-    if(state == NETWORK_HTTP_REQUEST_STATE_DONE) {
-      eventInvoke(&request->onComplete, request);
-    } else if(state == NETWORK_HTTP_REQUEST_STATE_ERROR) {
-      eventInvoke(&request->onError, request);
-    } else {
-      continue;
-    }
-
-    networkHttpRequestReset(request);
-  }
-
-  errorOk();
-}
-
-errorret_t networkHttpDispose(void) {
-  threadStop(&NETWORK_HTTP.thread);
-  errorOk();
-}

src/dusk/network/http/networkhttp.h

@@ -1,40 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "error/error.h"
-#include "thread/thread.h"
-
-typedef struct {
-  thread_t thread;
-} networkhttp_t;
-
-extern networkhttp_t NETWORK_HTTP;
-
-/**
- * Initializes the HTTP client: prepares the request pool and starts
- * the background worker thread. Called once during engine startup.
- *
- * @return Any error that occurs.
- */
-errorret_t networkHttpInit(void);
-
-/**
- * Dispatches any requests that finished on the background thread since
- * the last call: fires onComplete/onError on the main thread, frees
- * the response, and returns the slot to the pool. Call once per frame.
- *
- * @return Any error that occurs.
- */
-errorret_t networkHttpUpdate(void);
-
-/**
- * Stops the background worker thread and disposes of the HTTP client.
- *
- * @return Any error that occurs.
- */
-errorret_t networkHttpDispose(void);

src/dusk/network/http/networkhttpheader.c

@@ -1,49 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "networkhttpheader.h"
-#include "util/memory.h"
-#include "util/string.h"
-
-void networkHttpHeaderListClear(networkhttpheaderlist_t *list) {
-  memoryZero(list, sizeof(networkhttpheaderlist_t));
-}
-
-bool_t networkHttpHeaderIsReserved(const char_t *name) {
-  return
-    stringCompareInsensitive(name, "Host") == 0 ||
-    stringCompareInsensitive(name, "Connection") == 0 ||
-    stringCompareInsensitive(name, "Content-Length") == 0;
-}
-
-void networkHttpHeaderListAdd(
-  networkhttpheaderlist_t *list,
-  const char_t *name,
-  const char_t *value,
-  const bool_t skipReserved
-) {
-  if(list->count >= NETWORK_HTTP_HEADER_COUNT_MAX) return;
-  if(skipReserved && networkHttpHeaderIsReserved(name)) return;
-
-  networkhttpheader_t *header = &list->headers[list->count];
-  stringCopy(header->name, name, NETWORK_HTTP_HEADER_NAME_MAX - 1);
-  stringCopy(header->value, value, NETWORK_HTTP_HEADER_VALUE_MAX - 1);
-  list->count++;
-}
-
-const networkhttpheader_t * networkHttpHeaderListFind(
-  const networkhttpheaderlist_t *list,
-  const char_t *name
-) {
-  for(uint32_t i = 0; i < list->count; i++) {
-    if(stringCompareInsensitive(list->headers[i].name, name) == 0) {
-      return &list->headers[i];
-    }
-  }
-
-  return NULL;
-}

src/dusk/network/http/networkhttpheader.h

@@ -1,70 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "dusk.h"
-
-#define NETWORK_HTTP_HEADER_COUNT_MAX 16
-#define NETWORK_HTTP_HEADER_NAME_MAX  64
-#define NETWORK_HTTP_HEADER_VALUE_MAX 256
-
-typedef struct {
-  char_t name[NETWORK_HTTP_HEADER_NAME_MAX];
-  char_t value[NETWORK_HTTP_HEADER_VALUE_MAX];
-} networkhttpheader_t;
-
-typedef struct {
-  networkhttpheader_t headers[NETWORK_HTTP_HEADER_COUNT_MAX];
-  uint32_t count;
-} networkhttpheaderlist_t;
-
-/**
- * Clears a header list, removing all entries.
- *
- * @param list The header list to clear.
- */
-void networkHttpHeaderListClear(networkhttpheaderlist_t *list);
-
-/**
- * Determines whether a header name is reserved, meaning it is computed
- * internally by the request writer and must not be set by the caller.
- * This is Host, Connection and Content-Length.
- *
- * @param name The header name to check, compared case-insensitively.
- * @return true if the header name is reserved.
- */
-bool_t networkHttpHeaderIsReserved(const char_t *name);
-
-/**
- * Appends a header to the list, silently doing nothing if the list is
- * already full or if skipReserved is true and the name is reserved (see
- * networkHttpHeaderIsReserved).
- *
- * @param list The header list to append to.
- * @param name The header name.
- * @param value The header value.
- * @param skipReserved If true, reserved header names are ignored.
- */
-void networkHttpHeaderListAdd(
-  networkhttpheaderlist_t *list,
-  const char_t *name,
-  const char_t *value,
-  const bool_t skipReserved
-);
-
-/**
- * Finds the first header in the list matching the given name, compared
- * case-insensitively.
- *
- * @param list The header list to search.
- * @param name The header name to search for.
- * @return Pointer to the matching header, or NULL if not found.
- */
-const networkhttpheader_t * networkHttpHeaderListFind(
-  const networkhttpheaderlist_t *list,
-  const char_t *name
-);

src/dusk/network/http/networkhttpprocess.c

@@ -1,346 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "networkhttpprocess.h"
-#include "util/memory.h"
-#include "util/string.h"
-#include "assert/assert.h"
-
-const char_t * networkHttpProcessMethodName(
-  const networkhttpmethod_t method
-) {
-  switch(method) {
-    case NETWORK_HTTP_METHOD_POST: return "POST";
-    case NETWORK_HTTP_METHOD_PUT:  return "PUT";
-    case NETWORK_HTTP_METHOD_GET:
-    default:
-      return "GET";
-  }
-}
-
-errorret_t networkHttpProcessBuildHead(
-  const networkhttprequest_t *request,
-  const networkhttpurl_t *target,
-  char_t *dest,
-  const size_t destSize,
-  size_t *outLength
-) {
-  size_t cursor = 0;
-
-  errorChain(networkHttpUrlAppend(
-    dest, destSize, &cursor, networkHttpProcessMethodName(request->method)
-  ));
-  errorChain(networkHttpUrlAppend(dest, destSize, &cursor, " "));
-  errorChain(networkHttpUrlAppend(dest, destSize, &cursor, target->path));
-  errorChain(networkHttpUrlAppend(dest, destSize, &cursor, " HTTP/1.1\r\n"));
-
-  errorChain(networkHttpUrlAppend(dest, destSize, &cursor, "Host: "));
-  errorChain(networkHttpUrlAppend(dest, destSize, &cursor, target->host));
-  errorChain(networkHttpUrlAppend(dest, destSize, &cursor, "\r\n"));
-
-  errorChain(networkHttpUrlAppend(
-    dest, destSize, &cursor, "Connection: close\r\n"
-  ));
-
-  for(uint32_t i = 0; i < request->requestHeaders.count; i++) {
-    const networkhttpheader_t *header = &request->requestHeaders.headers[i];
-    errorChain(networkHttpUrlAppend(dest, destSize, &cursor, header->name));
-    errorChain(networkHttpUrlAppend(dest, destSize, &cursor, ": "));
-    errorChain(networkHttpUrlAppend(dest, destSize, &cursor, header->value));
-    errorChain(networkHttpUrlAppend(dest, destSize, &cursor, "\r\n"));
-  }
-
-  if(request->bodyLength > 0) {
-    char_t lengthStr[24];
-    stringFormat(lengthStr, sizeof(lengthStr) - 1, "%zu", request->bodyLength);
-
-    errorChain(networkHttpUrlAppend(
-      dest, destSize, &cursor, "Content-Length: "
-    ));
-    errorChain(networkHttpUrlAppend(dest, destSize, &cursor, lengthStr));
-    errorChain(networkHttpUrlAppend(dest, destSize, &cursor, "\r\n"));
-  }
-
-  errorChain(networkHttpUrlAppend(dest, destSize, &cursor, "\r\n"));
-
-  *outLength = cursor;
-  errorOk();
-}
-
-errorret_t networkHttpProcessSendAll(
-  networksocketplatform_t *sock,
-  const uint8_t *data,
-  const size_t length
-) {
-  size_t sentTotal = 0;
-  while(sentTotal < length) {
-    size_t sent = 0;
-    errorChain(networkSocketPlatformSend(
-      sock, data + sentTotal, length - sentTotal, &sent
-    ));
-    if(sent == 0) errorThrow("Connection closed while sending data");
-    sentTotal += sent;
-  }
-
-  errorOk();
-}
-
-errorret_t networkHttpProcessReceiveHeaders(
-  networksocketplatform_t *sock,
-  char_t *headerBuf,
-  const size_t headerBufSize,
-  uint8_t *leftover,
-  const size_t leftoverBufSize,
-  size_t *outLeftoverLength
-) {
-  size_t headerLength = 0;
-  headerBuf[0] = '\0';
-
-  uint8_t chunk[NETWORK_HTTP_PROCESS_READ_CHUNK_SIZE];
-
-  for(;;) {
-    size_t received = 0;
-    errorChain(networkSocketPlatformReceive(
-      sock, chunk, sizeof(chunk), &received
-    ));
-    if(received == 0) {
-      errorThrow("Connection closed before response headers completed");
-    }
-
-    if(headerLength + received >= headerBufSize) {
-      errorThrow("Response headers too large");
-    }
-
-    memoryCopy(headerBuf + headerLength, chunk, received);
-    headerLength += received;
-    headerBuf[headerLength] = '\0';
-
-    char_t *terminator = strstr(headerBuf, "\r\n\r\n");
-    if(terminator == NULL) continue;
-
-    const size_t terminatorOffset = (size_t)(terminator - headerBuf);
-    const size_t bodyStart = terminatorOffset + 4;
-    const size_t extra = headerLength - bodyStart;
-
-    if(extra > leftoverBufSize) errorThrow("Too much body data buffered");
-    if(extra > 0) memoryCopy(leftover, headerBuf + bodyStart, extra);
-    *outLeftoverLength = extra;
-
-    // Keep the trailing "\r\n" of the last header line, drop the blank
-    // line so callers can split on "\r\n" without a special case.
-    headerBuf[terminatorOffset + 2] = '\0';
-    break;
-  }
-
-  errorOk();
-}
-
-errorret_t networkHttpProcessParseStatusLine(
-  const char_t *line,
-  uint16_t *outStatus
-) {
-  const char_t *space = strchr(line, ' ');
-  if(space == NULL) errorThrow("Malformed status line: %s", line);
-
-  char_t statusStr[4];
-  if(strlen(space + 1) < 3) errorThrow("Malformed status line: %s", line);
-  memoryCopy(statusStr, space + 1, 3);
-  statusStr[3] = '\0';
-
-  if(!stringToU16(statusStr, outStatus)) {
-    errorThrow("Malformed status code: %s", line);
-  }
-
-  errorOk();
-}
-
-void networkHttpProcessParseHeaderLine(
-  const char_t *line,
-  networkhttpheaderlist_t *outHeaders
-) {
-  const char_t *colon = strchr(line, ':');
-  if(colon == NULL) return;
-
-  const size_t nameLength = (size_t)(colon - line);
-  if(nameLength == 0 || nameLength >= NETWORK_HTTP_HEADER_NAME_MAX) return;
-
-  char_t name[NETWORK_HTTP_HEADER_NAME_MAX];
-  memoryCopy(name, line, nameLength);
-  name[nameLength] = '\0';
-
-  const char_t *valueStart = colon + 1;
-  while(*valueStart == ' ') valueStart++;
-
-  const size_t valueLength = strlen(valueStart);
-  if(valueLength >= NETWORK_HTTP_HEADER_VALUE_MAX) return;
-
-  char_t value[NETWORK_HTTP_HEADER_VALUE_MAX];
-  memoryCopy(value, valueStart, valueLength + 1);
-
-  networkHttpHeaderListAdd(outHeaders, name, value, false);
-}
-
-errorret_t networkHttpProcessParseHeaders(
-  char_t *headerBuf,
-  uint16_t *outStatus,
-  networkhttpheaderlist_t *outHeaders
-) {
-  char_t *cursor = headerBuf;
-  bool_t first = true;
-
-  for(;;) {
-    char_t *lineEnd = strstr(cursor, "\r\n");
-    const bool_t isLast = lineEnd == NULL;
-    if(lineEnd != NULL) *lineEnd = '\0';
-
-    if(first) {
-      errorChain(networkHttpProcessParseStatusLine(cursor, outStatus));
-      first = false;
-    } else if(cursor[0] != '\0') {
-      networkHttpProcessParseHeaderLine(cursor, outHeaders);
-    }
-
-    if(isLast) break;
-    cursor = lineEnd + 2;
-  }
-
-  errorOk();
-}
-
-errorret_t networkHttpProcessReadBody(
-  networksocketplatform_t *sock,
-  const networkhttpheaderlist_t *headers,
-  const uint8_t *leftover,
-  const size_t leftoverLength,
-  uint8_t **outBody,
-  size_t *outBodyLength
-) {
-  const networkhttpheader_t *contentLength =
-    networkHttpHeaderListFind(headers, "Content-Length");
-
-  if(contentLength != NULL) {
-    int64_t expected = 0;
-    if(!stringToI64(contentLength->value, &expected) || expected < 0) {
-      errorThrow("Malformed Content-Length header: %s", contentLength->value);
-    }
-
-    if(expected == 0) {
-      *outBody = NULL;
-      *outBodyLength = 0;
-      errorOk();
-    }
-
-    uint8_t *body = memoryAllocate((size_t)expected);
-    const size_t initialCopy =
-      leftoverLength < (size_t)expected ? leftoverLength : (size_t)expected;
-    if(initialCopy > 0) memoryCopy(body, leftover, initialCopy);
-    size_t received = initialCopy;
-
-    while(received < (size_t)expected) {
-      size_t got = 0;
-      errorret_t ret = networkSocketPlatformReceive(
-        sock, body + received, (size_t)expected - received, &got
-      );
-      if(errorIsNotOk(ret)) {
-        memoryFree(body);
-        return errorChainImpl(ret, __FILE__, __func__, __LINE__);
-      }
-      if(got == 0) {
-        memoryFree(body);
-        errorThrow("Connection closed before full body was received");
-      }
-      received += got;
-    }
-
-    *outBody = body;
-    *outBodyLength = (size_t)expected;
-    errorOk();
-  }
-
-  // No Content-Length: read until the connection closes.
-  size_t capacity = NETWORK_HTTP_PROCESS_BODY_INITIAL_SIZE;
-  if(leftoverLength > capacity) capacity = leftoverLength;
-
-  uint8_t *body = memoryAllocate(capacity);
-  size_t length = 0;
-  if(leftoverLength > 0) {
-    memoryCopy(body, leftover, leftoverLength);
-    length = leftoverLength;
-  }
-
-  for(;;) {
-    if(length == capacity) {
-      const size_t newCapacity = capacity * 2;
-      memoryResize((void **)&body, capacity, newCapacity);
-      capacity = newCapacity;
-    }
-
-    size_t got = 0;
-    errorret_t ret = networkSocketPlatformReceive(
-      sock, body + length, capacity - length, &got
-    );
-    if(errorIsNotOk(ret)) {
-      memoryFree(body);
-      return errorChainImpl(ret, __FILE__, __func__, __LINE__);
-    }
-    if(got == 0) break;
-    length += got;
-  }
-
-  *outBody = body;
-  *outBodyLength = length;
-  errorOk();
-}
-
-errorret_t networkHttpProcessAttempt(
-  const networkhttprequest_t *request,
-  const networkhttpurl_t *target,
-  networkhttpresponse_t *outResponse
-) {
-  memoryZero(outResponse, sizeof(networkhttpresponse_t));
-
-  networksocketplatform_t sock;
-  errorChain(networkSocketPlatformConnect(&sock, target->host, target->port));
-
-  char_t head[NETWORK_HTTP_PROCESS_HEAD_BUF_SIZE];
-  size_t headLength = 0;
-  networkHttpProcessErrorChain(&sock, networkHttpProcessBuildHead(
-    request, target, head, NETWORK_HTTP_PROCESS_HEAD_BUF_SIZE, &headLength
-  ));
-
-  networkHttpProcessErrorChain(&sock, networkHttpProcessSendAll(
-    &sock, (const uint8_t *)head, headLength
-  ));
-
-  if(request->bodyLength > 0) {
-    networkHttpProcessErrorChain(&sock, networkHttpProcessSendAll(
-      &sock, request->body, request->bodyLength
-    ));
-  }
-
-  char_t headerBuf[NETWORK_HTTP_PROCESS_HEADER_BUF_SIZE];
-  uint8_t leftover[NETWORK_HTTP_PROCESS_READ_CHUNK_SIZE];
-  size_t leftoverLength = 0;
-
-  networkHttpProcessErrorChain(&sock, networkHttpProcessReceiveHeaders(
-    &sock, headerBuf, NETWORK_HTTP_PROCESS_HEADER_BUF_SIZE,
-    leftover, NETWORK_HTTP_PROCESS_READ_CHUNK_SIZE, &leftoverLength
-  ));
-
-  networkHttpProcessErrorChain(&sock, networkHttpProcessParseHeaders(
-    headerBuf, &outResponse->status, &outResponse->headers
-  ));
-
-  errorret_t bodyRet = networkHttpProcessReadBody(
-    &sock, &outResponse->headers, leftover, leftoverLength,
-    &outResponse->body, &outResponse->bodyLength
-  );
-  networkSocketPlatformClose(&sock);
-  errorChain(bodyRet);
-
-  errorOk();
-}

src/dusk/network/http/networkhttpprocess.h

@@ -1,185 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "error/error.h"
-#include "network/http/networkhttprequest.h"
-#include "network/http/networkhttpurl.h"
-#include "network/networksocketplatform.h"
-
-#define NETWORK_HTTP_PROCESS_HEAD_BUF_SIZE     4096
-#define NETWORK_HTTP_PROCESS_HEADER_BUF_SIZE   8192
-#define NETWORK_HTTP_PROCESS_READ_CHUNK_SIZE   2048
-#define NETWORK_HTTP_PROCESS_BODY_INITIAL_SIZE 4096
-
-/**
- * Shorthand to chain an error, closing sock first if expr failed. Used
- * for every step of an attempt after the socket has connected, since
- * failing partway through must not leak the socket.
- */
-#define networkHttpProcessErrorChain(sock, _expr) { \
-  errorret_t _nhpErr = (_expr); \
-  if(errorIsNotOk(_nhpErr)) { \
-    networkSocketPlatformClose(sock); \
-    return errorChainImpl(_nhpErr, __FILE__, __func__, __LINE__); \
-  } \
-}
-
-/**
- * Returns the wire method name ("GET", "POST", "PUT") for method.
- *
- * @param method The method to name.
- * @return A static string naming the method.
- */
-const char_t * networkHttpProcessMethodName(
-  const networkhttpmethod_t method
-);
-
-/**
- * Builds the request line, headers and blank line terminator (but not
- * the body) for request, targeting target, into dest.
- *
- * @param request The request being sent.
- * @param target The resolved host/port/path for this attempt.
- * @param dest The destination buffer.
- * @param destSize The size of dest, including the null terminator.
- * @param outLength The number of bytes written is written here.
- * @return An error if the result would not fit in dest.
- */
-errorret_t networkHttpProcessBuildHead(
-  const networkhttprequest_t *request,
-  const networkhttpurl_t *target,
-  char_t *dest,
-  const size_t destSize,
-  size_t *outLength
-);
-
-/**
- * Sends length bytes of data over sock, looping until all of it has
- * been written.
- *
- * @param sock The connected socket.
- * @param data The data to send.
- * @param length The number of bytes in data.
- * @return An error if the send failed or the connection closed early.
- */
-errorret_t networkHttpProcessSendAll(
-  networksocketplatform_t *sock,
-  const uint8_t *data,
-  const size_t length
-);
-
-/**
- * Reads from sock until the blank line ("\r\n\r\n") terminating the
- * response headers has been seen, writing the status line and header
- * lines (without the blank line) into headerBuf as a null-terminated
- * string. Any body bytes read past the terminator in the same receive
- * are written to leftover.
- *
- * @param sock The connected socket.
- * @param headerBuf The destination buffer for the header text.
- * @param headerBufSize The size of headerBuf, including the null
- *        terminator.
- * @param leftover Destination buffer for any body bytes read early.
- * @param leftoverBufSize The size of leftover.
- * @param outLeftoverLength The number of bytes written to leftover is
- *        written here.
- * @return An error if the headers could not be read, were malformed,
- *         or did not fit within the given buffers.
- */
-errorret_t networkHttpProcessReceiveHeaders(
-  networksocketplatform_t *sock,
-  char_t *headerBuf,
-  const size_t headerBufSize,
-  uint8_t *leftover,
-  const size_t leftoverBufSize,
-  size_t *outLeftoverLength
-);
-
-/**
- * Parses a "HTTP/1.1 <status> <reason>" status line.
- *
- * @param line The status line, null-terminated.
- * @param outStatus The parsed status code is written here.
- * @return An error if the status line is malformed.
- */
-errorret_t networkHttpProcessParseStatusLine(
-  const char_t *line,
-  uint16_t *outStatus
-);
-
-/**
- * Parses a single "Name: Value" response header line and appends it to
- * outHeaders. Silently does nothing if the line has no colon or the
- * name/value are too long to fit a networkhttpheader_t.
- *
- * @param line The header line, null-terminated.
- * @param outHeaders The header list to append to.
- */
-void networkHttpProcessParseHeaderLine(
-  const char_t *line,
-  networkhttpheaderlist_t *outHeaders
-);
-
-/**
- * Parses the status line and every header line out of headerBuf (as
- * produced by networkHttpProcessReceiveHeaders). Mutates headerBuf in
- * place to split it into lines.
- *
- * @param headerBuf The header text to parse.
- * @param outStatus The parsed status code is written here.
- * @param outHeaders The header list to populate.
- * @return An error if the status line is malformed.
- */
-errorret_t networkHttpProcessParseHeaders(
-  char_t *headerBuf,
-  uint16_t *outStatus,
-  networkhttpheaderlist_t *outHeaders
-);
-
-/**
- * Reads the response body from sock. If headers contains a
- * Content-Length, reads exactly that many bytes; otherwise reads until
- * the connection closes. Either way, leftover/leftoverLength (body
- * bytes already read while looking for the header terminator) are
- * included at the start of the result.
- *
- * @param sock The connected socket.
- * @param headers The parsed response headers.
- * @param leftover Body bytes already read past the header terminator.
- * @param leftoverLength The number of bytes in leftover.
- * @param outBody A memoryAllocate'd buffer holding the body is written
- *        here, or NULL if the body is empty. Owned by the caller.
- * @param outBodyLength The number of bytes in *outBody is written here.
- * @return An error if the body could not be fully read.
- */
-errorret_t networkHttpProcessReadBody(
-  networksocketplatform_t *sock,
-  const networkhttpheaderlist_t *headers,
-  const uint8_t *leftover,
-  const size_t leftoverLength,
-  uint8_t **outBody,
-  size_t *outBodyLength
-);
-
-/**
- * Performs a single blocking HTTP exchange: connects to target, writes
- * the request head + body, and reads back one parsed response. Does
- * not follow redirects -- that is the caller's responsibility.
- *
- * @param request The request to send (method, headers, body).
- * @param target The resolved host/port/path to connect to for this
- *        attempt (may differ from the request's own URL if this is a
- *        redirected attempt).
- * @param outResponse The parsed response is written here on success.
- * @return An error if the exchange could not be completed.
- */
-errorret_t networkHttpProcessAttempt(
-  const networkhttprequest_t *request,
-  const networkhttpurl_t *target,
-  networkhttpresponse_t *outResponse
-);

src/dusk/network/http/networkhttprequest.c

@@ -1,121 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "networkhttprequest.h"
-#include "util/memory.h"
-#include "assert/assert.h"
-
-networkhttprequest_t NETWORK_HTTP_REQUESTS[NETWORK_HTTP_REQUEST_COUNT_MAX];
-
-void networkHttpRequestPoolInit(void) {
-  for(uint32_t i = 0; i < NETWORK_HTTP_REQUEST_COUNT_MAX; i++) {
-    networkhttprequest_t *request = &NETWORK_HTTP_REQUESTS[i];
-
-    memoryZero(request, sizeof(networkhttprequest_t));
-    threadMutexInit(&request->mutex);
-    eventInit(
-      &request->onComplete, request->onCompleteCallbacks,
-      request->onCompleteUsers, NETWORK_HTTP_REQUEST_EVENT_MAX
-    );
-    eventInit(
-      &request->onError, request->onErrorCallbacks,
-      request->onErrorUsers, NETWORK_HTTP_REQUEST_EVENT_MAX
-    );
-    request->state = NETWORK_HTTP_REQUEST_STATE_FREE;
-  }
-}
-
-networkhttprequest_t * networkHttpRequestClaim(void) {
-  for(uint32_t i = 0; i < NETWORK_HTTP_REQUEST_COUNT_MAX; i++) {
-    networkhttprequest_t *request = &NETWORK_HTTP_REQUESTS[i];
-
-    threadMutexLock(&request->mutex);
-    if(request->state != NETWORK_HTTP_REQUEST_STATE_FREE) {
-      threadMutexUnlock(&request->mutex);
-      continue;
-    }
-    threadMutexUnlock(&request->mutex);
-    return request;
-  }
-
-  assertUnreachable("No available HTTP request slots.");
-  return NULL;
-}
-
-void networkHttpRequestReset(networkhttprequest_t *request) {
-  assertNotNull(request, "request must not be NULL");
-
-  threadMutexLock(&request->mutex);
-
-  if(request->body != NULL) memoryFree(request->body);
-  request->body = NULL;
-  request->bodyLength = 0;
-
-  if(request->response.body != NULL) memoryFree(request->response.body);
-  memoryZero(&request->response, sizeof(networkhttpresponse_t));
-
-  networkHttpHeaderListClear(&request->requestHeaders);
-
-  eventInit(
-    &request->onComplete, request->onCompleteCallbacks,
-    request->onCompleteUsers, NETWORK_HTTP_REQUEST_EVENT_MAX
-  );
-  eventInit(
-    &request->onError, request->onErrorCallbacks,
-    request->onErrorUsers, NETWORK_HTTP_REQUEST_EVENT_MAX
-  );
-
-  request->state = NETWORK_HTTP_REQUEST_STATE_FREE;
-
-  threadMutexUnlock(&request->mutex);
-}
-
-errorret_t networkHttpRequest(
-  const networkhttpmethod_t method,
-  const char_t *url,
-  const networkhttpheader_t *headers,
-  const uint32_t headerCount,
-  const networkhttpheader_t *queryParams,
-  const uint32_t queryParamCount,
-  const uint8_t *body,
-  const size_t bodyLength,
-  const eventcallback_t onComplete,
-  const eventcallback_t onError,
-  void *user
-) {
-  assertNotNull(url, "url must not be NULL");
-
-  networkhttprequest_t *request = networkHttpRequestClaim();
-  request->method = method;
-
-  errorChain(networkHttpUrlBuild(
-    request->url, NETWORK_HTTP_URL_MAX, url, queryParams, queryParamCount
-  ));
-
-  networkHttpHeaderListClear(&request->requestHeaders);
-  for(uint32_t i = 0; i < headerCount; i++) {
-    networkHttpHeaderListAdd(
-      &request->requestHeaders, headers[i].name, headers[i].value, true
-    );
-  }
-
-  request->bodyLength = bodyLength;
-  if(bodyLength > 0) {
-    assertNotNull(body, "body must not be NULL when bodyLength > 0");
-    request->body = memoryAllocate(bodyLength);
-    memoryCopy(request->body, body, bodyLength);
-  }
-
-  if(onComplete != NULL) eventSubscribe(&request->onComplete, onComplete, user);
-  if(onError != NULL) eventSubscribe(&request->onError, onError, user);
-
-  threadMutexLock(&request->mutex);
-  request->state = NETWORK_HTTP_REQUEST_STATE_PENDING;
-  threadMutexUnlock(&request->mutex);
-
-  errorOk();
-}

src/dusk/network/http/networkhttprequest.h

@@ -1,137 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "error/error.h"
-#include "event/event.h"
-#include "thread/threadmutex.h"
-#include "network/http/networkhttpheader.h"
-#include "network/http/networkhttpurl.h"
-
-#define NETWORK_HTTP_REQUEST_COUNT_MAX 4
-#define NETWORK_HTTP_REQUEST_EVENT_MAX 1
-
-typedef enum {
-  NETWORK_HTTP_METHOD_GET,
-  NETWORK_HTTP_METHOD_POST,
-  NETWORK_HTTP_METHOD_PUT
-} networkhttpmethod_t;
-
-typedef enum {
-  NETWORK_HTTP_REQUEST_STATE_FREE,
-  NETWORK_HTTP_REQUEST_STATE_PENDING,
-  NETWORK_HTTP_REQUEST_STATE_ACTIVE,
-  NETWORK_HTTP_REQUEST_STATE_DONE,
-  NETWORK_HTTP_REQUEST_STATE_ERROR
-} networkhttprequeststate_t;
-
-typedef struct {
-  uint16_t status;
-  networkhttpheaderlist_t headers;
-
-  // Owned, memoryAllocate'd. Only valid until the onComplete/onError
-  // event has finished firing, at which point it is freed.
-  uint8_t *body;
-  size_t bodyLength;
-} networkhttpresponse_t;
-
-typedef struct {
-  threadmutex_t mutex;
-  networkhttprequeststate_t state;
-
-  networkhttpmethod_t method;
-
-  // Fully built, including any query params, by networkHttpRequest.
-  char_t url[NETWORK_HTTP_URL_MAX];
-  networkhttpheaderlist_t requestHeaders;
-
-  // Owned copy, memoryAllocate'd.
-  uint8_t *body;
-  size_t bodyLength;
-
-  /** Fired on the main thread once a response has been received. */
-  event_t onComplete;
-  eventcallback_t onCompleteCallbacks[NETWORK_HTTP_REQUEST_EVENT_MAX];
-  void *onCompleteUsers[NETWORK_HTTP_REQUEST_EVENT_MAX];
-
-  /** Fired on the main thread if the request could not be completed. */
-  event_t onError;
-  eventcallback_t onErrorCallbacks[NETWORK_HTTP_REQUEST_EVENT_MAX];
-  void *onErrorUsers[NETWORK_HTTP_REQUEST_EVENT_MAX];
-
-  networkhttpresponse_t response;
-} networkhttprequest_t;
-
-extern networkhttprequest_t
-  NETWORK_HTTP_REQUESTS[NETWORK_HTTP_REQUEST_COUNT_MAX];
-
-/**
- * Initializes the request pool: prepares every slot's mutex and events
- * and marks them all FREE. Called once by networkHttpInit.
- */
-void networkHttpRequestPoolInit(void);
-
-/**
- * Finds and returns a FREE slot in the request pool. The slot is not
- * marked as in-use by this call; the caller must populate it and then
- * set its state to PENDING.
- *
- * @return A free request slot.
- */
-networkhttprequest_t * networkHttpRequestClaim(void);
-
-/**
- * Resets a request slot back to FREE, freeing any owned buffers
- * (request body, response body) and clearing its event subscribers.
- *
- * @param request The request slot to reset.
- */
-void networkHttpRequestReset(networkhttprequest_t *request);
-
-/**
- * Sends an HTTP request asynchronously. The request runs on a
- * background thread; onComplete or onError is invoked on the main
- * thread (from networkHttpUpdate) once it finishes. 301 redirects are
- * followed automatically.
- *
- * @param method The HTTP method to use.
- * @param url The "http://host[:port]/path" URL to request. Must not
- *        use any scheme other than http.
- * @param headers Request headers to send, may be NULL if headerCount
- *        is 0. The Host, Connection and Content-Length headers are
- *        reserved and computed internally; any of those passed here
- *        are ignored.
- * @param headerCount Number of entries in headers.
- * @param queryParams Query string parameters to append to url, may be
- *        NULL if queryParamCount is 0.
- * @param queryParamCount Number of entries in queryParams.
- * @param body Request body to send for POST/PUT, may be NULL if
- *        bodyLength is 0. Ignored for GET.
- * @param bodyLength Number of bytes in body.
- * @param onComplete Invoked with (networkhttprequest_t *, user) once a
- *        response has been received, whatever its status code. May be
- *        NULL to ignore.
- * @param onError Invoked with (networkhttprequest_t *, user) if the
- *        request could not be completed (DNS/connect/send/receive
- *        failure, or a malformed response). May be NULL to ignore.
- * @param user Arbitrary pointer forwarded to onComplete/onError.
- * @return An error if the request could not be queued (e.g. a
- *         malformed url).
- */
-errorret_t networkHttpRequest(
-  const networkhttpmethod_t method,
-  const char_t *url,
-  const networkhttpheader_t *headers,
-  const uint32_t headerCount,
-  const networkhttpheader_t *queryParams,
-  const uint32_t queryParamCount,
-  const uint8_t *body,
-  const size_t bodyLength,
-  const eventcallback_t onComplete,
-  const eventcallback_t onError,
-  void *user
-);

src/dusk/network/http/networkhttpthread.c

@@ -1,88 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "networkhttpthread.h"
-#include "networkhttpprocess.h"
-#include "util/memory.h"
-#include "assert/assert.h"
-#include <unistd.h>
-
-void networkHttpThreadRun(thread_t *thread) {
-  assertNotMainThread("networkHttpThreadRun must not run on the main thread.");
-
-  while(!threadShouldStop(thread)) {
-    bool_t didWork = false;
-
-    for(uint32_t i = 0; i < NETWORK_HTTP_REQUEST_COUNT_MAX; i++) {
-      networkhttprequest_t *request = &NETWORK_HTTP_REQUESTS[i];
-
-      threadMutexLock(&request->mutex);
-      if(request->state != NETWORK_HTTP_REQUEST_STATE_PENDING) {
-        threadMutexUnlock(&request->mutex);
-        continue;
-      }
-      request->state = NETWORK_HTTP_REQUEST_STATE_ACTIVE;
-      threadMutexUnlock(&request->mutex);
-
-      didWork = true;
-      networkHttpThreadProcessRequest(request);
-    }
-
-    if(threadShouldStop(thread)) break;
-    if(!didWork) usleep(1000);
-  }
-}
-
-void networkHttpThreadProcessRequest(networkhttprequest_t *request) {
-  networkhttpurl_t target;
-  errorret_t parseRet = networkHttpUrlParse(request->url, &target);
-
-  networkhttprequeststate_t finalState = NETWORK_HTTP_REQUEST_STATE_DONE;
-
-  if(errorIsNotOk(parseRet)) {
-    errorCatch(errorPrint(parseRet));
-    finalState = NETWORK_HTTP_REQUEST_STATE_ERROR;
-  } else {
-    for(uint32_t redirect = 0; ; redirect++) {
-      errorret_t ret = networkHttpProcessAttempt(
-        request, &target, &request->response
-      );
-
-      if(errorIsNotOk(ret)) {
-        errorCatch(errorPrint(ret));
-        finalState = NETWORK_HTTP_REQUEST_STATE_ERROR;
-        break;
-      }
-
-      const bool_t isRedirect = request->response.status == 301;
-      const networkhttpheader_t *location = isRedirect ?
-        networkHttpHeaderListFind(&request->response.headers, "Location") :
-        NULL;
-
-      if(location == NULL || redirect >= NETWORK_HTTP_REDIRECT_COUNT_MAX) {
-        break;
-      }
-
-      networkhttpurl_t nextTarget;
-      errorret_t nextRet = networkHttpUrlParse(location->value, &nextTarget);
-      if(errorIsNotOk(nextRet)) {
-        // Not an absolute URL we can follow -- treat the 301 itself as
-        // the final response instead of failing the whole request.
-        errorCatch(errorPrint(nextRet));
-        break;
-      }
-
-      // Free the intermediate response body before following further.
-      if(request->response.body != NULL) memoryFree(request->response.body);
-      target = nextTarget;
-    }
-  }
-
-  threadMutexLock(&request->mutex);
-  request->state = finalState;
-  threadMutexUnlock(&request->mutex);
-}

src/dusk/network/http/networkhttpthread.h

@@ -1,31 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "thread/thread.h"
-#include "network/http/networkhttprequest.h"
-
-#define NETWORK_HTTP_REDIRECT_COUNT_MAX 5
-
-/**
- * The background worker thread body: repeatedly scans the request
- * pool for PENDING slots, processes each to completion, and marks it
- * DONE or ERROR. Idles briefly when there is nothing to do. Runs
- * until the thread is stopped.
- *
- * @param thread The thread runner.
- */
-void networkHttpThreadRun(thread_t *thread);
-
-/**
- * Processes a single ACTIVE request slot to completion, following up
- * to NETWORK_HTTP_REDIRECT_COUNT_MAX HTTP 301 redirects, and leaves it
- * in the DONE or ERROR state. Only called from the background thread.
- *
- * @param request The request slot to process.
- */
-void networkHttpThreadProcessRequest(networkhttprequest_t *request);

src/dusk/network/http/networkhttpurl.c

@@ -1,136 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "networkhttpurl.h"
-#include "util/memory.h"
-#include "util/string.h"
-#include "assert/assert.h"
-
-errorret_t networkHttpUrlParse(const char_t *url, networkhttpurl_t *out) {
-  assertNotNull(url, "url must not be NULL");
-  assertNotNull(out, "out must not be NULL");
-
-  if(strlen(url) <= 7 || strncasecmp(url, "http://", 7) != 0) {
-    errorThrow("Unsupported URL scheme (only http:// is supported): %s", url);
-  }
-
-  const char_t *rest = url + 7;
-
-  const size_t hostLen = strcspn(rest, ":/");
-  if(hostLen == 0 || hostLen >= NETWORK_HTTP_HOST_MAX) {
-    errorThrow("Invalid host in URL: %s", url);
-  }
-  memoryCopy(out->host, rest, hostLen);
-  out->host[hostLen] = '\0';
-  rest += hostLen;
-
-  if(*rest == ':') {
-    rest++;
-
-    const size_t portLen = strcspn(rest, "/");
-    char_t portStr[8];
-    if(portLen == 0 || portLen >= sizeof(portStr)) {
-      errorThrow("Invalid port in URL: %s", url);
-    }
-    memoryCopy(portStr, rest, portLen);
-    portStr[portLen] = '\0';
-
-    if(!stringToU16(portStr, &out->port)) {
-      errorThrow("Invalid port in URL: %s", url);
-    }
-    rest += portLen;
-  } else {
-    out->port = NETWORK_HTTP_PORT_DEFAULT;
-  }
-
-  const char_t *path = *rest == '\0' ? "/" : rest;
-  const size_t pathLen = strlen(path);
-  if(pathLen >= NETWORK_HTTP_PATH_MAX) {
-    errorThrow("Path too long in URL: %s", url);
-  }
-  memoryCopy(out->path, path, pathLen + 1);
-
-  errorOk();
-}
-
-errorret_t networkHttpUrlBuild(
-  char_t *dest,
-  const size_t destSize,
-  const char_t *baseUrl,
-  const networkhttpheader_t *queryParams,
-  const uint32_t queryParamCount
-) {
-  assertNotNull(dest, "dest must not be NULL");
-  assertNotNull(baseUrl, "baseUrl must not be NULL");
-
-  const size_t baseLen = strlen(baseUrl);
-  if(baseLen >= destSize) errorThrow("URL too long: %s", baseUrl);
-  memoryCopy(dest, baseUrl, baseLen + 1);
-
-  size_t cursor = baseLen;
-  bool_t hasQuery = stringIncludesString(baseUrl, "?");
-
-  for(uint32_t i = 0; i < queryParamCount; i++) {
-    errorChain(networkHttpUrlAppend(
-      dest, destSize, &cursor, hasQuery ? "&" : "?"
-    ));
-    hasQuery = true;
-
-    errorChain(networkHttpUrlEncodeComponent(
-      dest, destSize, &cursor, queryParams[i].name
-    ));
-    errorChain(networkHttpUrlAppend(dest, destSize, &cursor, "="));
-    errorChain(networkHttpUrlEncodeComponent(
-      dest, destSize, &cursor, queryParams[i].value
-    ));
-  }
-
-  errorOk();
-}
-
-errorret_t networkHttpUrlAppend(
-  char_t *dest,
-  const size_t destSize,
-  size_t *cursor,
-  const char_t *str
-) {
-  const size_t len = strlen(str);
-  if(*cursor + len >= destSize) errorThrow("URL buffer too small");
-
-  memoryCopy(dest + *cursor, str, len + 1);
-  *cursor += len;
-  errorOk();
-}
-
-errorret_t networkHttpUrlEncodeComponent(
-  char_t *dest,
-  const size_t destSize,
-  size_t *cursor,
-  const char_t *src
-) {
-  const char_t *hex = "0123456789ABCDEF";
-
-  for(const char_t *p = src; *p != '\0'; p++) {
-    const uint8_t c = (uint8_t)*p;
-    const bool_t unreserved =
-      (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
-      (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == '~';
-
-    if(unreserved) {
-      if(*cursor + 1 >= destSize) errorThrow("URL buffer too small");
-      dest[(*cursor)++] = (char_t)c;
-    } else {
-      if(*cursor + 3 >= destSize) errorThrow("URL buffer too small");
-      dest[(*cursor)++] = '%';
-      dest[(*cursor)++] = hex[(c >> 4) & 0xF];
-      dest[(*cursor)++] = hex[c & 0xF];
-    }
-  }
-
-  dest[*cursor] = '\0';
-  errorOk();
-}

src/dusk/network/http/networkhttpurl.h

@@ -1,89 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "error/error.h"
-#include "network/http/networkhttpheader.h"
-
-#define NETWORK_HTTP_URL_MAX      1024
-#define NETWORK_HTTP_HOST_MAX     256
-#define NETWORK_HTTP_PATH_MAX     768
-#define NETWORK_HTTP_PORT_DEFAULT 80
-
-typedef struct {
-  char_t host[NETWORK_HTTP_HOST_MAX];
-  uint16_t port;
-
-  // Includes the leading slash and, if present, the query string.
-  char_t path[NETWORK_HTTP_PATH_MAX];
-} networkhttpurl_t;
-
-/**
- * Parses a "http://host[:port]/path[?query]" URL. Any other scheme is
- * rejected, since this client does not support TLS.
- *
- * @param url The URL to parse.
- * @param out The parsed URL is written here.
- * @return An error if the URL is malformed or uses an unsupported scheme.
- */
-errorret_t networkHttpUrlParse(const char_t *url, networkhttpurl_t *out);
-
-/**
- * Copies baseUrl into dest, then appends each queryParam as a
- * percent-encoded "key=value" pair, joined with "&" (or "?" for the
- * first one, unless baseUrl already contains a "?").
- *
- * @param dest The destination buffer.
- * @param destSize The size of dest, including the null terminator.
- * @param baseUrl The URL to copy before appending query params.
- * @param queryParams Array of query parameters to append, may be NULL if
- *        queryParamCount is 0.
- * @param queryParamCount Number of entries in queryParams.
- * @return An error if the result would not fit in dest.
- */
-errorret_t networkHttpUrlBuild(
-  char_t *dest,
-  const size_t destSize,
-  const char_t *baseUrl,
-  const networkhttpheader_t *queryParams,
-  const uint32_t queryParamCount
-);
-
-/**
- * Appends a raw (not percent-encoded) string to dest at *cursor,
- * advancing *cursor and keeping dest null-terminated.
- *
- * @param dest The destination buffer.
- * @param destSize The size of dest, including the null terminator.
- * @param cursor The current write offset into dest, updated in place.
- * @param str The string to append.
- * @return An error if the result would not fit in dest.
- */
-errorret_t networkHttpUrlAppend(
-  char_t *dest,
-  const size_t destSize,
-  size_t *cursor,
-  const char_t *str
-);
-
-/**
- * Percent-encodes src and appends it to dest at *cursor, advancing
- * *cursor and keeping dest null-terminated. Unreserved characters
- * (letters, digits, "-", "_", ".", "~") are copied as-is.
- *
- * @param dest The destination buffer.
- * @param destSize The size of dest, including the null terminator.
- * @param cursor The current write offset into dest, updated in place.
- * @param src The string to percent-encode and append.
- * @return An error if the result would not fit in dest.
- */
-errorret_t networkHttpUrlEncodeComponent(
-  char_t *dest,
-  const size_t destSize,
-  size_t *cursor,
-  const char_t *src
-);

src/dusk/network/network.c

@@ -6,7 +6,6 @@
  */
 
 #include "network.h"
-#include "network/http/networkhttp.h"
 #include "util/memory.h"
 #include "assert/assert.h"
 #include "log/log.h"
@@ -19,13 +18,11 @@ errorret_t networkInit() {
   NETWORK.errorState.code = ERROR_OK;
   NETWORK.onDisconnect = NULL;
 
-  errorChain(networkPlatformInit());
-  return networkHttpInit();
+  return networkPlatformInit();
 }
 
 errorret_t networkUpdate() {
   errorChain(networkPlatformUpdate());
-  errorChain(networkHttpUpdate());
 
   if(NETWORK.state == NETWORK_STATE_CONNECTED && !networkIsConnected()) {
     NETWORK.state = NETWORK_STATE_DISCONNECTED;
@@ -115,5 +112,5 @@ errorret_t networkDispose() {
   }
   
   errorChain(networkPlatformDispose());
-  return networkHttpDispose();
+  errorOk();
 }

src/dusk/rpg/CMakeLists.txt

@@ -11,8 +11,10 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
 )
 
 # Subdirs
+add_subdirectory(battle)
 add_subdirectory(cutscene)
 add_subdirectory(entity)
 add_subdirectory(overworld)
+
+add_subdirectory(story)
 add_subdirectory(item)
-add_subdirectory(physics)

src/dusk/rpg/battle/CMakeLists.txt

@@ -3,12 +3,10 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
+# Sources
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
-    networkhttpheader.c
-    networkhttpurl.c
-    networkhttprequest.c
-    networkhttpprocess.c
-    networkhttpthread.c
-    networkhttp.c
+    battle.c
+    battlefighter.c
+    party.c
 )

src/dusk/rpg/battle/battle.c

@@ -0,0 +1,223 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "battle.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+
+battle_t BATTLE;
+
+void battleInit(void) {
+  memoryZero(&BATTLE, sizeof(battle_t));
+  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
+    BATTLE.fighters[i].id = i;
+  }
+}
+
+uint8_t battleGetAvailableFighter(void) {
+  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
+    if(BATTLE.fighters[i].status == BATTLE_FIGHTER_STATUS_NULL) return i;
+  }
+
+  return 0xFF;
+}
+
+battlefighter_t *battleAddFighter(
+  const battlefighterteam_t team,
+  const battlefightercontroller_t controller,
+  const battlefighterstats_t stats,
+  const uint16_t healthMax,
+  const uint16_t mpMax
+) {
+  const uint8_t index = battleGetAvailableFighter();
+  if(index == 0xFF) return NULL;
+
+  battlefighter_t *fighter = &BATTLE.fighters[index];
+  battleFighterInit(fighter, team, controller, stats, healthMax, mpMax);
+  return fighter;
+}
+
+void battleStart(
+  const battleencountertype_t encounterType,
+  const bool_t fleeAvailable
+) {
+  assertTrue(encounterType < BATTLE_ENCOUNTER_COUNT, "Invalid encounter type");
+
+  BATTLE.encounterType = encounterType;
+  BATTLE.fleeAvailable = fleeAvailable;
+  BATTLE.result = BATTLE_RESULT_NONE;
+  BATTLE.round = 1;
+  BATTLE.turnIndex = 0;
+  battleBuildTurnOrder(true);
+
+  BATTLE.active = true;
+}
+
+void battleDispose(void) {
+  battleInit();
+}
+
+battlefighter_t *battleGetCurrentFighter(void) {
+  if(!BATTLE.active) return NULL;
+  if(BATTLE.turnIndex >= BATTLE.turnCount) return NULL;
+  return &BATTLE.fighters[BATTLE.turnOrder[BATTLE.turnIndex]];
+}
+
+uint8_t battleGetAliveCount(const battlefighterteam_t team) {
+  uint8_t count = 0;
+  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
+    if(BATTLE.fighters[i].team != team) continue;
+    if(!battleFighterIsAlive(&BATTLE.fighters[i])) continue;
+    count++;
+  }
+  return count;
+}
+
+void battleResolveAttack(
+  battlefighter_t *attacker,
+  battlefighter_t *defender
+) {
+  assertNotNull(attacker, "Attacker cannot be NULL");
+  assertNotNull(defender, "Defender cannot be NULL");
+
+  const int32_t rawDamage =
+    (int32_t)attacker->stats.attack - (int32_t)defender->stats.defense;
+  const uint16_t damage = rawDamage > 0 ? (uint16_t)rawDamage : 1;
+
+  defender->health = damage >= defender->health ? 0 : defender->health - damage;
+  if(defender->health == 0) defender->status = BATTLE_FIGHTER_STATUS_DEAD;
+}
+
+void battleNextTurn(void) {
+  BATTLE.turnIndex++;
+  if(BATTLE.turnIndex < BATTLE.turnCount) return;
+
+  BATTLE.round++;
+  BATTLE.turnIndex = 0;
+  battleBuildTurnOrder(false);
+}
+
+battleresult_t battleCheckResult(void) {
+  if(BATTLE.result != BATTLE_RESULT_NONE) return BATTLE.result;
+
+  if(battleGetAliveCount(BATTLE_FIGHTER_TEAM_ALLY) == 0) {
+    BATTLE.result = BATTLE_RESULT_LOSS;
+  } else if(battleGetAliveCount(BATTLE_FIGHTER_TEAM_ENEMY) == 0) {
+    BATTLE.result = BATTLE_RESULT_WIN;
+  }
+
+  return BATTLE.result;
+}
+
+void battlePlayerAttack(const uint8_t targetIndex) {
+  battlefighter_t *attacker = battleGetCurrentFighter();
+  if(attacker == NULL) return;
+  if(attacker->controller != BATTLE_FIGHTER_CONTROLLER_PLAYER) return;
+  if(targetIndex >= BATTLE_FIGHTER_COUNT_MAX) return;
+
+  battlefighter_t *defender = &BATTLE.fighters[targetIndex];
+  if(!battleFighterIsAlive(defender)) return;
+
+  battleResolveAttack(attacker, defender);
+  battleCheckResult();
+  if(BATTLE.result == BATTLE_RESULT_NONE) battleNextTurn();
+}
+
+void battlePlayerFlee(void) {
+  battlefighter_t *fighter = battleGetCurrentFighter();
+  if(fighter == NULL) return;
+  if(fighter->controller != BATTLE_FIGHTER_CONTROLLER_PLAYER) return;
+  if(!BATTLE.fleeAvailable) return;
+
+  BATTLE.result = BATTLE_RESULT_FLED;
+}
+
+void battleUpdate(void) {
+  if(!BATTLE.active) return;
+  if(BATTLE.result != BATTLE_RESULT_NONE) return;
+
+  battlefighter_t *current = battleGetCurrentFighter();
+  if(current == NULL) return;
+
+  if(!battleFighterIsAlive(current)) {
+    battleNextTurn();
+    return;
+  }
+
+  if(current->controller != BATTLE_FIGHTER_CONTROLLER_AI) return;
+
+  battlefighter_t *target = battleAIChooseTarget(current);
+  if(target != NULL) battleResolveAttack(current, target);
+
+  battleCheckResult();
+  if(BATTLE.result == BATTLE_RESULT_NONE) battleNextTurn();
+}
+
+void battleBuildTurnOrder(const bool_t applyEncounterBias) {
+  BATTLE.turnCount = 0;
+  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
+    if(!battleFighterIsAlive(&BATTLE.fighters[i])) continue;
+    BATTLE.turnOrder[BATTLE.turnCount++] = i;
+  }
+
+  // Insertion sort by speed descending -- fine for BATTLE_FIGHTER_COUNT_MAX.
+  for(uint8_t i = 1; i < BATTLE.turnCount; i++) {
+    const uint8_t key = BATTLE.turnOrder[i];
+    const uint16_t keySpeed = BATTLE.fighters[key].stats.speed;
+
+    int8_t j = (int8_t)i - 1;
+    while(
+      j >= 0 && BATTLE.fighters[BATTLE.turnOrder[j]].stats.speed < keySpeed
+    ) {
+      BATTLE.turnOrder[j + 1] = BATTLE.turnOrder[j];
+      j--;
+    }
+    BATTLE.turnOrder[j + 1] = key;
+  }
+
+  if(!applyEncounterBias) return;
+
+  if(BATTLE.encounterType == BATTLE_ENCOUNTER_PLAYER_ADVANTAGE) {
+    battleMoveTeamFirst(BATTLE_FIGHTER_TEAM_ALLY);
+  } else if(BATTLE.encounterType == BATTLE_ENCOUNTER_BACK_ATTACK) {
+    battleMoveTeamFirst(BATTLE_FIGHTER_TEAM_ENEMY);
+  }
+}
+
+void battleMoveTeamFirst(const battlefighterteam_t team) {
+  uint8_t sorted[BATTLE_FIGHTER_COUNT_MAX];
+  uint8_t count = 0;
+
+  for(uint8_t i = 0; i < BATTLE.turnCount; i++) {
+    if(BATTLE.fighters[BATTLE.turnOrder[i]].team != team) continue;
+    sorted[count++] = BATTLE.turnOrder[i];
+  }
+  for(uint8_t i = 0; i < BATTLE.turnCount; i++) {
+    if(BATTLE.fighters[BATTLE.turnOrder[i]].team == team) continue;
+    sorted[count++] = BATTLE.turnOrder[i];
+  }
+
+  memoryCopy(BATTLE.turnOrder, sorted, sizeof(uint8_t) * BATTLE.turnCount);
+}
+
+battlefighter_t *battleAIChooseTarget(const battlefighter_t *fighter) {
+  const battlefighterteam_t enemyTeam =
+    fighter->team == BATTLE_FIGHTER_TEAM_ALLY ?
+      BATTLE_FIGHTER_TEAM_ENEMY : BATTLE_FIGHTER_TEAM_ALLY;
+
+  battlefighter_t *weakest = NULL;
+  for(uint8_t i = 0; i < BATTLE_FIGHTER_COUNT_MAX; i++) {
+    battlefighter_t *candidate = &BATTLE.fighters[i];
+    if(candidate->team != enemyTeam) continue;
+    if(!battleFighterIsAlive(candidate)) continue;
+    if(weakest == NULL || candidate->health < weakest->health) {
+      weakest = candidate;
+    }
+  }
+
+  return weakest;
+}

src/dusk/rpg/battle/battle.h

@@ -0,0 +1,194 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "battlefighter.h"
+
+#define BATTLE_FIGHTER_COUNT_MAX 8
+
+typedef enum {
+  BATTLE_ENCOUNTER_REGULAR,
+  BATTLE_ENCOUNTER_PLAYER_ADVANTAGE,
+  BATTLE_ENCOUNTER_BACK_ATTACK,
+
+  BATTLE_ENCOUNTER_COUNT
+} battleencountertype_t;
+
+typedef enum {
+  BATTLE_RESULT_NONE,
+  BATTLE_RESULT_WIN,
+  BATTLE_RESULT_LOSS,
+  BATTLE_RESULT_FLED,
+
+  BATTLE_RESULT_COUNT
+} battleresult_t;
+
+typedef struct {
+  bool_t active;
+  battlefighter_t fighters[BATTLE_FIGHTER_COUNT_MAX];
+
+  battleencountertype_t encounterType;
+  bool_t fleeAvailable;
+  battleresult_t result;
+
+  // Fighter indices (into fighters[]), sorted for the current round.
+  uint8_t turnOrder[BATTLE_FIGHTER_COUNT_MAX];
+  uint8_t turnCount;
+  uint8_t turnIndex;
+  uint16_t round;
+} battle_t;
+
+extern battle_t BATTLE;
+
+/**
+ * Initializes the battle system. Marks it as inactive with no fighters.
+ */
+void battleInit(void);
+
+/**
+ * Gets an available (unused) fighter slot index.
+ *
+ * @return The index of an available fighter slot, or 0xFF if none are
+ *         available.
+ */
+uint8_t battleGetAvailableFighter(void);
+
+/**
+ * Adds a fighter to the battle in the next available slot.
+ *
+ * @param team The team the fighter belongs to.
+ * @param controller Who makes decisions for the fighter.
+ * @param stats The fighter's base combat stats.
+ * @param healthMax The fighter's maximum health.
+ * @param mpMax The fighter's maximum mp.
+ * @return Pointer to the newly added fighter, or NULL if the battle is
+ *         already full.
+ */
+battlefighter_t *battleAddFighter(
+  const battlefighterteam_t team,
+  const battlefightercontroller_t controller,
+  const battlefighterstats_t stats,
+  const uint16_t healthMax,
+  const uint16_t mpMax
+);
+
+/**
+ * Starts the battle: builds the opening turn order (biased by
+ * encounterType for the first round only) and marks the battle active.
+ * Call once every fighter has been added via battleAddFighter.
+ *
+ * @param encounterType Determines the opening round's turn order.
+ * @param fleeAvailable Whether the party may attempt to flee this battle.
+ */
+void battleStart(
+  const battleencountertype_t encounterType,
+  const bool_t fleeAvailable
+);
+
+/**
+ * Disposes of the battle, clearing all fighters and marking it inactive.
+ */
+void battleDispose(void);
+
+/**
+ * Returns the fighter whose turn it currently is.
+ *
+ * @return Pointer to the active fighter, or NULL if the battle isn't
+ *         active or has no living fighters left to act.
+ */
+battlefighter_t *battleGetCurrentFighter(void);
+
+/**
+ * Returns the number of living fighters on a team.
+ *
+ * @param team The team to count.
+ * @return Count of living fighters on that team.
+ */
+uint8_t battleGetAliveCount(const battlefighterteam_t team);
+
+/**
+ * Resolves a physical attack from attacker onto defender: damage is the
+ * attacker's attack stat minus the defender's defense stat (minimum 1),
+ * subtracted from the defender's health. The defender is marked dead
+ * once health reaches 0.
+ *
+ * @param attacker The attacking fighter.
+ * @param defender The defending fighter.
+ */
+void battleResolveAttack(
+  battlefighter_t *attacker,
+  battlefighter_t *defender
+);
+
+/**
+ * Ends the current fighter's turn and advances to the next fighter in
+ * the turn order, starting a new round (rebuilding turn order purely by
+ * speed) once every fighter in the current round has acted.
+ */
+void battleNextTurn(void);
+
+/**
+ * Checks whether the battle has been won or lost, updating and
+ * returning BATTLE.result. Does nothing if a result has already been
+ * set (e.g. by a successful flee).
+ *
+ * @return The battle's current result.
+ */
+battleresult_t battleCheckResult(void);
+
+/**
+ * Submits the current fighter's attack against a target, if it is
+ * currently a player-controlled fighter's turn. Resolves the attack,
+ * checks for a battle result, and advances the turn.
+ *
+ * @param targetIndex Index into BATTLE.fighters of the target.
+ */
+void battlePlayerAttack(const uint8_t targetIndex);
+
+/**
+ * Submits a flee attempt for the current fighter's turn, if it is
+ * currently a player-controlled fighter's turn and fleeing is
+ * available for this battle. Always succeeds, ending the battle with
+ * BATTLE_RESULT_FLED.
+ */
+void battlePlayerFlee(void);
+
+/**
+ * Updates the battle simulation for one frame: resolves the current
+ * fighter's turn automatically if AI-controlled, otherwise waits for a
+ * player action via battlePlayerAttack/battlePlayerFlee. No-op if the
+ * battle isn't active or already has a result.
+ */
+void battleUpdate(void);
+
+/**
+ * Rebuilds BATTLE.turnOrder/turnCount from every currently living
+ * fighter, sorted by speed descending.
+ *
+ * @param applyEncounterBias If true, reorders the freshly speed-sorted
+ * queue so BATTLE.encounterType's favoured team goes first (used only
+ * for the opening round).
+ */
+void battleBuildTurnOrder(const bool_t applyEncounterBias);
+
+/**
+ * Stably partitions BATTLE.turnOrder so every fighter on the given team
+ * comes first, preserving each side's relative (speed-sorted) order.
+ *
+ * @param team The team to move to the front of the turn order.
+ */
+void battleMoveTeamFirst(const battlefighterteam_t team);
+
+/**
+ * Picks an AI target for fighter: the lowest-health living fighter on
+ * the opposing team.
+ *
+ * @param fighter The AI-controlled fighter choosing a target.
+ * @return The chosen target, or NULL if the opposing team has no
+ *         living fighters.
+ */
+battlefighter_t *battleAIChooseTarget(const battlefighter_t *fighter);

src/dusk/rpg/battle/battlefighter.c

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "battlefighter.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+
+void battleFighterInit(
+  battlefighter_t *fighter,
+  const battlefighterteam_t team,
+  const battlefightercontroller_t controller,
+  const battlefighterstats_t stats,
+  const uint16_t healthMax,
+  const uint16_t mpMax
+) {
+  assertNotNull(fighter, "Fighter pointer cannot be NULL");
+  assertTrue(team < BATTLE_FIGHTER_TEAM_COUNT, "Invalid fighter team");
+  assertTrue(
+    controller < BATTLE_FIGHTER_CONTROLLER_COUNT,
+    "Invalid fighter controller"
+  );
+
+  const uint8_t id = fighter->id;
+  memoryZero(fighter, sizeof(battlefighter_t));
+  fighter->id = id;
+  fighter->status = BATTLE_FIGHTER_STATUS_NORMAL;
+  fighter->team = team;
+  fighter->controller = controller;
+  fighter->stats = stats;
+  fighter->healthMax = healthMax;
+  fighter->health = healthMax;
+  fighter->mpMax = mpMax;
+  fighter->mp = mpMax;
+}
+
+bool_t battleFighterIsAlive(const battlefighter_t *fighter) {
+  assertNotNull(fighter, "Fighter pointer cannot be NULL");
+  return fighter->status == BATTLE_FIGHTER_STATUS_NORMAL;
+}

src/dusk/rpg/battle/battlefighter.h

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+
+// An empty status means the slot in BATTLE.fighters is unused.
+typedef enum {
+  BATTLE_FIGHTER_STATUS_NULL,
+
+  BATTLE_FIGHTER_STATUS_NORMAL,
+  BATTLE_FIGHTER_STATUS_DEAD,
+
+  BATTLE_FIGHTER_STATUS_COUNT
+} battlefighterstatus_t;
+
+typedef enum {
+  BATTLE_FIGHTER_TEAM_ALLY,
+  BATTLE_FIGHTER_TEAM_ENEMY,
+
+  BATTLE_FIGHTER_TEAM_COUNT
+} battlefighterteam_t;
+
+typedef enum {
+  BATTLE_FIGHTER_CONTROLLER_PLAYER,
+  BATTLE_FIGHTER_CONTROLLER_AI,
+
+  BATTLE_FIGHTER_CONTROLLER_COUNT
+} battlefightercontroller_t;
+
+// Base combat stats, kept separate from the resource pools (health/mp) on
+// battlefighter_t so that equipment/buffs can later modify them without
+// touching current health/mp state.
+typedef struct {
+  uint16_t attack;
+  uint16_t defense;
+  uint16_t magic;
+  uint16_t speed;
+  uint16_t luck;
+} battlefighterstats_t;
+
+typedef struct {
+  uint8_t id;
+  battlefighterstatus_t status;
+  battlefighterteam_t team;
+  battlefightercontroller_t controller;
+
+  uint16_t health;
+  uint16_t healthMax;
+  uint16_t mp;
+  uint16_t mpMax;
+
+  battlefighterstats_t stats;
+} battlefighter_t;
+
+/**
+ * Initializes a battle fighter in place, filling health/mp to their maximum
+ * values and setting its status to normal.
+ *
+ * @param fighter Pointer to the fighter to initialize.
+ * @param team The team the fighter belongs to.
+ * @param controller Who makes decisions for the fighter.
+ * @param stats The fighter's base combat stats.
+ * @param healthMax The fighter's maximum health.
+ * @param mpMax The fighter's maximum mp.
+ */
+void battleFighterInit(
+  battlefighter_t *fighter,
+  const battlefighterteam_t team,
+  const battlefightercontroller_t controller,
+  const battlefighterstats_t stats,
+  const uint16_t healthMax,
+  const uint16_t mpMax
+);
+
+/**
+ * Returns true if the fighter is in a state where it can still act (i.e.
+ * is not dead).
+ *
+ * @param fighter Pointer to the fighter to check.
+ * @returns True if the fighter can act.
+ */
+bool_t battleFighterIsAlive(const battlefighter_t *fighter);

src/dusk/rpg/battle/party.c

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "party.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+
+party_t PARTY;
+
+void partyInit(void) {
+  memoryZero(&PARTY, sizeof(party_t));
+  for(uint8_t i = 0; i < PARTY_MEMBER_COUNT_MAX; i++) {
+    PARTY.members[i].id = i;
+  }
+  for(uint8_t i = 0; i < PARTY_ACTIVE_SIZE_MAX; i++) {
+    PARTY.order[i] = PARTY_ORDER_EMPTY;
+  }
+}
+
+uint8_t partyGetAvailableMember(void) {
+  for(uint8_t i = 0; i < PARTY_MEMBER_COUNT_MAX; i++) {
+    if(PARTY.members[i].status == BATTLE_FIGHTER_STATUS_NULL) return i;
+  }
+
+  return 0xFF;
+}
+
+battlefighter_t *partyAddMember(
+  const battlefighterstats_t stats,
+  const uint16_t healthMax,
+  const uint16_t mpMax
+) {
+  const uint8_t index = partyGetAvailableMember();
+  if(index == 0xFF) return NULL;
+
+  battlefighter_t *member = &PARTY.members[index];
+  battleFighterInit(
+    member, BATTLE_FIGHTER_TEAM_ALLY, BATTLE_FIGHTER_CONTROLLER_PLAYER,
+    stats, healthMax, mpMax
+  );
+
+  for(uint8_t i = 0; i < PARTY_ACTIVE_SIZE_MAX; i++) {
+    if(PARTY.order[i] != PARTY_ORDER_EMPTY) continue;
+    PARTY.order[i] = index;
+    break;
+  }
+
+  return member;
+}
+
+battlefighter_t *partyGetOrderMember(const uint8_t slot) {
+  assertTrue(slot < PARTY_ACTIVE_SIZE_MAX, "Invalid party order slot");
+
+  const uint8_t index = PARTY.order[slot];
+  if(index == PARTY_ORDER_EMPTY) return NULL;
+  return &PARTY.members[index];
+}
+
+void partySetOrder(const uint8_t slot, const uint8_t memberIndex) {
+  assertTrue(slot < PARTY_ACTIVE_SIZE_MAX, "Invalid party order slot");
+  assertTrue(
+    memberIndex == PARTY_ORDER_EMPTY || memberIndex < PARTY_MEMBER_COUNT_MAX,
+    "Invalid party member index"
+  );
+
+  PARTY.order[slot] = memberIndex;
+}

src/dusk/rpg/battle/party.h

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "battlefighter.h"
+
+#define PARTY_MEMBER_COUNT_MAX 4
+#define PARTY_ACTIVE_SIZE_MAX 3
+#define PARTY_ORDER_EMPTY 0xFF
+
+typedef struct {
+  battlefighter_t members[PARTY_MEMBER_COUNT_MAX];
+
+  // Maps an active battle slot to the roster member filling it, or
+  // PARTY_ORDER_EMPTY if the slot is unfilled. Only the first
+  // PARTY_ACTIVE_SIZE_MAX of the PARTY_MEMBER_COUNT_MAX roster members
+  // can be in the active lineup at once.
+  uint8_t order[PARTY_ACTIVE_SIZE_MAX];
+} party_t;
+
+extern party_t PARTY;
+
+/**
+ * Initializes the party system with an empty roster and order.
+ */
+void partyInit(void);
+
+/**
+ * Gets an available (unused) party member slot index.
+ *
+ * @return The index of an available slot, or 0xFF if the party is full.
+ */
+uint8_t partyGetAvailableMember(void);
+
+/**
+ * Adds a member to the party roster in the next available slot. Party
+ * members are always allies controlled by the player. If there is a
+ * free active order slot, the new member is placed into it.
+ *
+ * @param stats The member's base combat stats.
+ * @param healthMax The member's maximum health.
+ * @param mpMax The member's maximum mp.
+ * @return Pointer to the newly added party member, or NULL if the party is
+ *         already full.
+ */
+battlefighter_t *partyAddMember(
+  const battlefighterstats_t stats,
+  const uint16_t healthMax,
+  const uint16_t mpMax
+);
+
+/**
+ * Gets the roster member currently occupying an active order slot.
+ *
+ * @param slot The active order slot to query.
+ * @return Pointer to the member in that slot, or NULL if the slot is
+ *         empty.
+ */
+battlefighter_t *partyGetOrderMember(const uint8_t slot);
+
+/**
+ * Assigns a roster member to an active order slot, replacing whatever
+ * was there. Use PARTY_ORDER_EMPTY to clear a slot.
+ *
+ * @param slot The active order slot to assign.
+ * @param memberIndex The roster member index to place there, or
+ *        PARTY_ORDER_EMPTY to clear the slot.
+ */
+void partySetOrder(const uint8_t slot, const uint8_t memberIndex);

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

@@ -14,3 +14,4 @@ add_subdirectory(entity)
 add_subdirectory(item)
 add_subdirectory(maparea)
 add_subdirectory(ui)
+add_subdirectory(battle)

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

@@ -5,6 +5,5 @@
 
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
-    physicsbody.c
-    physicsworld.c
+    cutscenestartbattle.c
 )

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

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "rpg/cutscene/item/cutsceneitem.h"
+#include "rpg/battle/party.h"
+#include "scene/scene.h"
+
+void cutsceneStartBattleStart(
+  const cutsceneitem_t *item,
+  cutsceneitemdata_t *data
+) {
+  const cutscenestartbattle_t *config = &item->startBattle;
+
+  battleInit();
+
+  for(uint8_t i = 0; i < PARTY_ACTIVE_SIZE_MAX; i++) {
+    battlefighter_t *member = partyGetOrderMember(i);
+    if(member == NULL) continue;
+
+    battlefighter_t *fighter = battleAddFighter(
+      BATTLE_FIGHTER_TEAM_ALLY, BATTLE_FIGHTER_CONTROLLER_PLAYER,
+      member->stats, member->healthMax, member->mpMax
+    );
+    if(fighter == NULL) continue;
+
+    fighter->health = member->health;
+    fighter->mp = member->mp;
+    fighter->status = member->status;
+  }
+
+  for(uint8_t i = 0; i < config->enemyCount; i++) {
+    const cutscenestartbattleenemy_t *enemy = &config->enemies[i];
+    battleAddFighter(
+      BATTLE_FIGHTER_TEAM_ENEMY, BATTLE_FIGHTER_CONTROLLER_AI,
+      enemy->stats, enemy->healthMax, enemy->mpMax
+    );
+  }
+
+  battleStart(config->encounterType, config->fleeAvailable);
+  sceneSet(SCENE_TYPE_BATTLE);
+}
+
+bool_t cutsceneStartBattleUpdate(
+  const cutsceneitem_t *item,
+  cutsceneitemdata_t *data
+) {
+  if(BATTLE.result == BATTLE_RESULT_NONE) return false;
+
+  // Sync ally HP/MP back to the persistent party roster. Relies on
+  // ally fighters having been added to BATTLE.fighters in the same
+  // order partyGetOrderMember() iterates, starting at index 0 (see
+  // cutsceneStartBattleStart).
+  uint8_t allySlot = 0;
+  for(uint8_t i = 0; i < PARTY_ACTIVE_SIZE_MAX; i++) {
+    battlefighter_t *member = partyGetOrderMember(i);
+    if(member == NULL) continue;
+
+    battlefighter_t *fighter = &BATTLE.fighters[allySlot++];
+    member->health = fighter->health;
+    member->mp = fighter->mp;
+    member->status = fighter->status;
+  }
+
+  sceneSet(SCENE_TYPE_OVERWORLD);
+  battleDispose();
+  return true;
+}

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

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "rpg/battle/battle.h"
+
+#define CUTSCENE_START_BATTLE_ENEMY_COUNT_MAX 4
+
+typedef struct {
+  battlefighterstats_t stats;
+  uint16_t healthMax;
+  uint16_t mpMax;
+} cutscenestartbattleenemy_t;
+
+typedef struct cutsceneitem_s cutsceneitem_t;
+typedef union cutsceneitemdata_u cutsceneitemdata_t;
+
+typedef struct {
+  battleencountertype_t encounterType;
+  bool_t fleeAvailable;
+  uint8_t enemyCount;
+  cutscenestartbattleenemy_t enemies[CUTSCENE_START_BATTLE_ENEMY_COUNT_MAX];
+} cutscenestartbattle_t;
+
+/**
+ * Starts a battle: seeds BATTLE with the party's active order members
+ * and the item's configured enemies, then switches to the battle
+ * scene.
+ *
+ * @param item The cutscene item.
+ * @param data Runtime data storage.
+ */
+void cutsceneStartBattleStart(
+  const cutsceneitem_t *item,
+  cutsceneitemdata_t *data
+);
+
+/**
+ * Waits for the battle to produce a result, syncs ally HP/MP back to
+ * the party roster, then returns to the overworld scene.
+ *
+ * @param item The cutscene item.
+ * @param data Runtime data storage.
+ * @returns true once the battle has ended.
+ */
+bool_t cutsceneStartBattleUpdate(
+  const cutsceneitem_t *item,
+  cutsceneitemdata_t *data
+);

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

@@ -105,6 +105,11 @@ cutsceneitemcallbacks_t CUTSCENE_ITEM_CALLBACKS[CUTSCENE_ITEM_TYPE_COUNT] = {
     .update = cutsceneMapAreaWaitUpdate
   },
 
+  [CUTSCENE_ITEM_TYPE_START_BATTLE] = {
+    .init = cutsceneStartBattleStart,
+    .update = cutsceneStartBattleUpdate
+  },
+
   [CUTSCENE_ITEM_TYPE_EMOJI] = {
     .init = cutsceneEmojiStart,
     .update = cutsceneEmojiUpdate

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

@@ -26,6 +26,7 @@
 #include "maparea/cutscenemapareaadd.h"
 #include "maparea/cutscenemaparearemove.h"
 #include "maparea/cutscenemapareawait.h"
+#include "battle/cutscenestartbattle.h"
 
 typedef struct cutscene_s cutscene_t;
 
@@ -51,6 +52,7 @@ typedef enum {
   CUTSCENE_ITEM_TYPE_MAP_AREA_ADD,
   CUTSCENE_ITEM_TYPE_MAP_AREA_REMOVE,
   CUTSCENE_ITEM_TYPE_MAP_AREA_WAIT,
+  CUTSCENE_ITEM_TYPE_START_BATTLE,
   CUTSCENE_ITEM_TYPE_EMOJI,
   CUTSCENE_ITEM_TYPE_SHAKE,
 
@@ -80,6 +82,7 @@ struct cutsceneitem_s {
     cutscenemapareaadd_t mapAreaAdd;
     cutscenemaparearemove_t mapAreaRemove;
     cutscenemapareawait_t mapAreaWait;
+    cutscenestartbattle_t startBattle;
     cutsceneemoji_t emoji;
     cutsceneshake_t shake;
   };

src/dusk/rpg/entity/CMakeLists.txt

@@ -12,6 +12,7 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
     player.c
 )
 
+add_subdirectory(anim)
 add_subdirectory(interact)
 add_subdirectory(npc)
 add_subdirectory(item)

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

@@ -0,0 +1,13 @@
+# 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
+    entityanim.c
+    entityanimidle.c
+    entityanimturn.c
+    entityanimwalk.c
+    entityanimrun.c
+)

src/dusk/rpg/entity/anim/entityanim.c

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "rpg/entity/entity.h"
+#include "rpg/overworld/map.h"
+#include "rpg/overworld/tile.h"
+#include "time/time.h"
+#include "entityanimwalk.h"
+
+const entityanimcallback_t ENTITY_ANIM_CALLBACKS[ENTITY_ANIM_COUNT] = {
+  [ENTITY_ANIM_IDLE] = { entityAnimIdleUpdate },
+  [ENTITY_ANIM_TURN] = { entityAnimTurnUpdate },
+  [ENTITY_ANIM_WALK] = { entityAnimWalkUpdate },
+  [ENTITY_ANIM_RUN]  = { entityAnimRunUpdate  },
+};
+
+float_t entityAnimTileZOffset(const worldpos_t pos) {
+  return tileShapeIsRamp(mapGetTile(pos).shape) ? 0.5f : 0.0f;
+}
+
+void entityAnimUpdate(entity_t *entity) {
+  if(entity->animation != ENTITY_ANIM_IDLE) {
+    entity->animTime -= TIME.delta;
+    if(entity->animTime <= 0) {
+      if(
+        entity->animation == ENTITY_ANIM_WALK ||
+        entity->animation == ENTITY_ANIM_RUN
+      ) {
+        entity->walkEndCooldown = ENTITY_ANIM_WALK_TURN_COOLDOWN;
+      }
+      entity->animation = ENTITY_ANIM_IDLE; 
+      entity->animTime = 0;
+    }
+  }
+  if(entity->walkEndCooldown > 0) {
+    entity->walkEndCooldown -= TIME.delta;
+    if(entity->walkEndCooldown < 0) entity->walkEndCooldown = 0;
+  }
+  ENTITY_ANIM_CALLBACKS[entity->animation].update(entity);
+}

src/dusk/rpg/entity/anim/entityanim.h

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+#include "entityanimidle.h"
+#include "entityanimturn.h"
+#include "entityanimwalk.h"
+#include "entityanimrun.h"
+
+typedef struct entity_s entity_t;
+
+typedef enum {
+  ENTITY_ANIM_IDLE,
+  ENTITY_ANIM_TURN,
+  ENTITY_ANIM_WALK,
+  ENTITY_ANIM_RUN,
+  ENTITY_ANIM_COUNT
+} entityanim_t;
+
+typedef struct {
+  /** Updates the render position for this animation state. */
+  void (*update)(entity_t *entity);
+} entityanimcallback_t;
+
+extern const entityanimcallback_t ENTITY_ANIM_CALLBACKS[ENTITY_ANIM_COUNT];
+
+/**
+ * Updates the entity animation timer and render position.
+ *
+ * @param entity Pointer to the entity to update.
+ */
+void entityAnimUpdate(entity_t *entity);
+
+/**
+ * Returns 0.5 if the tile at pos is a ramp, 0.0 otherwise.
+ * Used to lift entity render position to mid-ramp height.
+ *
+ * @param pos World position to sample.
+ * @returns float_t The Z offset to apply.
+ */
+float_t entityAnimTileZOffset(const worldpos_t pos);

src/dusk/rpg/entity/anim/entityanimidle.c

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "rpg/entity/entity.h"
+#include "entityanim.h"
+
+void entityAnimIdleUpdate(entity_t *entity) {
+  entity->renderPosition[0] = (float_t)entity->position.x;
+  entity->renderPosition[1] = (float_t)entity->position.y;
+  entity->renderPosition[2] = (
+    (float_t)entity->position.z + entityAnimTileZOffset(entity->position)
+  ) * WORLD_LAYER_HEIGHT;
+}

src/dusk/rpg/entity/anim/entityanimidle.h

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+
+typedef struct entity_s entity_t;
+
+/**
+ * Updates render position for the idle animation state.
+ *
+ * @param entity Pointer to the entity to update.
+ */
+void entityAnimIdleUpdate(entity_t *entity);

src/dusk/rpg/entity/anim/entityanimrun.c

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "rpg/entity/entity.h"
+#include "entityanim.h"
+
+void entityAnimRunUpdate(entity_t *entity) {
+  float_t t = 1.0f - (entity->animTime / ENTITY_ANIM_RUN_DURATION);
+  float_t zFrom = (float_t)entity->lastPosition.z
+    + entityAnimTileZOffset(entity->lastPosition);
+  float_t zTo = (float_t)entity->position.z
+    + entityAnimTileZOffset(entity->position);
+  entity->renderPosition[0] = (float_t)entity->lastPosition.x + t * (
+    (float_t)entity->position.x - (float_t)entity->lastPosition.x
+  );
+  entity->renderPosition[1] = (float_t)entity->lastPosition.y + t * (
+    (float_t)entity->position.y - (float_t)entity->lastPosition.y
+  );
+  entity->renderPosition[2] = (zFrom + t * (zTo - zFrom)) * WORLD_LAYER_HEIGHT;
+}

src/dusk/rpg/entity/anim/entityanimrun.h

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+#include "time/time.h"
+
+typedef struct entity_s entity_t;
+
+#define ENTITY_ANIM_RUN_DURATION TIME_TICKS_TO_TIME(6)
+
+/**
+ * Updates render position for the run animation state.
+ *
+ * @param entity Pointer to the entity to update.
+ */
+void entityAnimRunUpdate(entity_t *entity);

src/dusk/rpg/entity/anim/entityanimturn.c

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "rpg/entity/entity.h"
+#include "entityanim.h"
+
+void entityAnimTurnUpdate(entity_t *entity) {
+  entity->renderPosition[0] = (float_t)entity->position.x;
+  entity->renderPosition[1] = (float_t)entity->position.y;
+  entity->renderPosition[2] = (
+    (float_t)entity->position.z + entityAnimTileZOffset(entity->position)
+  ) * WORLD_LAYER_HEIGHT;
+}

src/dusk/rpg/entity/anim/entityanimturn.h

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+#include "time/time.h"
+
+typedef struct entity_s entity_t;
+
+#define ENTITY_ANIM_TURN_DURATION TIME_TICKS_TO_TIME(4)
+
+/**
+ * Updates render position for the turn animation state.
+ *
+ * @param entity Pointer to the entity to update.
+ */
+void entityAnimTurnUpdate(entity_t *entity);

src/dusk/rpg/entity/anim/entityanimwalk.c

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "rpg/entity/entity.h"
+#include "entityanim.h"
+
+void entityAnimWalkUpdate(entity_t *entity) {
+  float_t t = 1.0f - (entity->animTime / ENTITY_ANIM_WALK_DURATION);
+  float_t zFrom = (float_t)entity->lastPosition.z
+    + entityAnimTileZOffset(entity->lastPosition);
+  float_t zTo = (float_t)entity->position.z
+    + entityAnimTileZOffset(entity->position);
+  entity->renderPosition[0] = (float_t)entity->lastPosition.x + t * (
+    (float_t)entity->position.x - (float_t)entity->lastPosition.x
+  );
+  entity->renderPosition[1] = (float_t)entity->lastPosition.y + t * (
+    (float_t)entity->position.y - (float_t)entity->lastPosition.y
+  );
+  entity->renderPosition[2] = (zFrom + t * (zTo - zFrom)) * WORLD_LAYER_HEIGHT;
+}

src/dusk/rpg/entity/anim/entityanimwalk.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 "dusk.h"
+#include "time/time.h"
+
+typedef struct entity_s entity_t;
+
+#define ENTITY_ANIM_WALK_DURATION TIME_TICKS_TO_TIME(12)
+#define ENTITY_ANIM_WALK_TURN_COOLDOWN TIME_TICKS_TO_TIME(4)
+
+/**
+ * Updates render position for the walk animation state.
+ *
+ * @param entity Pointer to the entity to update.
+ */
+void entityAnimWalkUpdate(entity_t *entity);

src/dusk/rpg/entity/entity.c

@@ -8,14 +8,15 @@
 #include "entity.h"
 #include "assert/assert.h"
 #include "util/memory.h"
-#include "util/math.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"
+#include "rpg/overworld/tile.h"
 
 entity_t ENTITIES[ENTITY_COUNT];
-physicsworld_t ENTITY_PHYSICS_WORLD;
 
 void entityInit(entity_t *entity, const entitytype_t type) {
   assertNotNull(entity, "Entity pointer cannot be NULL");
@@ -32,9 +33,6 @@ void entityInit(entity_t *entity, const entitytype_t type) {
   entity->type = type;
   entity->chunkIndex = 0xFF;
 
-  const vec3 extents = ENTITY_PHYSICS_EXTENTS_DEFAULT;
-  physicsBodyInit(&entity->body, (vec3){ 0.0f, 0.0f, 0.0f }, extents);
-
   if(ENTITY_CALLBACKS[type].init != NULL) ENTITY_CALLBACKS[type].init(entity);
 }
 
@@ -43,115 +41,212 @@ void entityUpdate(entity_t *entity) {
   assertTrue(entity->type < ENTITY_TYPE_COUNT, "Invalid entity type");
   assertTrue(entity->type != ENTITY_TYPE_NULL, "Cannot have NULL entity type");
 
+  // What state is the entity in?
+  entityAnimUpdate(entity);
+
+  // Movement code.
   if(ENTITY_CALLBACKS[entity->type].movement != NULL) {
     ENTITY_CALLBACKS[entity->type].movement(entity);
   }
+}
 
-  physicsbody_t *others[ENTITY_COUNT];
-  uint32_t othersCount = 0;
-  for(uint8_t i = 0; i < ENTITY_COUNT; i++) {
-    if(ENTITIES[i].type == ENTITY_TYPE_NULL) continue;
-    if(&ENTITIES[i] == entity) continue;
-    others[othersCount++] = &ENTITIES[i].body;
-  }
+bool_t entityCanTurn(entity_t *entity) {
+  return entity->animation == ENTITY_ANIM_IDLE &&
+    entity->walkEndCooldown <= 0;
+}
 
-  physicsWorldStep(
-    &ENTITY_PHYSICS_WORLD, &entity->body, TIME.delta, others, othersCount
-  );
-  entitySyncFromPhysics(entity);
+bool_t entityCanWalk(entity_t *entity) {
+  return entity->animation == ENTITY_ANIM_IDLE;
+}
+
+bool_t entityCanRun(entity_t *entity) {
+  return entity->animation == ENTITY_ANIM_IDLE;
 }
 
 bool_t entityCanUnload(entity_t *entity) {
   return entity->globalId < ENTITY_GLOBAL_ID_START;
 }
 
-void entityMove(
-  entity_t *entity, const vec2 direction, const bool_t running
-) {
-  assertNotNull(entity, "Entity pointer cannot be NULL");
-
-  const float_t magSq =
-    direction[0] * direction[0] + direction[1] * direction[1];
-  if(magSq <= ENTITY_MOVE_DEADZONE * ENTITY_MOVE_DEADZONE) {
-    entity->body.velocity[0] = 0.0f;
-    entity->body.velocity[1] = 0.0f;
-    entity->animation = ENTITY_ANIM_IDLE;
-    return;
-  }
-
-  const float_t mag = sqrtf(magSq);
-  const float_t clampedMag = mathMin(mag, 1.0f);
-  const float_t speed = running ? ENTITY_MOVE_RUN_SPEED : ENTITY_MOVE_WALK_SPEED;
-
-  entity->body.velocity[0] = (direction[0] / mag) * clampedMag * speed;
-  entity->body.velocity[1] = (direction[1] / mag) * clampedMag * speed;
-  entity->direction = entityDirFromVec2(direction);
-  entity->animation = running ? ENTITY_ANIM_RUN : ENTITY_ANIM_WALK;
-}
-
-void entityStop(entity_t *entity) {
-  const vec2 zero = { 0.0f, 0.0f };
-  entityMove(entity, zero, false);
-}
-
 void entityTurn(entity_t *entity, const entitydir_t direction) {
-  assertNotNull(entity, "Entity pointer cannot be NULL");
+  if(!entityCanTurn(entity)) return;
   entity->direction = direction;
+  entity->animation = ENTITY_ANIM_TURN;
+  entity->animTime = ENTITY_ANIM_TURN_DURATION;
 }
 
 void entityWalk(entity_t *entity, const entitydir_t direction) {
-  vec2 dirVec;
-  entityDirToVec2(direction, dirVec);
-  entityMove(entity, dirVec, false);
+  if(!entityCanWalk(entity)) return;
+  // TODO: Animation, delay, etc.
+  entity->direction = direction;
+
+  // Where are we moving?
+  worldpos_t newPos = entity->position;
+  worldunits_t relX, relY;
+  {
+    entityDirGetRelative(direction, &relX, &relY);
+    newPos.x += relX;
+    newPos.y += relY;
+  }
+
+  // Get tile under foot
+  tile_t tileCurrent = mapGetTile(entity->position);
+  tile_t tileNew = mapGetTile(newPos);
+  bool_t fall = false;
+  bool_t raise = false;
+
+  // Are we walking up a ramp?
+  if(
+    tileShapeIsRamp(tileCurrent.shape) &&
+    (
+      // Can only walk UP the direction the ramp faces.
+      (direction+TILE_SHAPE_RAMP_NORTH) == tileCurrent.shape ||
+      // If diagonal ramp, can go up one of two ways only. Inner ramps
+      // share the same allowed directions as their outer counterparts.
+      (
+        (
+          (
+            tileCurrent.shape == TILE_SHAPE_RAMP_SOUTHEAST ||
+            tileCurrent.shape == TILE_SHAPE_RAMP_SOUTHEAST_INNER
+          ) &&
+          (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_EAST)
+        ) ||
+        (
+          (
+            tileCurrent.shape == TILE_SHAPE_RAMP_SOUTHWEST ||
+            tileCurrent.shape == TILE_SHAPE_RAMP_SOUTHWEST_INNER
+          ) &&
+          (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_WEST)
+        ) ||
+        (
+          (
+            tileCurrent.shape == TILE_SHAPE_RAMP_NORTHEAST ||
+            tileCurrent.shape == TILE_SHAPE_RAMP_NORTHEAST_INNER
+          ) &&
+          (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_EAST)
+        ) ||
+        (
+          (
+            tileCurrent.shape == TILE_SHAPE_RAMP_NORTHWEST ||
+            tileCurrent.shape == TILE_SHAPE_RAMP_NORTHWEST_INNER
+          ) &&
+          (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_WEST)
+        )
+      )
+    // Must be able to walk up.
+    )
+  ) {
+    tile_t tileNewSaved = tileNew;
+    tileNew = TILE_NULL;
+    worldpos_t abovePos = newPos;
+    abovePos.z += 1;
+    tile_t tileAbove = mapGetTile(abovePos);
+
+    if(
+      tileAbove.shape != TILE_SHAPE_NULL &&
+      tileShapeIsWalkable(tileAbove.shape)
+    ) {
+      raise = true;
+    } else {
+      tileNew = tileNewSaved;
+    }
+  } else if(tileNew.shape == TILE_SHAPE_NULL && newPos.z > 0) {
+    // Falling down?
+    worldpos_t belowPos = newPos;
+    belowPos.z -= 1;
+    tile_t tileBelow = mapGetTile(belowPos);
+    if(
+      tileBelow.shape != TILE_SHAPE_NULL &&
+      tileShapeIsRamp(tileBelow.shape) &&
+      (
+        // This handles regular cardinal ramps
+        (
+          entityDirGetOpposite(direction)+TILE_SHAPE_RAMP_NORTH
+        ) == tileBelow.shape ||
+        // This handles diagonal ramps. Inner ramps share the same
+        // allowed directions as their outer counterparts.
+        (
+          (
+            (
+              tileBelow.shape == TILE_SHAPE_RAMP_SOUTHEAST ||
+              tileBelow.shape == TILE_SHAPE_RAMP_SOUTHEAST_INNER
+            ) &&
+            (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_WEST)
+          ) ||
+          (
+            (
+              tileBelow.shape == TILE_SHAPE_RAMP_SOUTHWEST ||
+              tileBelow.shape == TILE_SHAPE_RAMP_SOUTHWEST_INNER
+            ) &&
+            (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_EAST)
+          ) ||
+          (
+            (
+              tileBelow.shape == TILE_SHAPE_RAMP_NORTHEAST ||
+              tileBelow.shape == TILE_SHAPE_RAMP_NORTHEAST_INNER
+            ) &&
+            (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_WEST)
+          ) ||
+          (
+            (
+              tileBelow.shape == TILE_SHAPE_RAMP_NORTHWEST ||
+              tileBelow.shape == TILE_SHAPE_RAMP_NORTHWEST_INNER
+            ) &&
+            (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_EAST)
+          )
+        )
+      )
+    ) {
+      // We will fall to this tile.
+      fall = true;
+    }
+  }
+
+  // Can we walk here?
+  if(!raise && !fall && !tileShapeIsWalkable(tileNew.shape)) return;// Blocked
+
+  // Raise/fall must be applied before checking for blocking entities,
+  // otherwise the check compares against the wrong z-level.
+  if(raise) {
+    newPos.z += 1;
+  } else if(fall) {
+    newPos.z -= 1;
+  }
+
+  // Entity in way?
+  entity_t *other = ENTITIES;
+  do {
+    if(other == entity) continue;
+    if(other->type == ENTITY_TYPE_NULL) continue;
+    if(!worldPosIsEqual(other->position, newPos)) continue;
+    return;// Blocked
+  } while(++other, other < &ENTITIES[ENTITY_COUNT]);
+
+  entity->lastPosition = entity->position;
+  entity->position = newPos;
+  entity->animation = ENTITY_ANIM_WALK;
+  entity->animTime = ENTITY_ANIM_WALK_DURATION;// TODO: Running vs walking
+  entityUpdateChunk(entity);
+  mapAreaCheckEntity(entity);
 }
 
 void entityRun(entity_t *entity, const entitydir_t direction) {
-  vec2 dirVec;
-  entityDirToVec2(direction, dirVec);
-  entityMove(entity, dirVec, true);
+  if(!entityCanRun(entity)) return;
+  entityWalk(entity, direction);
+  if(entity->animation == ENTITY_ANIM_WALK) {
+    entity->animation = ENTITY_ANIM_RUN;
+    entity->animTime = ENTITY_ANIM_RUN_DURATION;
+  }
 }
 
-entity_t * entityGetFacing(entity_t *entity, const float_t range) {
-  assertNotNull(entity, "Entity pointer cannot be NULL");
-
-  vec2 dir;
-  entityDirToVec2(entity->direction, dir);
-
-  vec3 min, max;
-  physicsBodyGetBounds(&entity->body, min, max);
-
-  const vec3 probeMin = {
-    min[0] + dir[0] * range, min[1] + dir[1] * range, min[2]
-  };
-  const vec3 probeMax = {
-    max[0] + dir[0] * range, max[1] + dir[1] * range, max[2]
-  };
-
-  entity_t *best = NULL;
-  float_t bestDistSq = 0.0f;
-
+entity_t * entityGetAt(const worldpos_t position) {
   entity_t *ent = ENTITIES;
   do {
     if(ent->type == ENTITY_TYPE_NULL) continue;
-    if(ent == entity) continue;
-
-    vec3 oMin, oMax;
-    physicsBodyGetBounds(&ent->body, oMin, oMax);
-
-    if(probeMin[0] >= oMax[0] || probeMax[0] <= oMin[0]) continue;
-    if(probeMin[1] >= oMax[1] || probeMax[1] <= oMin[1]) continue;
-    if(probeMin[2] >= oMax[2] || probeMax[2] <= oMin[2]) continue;
-
-    const float_t dx = ent->body.position[0] - entity->body.position[0];
-    const float_t dy = ent->body.position[1] - entity->body.position[1];
-    const float_t distSq = dx * dx + dy * dy;
-
-    if(best != NULL && distSq >= bestDistSq) continue;
-    best = ent;
-    bestDistSq = distSq;
+    if(!worldPosIsEqual(ent->position, position)) continue;
+    return ent;
   } while(++ent, ent < &ENTITIES[ENTITY_COUNT]);
 
-  return best;
+  return NULL;
 }
 
 entity_t * entityGetByGlobalId(const entityglobalid_t globalId) {
@@ -176,14 +271,12 @@ uint8_t entityGetAvailable() {
 
 void entityPositionSet(entity_t *entity, const worldpos_t pos) {
   assertNotNull(entity, "Entity pointer cannot be NULL");
-
-  const vec3 floatPos = {
-    (float_t)pos.x, (float_t)pos.y, (float_t)pos.z
-  };
-  const vec3 extents = ENTITY_PHYSICS_EXTENTS_DEFAULT;
-  physicsBodyInit(&entity->body, floatPos, extents);
+  entity->lastPosition = pos;
+  entity->position = pos;
   entity->animation = ENTITY_ANIM_IDLE;
-  entitySyncFromPhysics(entity);
+  entity->animTime = 0;
+  entity->walkEndCooldown = 0;
+  entityUpdateChunk(entity);
 }
 
 void entitySetChunk(entity_t *entity, const uint8_t chunkIndex) {
@@ -200,19 +293,27 @@ 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);
     if(next != NULL) {
-      bool_t inserted = false;
       for(uint8_t i = 0; i < CHUNK_ENTITY_COUNT_MAX; i++) {
         if(next->entities[i] != 0xFF) continue;
         next->entities[i] = entity->id;
-        inserted = true;
+        entity->chunkIndex = chunkIndex;
         break;
       }
-      assertTrue(inserted, "Chunk entity slot overflow");
+      if(entity->chunkIndex != chunkIndex) {
+        consolePrint(
+          "entitySetChunk: chunk %u has no free entity slots, entity %u "
+          "left untracked",
+          chunkIndex, entity->id
+        );
+      }
     }
   }
 }
@@ -223,22 +324,5 @@ void entityUpdateChunk(entity_t *entity) {
   chunkpos_t cp;
   worldPosToChunkPos(&entity->position, &cp);
   chunkindex_t ci = mapGetChunkIndexAt(cp);
-  if(ci == -1 || ci == entity->chunkIndex) return;
-  entitySetChunk(entity, (uint8_t)ci);
-}
-
-void entitySyncFromPhysics(entity_t *entity) {
-  assertNotNull(entity, "Entity pointer cannot be NULL");
-
-  entity->position = (worldpos_t){
-    (worldunit_t)floorf(entity->body.position[0]),
-    (worldunit_t)floorf(entity->body.position[1]),
-    (worldunit_t)floorf(entity->body.position[2])
-  };
-
-  glm_vec3_copy(entity->body.position, entity->renderPosition);
-  entity->renderPosition[2] *= WORLD_LAYER_HEIGHT;
-
-  entityUpdateChunk(entity);
-  mapAreaCheckEntity(entity);
+  if(ci != -1) entitySetChunk(entity, (uint8_t)ci);
 }

src/dusk/rpg/entity/entity.h

@@ -7,11 +7,10 @@
 
 #pragma once
 #include "entitydir.h"
+#include "anim/entityanim.h"
 #include "interact/entityinteract.h"
 #include "entitytype.h"
 #include "npc/npc.h"
-#include "rpg/physics/physicsbody.h"
-#include "rpg/physics/physicsworld.h"
 
 typedef struct map_s map_t;
 
@@ -21,29 +20,6 @@ typedef uint16_t entityglobalid_t;
 #define ENTITY_GLOBAL_ID_START 1
 #define ENTITY_GLOBAL_ID_PLAYER 1
 
-// Default collision box for every entity's physics body - matches the old
-// system's exact one-tile footprint.
-#define ENTITY_PHYSICS_EXTENTS_DEFAULT { 1.0f, 1.0f, 1.0f }
-
-// Movement speeds, in grid units per second - chosen to match the feel of
-// the old fixed-duration one-tile-per-step system (12 ticks/tile walking,
-// 6 ticks/tile running, at DUSK_TIME_STEP = 16ms).
-#define ENTITY_MOVE_WALK_SPEED 5.2083f
-#define ENTITY_MOVE_RUN_SPEED 10.4167f
-
-// Movement vectors below this magnitude are treated as no movement.
-#define ENTITY_MOVE_DEADZONE 0.1f
-
-// How far in front of an entity entityGetFacing probes for a target.
-#define ENTITY_INTERACT_RANGE 1.0f
-
-typedef enum {
-  ENTITY_ANIM_IDLE,
-  ENTITY_ANIM_WALK,
-  ENTITY_ANIM_RUN,
-  ENTITY_ANIM_COUNT
-} entityanim_t;
-
 typedef struct entity_s {
   uint8_t id;
   entityglobalid_t globalId;
@@ -52,18 +28,13 @@ typedef struct entity_s {
 
   // Movement
   entitydir_t direction;
-  physicsbody_t body;
-
-  // Derived each frame from body.position (floored) - kept for systems
-  // that still assume an integer grid position (chunk membership, map
-  // area triggers, entity-at-position queries).
   worldpos_t position;
-
-  // Derived each frame from body.position - mirrors the physics position
-  // into render/world-float space (z scaled by WORLD_LAYER_HEIGHT).
+  worldpos_t lastPosition;
   vec3 renderPosition;
 
   entityanim_t animation;
+  float_t animTime;
+  float_t walkEndCooldown;
 
   entityinteract_t interact;
 
@@ -72,9 +43,6 @@ typedef struct entity_s {
 
 extern entity_t ENTITIES[ENTITY_COUNT];
 
-// Shared physics world every entity's body steps against.
-extern physicsworld_t ENTITY_PHYSICS_WORLD;
-
 /**
  * Initializes an entity structure.
  * 
@@ -90,6 +58,30 @@ void entityInit(entity_t *entity, const entitytype_t type);
  */
 void entityUpdate(entity_t *entity);
 
+/**
+ * Returns true if the entity is in a state where it can turn.
+ *
+ * @param entity Pointer to the entity to check.
+ * @returns True if the entity can turn.
+ */
+bool_t entityCanTurn(entity_t *entity);
+
+/**
+ * Returns true if the entity is in a state where it can walk.
+ *
+ * @param entity Pointer to the entity to check.
+ * @returns True if the entity can walk.
+ */
+bool_t entityCanWalk(entity_t *entity);
+
+/**
+ * Returns true if the entity is in a state where it can run.
+ *
+ * @param entity Pointer to the entity to check.
+ * @returns True if the entity can run.
+ */
+bool_t entityCanRun(entity_t *entity);
+
 /**
  * Returns true if the entity is allowed to be unloaded. By default this is
  * true for entities whose global ID falls within the randomly assigned
@@ -101,29 +93,7 @@ void entityUpdate(entity_t *entity);
 bool_t entityCanUnload(entity_t *entity);
 
 /**
- * Moves an entity continuously in a direction, at walking or running
- * speed. Sets the entity's facing to the nearest cardinal direction that
- * matches the movement vector. Must be called every tick the entity
- * should keep moving - unlike the old tile-stepping system this does not
- * complete a move on its own; call entityStop to stop.
- *
- * @param entity Pointer to the entity to move.
- * @param direction Movement vector, magnitude 0-1 (values longer than 1
- *   are clamped to 1, so diagonals aren't faster than cardinals).
- * @param running Whether to move at running speed instead of walking.
- */
-void entityMove(entity_t *entity, const vec2 direction, const bool_t running);
-
-/**
- * Stops an entity's horizontal movement (equivalent to
- * entityMove(entity, {0, 0}, false)).
- *
- * @param entity Pointer to the entity to stop.
- */
-void entityStop(entity_t *entity);
-
-/**
- * Turn an entity to face a new direction, instantly, without moving it.
+ * Turn an entity to face a new direction.
  *
  * @param entity Pointer to the entity to turn.
  * @param direction The direction to face.
@@ -131,10 +101,7 @@ void entityStop(entity_t *entity);
 void entityTurn(entity_t *entity, const entitydir_t direction);
 
 /**
- * Makes an entity walk continuously in a cardinal direction, at walking
- * speed. Convenience wrapper over entityMove for callers that only think
- * in terms of the 4 cardinal directions. Must be called every tick the
- * entity should keep moving.
+ * Make an entity walk in a direction.
  *
  * @param entity Pointer to the entity to make walk.
  * @param direction The direction to walk in.
@@ -142,8 +109,7 @@ void entityTurn(entity_t *entity, const entitydir_t direction);
 void entityWalk(entity_t *entity, const entitydir_t direction);
 
 /**
- * Makes an entity walk continuously in a cardinal direction, at running
- * speed. See entityWalk.
+ * Make an entity run in a direction.
  *
  * @param entity Pointer to the entity to make run.
  * @param direction The direction to run in.
@@ -151,16 +117,13 @@ void entityWalk(entity_t *entity, const entitydir_t direction);
 void entityRun(entity_t *entity, const entitydir_t direction);
 
 /**
- * Finds the closest other entity whose bounds overlap a probe box
- * projected out from the given entity's own bounds, along its current
- * facing direction. Used for interaction targeting - continuous-position
- * aware, unlike an exact tile match.
+ * Gets the entity at a specific world position.
  *
- * @param entity Pointer to the entity to probe from.
- * @param range Distance, in grid units, to project the probe box.
- * @return Pointer to the closest overlapping entity, or NULL if none.
+ * @param map Pointer to the map to check.
+ * @param pos The world position to check.
+ * @return Pointer to the entity at the position, or NULL if none.
  */
-entity_t *entityGetFacing(entity_t *entity, const float_t range);
+entity_t *entityGetAt(const worldpos_t pos);
 
 /**
  * Gets the entity with the given global ID, if one is currently loaded.
@@ -179,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.
@@ -202,12 +168,3 @@ void entityUpdateChunk(entity_t *entity);
  * @param pos The world position to place the entity at.
  */
 void entityPositionSet(entity_t *entity, const worldpos_t pos);
-
-/**
- * Derives position and renderPosition from the entity's physics body, and
- * refreshes chunk membership and map area triggers to match. Called once
- * per entity per frame, after the physics step.
- *
- * @param entity Pointer to the entity to sync.
- */
-void entitySyncFromPhysics(entity_t *entity);

src/dusk/rpg/entity/entitydir.c

@@ -49,26 +49,3 @@ void entityDirGetRelative(
       break;
   }
 }
-
-void entityDirToVec2(const entitydir_t dir, vec2 out) {
-  assertValidEntityDir(dir, "Invalid direction provided");
-  assertNotNull(out, "Output vector cannot be NULL");
-
-  worldunits_t relX, relY;
-  entityDirGetRelative(dir, &relX, &relY);
-  out[0] = (float_t)relX;
-  out[1] = (float_t)relY;
-}
-
-entitydir_t entityDirFromVec2(const vec2 direction) {
-  assertNotNull(direction, "Direction vector cannot be NULL");
-  assertTrue(
-    direction[0] != 0.0f || direction[1] != 0.0f,
-    "Direction vector cannot be zero"
-  );
-
-  if(fabsf(direction[0]) > fabsf(direction[1])) {
-    return direction[0] > 0.0f ? ENTITY_DIR_EAST : ENTITY_DIR_WEST;
-  }
-  return direction[1] > 0.0f ? ENTITY_DIR_NORTH : ENTITY_DIR_SOUTH;
-}

src/dusk/rpg/entity/entitydir.h

@@ -52,22 +52,3 @@ entitydir_t entityDirGetOpposite(const entitydir_t dir);
 void entityDirGetRelative(
   const entitydir_t dir, worldunits_t *relX, worldunits_t *relY
 );
-
-/**
- * Converts a cardinal direction to a unit 2D vector, using the same axis
- * convention as entityDirGetRelative (north = +y, east = +x).
- *
- * @param dir The direction to convert.
- * @param out Output unit vector for the direction.
- */
-void entityDirToVec2(const entitydir_t dir, vec2 out);
-
-/**
- * Quantizes a 2D direction vector to the nearest cardinal direction, by
- * comparing the magnitude of its x and y components.
- *
- * @param direction The direction vector to quantize. Must not be a zero
- *   vector.
- * @return The nearest cardinal direction.
- */
-entitydir_t entityDirFromVec2(const vec2 direction);

src/dusk/rpg/entity/entitypathstep.c

@@ -9,10 +9,6 @@
 #include "entitydir.h"
 #include "assert/assert.h"
 
-// Distance, in grid units, within which the entity is considered to have
-// arrived at its path target.
-#define ENTITY_PATH_ARRIVE_EPSILON 0.05f
-
 bool_t entityPathStep(
   entity_t *entity,
   const worldpos_t target,
@@ -28,44 +24,36 @@ bool_t entityPathStep(
     "Entity pointer is out of bounds"
   );
 
-  const float_t dx = (float_t)target.x - entity->body.position[0];
-  const float_t dy = (float_t)target.y - entity->body.position[1];
-
-  if(
-    fabsf(dx) <= ENTITY_PATH_ARRIVE_EPSILON &&
-    fabsf(dy) <= ENTITY_PATH_ARRIVE_EPSILON
-  ) {
-    entityStop(entity);
+  if(worldPosIsEqual(entity->position, target) && entityCanWalk(entity)) {
     return true;
   }
+  if(!entityCanWalk(entity)) return false;
 
   entitydir_t dir;
-  bool_t horizontal;
-  if(fabsf(dx) > fabsf(dy)) {
-    dir = dx > 0.0f ? ENTITY_DIR_EAST : ENTITY_DIR_WEST;
-    horizontal = true;
+  if(entity->position.x != target.x) {
+    dir = entity->position.x < target.x ? ENTITY_DIR_EAST : ENTITY_DIR_WEST;
+  } else if(entity->position.y != target.y) {
+    dir = entity->position.y < target.y ? ENTITY_DIR_NORTH : ENTITY_DIR_SOUTH;
   } else {
-    dir = dy > 0.0f ? ENTITY_DIR_NORTH : ENTITY_DIR_SOUTH;
-    horizontal = false;
-  }
-
-  // Was the entity trying to walk on this axis last tick, but ended up not
-  // moving (velocity clamped by a collision)? If so, treat it as blocked.
-  if(walkAround) {
-    const uint8_t axis = horizontal ? 0 : 1;
-    const bool_t blockedLastTick =
-      entity->animation != ENTITY_ANIM_IDLE &&
-      fabsf(entity->body.velocity[axis]) <= ENTITY_MOVE_DEADZONE;
-
-    if(blockedLastTick) {
-      const entitydir_t alt = horizontal
-        ? (dy >= 0.0f ? ENTITY_DIR_NORTH : ENTITY_DIR_SOUTH)
-        : (dx >= 0.0f ? ENTITY_DIR_EAST : ENTITY_DIR_WEST);
-      entityWalk(entity, alt);
-      return false;
-    }
+    dir = entity->position.z < target.z ? ENTITY_DIR_NORTH : ENTITY_DIR_SOUTH;
   }
 
   entityWalk(entity, dir);
+
+  if(walkAround && entity->animation == ENTITY_ANIM_IDLE) {
+    // Primary direction blocked - try perpendicular axes.
+    entitydir_t alt, altOpp;
+    if(dir == ENTITY_DIR_EAST || dir == ENTITY_DIR_WEST) {
+      alt = entity->position.y <= target.y
+        ? ENTITY_DIR_NORTH : ENTITY_DIR_SOUTH;
+    } else {
+      alt = entity->position.x <= target.x
+        ? ENTITY_DIR_EAST : ENTITY_DIR_WEST;
+    }
+    altOpp = entityDirGetOpposite(alt);
+    entityWalk(entity, alt);
+    if(entity->animation == ENTITY_ANIM_IDLE) entityWalk(entity, altOpp);
+  }
+
   return false;
 }

src/dusk/rpg/entity/entitypathstep.h

@@ -9,17 +9,15 @@
 #include "entity.h"
 
 /**
- * Continuously walks the entity toward target's X/Y position (Z is left to
- * gravity/ground collision, not deliberate path-stepping). Prefers closing
- * whichever of X/Y currently differs most. Must be called every tick until
- * it returns true. When walkAround is true and the last tick's movement on
- * the current axis was blocked (its velocity on that axis reads as zero
- * despite currently walking), tries a perpendicular direction instead.
+ * Attempts to walk the entity one tile toward target. Prefers resolving X
+ * first, then Y, then Z. Does nothing if the entity cannot currently walk.
+ * When walkAround is true and the preferred direction is blocked by an entity,
+ * tries perpendicular directions to navigate around it.
  *
  * @param entity     Pointer to the entity to move.
- * @param target     The world position to move toward (Z is ignored).
- * @param walkAround Whether to try a perpendicular direction when blocked.
- * @returns true once the entity is within arrival distance of target.
+ * @param target     The world position to move toward.
+ * @param walkAround Whether to try perpendicular directions when blocked.
+ * @returns true if the entity is already at target, false otherwise.
  */
 bool_t entityPathStep(
   entity_t *entity,

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/entity/npc/npcpath.c

@@ -29,9 +29,15 @@ void npcPathAddNode(npc_t *npc, const worldpos_t pos) {
 void npcPathMovement(entity_t *entity) {
   npcpath_t *path = &entity->data.npc.moveData.path;
   if(path->count == 0) return;
+  if(!entityCanWalk(entity)) return;
 
-  const worldpos_t target = path->positions[path->index];
-  if(entityPathStep(entity, target, false)) {
+  // Advance past any waypoints already reached (including the current one).
+  worldpos_t *target = &path->positions[path->index];
+  if(entityPathStep(entity, *target, false)) {
     path->index = (path->index + 1) % path->count;
+    target = &path->positions[path->index];
+    // New target is the same tile - nothing to do this tick
+    if(worldPosIsEqual(entity->position, *target)) return;
+    entityPathStep(entity, *target, false);
   }
 }

src/dusk/rpg/entity/npc/npcturn.c

@@ -23,5 +23,5 @@ void npcRandomTurnMovement(entity_t *entity) {
   turn->timer -= TIME.delta;
   if(turn->timer > 0.0f) return;
   turn->timer = randomFloat(turn->frequencyMin, turn->frequencyMax);
-  entityTurn(entity, (entitydir_t)(rand() % 4));
+  if(entityCanTurn(entity)) entityTurn(entity, (entitydir_t)(rand() % 4));
 }

src/dusk/rpg/entity/npc/npcwalk.c

@@ -16,24 +16,14 @@ void npcRandomWalkInit(npc_t *npc) {
   walk->frequencyMin = NPC_RANDOM_WALK_FREQUENCY_MIN_DEFAULT;
   walk->frequencyMax = NPC_RANDOM_WALK_FREQUENCY_MAX_DEFAULT;
   walk->timer = randomFloat(walk->frequencyMin, walk->frequencyMax);
-  walk->moveDuration = 0.0f;
 }
 
 void npcRandomWalkMovement(entity_t *entity) {
   npcrandomwalk_t *walk = &entity->data.npc.moveData.randomWalk;
-
-  if(walk->moveDuration > 0.0f) {
-    walk->moveDuration -= TIME.delta;
-    entityWalk(entity, walk->direction);
-    if(walk->moveDuration <= 0.0f) entityStop(entity);
-    return;
-  }
-
   walk->timer -= TIME.delta;
   if(walk->timer > 0.0f) return;
   walk->timer = randomFloat(walk->frequencyMin, walk->frequencyMax);
-  walk->direction = (entitydir_t)(rand() % 4);
-  walk->moveDuration = NPC_RANDOM_WALK_MOVE_DURATION_DEFAULT;
+  if(entityCanWalk(entity)) entityWalk(entity, (entitydir_t)(rand() % 4));
 }
 
 void npcRandomTurnAndWalkInit(npc_t *npc) {
@@ -42,30 +32,21 @@ void npcRandomTurnAndWalkInit(npc_t *npc) {
   tw->walk.frequencyMin = NPC_RANDOM_WALK_FREQUENCY_MIN_DEFAULT;
   tw->walk.frequencyMax = NPC_RANDOM_WALK_FREQUENCY_MAX_DEFAULT;
   tw->walk.timer = randomFloat(tw->walk.frequencyMin, tw->walk.frequencyMax);
-  tw->walk.moveDuration = 0.0f;
 }
 
 void npcRandomTurnAndWalkMovement(entity_t *entity) {
   npcrandomturnandwalk_t *tw = &entity->data.npc.moveData.randomTurnAndWalk;
 
-  if(tw->walk.moveDuration > 0.0f) {
-    tw->walk.moveDuration -= TIME.delta;
-    entityWalk(entity, tw->walk.direction);
-    if(tw->walk.moveDuration <= 0.0f) entityStop(entity);
-    return;
-  }
-
   tw->turn.timer -= TIME.delta;
   if(tw->turn.timer <= 0.0f) {
     tw->turn.timer = randomFloat(tw->turn.frequencyMin, tw->turn.frequencyMax);
-    entityTurn(entity, (entitydir_t)(rand() % 4));
+    if(entityCanTurn(entity)) entityTurn(entity, (entitydir_t)(rand() % 4));
   }
 
   tw->walk.timer -= TIME.delta;
   if(tw->walk.timer <= 0.0f) {
     tw->walk.timer = randomFloat(tw->walk.frequencyMin, tw->walk.frequencyMax);
-    tw->walk.direction = (entitydir_t)(rand() % 4);
-    tw->walk.moveDuration = NPC_RANDOM_WALK_MOVE_DURATION_DEFAULT;
+    if(entityCanWalk(entity)) entityWalk(entity, (entitydir_t)(rand() % 4));
   }
 }
 

src/dusk/rpg/entity/npc/npcwalk.h

@@ -8,25 +8,15 @@
 #pragma once
 #include "dusk.h"
 #include "npcturn.h"
-#include "rpg/entity/entitydir.h"
 
 /** Default min/max seconds between NPC random-walk ticks. */
 #define NPC_RANDOM_WALK_FREQUENCY_MIN_DEFAULT 2.0f
 #define NPC_RANDOM_WALK_FREQUENCY_MAX_DEFAULT 5.0f
 
-/** How long a random-walk move lasts once triggered, roughly one tile's
- *  worth of travel at walking speed. */
-#define NPC_RANDOM_WALK_MOVE_DURATION_DEFAULT 0.2f
-
 typedef struct {
   float_t frequencyMin;
   float_t frequencyMax;
   float_t timer;
-
-  // In-progress move state - while moveDuration > 0, movement keeps
-  // walking in direction every tick.
-  float_t moveDuration;
-  entitydir_t direction;
 } npcrandomwalk_t;
 
 typedef struct {

src/dusk/rpg/entity/player.c

@@ -25,10 +25,7 @@ bool_t playerCanInteract(entity_t *entity) {
 
 void playerInput(entity_t *entity) {
   assertNotNull(entity, "Entity pointer cannot be NULL");
-  if(CUTSCENE_SYSTEM.pause & CUTSCENE_PAUSE_PLAYER) {
-    entityStop(entity);
-    return;
-  }
+  if(CUTSCENE_SYSTEM.pause & CUTSCENE_PAUSE_PLAYER) return;
   
   // Toggle game menu on pause
   if(uiGameMenuIsOpen() && inputPressed(INPUT_ACTION_PAUSE)) {
@@ -41,27 +38,63 @@ void playerInput(entity_t *entity) {
   }
 
   // Can player act?
-  if(UI_FOCUS.count > 0) {
-    entityStop(entity);
-    return;
+  if(UI_FOCUS.count > 0) return;
+
+  // Determine direction player may be trying to face/go.
+  const playerinputdirmap_t *dirMap;
+
+  // First pass, we want to prefer a button relative to what the player is 
+  // already facing, e.g. if they hold DOWN and start moving down, then tap
+  // right we want to prefer down over right.
+
+  // Determine current dirmap based on facing direction.
+  dirMap = PLAYER_INPUT_DIR_MAP;
+  do {
+    if(dirMap->direction != entity->direction) continue;
+    break;
+  } while((++dirMap)->action != 0xFF);
+
+  // Are we holding that button?
+  if(!inputIsDown(dirMap->action)) {
+    // No, so we need to check all directions.
+    dirMap = PLAYER_INPUT_DIR_MAP;
+    do {
+      if(!inputIsDown(dirMap->action)) continue;
+      break;
+    } while((++dirMap)->action != 0xFF);
   }
 
-  // Analog/free-angle movement vector from the 4 directional actions -
-  // already normalized so diagonals aren't faster than cardinals, and
-  // preserves real analog magnitude on platforms that bind an actual
-  // gamepad stick to these actions.
-  vec2 moveDir;
-  inputAngle2D(
-    INPUT_ACTION_LEFT, INPUT_ACTION_RIGHT,
-    INPUT_ACTION_DOWN, INPUT_ACTION_UP,
-    moveDir
-  );
+  // Trying to direct?
+  if(dirMap->action != 0xFF) {
+    // Is the player attempting to turn? That is, is the player idle and has the
+    // turn lockout passed?
+    if(entityCanTurn(entity)) {
+      if(entity->direction != dirMap->direction) {
+        entityTurn(entity, dirMap->direction);
+        return;
+      }
+    }
 
-  entityMove(entity, moveDir, inputIsDown(INPUT_ACTION_CANCEL));
+    bool_t running = inputIsDown(INPUT_ACTION_CANCEL);
+    if(running && entityCanRun(entity)) {
+      entityRun(entity, dirMap->direction);
+    } else if(entityCanWalk(entity)) {
+      entityWalk(entity, dirMap->direction);
+    }
+  }
 
   // Interaction
   if(inputPressed(INPUT_ACTION_ACCEPT) && playerCanInteract(entity)) {
-    entity_t *target = entityGetFacing(entity, ENTITY_INTERACT_RANGE);
+    worldunit_t x, y, z;
+    {
+      worldunits_t relX, relY;
+      entityDirGetRelative(entity->direction, &relX, &relY);
+      x = entity->position.x + relX;
+      y = entity->position.y + relY;
+      z = entity->position.z;
+    }
+
+    entity_t *target = entityGetAt((worldpos_t){ x, y, z });
     if(target == NULL) return;
     entityInteractWith(entity, target);
   }

src/dusk/rpg/entity/player.h

@@ -15,6 +15,20 @@ typedef struct {
   void *nothing;
 } player_t;
 
+typedef struct {
+  inputaction_t action;
+  entitydir_t direction;
+} playerinputdirmap_t;
+
+static const playerinputdirmap_t PLAYER_INPUT_DIR_MAP[] = {
+  { INPUT_ACTION_UP, ENTITY_DIR_NORTH },
+  { INPUT_ACTION_DOWN, ENTITY_DIR_SOUTH },
+  { INPUT_ACTION_LEFT, ENTITY_DIR_WEST },
+  { INPUT_ACTION_RIGHT, ENTITY_DIR_EAST },
+
+  { 0xFF, 0xFF }
+};
+
 /**
  * Initializes a player entity.
  * 

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

@@ -3,4 +3,7 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-add_subdirectory(http)
+# 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];
@@ -168,14 +195,6 @@ errorret_t mapChunkLoad(chunk_t *chunk) {
     errorOk();
   }
 
-  // Placeholder-fill with flat ground while the real data streams in
-  // asynchronously - entities standing on this chunk (subject to gravity)
-  // would otherwise fall through the zeroed/empty tiles until
-  // mapChunkLoaded() replaces them with the real data.
-  for(uint32_t i = 0; i < CHUNK_TILE_COUNT; i++) {
-    chunk->tiles[i] = (tile_t){ .shape = TILE_SHAPE_GROUND };
-  }
-
   assertTrue(
     MAP.loadQueueCount < MAP_CHUNK_COUNT,
     "Chunk load queue overflow"
@@ -186,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];
@@ -194,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(
@@ -209,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) {
@@ -380,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();
 }
 
@@ -441,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];
 
@@ -38,7 +39,6 @@ void mapAreaInit(
   area->triggerCount = 0;
 
   memorySet(area->entities, 0, sizeof(area->entities));
-  memorySet(area->lastStepPosition, 0, sizeof(area->lastStepPosition));
 }
 
 bool_t mapAreaIsInside(const maparea_t *area, const worldpos_t position) {
@@ -133,13 +133,9 @@ void mapAreaCheckEntity(entity_t *entity) {
 
     if(isInside && !wasInside) {
       area->entities[entity->id] = 1;
-      area->lastStepPosition[entity->id] = entity->position;
       trigger = MAP_TRIGGER_ENTER;
     } else if(isInside && wasInside) {
-      if(!worldPosIsEqual(entity->position, area->lastStepPosition[entity->id])) {
-        area->lastStepPosition[entity->id] = entity->position;
       trigger = MAP_TRIGGER_STEP;
-      }
     } else if(!isInside && wasInside) {
       area->entities[entity->id] = 0;
       trigger = MAP_TRIGGER_EXIT;
@@ -153,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

@@ -18,8 +18,6 @@ typedef struct maparea_s maparea_t;
 #define MAP_AREA_NOTIFY_NPC (1 << 1)
 #define MAP_AREA_NOTIFY_ALL (MAP_AREA_NOTIFY_PLAYER | MAP_AREA_NOTIFY_NPC)
 
-// Fires once per newly-entered tile while an entity remains inside the
-// area (not once per frame) - see mapAreaCheckEntity.
 #define MAP_TRIGGER_STEP  (1 << 0)
 #define MAP_TRIGGER_ENTER (1 << 1)
 #define MAP_TRIGGER_EXIT  (1 << 2)
@@ -41,11 +39,6 @@ typedef struct maparea_s {
   uint8_t trigger;
   uint8_t entities[ENTITY_COUNT];
 
-  // The floored tile position ENTER or STEP last fired at, per entity.
-  // Used to fire STEP only once per newly-entered tile rather than
-  // every frame the entity remains inside the area.
-  worldpos_t lastStepPosition[ENTITY_COUNT];
-
   // Incremented every time this area's callback is invoked. Lets other
   // systems (e.g. cutscenes) detect "has this area fired since I last
   // checked" without needing to be the callback themselves.
@@ -150,10 +143,8 @@ void mapAreaRemove(const uint8_t id);
  * Checks every active map area against an entity's current position,
  * for areas whose notify flags include the entity's type. Invokes the
  * area's callback with MAP_TRIGGER_ENTER the frame the entity first
- * becomes inside, MAP_TRIGGER_STEP the frame it moves into a different
- * tile while remaining inside, and MAP_TRIGGER_EXIT the frame it leaves.
- * Safe (and expected) to call every frame - trigger conditions are
- * edge-detected against the entity's tile position, not the frame rate.
+ * becomes inside, MAP_TRIGGER_STEP on every subsequent frame it remains
+ * inside, and MAP_TRIGGER_EXIT the frame it leaves.
  *
  * @param entity Pointer to the entity to check.
  */
@@ -168,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/overworld/tileshape.c

@@ -6,28 +6,6 @@
  */
 
 #include "tileshape.h"
-#include "assert/assert.h"
-
-// Per-shape corner heights as [sw, se, ne, nw] offsets (0 or 1) from the
-// tile's base Z layer - transcribed verbatim from the mesh generator's
-// ramp tables (tools/asset/chunk/__main__.py _RAMP_CORNERS,
-// editor/client/public/common/chunkterrain.js RAMP_CORNERS) so the
-// walkable surface always matches what's rendered.
-static const float_t TILE_SHAPE_RAMP_CORNERS[TILE_SHAPE_COUNT][4] = {
-  [TILE_SHAPE_GROUND]               = { 0.0f, 0.0f, 0.0f, 0.0f },
-  [TILE_SHAPE_RAMP_NORTH]           = { 0.0f, 0.0f, 1.0f, 1.0f },
-  [TILE_SHAPE_RAMP_SOUTH]           = { 1.0f, 1.0f, 0.0f, 0.0f },
-  [TILE_SHAPE_RAMP_EAST]            = { 0.0f, 1.0f, 1.0f, 0.0f },
-  [TILE_SHAPE_RAMP_WEST]            = { 1.0f, 0.0f, 0.0f, 1.0f },
-  [TILE_SHAPE_RAMP_NORTHEAST]       = { 0.0f, 0.0f, 1.0f, 0.0f },
-  [TILE_SHAPE_RAMP_NORTHWEST]       = { 0.0f, 0.0f, 0.0f, 1.0f },
-  [TILE_SHAPE_RAMP_SOUTHEAST]       = { 0.0f, 1.0f, 0.0f, 0.0f },
-  [TILE_SHAPE_RAMP_SOUTHWEST]       = { 1.0f, 0.0f, 0.0f, 0.0f },
-  [TILE_SHAPE_RAMP_NORTHEAST_INNER] = { 0.0f, 1.0f, 1.0f, 1.0f },
-  [TILE_SHAPE_RAMP_NORTHWEST_INNER] = { 1.0f, 0.0f, 1.0f, 1.0f },
-  [TILE_SHAPE_RAMP_SOUTHEAST_INNER] = { 1.0f, 1.0f, 1.0f, 0.0f },
-  [TILE_SHAPE_RAMP_SOUTHWEST_INNER] = { 1.0f, 1.0f, 0.0f, 1.0f },
-};
 
 bool_t tileShapeIsWalkable(const tileshape_t shape) {
   switch(shape) {
@@ -59,23 +37,3 @@ bool_t tileShapeIsRamp(const tileshape_t shape) {
       return false;
   }
 }
-
-float_t tileShapeGetRampHeight(
-  const tileshape_t shape, const float_t localX, const float_t localY
-) {
-  assertTrue(localX >= 0.0f && localX <= 1.0f, "localX must be in [0,1]");
-  assertTrue(localY >= 0.0f && localY <= 1.0f, "localY must be in [0,1]");
-
-  const float_t sw = TILE_SHAPE_RAMP_CORNERS[shape][0];
-  const float_t se = TILE_SHAPE_RAMP_CORNERS[shape][1];
-  const float_t ne = TILE_SHAPE_RAMP_CORNERS[shape][2];
-  const float_t nw = TILE_SHAPE_RAMP_CORNERS[shape][3];
-
-  // Planar interpolation per triangle, split along the SW-NE diagonal -
-  // matches the two-triangle quad the mesh generator emits exactly,
-  // rather than a smooth (but unrendered) bilinear blend.
-  if(localY <= localX) {
-    return sw + (se - sw) * localX + (ne - se) * localY;
-  }
-  return sw + (ne - nw) * localX + (nw - sw) * localY;
-}

src/dusk/rpg/overworld/tileshape.h

@@ -43,20 +43,3 @@ bool_t tileShapeIsRamp(const tileshape_t shape);
  * @return bool_t True if walkable, false if not.
  */
 bool_t tileShapeIsWalkable(const tileshape_t shape);
-
-/**
- * Returns the floor height offset (0 to 1, above the tile's base Z
- * layer) for the given tile shape at a local position within the tile.
- * Flat ground is always 0. Ramp shapes vary linearly across the tile,
- * matching the two-triangle mesh generated for rendering (split along
- * the SW-NE diagonal) exactly, so the walkable surface and the
- * rendered surface never disagree.
- *
- * @param shape The tile shape to query.
- * @param localX Local X position within the tile, in [0, 1].
- * @param localY Local Y position within the tile, in [0, 1].
- * @return float_t The height offset above the tile's base Z layer.
- */
-float_t tileShapeGetRampHeight(
-  const tileshape_t shape, const float_t localX, const float_t localY
-);

src/dusk/rpg/physics/physicsbody.c

@@ -1,36 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "physicsbody.h"
-#include "assert/assert.h"
-
-void physicsBodyInit(
-  physicsbody_t *body, const vec3 position, const vec3 extents
-) {
-  assertNotNull(body, "body must not be null");
-  assertNotNull(position, "position must not be null");
-  assertNotNull(extents, "extents must not be null");
-  assertTrue(extents[0] > 0.0f, "extents.x must be greater than 0");
-  assertTrue(extents[1] > 0.0f, "extents.y must be greater than 0");
-  assertTrue(extents[2] > 0.0f, "extents.z must be greater than 0");
-
-  glm_vec3_copy((float_t *)position, body->position);
-  glm_vec3_copy((float_t *)extents, body->extents);
-  glm_vec3_zero(body->velocity);
-  body->grounded = false;
-}
-
-void physicsBodyGetBounds(
-  const physicsbody_t *body, vec3 outMin, vec3 outMax
-) {
-  assertNotNull(body, "body must not be null");
-  assertNotNull(outMin, "outMin must not be null");
-  assertNotNull(outMax, "outMax must not be null");
-
-  glm_vec3_copy((float_t *)body->position, outMin);
-  glm_vec3_add((float_t *)body->position, (float_t *)body->extents, outMax);
-}

src/dusk/rpg/physics/physicsbody.h

@@ -1,55 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "util/math.h"
-
-typedef struct physicsbody_s {
-  // Base/foot position, in raw grid units (same convention as worldpos_t -
-  // 1.0 equals one tile in X/Y, one Z-layer in Z). Not pre-scaled by
-  // WORLD_LAYER_HEIGHT, which is a cosmetic render-space value only.
-  vec3 position;
-
-  // Velocity, in grid units per second, per axis.
-  vec3 velocity;
-
-  // Full box size, in grid units. The box is anchored at position on all
-  // three axes and extends in the positive direction - i.e. it occupies
-  // [position, position + extents) - matching the tile grid's own
-  // convention that tile n occupies [n, n + 1).
-  vec3 extents;
-
-  // True if the last physicsWorldStep clamped a downward Z velocity
-  // against a walkable tile beneath the body.
-  bool_t grounded;
-} physicsbody_t;
-
-/**
- * Initializes a physics body at the given position with the given extents.
- * Velocity is zeroed and grounded is set to false.
- *
- * @param body Pointer to the physics body to initialize.
- * @param position The initial position of the body.
- * @param extents The size of the body's collision box.
- */
-void physicsBodyInit(
-  physicsbody_t *body, const vec3 position, const vec3 extents
-);
-
-/**
- * Computes the world-space min/max bounds of a physics body's collision
- * box, from its position and extents. The box is anchored at position
- * and extends in the positive direction on every axis, so outMin equals
- * position and outMax equals position + extents.
- *
- * @param body Pointer to the physics body.
- * @param outMin Output, set to the box's minimum corner.
- * @param outMax Output, set to the box's maximum corner.
- */
-void physicsBodyGetBounds(
-  const physicsbody_t *body, vec3 outMin, vec3 outMax
-);

src/dusk/rpg/physics/physicsworld.c

@@ -1,423 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "physicsworld.h"
-#include "assert/assert.h"
-#include "rpg/overworld/map.h"
-#include "rpg/overworld/tile.h"
-#include "rpg/overworld/tileshape.h"
-#include "rpg/overworld/worldpos.h"
-
-// Tolerance used when converting a float boundary coordinate into a tile
-// column/layer index, so that a coordinate sitting exactly on a tile
-// boundary is treated as belonging to the tile it is entering/leaving,
-// not the neighbour on the far side of the boundary.
-#define PHYSICS_EPSILON 0.0001f
-
-void physicsWorldInit(
-  physicsworld_t *world,
-  const float_t gravity,
-  const float_t terminalVelocity
-) {
-  assertNotNull(world, "world must not be null");
-  assertTrue(terminalVelocity > 0.0f, "terminalVelocity must be positive");
-
-  world->gravity = gravity;
-  world->terminalVelocity = terminalVelocity;
-}
-
-void physicsWorldStep(
-  const physicsworld_t *world,
-  physicsbody_t *body,
-  const float_t dt,
-  physicsbody_t * const *others,
-  const uint32_t othersCount
-) {
-  assertNotNull(world, "world must not be null");
-  assertNotNull(body, "body must not be null");
-
-  body->velocity[2] -= world->gravity * dt;
-  body->velocity[2] = mathClamp(
-    body->velocity[2], -world->terminalVelocity, world->terminalVelocity
-  );
-
-  physicsWorldResolveAxisX(world, body, dt, others, othersCount);
-  physicsWorldResolveAxisY(world, body, dt, others, othersCount);
-  physicsWorldResolveAxisZ(world, body, dt, others, othersCount);
-}
-
-void physicsWorldResolveAxisX(
-  const physicsworld_t *world,
-  physicsbody_t *body,
-  const float_t dt,
-  physicsbody_t * const *others,
-  const uint32_t othersCount
-) {
-  assertNotNull(world, "world must not be null");
-  assertNotNull(body, "body must not be null");
-
-  const float_t vx = body->velocity[0];
-  if(vx == 0.0f) return;
-
-  vec3 min, max;
-  physicsBodyGetBounds(body, min, max);
-
-  const worldunit_t yStart = (worldunit_t)floorf(min[1] + PHYSICS_EPSILON);
-  const worldunit_t yEnd = (worldunit_t)floorf(max[1] - PHYSICS_EPSILON);
-  const worldunit_t layerZ =
-    (worldunit_t)floorf(body->position[2] + PHYSICS_EPSILON);
-
-  if(vx > 0.0f) {
-    const worldunit_t oldColMax =
-      (worldunit_t)floorf(max[0] - PHYSICS_EPSILON);
-    const float_t newMax = max[0] + vx * dt;
-    const worldunit_t newColMax =
-      (worldunit_t)floorf(newMax - PHYSICS_EPSILON);
-
-    for(worldunit_t col = oldColMax + 1; col <= newColMax; col++) {
-      bool_t blocked = false;
-      for(worldunit_t y = yStart; y <= yEnd; y++) {
-        worldunit_t unusedBase;
-        tileshape_t unusedShape;
-        if(
-          !physicsWorldFindColumnTile(
-            col, y, layerZ, true, &unusedBase, &unusedShape
-          )
-        ) {
-          blocked = true;
-          break;
-        }
-      }
-
-      if(blocked) {
-        body->position[0] = (float_t)col - body->extents[0];
-        body->velocity[0] = 0.0f;
-        physicsWorldResolveBodyOverlap(body, 0, others, othersCount);
-        return;
-      }
-    }
-
-    body->position[0] += vx * dt;
-  } else {
-    const worldunit_t oldColMin =
-      (worldunit_t)floorf(min[0] + PHYSICS_EPSILON);
-    const float_t newMin = min[0] + vx * dt;
-    const worldunit_t newColMin =
-      (worldunit_t)floorf(newMin + PHYSICS_EPSILON);
-
-    for(worldunit_t col = oldColMin - 1; col >= newColMin; col--) {
-      bool_t blocked = false;
-      for(worldunit_t y = yStart; y <= yEnd; y++) {
-        worldunit_t unusedBase;
-        tileshape_t unusedShape;
-        if(
-          !physicsWorldFindColumnTile(
-            col, y, layerZ, true, &unusedBase, &unusedShape
-          )
-        ) {
-          blocked = true;
-          break;
-        }
-      }
-
-      if(blocked) {
-        body->position[0] = (float_t)(col + 1);
-        body->velocity[0] = 0.0f;
-        physicsWorldResolveBodyOverlap(body, 0, others, othersCount);
-        return;
-      }
-    }
-
-    body->position[0] += vx * dt;
-  }
-
-  physicsWorldResolveBodyOverlap(body, 0, others, othersCount);
-}
-
-void physicsWorldResolveAxisY(
-  const physicsworld_t *world,
-  physicsbody_t *body,
-  const float_t dt,
-  physicsbody_t * const *others,
-  const uint32_t othersCount
-) {
-  assertNotNull(world, "world must not be null");
-  assertNotNull(body, "body must not be null");
-
-  const float_t vy = body->velocity[1];
-  if(vy == 0.0f) return;
-
-  vec3 min, max;
-  physicsBodyGetBounds(body, min, max);
-
-  const worldunit_t xStart = (worldunit_t)floorf(min[0] + PHYSICS_EPSILON);
-  const worldunit_t xEnd = (worldunit_t)floorf(max[0] - PHYSICS_EPSILON);
-  const worldunit_t layerZ =
-    (worldunit_t)floorf(body->position[2] + PHYSICS_EPSILON);
-
-  if(vy > 0.0f) {
-    const worldunit_t oldRowMax =
-      (worldunit_t)floorf(max[1] - PHYSICS_EPSILON);
-    const float_t newMax = max[1] + vy * dt;
-    const worldunit_t newRowMax =
-      (worldunit_t)floorf(newMax - PHYSICS_EPSILON);
-
-    for(worldunit_t row = oldRowMax + 1; row <= newRowMax; row++) {
-      bool_t blocked = false;
-      for(worldunit_t x = xStart; x <= xEnd; x++) {
-        worldunit_t unusedBase;
-        tileshape_t unusedShape;
-        if(
-          !physicsWorldFindColumnTile(
-            x, row, layerZ, true, &unusedBase, &unusedShape
-          )
-        ) {
-          blocked = true;
-          break;
-        }
-      }
-
-      if(blocked) {
-        body->position[1] = (float_t)row - body->extents[1];
-        body->velocity[1] = 0.0f;
-        physicsWorldResolveBodyOverlap(body, 1, others, othersCount);
-        return;
-      }
-    }
-
-    body->position[1] += vy * dt;
-  } else {
-    const worldunit_t oldRowMin =
-      (worldunit_t)floorf(min[1] + PHYSICS_EPSILON);
-    const float_t newMin = min[1] + vy * dt;
-    const worldunit_t newRowMin =
-      (worldunit_t)floorf(newMin + PHYSICS_EPSILON);
-
-    for(worldunit_t row = oldRowMin - 1; row >= newRowMin; row--) {
-      bool_t blocked = false;
-      for(worldunit_t x = xStart; x <= xEnd; x++) {
-        worldunit_t unusedBase;
-        tileshape_t unusedShape;
-        if(
-          !physicsWorldFindColumnTile(
-            x, row, layerZ, true, &unusedBase, &unusedShape
-          )
-        ) {
-          blocked = true;
-          break;
-        }
-      }
-
-      if(blocked) {
-        body->position[1] = (float_t)(row + 1);
-        body->velocity[1] = 0.0f;
-        physicsWorldResolveBodyOverlap(body, 1, others, othersCount);
-        return;
-      }
-    }
-
-    body->position[1] += vy * dt;
-  }
-
-  physicsWorldResolveBodyOverlap(body, 1, others, othersCount);
-}
-
-void physicsWorldResolveAxisZ(
-  const physicsworld_t *world,
-  physicsbody_t *body,
-  const float_t dt,
-  physicsbody_t * const *others,
-  const uint32_t othersCount
-) {
-  assertNotNull(world, "world must not be null");
-  assertNotNull(body, "body must not be null");
-
-  vec3 min, max;
-  physicsBodyGetBounds(body, min, max);
-
-  const worldunit_t xStart = (worldunit_t)floorf(min[0] + PHYSICS_EPSILON);
-  const worldunit_t xEnd = (worldunit_t)floorf(max[0] - PHYSICS_EPSILON);
-  const worldunit_t yStart = (worldunit_t)floorf(min[1] + PHYSICS_EPSILON);
-  const worldunit_t yEnd = (worldunit_t)floorf(max[1] - PHYSICS_EPSILON);
-  const worldunit_t layer =
-    (worldunit_t)floorf(body->position[2] + PHYSICS_EPSILON);
-  const float_t vz = body->velocity[2];
-
-  // Whether a column not directly at the current layer should still
-  // count as walkable if its own tile sits one layer above or below -
-  // each column only ever has one real tile, so this is what lets a
-  // column just crossed into horizontally (see the +/-1 layer check in
-  // ResolveAxisX/Y) be recognised here too, whether its tile sits one
-  // layer above (finishing a climb) or below (starting a descent).
-  // Gating on horizontal movement (rather than vz's sign) keeps this
-  // from ever mistaking a genuine ceiling directly above a stationary
-  // body - e.g. the frame right after being blocked by one, when vz has
-  // just been zeroed - for ground to snap up onto.
-  const bool_t movingHorizontally =
-    body->velocity[0] != 0.0f || body->velocity[1] != 0.0f;
-
-  // Walkability across the whole footprint - every spanned column must
-  // have a walkable tile (at the current layer, or the +/-1 fallback
-  // above) for this layer to count as solid, same as before ramps.
-  bool_t solid = true;
-  for(worldunit_t x = xStart; x <= xEnd && solid; x++) {
-    for(worldunit_t y = yStart; y <= yEnd && solid; y++) {
-      worldunit_t unusedBase;
-      tileshape_t shape;
-      if(
-        !physicsWorldFindColumnTile(
-          x, y, layer, movingHorizontally, &unusedBase, &shape
-        )
-      ) {
-        solid = false;
-      }
-    }
-  }
-
-  // Ground/ramp height comes from a single reference column - the
-  // footprint's center, not the tallest of every spanned column. A 1-
-  // wide body sitting at a non-integer position always straddles two
-  // columns (e.g. [1.01, 2.01)); using the tallest of them would yank a
-  // body barely touching a taller neighbouring column onto its full
-  // height, rather than the column it's actually standing on.
-  float_t groundHeight = (float_t)layer;
-  if(solid) {
-    const float_t centerX = body->position[0] + body->extents[0] * 0.5f;
-    const float_t centerY = body->position[1] + body->extents[1] * 0.5f;
-    const worldunit_t centerCol =
-      (worldunit_t)floorf(centerX + PHYSICS_EPSILON);
-    const worldunit_t centerRow =
-      (worldunit_t)floorf(centerY + PHYSICS_EPSILON);
-
-    worldunit_t tileBase;
-    tileshape_t shape;
-    physicsWorldFindColumnTile(
-      centerCol, centerRow, layer, movingHorizontally, &tileBase, &shape
-    );
-
-    const float_t localX = mathClamp(centerX - centerCol, 0.0f, 1.0f);
-    const float_t localY = mathClamp(centerY - centerRow, 0.0f, 1.0f);
-    groundHeight =
-      (float_t)tileBase + tileShapeGetRampHeight(shape, localX, localY);
-  }
-
-  // Standing on, or embedded below, the ground/ramp surface - snap up to
-  // it regardless of vertical velocity direction. Gravity only ever
-  // pulls down, so walking onto a rising ramp needs this explicit lift
-  // rather than just a fall-clamp.
-  if(solid && body->position[2] < groundHeight) {
-    body->position[2] = groundHeight;
-    if(vz <= 0.0f) body->velocity[2] = 0.0f;
-    body->grounded = true;
-    physicsWorldResolveBodyOverlap(body, 2, others, othersCount);
-    return;
-  }
-
-  if(vz == 0.0f) return;
-
-  if(vz < 0.0f) {
-    const float_t newZ = body->position[2] + vz * dt;
-    if(solid && newZ < groundHeight) {
-      body->position[2] = groundHeight;
-      body->velocity[2] = 0.0f;
-      body->grounded = true;
-    } else {
-      body->position[2] = newZ;
-      body->grounded = false;
-    }
-  } else {
-    const float_t head = max[2];
-    const worldunit_t ceilLayer = (worldunit_t)ceilf(head - PHYSICS_EPSILON);
-
-    bool_t ceilingSolid = true;
-    for(worldunit_t x = xStart; x <= xEnd && ceilingSolid; x++) {
-      for(worldunit_t y = yStart; y <= yEnd && ceilingSolid; y++) {
-        const worldpos_t pos = { x, y, ceilLayer };
-        if(!tileShapeIsWalkable(mapGetTile(pos).shape)) ceilingSolid = false;
-      }
-    }
-
-    const float_t newHead = head + vz * dt;
-    if(ceilingSolid && newHead > (float_t)ceilLayer) {
-      body->position[2] = (float_t)ceilLayer - body->extents[2];
-      body->velocity[2] = 0.0f;
-    } else {
-      body->position[2] += vz * dt;
-    }
-  }
-
-  physicsWorldResolveBodyOverlap(body, 2, others, othersCount);
-}
-
-bool_t physicsWorldFindColumnTile(
-  const worldunit_t x,
-  const worldunit_t y,
-  const worldunit_t layer,
-  const bool_t movingHorizontally,
-  worldunit_t *outBase,
-  tileshape_t *outShape
-) {
-  assertNotNull(outBase, "outBase must not be null");
-  assertNotNull(outShape, "outShape must not be null");
-
-  tile_t tile = mapGetTile((worldpos_t){ x, y, layer });
-  worldunit_t base = layer;
-
-  if(!tileShapeIsWalkable(tile.shape) && movingHorizontally) {
-    const tile_t tileAbove =
-      mapGetTile((worldpos_t){ x, y, (worldunit_t)(layer + 1) });
-    if(tileShapeIsWalkable(tileAbove.shape)) {
-      tile = tileAbove;
-      base = (worldunit_t)(layer + 1);
-    } else {
-      const tile_t tileBelow =
-        mapGetTile((worldpos_t){ x, y, (worldunit_t)(layer - 1) });
-      if(tileShapeIsWalkable(tileBelow.shape)) {
-        tile = tileBelow;
-        base = (worldunit_t)(layer - 1);
-      }
-    }
-  }
-
-  *outBase = base;
-  *outShape = tile.shape;
-  return tileShapeIsWalkable(tile.shape);
-}
-
-void physicsWorldResolveBodyOverlap(
-  physicsbody_t *body,
-  const uint8_t axis,
-  physicsbody_t * const *others,
-  const uint32_t othersCount
-) {
-  assertNotNull(body, "body must not be null");
-  assertTrue(axis < 3, "axis must be 0, 1 or 2");
-
-  const float_t v = body->velocity[axis];
-  if(v == 0.0f) return;
-
-  for(uint32_t i = 0; i < othersCount; i++) {
-    physicsbody_t *other = others[i];
-    if(other == NULL || other == body) continue;
-
-    vec3 min, max;
-    physicsBodyGetBounds(body, min, max);
-    vec3 oMin, oMax;
-    physicsBodyGetBounds(other, oMin, oMax);
-
-    if(min[0] >= oMax[0] || max[0] <= oMin[0]) continue;
-    if(min[1] >= oMax[1] || max[1] <= oMin[1]) continue;
-    if(min[2] >= oMax[2] || max[2] <= oMin[2]) continue;
-
-    if(v > 0.0f) {
-      body->position[axis] -= max[axis] - oMin[axis];
-    } else {
-      body->position[axis] += oMax[axis] - min[axis];
-    }
-    body->velocity[axis] = 0.0f;
-  }
-}

src/dusk/rpg/physics/physicsworld.h

@@ -1,201 +0,0 @@
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "physicsbody.h"
-#include "rpg/overworld/worldpos.h"
-#include "rpg/overworld/tileshape.h"
-
-#define PHYSICS_WORLD_GRAVITY_DEFAULT 20.0f
-#define PHYSICS_WORLD_TERMINAL_VELOCITY_DEFAULT 40.0f
-
-typedef struct physicsworld_s {
-  // Downward acceleration applied to velocity.z every step, in grid units
-  // per second squared.
-  float_t gravity;
-
-  // Maximum magnitude velocity.z may reach while falling, in grid units
-  // per second. A safety clamp bounding how far a single step can move,
-  // to limit (not eliminate) the tunneling limitation documented on
-  // physicsWorldStep.
-  float_t terminalVelocity;
-} physicsworld_t;
-
-/**
- * Initializes a physics world with the given gravity and terminal
- * velocity.
- *
- * @param world Pointer to the physics world to initialize.
- * @param gravity Downward acceleration applied every step.
- * @param terminalVelocity Maximum falling speed.
- */
-void physicsWorldInit(
-  physicsworld_t *world,
-  const float_t gravity,
-  const float_t terminalVelocity
-);
-
-/**
- * Advances a body by one timestep: applies gravity, integrates velocity
- * into position (semi-implicit Euler), and resolves collisions against
- * the tile map one axis at a time (X, then Y, then Z), clamping position
- * and zeroing velocity on any axis that hits a tile boundary. After each
- * axis's tile resolution, also resolves overlap against any given other
- * bodies (see physicsWorldResolveBodyOverlap) - so another body is
- * treated as solid too, not just the tile map.
- *
- * Ramp tiles are walkable at a continuously-varying height (see
- * tileShapeGetRampHeight) rather than a flat Z layer - walking across one
- * lifts or drops the body smoothly to match the tile's sloped surface,
- * snapping upward as needed since gravity alone only ever pulls down.
- *
- * Known limitations, deliberately out of scope for this very basic pass:
- *  - Ceiling/head-bump checks are still flat and ramp-unaware - only the
- *    walking surface accounts for slope, not the underside of a ramp
- *    above the body.
- *  - Descending a fast-dropping ramp relies on gravity to close the gap
- *    each step rather than an explicit "snap down" - imperceptible at
- *    normal walk/run speeds given the default gravity, but a real
- *    asymmetry with the "snap up" case.
- *  - A body whose footprint spans multiple tile columns (unused by any
- *    entity today - all default to a 1x1 footprint) queries each
- *    column's ramp height using its own clamped local coordinate
- *    independently, rather than blending a single surface across tiles.
- *  - Limited wall/hole distinction - horizontal movement checks the
- *    body's current Z layer plus one layer above and below (each column
- *    only ever stores a single tile at one Z layer, so this covers
- *    stepping onto an adjacent ascending or descending ramp/ledge
- *    whose own layer differs from the body's current one). A column
- *    with nothing walkable within one layer either way is still treated
- *    as a solid wall rather than a deeper edge to fall from.
- *  - A single step can tunnel through an intervening solid Z layer if
- *    velocity.z * dt exceeds one grid unit; terminalVelocity bounds this
- *    but does not eliminate it for very small/thin floors.
- *  - Body-vs-body resolution only reacts to the axis currently being
- *    resolved - two bodies already overlapping on every axis, with no
- *    velocity on any of them, are never proactively separated.
- *
- * @param world Physics world configuration.
- * @param body The body to step. Its position/velocity/grounded fields are
- *   updated in place.
- * @param dt Timestep, in seconds (use DUSK_TIME_STEP for the fixed step).
- * @param others Array of pointers to other bodies to treat as solid.
- *   Pass NULL (with othersCount 0) to resolve against the tile map only.
- * @param othersCount Number of entries in others.
- */
-void physicsWorldStep(
-  const physicsworld_t *world,
-  physicsbody_t *body,
-  const float_t dt,
-  physicsbody_t * const *others,
-  const uint32_t othersCount
-);
-
-/**
- * Resolves the body's movement along the X axis for this step, clamping
- * position and zeroing velocity.x if a non-walkable column, or another
- * body, blocks the move. Declared publicly as an internal step helper,
- * not a stable public API on its own.
- *
- * @param world Physics world configuration.
- * @param body The body to resolve.
- * @param dt Timestep, in seconds.
- * @param others Array of pointers to other bodies to treat as solid.
- * @param othersCount Number of entries in others.
- */
-void physicsWorldResolveAxisX(
-  const physicsworld_t *world,
-  physicsbody_t *body,
-  const float_t dt,
-  physicsbody_t * const *others,
-  const uint32_t othersCount
-);
-
-/**
- * Resolves the body's movement along the Y axis for this step. See
- * physicsWorldResolveAxisX.
- *
- * @param world Physics world configuration.
- * @param body The body to resolve.
- * @param dt Timestep, in seconds.
- * @param others Array of pointers to other bodies to treat as solid.
- * @param othersCount Number of entries in others.
- */
-void physicsWorldResolveAxisY(
-  const physicsworld_t *world,
-  physicsbody_t *body,
-  const float_t dt,
-  physicsbody_t * const *others,
-  const uint32_t othersCount
-);
-
-/**
- * Resolves the body's movement along the Z axis for this step, clamping
- * against walkable tile planes above and below the body and updating
- * grounded. See physicsWorldResolveAxisX.
- *
- * @param world Physics world configuration.
- * @param body The body to resolve.
- * @param dt Timestep, in seconds.
- * @param others Array of pointers to other bodies to treat as solid.
- * @param othersCount Number of entries in others.
- */
-void physicsWorldResolveAxisZ(
-  const physicsworld_t *world,
-  physicsbody_t *body,
-  const float_t dt,
-  physicsbody_t * const *others,
-  const uint32_t othersCount
-);
-
-/**
- * Resolves the body's overlap against a set of other bodies along a
- * single axis: if the body's bounds fully overlap (on all 3 axes)
- * another body's bounds, pushes the body back along the given axis by
- * the overlap depth on that axis, in the opposite direction of its
- * current velocity on that axis, and zeroes that velocity component.
- * Does nothing if the body has no velocity on that axis, since there is
- * then no direction to know which way to push it out.
- *
- * @param body The body to resolve.
- * @param axis The axis to resolve overlap on (0 = x, 1 = y, 2 = z).
- * @param others Array of pointers to other bodies to check against.
- * @param othersCount Number of entries in others.
- */
-void physicsWorldResolveBodyOverlap(
-  physicsbody_t *body,
-  const uint8_t axis,
-  physicsbody_t * const *others,
-  const uint32_t othersCount
-);
-
-/**
- * Finds the walkable tile for a single tile column (x, y) near the given
- * layer: checks the layer itself first, and - only if movingHorizontally
- * is true, so a stationary body never mistakes a genuine ceiling above
- * it for ground - falls back to one layer above then one layer below.
- * Each column only ever has one real tile, so this lets a column whose
- * own tile sits adjacent to the current layer (e.g. finishing a climb
- * onto, or starting a descent from, an adjacent ramp/ledge) be found.
- *
- * @param x Column X coordinate.
- * @param y Column Y coordinate.
- * @param layer The layer to check first.
- * @param movingHorizontally Whether to also try one layer above/below.
- * @param outBase Output, set to the layer the found tile actually sits
- *   at (layer, layer + 1, or layer - 1).
- * @param outShape Output, set to the found tile's shape.
- * @return true if a walkable tile was found.
- */
-bool_t physicsWorldFindColumnTile(
-  const worldunit_t x,
-  const worldunit_t y,
-  const worldunit_t layer,
-  const bool_t movingHorizontally,
-  worldunit_t *outBase,
-  tileshape_t *outShape
-);

src/dusk/rpg/rpg.c

@@ -7,38 +7,42 @@
 
 #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 "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));
 
-  physicsWorldInit(
-    &ENTITY_PHYSICS_WORLD,
-    PHYSICS_WORLD_GRAVITY_DEFAULT,
-    PHYSICS_WORLD_TERMINAL_VELOCITY_DEFAULT
-  );
+  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();
 
   errorChain(mapInit());
@@ -47,7 +51,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];
@@ -56,31 +62,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();
 }
@@ -95,12 +81,17 @@ errorret_t rpgUpdate(void) {
   // 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/CMakeLists.txt

@@ -0,0 +1,19 @@
+# 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
+    storyflag.c
+)
+
+# Story Flag Definitions
+dusk_run_python(
+  dusk_story_defs
+  tools.story
+    --csv ${CMAKE_CURRENT_SOURCE_DIR}/storyflag.csv
+    --output ${DUSK_GENERATED_HEADERS_DIR}/rpg/story/storyflagvalue.h
+)
+add_dependencies(${DUSK_LIBRARY_TARGET_NAME} dusk_story_defs)

src/dusk/rpg/story/storyflag.c

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "storyflag.h"
+#include "assert/assert.h"
+
+void storyFlagSet(const storyflag_t flag, const storyflagvalue_t value) {
+  assertTrue(flag > STORY_FLAG_NULL && flag < STORY_FLAG_COUNT, "Bad Flag");
+  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.csv

@@ -0,0 +1,2 @@
+id,description,initial
+test,"Test flag for debugging purposes",1

src/dusk/rpg/story/storyflag.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 "rpg/story/storyflagvalue.h"
+#include "save/save.h"
+
+/**
+ * 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) (saveGetSlot(SAVE_ACTIVE_SLOT)->storyFlags[(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);