Prog on knulli

.github/workflows/build.yml

@@ -1,8 +1,13 @@
 name: Build Dusk
+
 on:
   push:
-    tags:
+    branches:
-      - '*'
+      - main
+  pull_request:
+    branches:
+      - main
+
 jobs:
   run-tests:
     runs-on: ubuntu-latest
@@ -50,42 +55,6 @@ jobs:
           path: ./git-artifcats/Dusk
           if-no-files-found: error
 
-  # build-vita:
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - name: Checkout repository
-  #       uses: actions/checkout@v6
-  #     - name: Set up Docker
-  #       uses: docker/setup-docker-action@v5
-  #     - name: Build Vita
-  #       run: ./scripts/build-vita-docker.sh
-  #     - name: Upload Vita binary
-  #       uses: actions/upload-artifact@v6
-  #       with:
-  #         name: dusk-vita
-  #         path: build-vita/Dusk.vpk
-  #         if-no-files-found: error
-
-  build-knulli:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-      - name: Set up Docker
-        uses: docker/setup-docker-action@v5
-      - name: Build knulli
-        run: ./scripts/build-knulli-docker.sh
-      - name: Move output to Dusk subfolder
-        run: |
-          mkdir -p ./git-artifcats/Dusk
-          cp -r build-knulli/dusk ./git-artifcats/Dusk
-      - name: Upload knulli binary
-        uses: actions/upload-artifact@v6
-        with:
-          name: dusk-knulli
-          path: ./git-artifcats/Dusk
-          if-no-files-found: error
-
   build-gamecube:
     runs-on: ubuntu-latest
     steps:
@@ -105,29 +74,6 @@ jobs:
         with:
           name: dusk-gamecube
           path: ./git-artifcats/Dusk
-          if-no-files-found: error
-
-  build-gamecube-iso:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-      - name: Set up Docker
-        uses: docker/setup-docker-action@v5
-      - name: Build GameCube ISO
-        run: ./scripts/build-gamecube-iso-docker.sh
-      - name: Copy output files.
-        run: |
-          mkdir -p ./git-artifcats/Dusk
-          cp build-gamecube-iso/Dusk-NTSC-J.iso ./git-artifcats/Dusk/Dusk-NTSC-J.iso
-          cp build-gamecube-iso/Dusk-NTSC-U.iso ./git-artifcats/Dusk/Dusk-NTSC-U.iso
-          cp build-gamecube-iso/Dusk-PAL.iso    ./git-artifcats/Dusk/Dusk-PAL.iso
-      - name: Upload GameCube ISO
-        uses: actions/upload-artifact@v6
-        with:
-          name: dusk-gamecube-iso
-          path: ./git-artifcats/Dusk
-          if-no-files-found: error
 
   build-wii:
     runs-on: ubuntu-latest
@@ -141,34 +87,11 @@ jobs:
       - name: Copy output files.
         run: |
           mkdir -p ./git-artifcats/Dusk/apps/Dusk
-          cp build-wii/boot.dol ./git-artifcats/Dusk/apps/Dusk/boot.dol
+          cp build-wii/Dusk.dol ./git-artifcats/Dusk/apps/Dusk/Dusk.dol
           cp build-wii/dusk.dsk ./git-artifcats/Dusk/apps/Dusk/dusk.dsk
-          cp build-wii/meta.xml ./git-artifcats/Dusk/apps/Dusk/meta.xml
+          cp docker/dolphin/meta.xml ./git-artifcats/Dusk/apps/Dusk/meta.xml
       - name: Upload Wii binary
         uses: actions/upload-artifact@v6
         with:
           name: dusk-wii
           path: ./git-artifcats/Dusk
-          if-no-files-found: error
-
-  build-wii-iso:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-      - name: Set up Docker
-        uses: docker/setup-docker-action@v5
-      - name: Build Wii ISO
-        run: ./scripts/build-wii-iso-docker.sh
-      - name: Copy output files.
-        run: |
-          mkdir -p ./git-artifcats/Dusk
-          cp build-wii-iso/Dusk-NTSC-J.iso ./git-artifcats/Dusk/Dusk-NTSC-J.iso
-          cp build-wii-iso/Dusk-NTSC-U.iso ./git-artifcats/Dusk/Dusk-NTSC-U.iso
-          cp build-wii-iso/Dusk-PAL.iso    ./git-artifcats/Dusk/Dusk-PAL.iso
-      - name: Upload Wii ISO
-        uses: actions/upload-artifact@v6
-        with:
-          name: dusk-wii-iso
-          path: ./git-artifcats/Dusk
-          if-no-files-found: error

.gitignore

@@ -83,6 +83,7 @@ assets/borrowed
 .VSCode*
 
 /vita
+
 ._*
 
 *~
@@ -104,6 +105,3 @@ yarn.lock
 
 /build2
 /build*
-/assets/test
-/tools_old
-/assets/test.png

CLAUDE.md

@@ -1,432 +0,0 @@
-# Dusk — Claude Code rules
-
-## File headers
-Every C, H, and JS file starts with:
-
-```c
-/**
- * Copyright (c) 2026 Dominic Masters
- *
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-```
-
-JS files use `//` comment style instead.
-
----
-
-## C conventions
-
-### Types
-Always use the project-defined aliases instead of bare C primitives:
-
-| Use       | Not          |
-|-----------|--------------|
-| `bool_t`  | `bool`       |
-| `int_t`   | `int`        |
-| `float_t` | `float`      |
-| `char_t`  | `char`       |
-
-Use `uint8_t`, `uint16_t`, `int32_t`, etc. for fixed-width integers.
-All struct and enum types end in `_t` (`animation_t`, `errorret_t`, …).
-
-### Naming
-- **Functions** — snake_case, prefixed with their module:
-  `assetLock()`, `entityPositionInit()`, `moduleAssetBatchCtor()`
-- **Struct fields** — camelCase: `keyframeCount`, `localPosition`
-- **Macros / constants** — UPPER_SNAKE_CASE:
-  `ENTITY_ID_INVALID`, `ERROR_OK`, `COMPONENT_TYPE_COUNT`
-- **Files** — snake_case matching the primary type: `entityposition.c`,
-  `moduleassetbatch.c`
-
-### Header files (`.h`)
-- Use `#pragma once` — no include guards.
-- Declare every public function, `#define`, and `extern` global.
-- Write a JSDoc block (`/** … */`) above every declaration explaining
-  purpose, `@param`s, and `@returns`.
-- Only include headers that the `.h` file itself strictly requires for
-  the types it exposes. Move everything else to the `.c` file.
-  Do not use forward declarations as a workaround — use the real
-  include in the `.c` file instead.
-
-### Implementation files (`.c`)
-- Contain function bodies only; no declarations.
-- Pull in whatever additional includes the implementation needs.
-- Do not use `static` or `inline` on **functions**. Every function,
-  including internal helpers, must be declared in the matching `.h` and
-  defined in the `.c` file. Internal helpers belong near the bottom of
-  the `.c` file, not at the top with a `static` qualifier.
-  `static` and `inline` on functions are only appropriate when the
-  function body is written directly inside a `.h` file.
-  `static` on **variables** (file-scope state) is fine and expected.
-
-### Formatting
-- Hard-wrap all lines at **80 characters**.
-
-### Error handling
-Return `errorret_t` from fallible functions. Use these macros:
-
-```c
-errorOk();                    // return success
-errorThrow("msg %d", val);    // return failure with message
-errorChain(someCall());       // propagate failure, continue on success
-errorIsOk(ret) / errorIsNotOk(ret)  // test a result
-errorCatch(ret);              // handle + free an error
-```
-
-Never return raw error codes or use `errno` for in-engine errors.
-
-### Memory
-Use the project allocator — never raw `malloc`/`free`:
-
-```c
-memoryAllocate(size)          // allocate
-memoryFree(ptr)               // free
-memoryZero(dest, size)        // zero a block
-memoryCopy(dest, src, size)   // copy
-```
-
-### Asserts
-Prefer specific assert macros over bare `assert()`:
-
-```c
-assertNotNull(ptr, "msg");
-assertTrue(cond, "msg");
-assertFalse(cond, "msg");
-assertUnreachable("msg");
-assertIsMainThread("msg");
-```
-
----
-
-## Build system
-Each subdirectory has its own `CMakeLists.txt` that adds sources with:
-
-```cmake
-target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PUBLIC
-    myfile.c
-)
-```
-
-Never add source files to the root `CMakeLists.txt` directly.
-
----
-
-## Platform support
-
-### Targets
-Set `DUSK_TARGET_SYSTEM` at CMake configure time to select a platform:
-
-| `DUSK_TARGET_SYSTEM` | Macro defined     | Platform         |
-|----------------------|-------------------|------------------|
-| `linux`              | `DUSK_LINUX`      | Linux desktop    |
-| `knulli`             | `DUSK_KNULLI`     | Knulli (handheld)|
-| `psp`                | `DUSK_PSP`        | Sony PSP         |
-| `vita`               | `DUSK_VITA`       | PlayStation Vita |
-| `gamecube`           | `DUSK_GAMECUBE`   | Nintendo GameCube|
-| `wii`                | `DUSK_WII`        | Nintendo Wii     |
-
-### Layer structure
-```
-src/dusk/          core, platform-agnostic game logic
-src/duskgl/        OpenGL abstraction (Linux, Knulli, PSP, Vita)
-src/dusksdl2/      SDL2 window + input (Linux, Knulli, PSP, Vita)
-src/dusklinux/     Linux + Knulli platform impl
-src/duskpsp/       PSP platform impl
-src/duskvita/      Vita platform impl
-src/duskdolphin/   GameCube / Wii platform impl (no SDL2/OpenGL)
-```
-
-Dolphin is the only target that bypasses SDL2 and OpenGL entirely —
-it uses native GameCube/Wii rendering and input APIs.
-
-### Platform guards
-Use the compile-time macros for platform-specific code:
-
-```c
-#ifdef DUSK_PSP
-  // PSP-only path
-#elif defined(DUSK_GAMECUBE) || defined(DUSK_WII)
-  // GameCube / Wii path
-#else
-  // Generic / Linux fallback
-#endif
-```
-
-Additional capability macros set per-target:
-`DUSK_SDL2`, `DUSK_OPENGL`, `DUSK_OPENGL_ES`, `DUSK_OPENGL_LEGACY`,
-`DUSK_INPUT_GAMEPAD`, `DUSK_INPUT_KEYBOARD`, `DUSK_INPUT_POINTER`,
-`DUSK_PLATFORM_ENDIAN_BIG` / `DUSK_PLATFORM_ENDIAN_LITTLE`.
-
-### Abstraction pattern
-Platform-specific implementations are wired in via `#define` macros in
-each platform's `displayplatform.h` / `inputplatform.h` etc., which
-the core calls through. Functions that a platform does not support are
-simply left undefined — the core guards calls with `#ifdef`.
-
-### Adding platform-specific code
-- Put it under `src/dusk<platform>/` in the matching subsystem folder.
-- Gate any core call-site with the appropriate `#ifdef DUSK_<PLATFORM>`
-  or capability macro.
-- Keep the `src/dusk/` core free of platform ifdefs — delegate through
-  the platform header macros instead.
-
----
-
-## Adding a new asset loader type
-1. Add an enum value to `assetloadertype_t` (before `_COUNT`) in
-   `src/dusk/asset/loader/assetloader.h`.
-2. Add fields to the input/loading/output unions in `assetloader.h`.
-3. Implement `assetXxxLoaderSync`, `assetXxxLoaderAsync`, and
-   `assetXxxDispose` in a new `src/dusk/asset/loader/xxx/` directory.
-4. Register the three callbacks in `ASSET_LOADER_CALLBACKS[]` in
-   `src/dusk/asset/loader/assetloader.c`.
-5. If user-facing, create a JS module (see below) and a `.d.ts` file.
-
----
-
-## Adding a new entity component
-1. Create `src/dusk/entity/component/<category>/entityMyComp.h/.c` with
-   struct `entityMyComp_t`, `entityMyCompInit()`, and optionally
-   `entityMyCompDispose()`.
-2. Add the include to `src/dusk/entity/componentlist.h` header block.
-3. Add a row to `src/dusk/entity/componentlist.h`:
-   ```c
-   X(MYCOMP, entityMyComp_t, myComp, entityMyCompInit, NULL, NULL)
-   ```
-   This auto-generates the enum, union field, and definition entry.
-4. If JS-facing, create the script module and `.d.ts` (see below).
-
----
-
-## Adding a new script (JS) module
-1. Create `src/dusk/script/module/<category>/moduleMyMod.h/.c`.
-   - Declare `extern scriptproto_t MODULE_MYMOD_PROTO;` in the header.
-   - Use `moduleBaseFunction(name)` to define JS-callable functions.
-   - Register props/funcs in `moduleMyModInit()` with
-     `scriptProtoDefineProp` / `scriptProtoDefineFunc` /
-     `scriptProtoDefineStaticFunc`.
-2. `#include` the header in
-   `src/dusk/script/module/modulelist.c` and call
-   `moduleMyModInit()` in `moduleListInit()` (and `Dispose` in
-   `moduleListDispose()`).
-3. For component modules also register in
-   `src/dusk/script/module/entity/component/modulecomponentlist.c`
-   so `entity.add()` returns the typed wrapper.
-4. Create `types/<category>/mymod.d.ts` and add a
-   `/// <reference path="..." />` line to `types/index.d.ts`.
-
----
-
-## Script module type declarations
-Whenever a `src/dusk/script/module/**/*.c` file is created or modified,
-check whether the corresponding `types/**/*.d.ts` needs updating and
-apply any changes before finishing the task.
-
----
-
-## JavaScript (asset scripts)
-- Use `var` for module-level state; `const` for values that never
-  change.
-- Always use semicolons.
-- Scene objects are plain objects (`var scene = {}`) with assigned
-  methods.
-- Export via `module.exports = scene`.
-- Async scene init should use `async function` and `await`.
-
----
-
-## Coding style
-
-### ASCII only
-Source files (`.c`, `.h`, `.js`) must contain only ASCII characters (U+0000–U+007F).
-Non-ASCII characters are banned even in comments and string literals.
-Use ASCII-only substitutes instead:
-- `--` or `-` instead of `—` (em dash)
-- `->` instead of `→` (arrow)
-- `x` or `*` instead of `×` (multiplication)
-
-Only non-script asset files (e.g. `.po` locale files) may contain non-ASCII text.
-
-### Indentation
-2 spaces. No tabs.
-
-### Keyword and operator spacing
-No space between a keyword or function name and its opening parenthesis:
-
-```c
-if(!ptr) return;
-for(uint8_t i = 0; i < count; i++) {
-while(entry->state != DONE) {
-switch(type) {
-sizeof(assetbatch_t)
-memoryZero(ptr, size)
-```
-
-Spaces around all binary operators and after every comma:
-
-```c
-pos->flags |= ENTITY_POSITION_FLAG_WORLD_DIRTY;
-(size_t)end - (size_t)start
-foo(a, b, c)
-```
-
-### Braces
-Opening brace on the **same line** as the statement (K&R style) for all
-constructs — functions, `if`, `else`, `for`, `while`, `switch`:
-
-```c
-void assetEntryLock(assetentry_t *entry) {
-  ...
-}
-
-if(dirty) {
-  ...
-} else {
-  ...
-}
-```
-
-### Guard returns
-Short guards go on one line with no braces:
-
-```c
-if(!ptr) return;
-if(!b || !b->batch) return jerry_undefined();
-if(!(flags & DIRTY)) return;
-```
-
-### Blank lines
-- One blank line between functions; no blank line at the start or end of
-  a function body.
-- One blank line between logical blocks inside a function body.
-- No trailing blank lines at the end of a file.
-
-### Pointer placement
-`*` is attached to the variable name, not the type:
-
-```c
-assetentry_t *entry
-const char_t *name
-void *ptr
-uint8_t *d = (uint8_t *)dest;
-```
-
-### Casts
-Space between cast and operand:
-
-```c
-(assetbatch_t *)user
-(uint8_t *)dest
-(textureformat_t)v
-```
-
-### Return
-No parentheses around the return value:
-
-```c
-return ptr;
-return MEMORY_POINTERS_IN_USE;
-```
-
-### switch / case
-`case` indented 2 spaces from `switch`; body indented 2 more from `case`:
-
-```c
-switch(type) {
-  case ASSET_LOADER_TYPE_TEXTURE:
-    descs[i].input.texture = (textureformat_t)v;
-    break;
-  default:
-    break;
-}
-```
-
-### Multi-line function signatures
-When parameters don't fit on one line, put each on its own line indented
-2 spaces; the closing `) {` (definition) or `);` (declaration) goes on
-its own line at column 0:
-
-```c
-void assetEntryInit(
-  assetentry_t *entry,
-  const char_t *name,
-  const assetloadertype_t type,
-  assetloaderinput_t *input
-) {
-
-errorret_t memoryCompare(
-  const void *a,
-  const void *b,
-  const size_t size
-);
-```
-
-### Structs and enums
-Anonymous inner struct or enum with a `typedef`, `_t` suffix, closing
-brace and name on the same line:
-
-```c
-typedef struct {
-  errorcode_t code;
-  char_t *message;
-} errorstate_t;
-
-typedef enum {
-  ASSET_LOADER_TYPE_NULL,
-  ASSET_LOADER_TYPE_COUNT
-} assetloadertype_t;
-```
-
-### Designated initialisers
-Spaces inside braces; `.field = value`:
-
-```c
-jsassetentry_t e = { .entry = entry };
-assetbatchloadedpend_t init = { .batch = batch };
-```
-
-### Ternary operator
-Spaces around `?` and `:`:
-
-```c
-const float val = psx > 0.0f ? pt[0][0] / psx : 0.0f;
-```
-
-### const placement
-`const` before the type, `*` attached to the variable:
-
-```c
-const char_t *name
-const void *src
-const size_t size
-```
-
-### Comments in `.c` files
-- Do not use section dividers (`/* ---- ... ---- */`). Just let the
-  functions follow one another with a single blank line between them.
-- Multi-line explanatory comments inside function bodies use `//` lines:
-  ```c
-  // Script modules are freed; orphaned JS wrapper objects now get GC'd
-  // so their finalizers fire before assetDispose() checks ref counts.
-  jerry_heap_gc(JERRY_GC_PRESSURE_HIGH);
-  ```
-- Do not use `/* */` for inline or inline-block comments inside `.c`
-  function bodies.
-
-### Comments in `.h` files
-Every public declaration gets a Javadoc block (`/** … */`) with
-`@param` and `@returns` where relevant. Keep it on the lines immediately
-above the declaration with no blank line in between.
-
----
-
-## Tests
-- Tests live in `test/` mirroring `src/dusk/` structure.
-- Use cmocka; include `dusktest.h`.
-- Test functions: `static void test_something(void **state)`.
-- After each test, assert `memoryGetAllocatedCount() == 0` to catch
-  leaks.
-- Build with `-DDUSK_BUILD_TESTS=ON`.

CMakeLists.txt

@@ -4,21 +4,14 @@
 # https://opensource.org/licenses/MIT
 
 # Setup
-cmake_minimum_required(VERSION 3.13)
+cmake_minimum_required(VERSION 3.18)
 
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
-cmake_policy(SET CMP0079 NEW)
-# set(FETCHCONTENT_UPDATES_DISCONNECTED ON)
 
 option(DUSK_BUILD_TESTS "Enable tests" OFF)
 
-set(DUSK_GAME_NAME "Dusk" CACHE STRING "Game display name")
-set(DUSK_GAME_AUTHOR "YourWishes" CACHE STRING "Game author / coder")
-set(DUSK_GAME_SHORT_DESCRIPTION "Dusk game" CACHE STRING "One-line description")
-set(DUSK_GAME_LONG_DESCRIPTION  "No description yet." CACHE STRING "Full description")
-
 # Prep cache
 set(DUSK_CACHE_TARGET "dusk-target")
 
@@ -49,7 +42,7 @@ file(MAKE_DIRECTORY ${DUSK_TEMP_DIR})
 file(MAKE_DIRECTORY ${DUSK_BUILT_ASSETS_DIR})
 
 # Required build packages
-find_package(Python3 COMPONENTS Interpreter REQUIRED)
+find_package(Python3 REQUIRED COMPONENTS Interpreter)
 
 # Init Project.
 project(${DUSK_LIBRARY_TARGET_NAME}
@@ -75,19 +68,10 @@ else()
   set(DUSK_LIBRARY_TARGET_NAME "${DUSK_BINARY_TARGET_NAME}" CACHE INTERNAL ${DUSK_CACHE_TARGET})
 endif()
 
-if(NOT DEFINED DUSK_VERSION)
-  string(TIMESTAMP DUSK_VERSION "debug-%y%m%d%H%M%S")
-endif()
-
 # Definitions
 target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     DUSK_TARGET_SYSTEM="${DUSK_TARGET_SYSTEM}"
-    DUSK_GAME_NAME="${DUSK_GAME_NAME}"
-    DUSK_GAME_AUTHOR="${DUSK_GAME_AUTHOR}"
-    DUSK_GAME_SHORT_DESCRIPTION="${DUSK_GAME_SHORT_DESCRIPTION}"
-    DUSK_GAME_LONG_DESCRIPTION="${DUSK_GAME_LONG_DESCRIPTION}"
-    DUSK_VERSION="${DUSK_VERSION}"
 )
 
 # Toolchains

archive/asset/args.py

@@ -0,0 +1,12 @@
+import sys, os
+import argparse
+
+# Check if the script is run with the correct arguments
+parser = argparse.ArgumentParser(description="Generate chunk header files")
+parser.add_argument('--assets', required=True, help='Dir to output built assets')
+parser.add_argument('--headers-dir', required=True, help='Directory to output individual asset headers (required for header build)')
+parser.add_argument('--output-headers', help='Output header file for built assets (required for header build)')
+parser.add_argument('--output-assets', required=True, help='Output directory for built assets')
+parser.add_argument('--output-file', required=True, help='Output file for built assets (required for wad build)')
+parser.add_argument('--input', required=True, help='Input assets to process', nargs='+')
+args = parser.parse_args()

archive/asset/bundle/__main__.py

@@ -0,0 +1,66 @@
+import sys, os
+from tools.asset.args import args
+from tools.asset.process.asset import processAsset
+from tools.asset.process.palette import processPaletteList
+from tools.asset.process.tileset import processTilesetList
+from tools.asset.process.language import processLanguageList
+from tools.asset.path import getBuiltAssetsRelativePath
+import zipfile
+
+# Parse input file args.
+inputAssets = []
+for inputArg in args.input:
+  files = inputArg.split('$')
+  for file in files:
+    if str(file).strip() == '':
+      continue
+    
+    pieces = file.split('#')
+
+    if len(pieces) < 2:
+      print(f"Error: Invalid input asset format '{file}'. Expected format: type#path[#option1%option2...]")
+      sys.exit(1)
+
+    options = {}
+    if len(pieces) > 2:
+      optionParts = pieces[2].split('%')
+      for part in optionParts:
+        partSplit = part.split('=')
+
+        if len(partSplit) < 1:
+          continue
+        if len(partSplit) == 2:
+          options[partSplit[0]] = partSplit[1]
+        else:
+          options[partSplit[0]] = True
+    
+    inputAssets.append({
+      'type': pieces[0],
+      'path': pieces[1],
+      'options': options
+    })
+
+if not inputAssets:
+  print("Error: No input assets provided.")
+  sys.exit(1)
+
+# Process each asset.
+files = []
+for asset in inputAssets:
+  asset = processAsset(asset)
+  files.extend(asset['files'])
+
+# Generate additional files
+files.extend(processLanguageList()['files'])
+
+# Take assets and add to a zip archive.
+outputFileName = args.output_file
+print(f"Creating output file: {outputFileName}")
+with zipfile.ZipFile(outputFileName, 'w') as zipf:
+  for file in files:
+    relativeOutputPath = getBuiltAssetsRelativePath(file)
+    zipf.write(file, arcname=relativeOutputPath)
+
+# Generate additional headers.
+processPaletteList()
+processTilesetList()

archive/asset/cache.py

@@ -0,0 +1,12 @@
+processedAssets = {}
+
+def assetGetCache(assetPath):
+  if assetPath in processedAssets:
+    return processedAssets[assetPath]
+  return None
+
+def assetCache(assetPath, processedData):
+  if assetPath in processedAssets:
+    return processedAssets[assetPath]
+  processedAssets[assetPath] = processedData
+  return processedData

archive/asset/path.py

@@ -0,0 +1,10 @@
+import os
+from tools.asset.args import args
+
+def getAssetRelativePath(fullPath):
+  # Get the relative path to the asset
+  return os.path.relpath(fullPath, start=args.assets).replace('\\', '/')
+
+def getBuiltAssetsRelativePath(fullPath):
+  # Get the relative path to the built asset
+  return os.path.relpath(fullPath, start=args.output_assets).replace('\\', '/')

archive/asset/process/asset.py

@@ -0,0 +1,33 @@
+import sys
+# from processtileset import processTileset
+from tools.asset.process.image import processImage
+from tools.asset.process.palette import processPalette
+from tools.asset.process.tileset import processTileset
+from tools.asset.process.map import processMap
+from tools.asset.process.language import processLanguage
+from tools.asset.process.script import processScript
+
+processedAssets = []
+
+def processAsset(asset):
+  if asset['path'] in processedAssets:
+    return
+  processedAssets.append(asset['path'])
+
+  # Handle tiled tilesets
+  t = asset['type'].lower()
+  if t == 'palette':
+    return processPalette(asset)
+  elif t == 'image':
+    return processImage(asset)
+  elif t == 'tileset':
+    return processTileset(asset)
+  elif t == 'map':
+    return processMap(asset)
+  elif t == 'language':
+    return processLanguage(asset)
+  elif t == 'script':
+    return processScript(asset)
+  else:
+    print(f"Error: Unknown asset type '{asset['type']}' for path '{asset['path']}'")
+    sys.exit(1)

archive/asset/process/image.py

@@ -0,0 +1,134 @@
+import os
+import sys
+from PIL import Image
+from tools.asset.process.palette import extractPaletteFromImage, palettes
+from tools.asset.args import args
+from tools.asset.path import getAssetRelativePath
+from tools.asset.cache import assetGetCache, assetCache
+
+images = []
+
+def processImage(asset):
+  cache = assetGetCache(asset['path'])
+  if cache is not None:
+    return cache
+
+  type = None
+  if 'type' in asset['options']:
+    type = asset['options'].get('type', 'PALETTIZED').upper()
+
+  if type == 'PALETTIZED' or type is None:
+    return assetCache(asset['path'], processPalettizedImage(asset))
+  elif type == 'ALPHA':
+    return assetCache(asset['path'], processAlphaImage(asset))
+  else:
+    print(f"Error: Unknown image type {type} for asset {asset['path']}")
+    sys.exit(1)
+
+def processPalettizedImage(asset):
+  assetPath = asset['path']
+  cache = assetGetCache(assetPath)
+  if cache is not None:
+    return cache
+
+  image = Image.open(assetPath)
+  imagePalette = extractPaletteFromImage(image)
+
+  # Find palette that contains every color
+  palette = None
+  for p in palettes:
+    hasAllColors = True
+    for color in imagePalette:
+      for palColor in p['pixels']:
+        if color[0] == palColor[0] and color[1] == palColor[1] and color[2] == palColor[2] and color[3] == palColor[3]:
+          break
+        elif color[3] == 0 and palColor[3] == 0:
+          break
+      else:
+        print('Pallete {} does not contain color #{}'.format(p['paletteName'], '{:02x}{:02x}{:02x}{:02x}'.format(color[0], color[1], color[2], color[3])))
+        hasAllColors = False
+        break
+    if hasAllColors:
+      palette = p
+      break
+    
+  if palette is None:
+    palette = palettes[0]  # Just to avoid reference error
+    print(f"No matching palette found for {assetPath}!")
+    # Find which pixel is missing
+    for color in imagePalette:
+      if color in palette['pixels']:
+        continue
+      # Convert to hex (with alpha)
+      hexColor = '#{:02x}{:02x}{:02x}{:02x}'.format(color[0], color[1], color[2], color[3])
+      print(f"Missing color: {hexColor} in palette {palette['paletteName']}")
+    sys.exit(1)
+  
+  print(f"Converting image {assetPath} to use palette")
+  
+  paletteIndexes = []
+  for pixel in list(image.getdata()):
+    if pixel[3] == 0:
+      pixel = (0, 0, 0, 0)
+    paletteIndex = palette['pixels'].index(pixel)
+    paletteIndexes.append(paletteIndex)
+  
+  data = bytearray()
+  data.extend(b"DPI")  # Dusk Palettized Image
+  data.extend(image.width.to_bytes(4, 'little'))   # Width
+  data.extend(image.height.to_bytes(4, 'little'))  # Height
+  data.append(palette['paletteIndex'])   # Palette index
+  for paletteIndex in paletteIndexes:
+    if paletteIndex > 255 or paletteIndex < 0:
+      print(f"Error: Palette index {paletteIndex} exceeds 255!")
+      sys.exit(1)
+    data.append(paletteIndex.to_bytes(1, 'little')[0])  # Pixel index
+
+  relative = getAssetRelativePath(assetPath)
+  fileNameWithoutExt = os.path.splitext(os.path.basename(assetPath))[0]
+  outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dpi")
+  outputFilePath = os.path.join(args.output_assets, outputFileRelative)
+  os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
+  with open(outputFilePath, "wb") as f:
+    f.write(data)
+
+  outImage = {
+    "imagePath": outputFileRelative,
+    "files": [ outputFilePath ],
+    'width': image.width,
+    'height': image.height,
+  }
+  return assetCache(assetPath, outImage)
+
+def processAlphaImage(asset):
+  assetPath = asset['path']
+  cache = assetGetCache(assetPath)
+  if cache is not None:
+    return cache
+
+  print(f"Processing alpha image: {assetPath}")
+
+  data = bytearray()
+  data.extend(b"DAI")  # Dusk Alpha Image
+  image = Image.open(assetPath).convert("RGBA")
+  data.extend(image.width.to_bytes(4, 'little'))   # Width
+  data.extend(image.height.to_bytes(4, 'little'))  # Height
+  for pixel in list(image.getdata()):
+    # Only write alpha channel
+    data.append(pixel[3].to_bytes(1, 'little')[0])  # Pixel alpha
+
+  relative = getAssetRelativePath(assetPath)
+  fileNameWithoutExt = os.path.splitext(os.path.basename(assetPath))[0]
+  outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dai")
+  outputFilePath = os.path.join(args.output_assets, outputFileRelative)
+  os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
+  with open(outputFilePath, "wb") as f:
+    f.write(data)
+
+  outImage = {
+    "imagePath": outputFileRelative,
+    "files": [ outputFilePath ],
+    'width': image.width,
+    'height': image.height,
+  }
+  return assetCache(assetPath, outImage)

archive/asset/process/language.py

@@ -0,0 +1,228 @@
+import sys
+import os
+from tools.asset.args import args
+from tools.asset.cache import assetCache, assetGetCache
+from tools.asset.path import getAssetRelativePath
+from tools.dusk.defs import defs
+import polib
+import re
+
+LANGUAGE_CHUNK_CHAR_COUNT = int(defs.get('ASSET_LANG_CHUNK_CHAR_COUNT'))
+
+LANGUAGE_DATA = {}
+LANGUAGE_KEYS = []
+
+def processLanguageList():
+  # Language keys header data
+  headerKeys = "// Auto-generated language keys header file.\n"
+  headerKeys += "#pragma once\n"
+  headerKeys += "#include \"dusk.h\"\n\n"
+
+  # This is the desired chunk groups list.. if a language key STARTS with any
+  # of the keys in this list we would "like to" put it in that chunk group.
+  # If there is no match, or the list is full then we will add it to the next
+  # available chunk group (that isn't a 'desired' one). If the chunk becomes
+  # full, then we attempt to make another chunk with the same prefix so that
+  # a second batching can occur.
+  desiredChunkGroups = {
+    'ui': 0
+  }
+
+  # Now, for each language key, create the header reference and index.
+  keyIndex = 0
+  languageKeyIndexes = {}
+  languageKeyChunk = {}
+  languageKeyChunkIndexes = {}
+  languageKeyChunkOffsets = {}
+  for key in LANGUAGE_KEYS:
+    headerKeys += f"#define {getLanguageVariableName(key)} {keyIndex}\n"
+    languageKeyIndexes[key] = keyIndex
+    keyIndex += 1
+
+    # Find desired chunk group
+    assignedChunk = None
+    for desiredKey in desiredChunkGroups:
+      if key.lower().startswith(desiredKey):
+        assignedChunk = desiredChunkGroups[desiredKey]
+        break
+    # If no desired chunk group matched, assign to -1
+    if assignedChunk is None:
+      assignedChunk = -1
+    languageKeyChunk[key] = assignedChunk
+
+    # Setup header.
+    for lang in LANGUAGE_DATA:
+      if key not in LANGUAGE_DATA[lang]:
+        print(f"Warning: Missing translation for key '{key}' in language '{lang}'")
+        sys.exit(1)
+
+  # Seal the header.
+  headerKeys += f"\n#define LANG_KEY_COUNT {len(LANGUAGE_KEYS)}\n"
+
+  # Now we can generate the language string chunks.
+  nextChunkIndex = max(desiredChunkGroups.values()) + 1
+  files = []
+
+  for lang in LANGUAGE_DATA:
+    langData = LANGUAGE_DATA[lang]
+
+    # Key = chunkIndex, value = chunkInfo
+    languageChunks = {}
+    for key in LANGUAGE_KEYS:
+      keyIndex = languageKeyIndexes[key]
+      chunkIndex = languageKeyChunk[key]
+      wasSetChunk = chunkIndex != -1
+
+      # This will keep looping until we find a chunk
+      while True:
+        # Determine the next chunkIndex IF chunkIndex is -1
+        if chunkIndex == -1:
+          chunkIndex = nextChunkIndex
+        
+        # Is the chunk full?
+        curLen = languageChunks.get(chunkIndex, {'len': 0})['len']
+        newLen = curLen + len(langData[key])
+        if newLen > LANGUAGE_CHUNK_CHAR_COUNT:
+          # Chunk is full, need to create a new chunk.
+          chunkIndex = -1
+          if wasSetChunk:
+            wasSetChunk = False
+          else:
+            nextChunkIndex += 1
+          continue
+
+        # Chunk is not full, we can use it.
+        if chunkIndex not in languageChunks:
+          languageChunks[chunkIndex] = {
+            'len': 0,
+            'keys': []
+          }
+        languageChunks[chunkIndex]['len'] = newLen
+        languageChunks[chunkIndex]['keys'].append(key)
+        languageKeyChunkIndexes[key] = chunkIndex
+        languageKeyChunkOffsets[key] = curLen
+        break
+
+    # We have now chunked all the keys for this language!
+    langBuffer = b""
+
+    # Write header info 
+    langBuffer += b'DLF'  # Dusk Language File
+
+    for key in LANGUAGE_KEYS:
+      # Write the chunk that this key belongs to as uint32_t
+      chunkIndex = languageKeyChunkIndexes[key]
+      langBuffer += chunkIndex.to_bytes(4, byteorder='little')
+
+      # Write the offset for this key as uint32_t
+      offset = languageKeyChunkOffsets[key]
+      langBuffer += offset.to_bytes(4, byteorder='little')
+
+      # Write the length of the string as uint32_t
+      strData = langData[key].encode('utf-8')
+      langBuffer += len(strData).to_bytes(4, byteorder='little')
+    
+    # Now write out each chunk's string data, packed tight and no null term.
+    for chunkIndex in sorted(languageChunks.keys()):
+      chunkInfo = languageChunks[chunkIndex]
+      for key in chunkInfo['keys']:
+        strData = langData[key].encode('utf-8')
+        langBuffer += strData
+
+      # Now pad the chunk to full size
+      curLen = chunkInfo['len']
+      if curLen < LANGUAGE_CHUNK_CHAR_COUNT:
+        padSize = LANGUAGE_CHUNK_CHAR_COUNT - curLen
+        langBuffer += b'\0' * padSize
+
+    # Write out the language data file
+    outputFile = os.path.join(args.output_assets, "language", f"{lang}.dlf")
+    files.append(outputFile)
+    os.makedirs(os.path.dirname(outputFile), exist_ok=True)
+    with open(outputFile, "wb") as f:
+      f.write(langBuffer)
+  
+  # Write out the language keys header file
+  outputFile = os.path.join(args.headers_dir, "locale", "language", "keys.h")
+  os.makedirs(os.path.dirname(outputFile), exist_ok=True)
+  with open(outputFile, "w") as f:
+    f.write(headerKeys)
+
+  # Generate language list.
+  langValues = {}
+  headerLocale = "#pragma once\n#include \"locale/localeinfo.h\"\n\n"
+  headerLocale += "typedef enum {\n"
+  count = 0
+  headerLocale += f"  DUSK_LOCALE_NULL = {count},\n"
+  count += 1
+  for lang in LANGUAGE_DATA:
+    langKey = lang.replace('-', '_').replace(' ', '_').upper()
+    langValues[lang] = count
+    headerLocale += f"  DUSK_LOCALE_{langKey} = {count},\n"
+    count += 1
+  headerLocale += f"  DUSK_LOCALE_COUNT = {count}\n"
+  headerLocale += "} dusklocale_t;\n\n"
+  
+  headerLocale += f"static const localeinfo_t LOCALE_INFOS[DUSK_LOCALE_COUNT] = {{\n"
+  for lang in LANGUAGE_DATA:
+    langKey = lang.replace('-', '_').replace(' ', '_').upper()
+    headerLocale += f"  [DUSK_LOCALE_{langKey}] = {{\n"
+    headerLocale += f"    .file = \"{lang}\"\n"
+    headerLocale += f"  }},\n"
+  headerLocale += "};\n"
+
+  headerLocale += f"static const char_t *LOCALE_SCRIPT = \n"
+  for lang in LANGUAGE_DATA:
+    langKey = lang.replace('-', '_').replace(' ', '_').upper()
+    langValue = langValues[lang]
+    headerLocale += f"  \"DUSK_LOCALE_{langKey} = {langValue}\\n\"\n"
+  headerLocale +=  ";\n"
+
+  # Write out the locale enum header file
+  outputFile = os.path.join(args.headers_dir, "locale", "locale.h")
+  os.makedirs(os.path.dirname(outputFile), exist_ok=True)
+  with open(outputFile, "w") as f:
+    f.write(headerLocale)
+
+  return {
+    'files': files
+  }
+
+def getLanguageVariableName(languageKey):
+  # Take the language key, prepend LANG_, uppercase, replace any non symbols
+  # with _
+  key = languageKey.strip().upper()
+  key = re.sub(r'[^A-Z0-9]', '_', key)
+  return f"LANG_{key}"
+
+def processLanguage(asset):
+  cache = assetGetCache(asset['path'])
+  if cache is not None:
+    return cache
+  
+  # Load PO File
+  po = polib.pofile(asset['path'])
+
+  langName = po.metadata.get('Language')
+  if langName not in LANGUAGE_DATA:
+    LANGUAGE_DATA[langName] = {}
+
+  for entry in po:
+    key = entry.msgid
+    val = entry.msgstr
+
+    if key not in LANGUAGE_KEYS:
+      LANGUAGE_KEYS.append(key)
+    
+    if key not in LANGUAGE_DATA[langName]:
+      LANGUAGE_DATA[langName][key] = val
+    else:
+      print(f"Error: Duplicate translation key '{key}' in language '{langName}'")
+      sys.exit(1)
+
+  outLanguageData = {
+    'data': po,
+    'path': asset['path'],
+    'files': []
+  }
+  return assetCache(asset['path'], outLanguageData)

archive/asset/process/map.py

@@ -0,0 +1,154 @@
+import struct
+import sys
+import os
+import json
+from tools.asset.args import args
+from tools.asset.cache import assetCache, assetGetCache
+from tools.asset.path import getAssetRelativePath
+from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, CHUNK_TILE_COUNT
+from tools.dusk.map import Map
+from tools.dusk.chunk import Chunk
+
+def convertModelData(modelData):
+  # TLDR; Model data stores things efficiently with indices, but we buffer it 
+  # out to 6 vertex quads for simplicity.
+  outVertices = []
+  outUVs = []
+  outColors = []
+  for indice in modelData['indices']:
+    vertex = modelData['vertices'][indice]
+    uv = modelData['uvs'][indice]
+    color = modelData['colors'][indice]
+    outVertices.append(vertex)
+    outUVs.append(uv)
+    outColors.append(color)
+
+  return {
+    'vertices': outVertices,
+    'uvs': outUVs,
+    'colors': outColors
+  }
+
+def processChunk(chunk):
+  cache = assetGetCache(chunk.getFilename())
+  if cache:
+    return cache
+
+  baseModel = {
+    'vertices': [],
+    'colors': [],
+    'uvs': []
+  }
+  models = [ baseModel ]
+
+  for tileIndex, tile in chunk.tiles.items():
+    tileBase = tile.getBaseTileModel()
+
+    convertedBase = convertModelData(tileBase)
+    baseModel['vertices'].extend(convertedBase['vertices'])
+    baseModel['colors'].extend(convertedBase['colors'])
+    baseModel['uvs'].extend(convertedBase['uvs'])
+
+  # Generate binary buffer for efficient output
+  buffer = bytearray()
+  buffer.extend(b'DMC')# Header
+  buffer.extend(len(chunk.tiles).to_bytes(4, 'little'))  # Number of tiles
+  buffer.extend(len(models).to_bytes(1, 'little'))  # Number of models
+  buffer.extend(len(chunk.entities).to_bytes(1, 'little'))  # Number of entities
+
+  # Buffer tile data as array of uint8_t
+  for tileIndex, tile in chunk.tiles.items():
+    buffer.extend(tile.shape.to_bytes(1, 'little'))
+
+  # # For each model
+  for model in models:
+    vertexCount = len(model['vertices'])
+    buffer.extend(vertexCount.to_bytes(4, 'little'))
+    for i in range(vertexCount):
+      vertex = model['vertices'][i]
+      uv = model['uvs'][i]
+      color = model['colors'][i]
+
+      buffer.extend(color[0].to_bytes(1, 'little'))
+      buffer.extend(color[1].to_bytes(1, 'little'))
+      buffer.extend(color[2].to_bytes(1, 'little'))
+      buffer.extend(color[3].to_bytes(1, 'little'))
+
+      buffer.extend(bytearray(struct.pack('<f', uv[0])))
+      buffer.extend(bytearray(struct.pack('<f', uv[1])))
+
+      buffer.extend(bytearray(struct.pack('<f', vertex[0])))
+      buffer.extend(bytearray(struct.pack('<f', vertex[1])))
+      buffer.extend(bytearray(struct.pack('<f', vertex[2])))
+  
+  # For each entity
+  for entity in chunk.entities.values():
+    buffer.extend(entity.type.to_bytes(1, 'little'))
+    buffer.extend(entity.localX.to_bytes(1, 'little'))
+    buffer.extend(entity.localY.to_bytes(1, 'little'))
+    buffer.extend(entity.localZ.to_bytes(1, 'little'))
+    pass
+
+  # Write out map file
+  relative = getAssetRelativePath(chunk.getFilename())
+  fileNameWithoutExt = os.path.splitext(os.path.basename(relative))[0]
+  outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dmc")
+  outputFilePath = os.path.join(args.output_assets, outputFileRelative)
+  os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
+  with open(outputFilePath, "wb") as f:
+    f.write(buffer)
+  
+  outChunk = {
+    'files': [ outputFilePath ],
+    'chunk': chunk
+  }
+  return assetCache(chunk.getFilename(), outChunk)
+
+def processMap(asset):
+  cache = assetGetCache(asset['path'])
+  if cache is not None:
+    return cache
+
+  map = Map(None)
+  map.load(asset['path'])
+  chunksDir = map.getChunkDirectory()
+
+  files = os.listdir(chunksDir)
+  if len(files) == 0:
+    print(f"Error: No chunk files found in {chunksDir}.")
+    sys.exit(1)
+
+  chunkFiles = []
+  for fileName in files:
+    if not fileName.endswith('.json'):
+      continue
+
+    fNameNoExt = os.path.splitext(fileName)[0]
+    fnPieces = fNameNoExt.split('_')
+    if len(fnPieces) != 3:
+      print(f"Error: Chunk filename {fileName} does not contain valid chunk coordinates.")
+      sys.exit(1)
+    chunk = Chunk(map, int(fnPieces[0]), int(fnPieces[1]), int(fnPieces[2]))
+    chunk.load()
+    result = processChunk(chunk)
+    chunkFiles.extend(result['files'])
+
+  # Map file
+  outBuffer = bytearray()
+  outBuffer.extend(b'DMF')
+  outBuffer.extend(len(chunkFiles).to_bytes(4, 'little'))
+  
+  # DMF (Dusk Map file)
+  fileRelative = getAssetRelativePath(asset['path'])
+  fileNameWithoutExt = os.path.splitext(os.path.basename(fileRelative))[0]
+  outputMapRelative = os.path.join(os.path.dirname(fileRelative), f"{fileNameWithoutExt}.dmf")
+  outputMapPath = os.path.join(args.output_assets, outputMapRelative)
+  os.makedirs(os.path.dirname(outputMapPath), exist_ok=True)
+  with open(outputMapPath, "wb") as f:
+    f.write(outBuffer)
+
+  outMap = {
+    'files': chunkFiles
+  }
+  outMap['files'].append(outputMapPath)
+  return assetCache(asset['path'], outMap)

archive/asset/process/palette.py

@@ -0,0 +1,96 @@
+import json
+import os
+from PIL import Image
+import datetime
+from tools.asset.args import args
+from tools.asset.cache import assetCache, assetGetCache
+
+palettes = []
+
+def extractPaletteFromImage(image):
+  # goes through and finds all unique colors in the image
+  if image.mode != 'RGBA':
+    image = image.convert('RGBA')
+  pixels = list(image.getdata())
+  uniqueColors = []
+  for color in pixels:
+    # We treat all alpha 0 as rgba(0,0,0,0) for palette purposes
+    if color[3] == 0:
+      color = (0, 0, 0, 0)
+    if color not in uniqueColors:
+      uniqueColors.append(color)
+  return uniqueColors
+
+def processPalette(asset):
+  print(f"Processing palette: {asset['path']}")
+  cache = assetGetCache(asset['path'])
+  if cache is not None:
+    return cache
+
+  paletteIndex = len(palettes)
+  image = Image.open(asset['path'])
+  pixels = extractPaletteFromImage(image)
+
+  fileNameWithoutExt = os.path.splitext(os.path.basename(asset['path']))[0]
+  fileNameWithoutPalette = os.path.splitext(fileNameWithoutExt)[0]
+
+  # PSP requires that the palette size be a power of two, so we will pad the
+  # palette with transparent colors if needed.
+  def mathNextPowTwo(x):
+    return 1 << (x - 1).bit_length()
+  
+  nextPowTwo = mathNextPowTwo(len(pixels))
+  while len(pixels) < nextPowTwo:
+    pixels.append((0, 0, 0, 0))
+
+  # Header
+  now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+  data = f"// Palette Generated for {asset['path']} at {now}\n"
+  data += f"#include \"display/palette/palette.h\"\n\n"
+  data += f"#define PALETTE_{paletteIndex}_COLOR_COUNT {len(pixels)}\n\n"
+  data += f"#pragma pack(push, 1)\n"
+  data += f"static const color_t PALETTE_{paletteIndex}_COLORS[PALETTE_{paletteIndex}_COLOR_COUNT] = {{\n"
+  for pixel in pixels:
+    data += f"  {{ 0x{pixel[0]:02X}, 0x{pixel[1]:02X}, 0x{pixel[2]:02X}, 0x{pixel[3]:02X} }},\n"
+  data += f"}};\n"
+  data += f"#pragma pack(pop)\n\n"
+  data += f"static const palette_t PALETTE_{paletteIndex} = {{\n"
+  data += f"  .colorCount = PALETTE_{paletteIndex}_COLOR_COUNT,\n"
+  data += f"  .colors = PALETTE_{paletteIndex}_COLORS,\n"
+  data += f"}};\n"
+
+  # Write Header
+  outputFile = os.path.join(args.headers_dir, "display", "palette", f"palette_{paletteIndex}.h")
+  os.makedirs(os.path.dirname(outputFile), exist_ok=True)
+  with open(outputFile, "w") as f:
+    f.write(data)
+
+  palette = {
+    "paletteIndex": paletteIndex,
+    "paletteName": fileNameWithoutPalette,
+    "pixels": pixels,
+    "headerFile": os.path.relpath(outputFile, args.headers_dir),
+    "asset": asset,
+    "files": [ ],# No zippable files.
+  }
+
+  palettes.append(palette)
+  return assetCache(asset['path'], palette)
+
+def processPaletteList():
+  data = f"// Auto-generated palette list\n"
+  print(f"Generating palette list with {len(palettes)} palettes.")
+  for palette in palettes:
+    data += f"#include \"{palette['headerFile']}\"\n"
+  data += f"\n"
+  data += f"#define PALETTE_LIST_COUNT {len(palettes)}\n\n"
+  data += f"static const palette_t* PALETTE_LIST[PALETTE_LIST_COUNT] = {{\n"
+  for palette in palettes:
+    data += f"  &PALETTE_{palette['paletteIndex']},\n"
+  data += f"}};\n"
+
+  # Write the palette list to a header file
+  outputFile = os.path.join(args.headers_dir, "display", "palette", "palettelist.h")
+  os.makedirs(os.path.dirname(outputFile), exist_ok=True)
+  with open(outputFile, "w") as f:
+    f.write(data)

archive/asset/process/script.py

@@ -0,0 +1,43 @@
+import sys
+import os
+from tools.asset.args import args
+from tools.asset.cache import assetCache, assetGetCache
+from tools.asset.path import getAssetRelativePath
+from tools.dusk.defs import fileDefs
+
+def processScript(asset):
+  cache = assetGetCache(asset['path'])
+  if cache is not None:
+    return cache
+  
+  # Load the lua file as a string
+  with open(asset['path'], 'r', encoding='utf-8') as f:
+    luaCode = f.read()
+    
+  # TODO: I will precompile or minify the Lua code here in the future
+
+  # Replace all definitions in the code
+  for key, val in fileDefs.items():
+    luaCode = luaCode.replace(key, str(val))
+
+  # Create output Dusk Script File (DSF) data
+  data = ""
+  data += "DSF"
+  data += luaCode
+
+  # Write to relative output file path.
+  relative = getAssetRelativePath(asset['path'])
+  fileNameWithoutExt = os.path.splitext(os.path.basename(asset['path']))[0]
+  outputFileRelative = os.path.join(os.path.dirname(relative), f"{fileNameWithoutExt}.dsf")
+  outputFilePath = os.path.join(args.output_assets, outputFileRelative)
+  os.makedirs(os.path.dirname(outputFilePath), exist_ok=True)
+  with open(outputFilePath, "wb") as f:
+    f.write(data.encode('utf-8'))
+
+  outScript = {
+    'data': data,
+    'path': asset['path'],
+    'files': [ outputFilePath ],
+    'scriptPath': outputFileRelative,
+  }
+  return assetCache(asset['path'], outScript)

archive/asset/process/tileset.py

@@ -0,0 +1,178 @@
+import json
+import sys
+import os
+import datetime
+from xml.etree import ElementTree
+from tools.asset.process.image import processImage
+from tools.asset.path import getAssetRelativePath
+from tools.asset.args import args
+from tools.asset.cache import assetGetCache, assetCache
+
+tilesets = []
+
+def loadTilesetFromTSX(asset):
+  # Load the TSX file
+  tree = ElementTree.parse(asset['path'])
+  root = tree.getroot()
+
+  # Expect tileheight, tilewidth, columns and tilecount attributes
+  if 'tilewidth' not in root.attrib or 'tileheight' not in root.attrib or 'columns' not in root.attrib or 'tilecount' not in root.attrib:
+    print(f"Error: TSX file {asset['path']} is missing required attributes (tilewidth, tileheight, columns, tilecount)")
+    sys.exit(1)
+
+  tileWidth = int(root.attrib['tilewidth'])
+  tileHeight = int(root.attrib['tileheight'])
+  columns = int(root.attrib['columns'])
+  tileCount = int(root.attrib['tilecount'])
+  rows = (tileCount + columns - 1) // columns  # Calculate rows based on tileCount and columns
+
+  # Find the image element
+  imageElement = root.find('image')
+  if imageElement is None or 'source' not in imageElement.attrib:
+    print(f"Error: TSX file {asset['path']} is missing an image element with a source attribute")
+    sys.exit(1)
+
+  imagePath = imageElement.attrib['source']
+
+  # Image is relative to the TSX file
+  imageAssetPath = os.path.join(os.path.dirname(asset['path']), imagePath)
+
+  image = processImage({
+    'path': imageAssetPath,
+    'options': asset['options'],
+  })
+
+  return {
+    "image": image,
+    "tileWidth": tileWidth,
+    "tileHeight": tileHeight,
+    "columns": columns,
+    "rows": rows,
+    "originalWidth": tileWidth * columns,
+    "originalHeight": tileHeight * rows,
+  }
+
+def loadTilesetFromArgs(asset):
+  # We need to determine how big each tile is. This can either be provided as
+  # an arg of tileWidth/tileHeight or as a count of rows/columns.
+  # Additionally, if the image has been factored, then the user can provide both
+  # tile sizes AND cols/rows to indicate the original size of the image.
+  image = processImage(asset)
+
+  tileWidth, tileHeight = None, None
+  columns, rows = None, None
+  originalWidth, originalHeight = image['width'], image['height']
+
+  if 'tileWidth' in asset['options'] and 'columns' in asset['options']:
+    tileWidth = int(asset['options']['tileWidth'])
+    columns = int(asset['options']['columns'])
+    originalWidth = tileWidth * columns
+  elif 'tileWidth' in asset['options']:
+    tileWidth = int(asset['options']['tileWidth'])
+    columns = image['width'] // tileWidth
+  elif 'columns' in asset['options']:
+    columns = int(asset['options']['columns'])
+    tileWidth = image['width'] // columns
+  else:
+    print(f"Error: Tileset {asset['path']} must specify either tileWidth or columns")
+    sys.exit(1)
+
+  if 'tileHeight' in asset['options'] and 'rows' in asset['options']:
+    tileHeight = int(asset['options']['tileHeight'])
+    rows = int(asset['options']['rows'])
+    originalHeight = tileHeight * rows
+  elif 'tileHeight' in asset['options']:
+    tileHeight = int(asset['options']['tileHeight'])
+    rows = image['height'] // tileHeight
+  elif 'rows' in asset['options']:
+    rows = int(asset['options']['rows'])
+    tileHeight = image['height'] // rows
+  else:
+    print(f"Error: Tileset {asset['path']} must specify either tileHeight or rows")
+    sys.exit(1)
+    
+  return {
+    "image": image,
+    "tileWidth": tileWidth,
+    "tileHeight": tileHeight,
+    "columns": columns,
+    "rows": rows,
+    "originalWidth": originalWidth,
+    "originalHeight": originalHeight,
+  }
+
+def processTileset(asset):
+  cache = assetGetCache(asset['path'])
+  if cache is not None:
+    return cache
+
+  print(f"Processing tileset: {asset['path']}")
+  tilesetData = None
+  if asset['path'].endswith('.tsx'):
+    tilesetData = loadTilesetFromTSX(asset)
+  else:
+    tilesetData = loadTilesetFromArgs(asset)
+  
+  fileNameWithoutExtension = os.path.splitext(os.path.basename(asset['path']))[0]
+  now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+  tilesetName = fileNameWithoutExtension
+  tilesetNameUpper = tilesetName.upper()
+
+  widthScale = tilesetData['originalWidth'] / tilesetData['image']['width']
+  heightScale = tilesetData['originalHeight'] / tilesetData['image']['height']
+
+  # Create header
+  data = f"// Tileset Generated for {asset['path']} at {now}\n"
+  data += f"#pragma once\n"
+  data += f"#include \"display/tileset/tileset.h\"\n\n"
+  data += f"static const tileset_t TILESET_{tilesetNameUpper} = {{\n"
+  data += f"  .name = {json.dumps(tilesetName)},\n"
+  data += f"  .tileWidth = {tilesetData['tileWidth']},\n"
+  data += f"  .tileHeight = {tilesetData['tileHeight']},\n"
+  data += f"  .tileCount = {tilesetData['columns'] * tilesetData['rows']},\n"
+  data += f"  .columns = {tilesetData['columns']},\n"
+  data += f"  .rows = {tilesetData['rows']},\n"
+  data += f"  .uv = {{ {widthScale / tilesetData['columns']}f, {heightScale / tilesetData['rows']}f }},\n"
+  data += f"  .image = {json.dumps(tilesetData['image']['imagePath'])},\n"
+  data += f"}};\n"
+
+
+  # Write Header
+  outputFile = os.path.join(args.headers_dir, "display", "tileset", f"tileset_{tilesetName}.h")
+  os.makedirs(os.path.dirname(outputFile), exist_ok=True)
+  with open(outputFile, 'w') as f:
+    f.write(data)
+
+  print(f"Write header for tileset: {outputFile}")
+
+  tileset = {
+    "files": [],
+    "image": tilesetData['image'],
+    "headerFile": os.path.relpath(outputFile, args.headers_dir),
+    "tilesetName": tilesetName,
+    "tilesetNameUpper": tilesetNameUpper,
+    "tilesetIndex": len(tilesets),
+    "tilesetData": tilesetData,
+    "files": tilesetData['image']['files'],
+  }
+
+  tilesets.append(tileset)
+  return assetCache(asset['path'], tileset)
+
+def processTilesetList():
+  data = f"// Tileset List Generated at {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
+  data += f"#pragma once\n"
+  for tileset in tilesets:
+    data += f"#include \"{tileset['headerFile']}\"\n"
+  data += f"\n"
+  data += f"#define TILESET_LIST_COUNT {len(tilesets)}\n\n"
+  data += f"static const tileset_t* TILESET_LIST[TILESET_LIST_COUNT] = {{\n"
+  for tileset in tilesets:
+    data += f"  &TILESET_{tileset['tilesetNameUpper']},\n"
+  data += f"}};\n"
+
+  # Write header.
+  outputFile = os.path.join(args.headers_dir, "display", "tileset", f"tilesetlist.h")
+  os.makedirs(os.path.dirname(outputFile), exist_ok=True)
+  with open(outputFile, 'w') as f:
+    f.write(data)

archive/assetpalette.c

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assetpalette.h"
+#include "asset/assettype.h"
+#include "assert/assert.h"
+
+errorret_t assetPaletteLoad(assetentire_t entire) {
+  assertNotNull(entire.data, "Data pointer cannot be NULL.");
+  assertNotNull(entire.output, "Output pointer cannot be NULL.");
+
+  assetpalette_t *assetData = (assetpalette_t *)entire.data;
+  palette_t *palette = (palette_t *)entire.output;
+
+  // Read header and version (first 4 bytes)
+  if(
+    assetData->header[0] != 'D' || 
+    assetData->header[1] != 'P' ||
+    assetData->header[2] != 'F'
+  ) {
+    errorThrow("Invalid palette header");
+  }
+  
+  // Version (can only be 1 atm)
+  if(assetData->version != 0x01) {
+    errorThrow("Unsupported palette version");
+  }
+
+  // Check color count.
+  if(
+    assetData->colorCount == 0 || 
+    assetData->colorCount > PALETTE_COLOR_COUNT_MAX
+  ) {
+    errorThrow("Invalid palette color count");
+  }
+  
+  paletteInit(
+    palette,
+    assetData->colorCount,
+    assetData->colors
+  );
+  errorOk();
+}

archive/assetpalette.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "display/texture/palette.h"
+
+typedef struct assetentire_s assetentire_t;
+
+#pragma pack(push, 1)
+typedef struct {
+  char_t header[3];
+  uint8_t version;
+
+  uint8_t colorCount;
+  color_t colors[PALETTE_COLOR_COUNT_MAX];
+} assetpalette_t;
+#pragma pack(pop)
+
+/**
+ * Loads a palette from the given data pointer into the output palette.
+ *
+ * @param entire Data received from the asset loader system.
+ * @return An error code.
+ */
+errorret_t assetPaletteLoad(assetentire_t entire);

archive/dusk/chunk.py

@@ -0,0 +1,158 @@
+import json
+import os
+from tools.dusk.event import Event
+from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, CHUNK_VERTEX_COUNT_MAX, TILE_SHAPE_NULL
+from tools.dusk.tile import Tile
+from tools.dusk.entity import Entity
+from tools.dusk.region import Region
+from tools.editor.map.vertexbuffer import VertexBuffer
+from OpenGL.GL import *
+
+class Chunk:
+  def __init__(self, map, x, y, z):
+    self.map = map
+    self.x = x
+    self.y = y
+    self.z = z
+    self.current = {}
+    self.original = {}
+    self.entities = {}
+    self.regions = {}
+    self.onChunkData = Event()
+    self.dirty = False
+
+    self.tiles = {}
+    self.vertexBuffer = VertexBuffer()
+
+    # Test Region
+    region = self.regions[0] = Region(self)
+    region.minX = 0
+    region.minY = 0
+    region.minZ = 0
+    region.maxX = 32
+    region.maxY = 32
+    region.maxZ = 32
+    region.updateVertexs()
+
+    # Gen tiles.
+    tileIndex = 0
+    for tz in range(CHUNK_DEPTH):
+      for ty in range(CHUNK_HEIGHT):
+        for tx in range(CHUNK_WIDTH):
+          self.tiles[tileIndex] = Tile(self, tx, ty, tz, tileIndex)
+          tileIndex += 1
+    
+    # Update vertices
+    self.tileUpdateVertices()
+
+  def reload(self, newX, newY, newZ):
+    self.x = newX
+    self.y = newY
+    self.z = newZ
+    self.entities = {}
+    for tile in self.tiles.values():
+      tile.chunkReload(newX, newY, newZ)
+    self.load()
+
+  def tileUpdateVertices(self):
+    self.vertexBuffer.clear()
+    for tile in self.tiles.values():
+      tile.buffer(self.vertexBuffer)
+    self.vertexBuffer.buildData()
+
+  def load(self):
+    fname = self.getFilename()
+    if not fname or not os.path.exists(fname):
+      self.new()
+      return
+    try:
+      with open(fname, 'r') as f:
+        data = json.load(f)
+
+      if not 'shapes' in data:
+        data['shapes'] = []
+      
+      # For each tile.
+      for tile in self.tiles.values():
+        tile.load(data)
+
+      # For each entity.
+      self.entities = {}
+      if 'entities' in data:
+        for id, entData in enumerate(data['entities']):
+          ent = Entity(self)
+          ent.load(entData)
+          self.entities[id] = ent
+      
+      self.tileUpdateVertices()
+      self.dirty = False
+      self.onChunkData.invoke(self)
+      self.map.onEntityData.invoke()
+    except Exception as e:
+      raise RuntimeError(f"Failed to load chunk file: {e}")
+
+  def save(self):
+    if not self.isDirty():
+      return
+    
+    dataOut = {
+      'shapes': [],
+      'entities': []
+    }
+
+    for tile in self.tiles.values():
+      dataOut['shapes'].append(tile.shape)
+      
+    for ent in self.entities.values():
+      entData = {}
+      ent.save(entData)
+      dataOut['entities'].append(entData)
+    
+    fname = self.getFilename()
+    if not fname:
+      raise ValueError("No filename specified for saving chunk.")
+    try:
+      with open(fname, 'w') as f:
+        json.dump(dataOut, f)
+      self.dirty = False
+      self.onChunkData.invoke(self)
+    except Exception as e:
+      raise RuntimeError(f"Failed to save chunk file: {e}")
+
+  def new(self):
+    for tile in self.tiles.values():
+      tile.shape = TILE_SHAPE_NULL
+
+    self.tileUpdateVertices()
+    self.dirty = False
+    self.onChunkData.invoke(self)
+
+  def isDirty(self):
+    return self.dirty
+
+  def getFilename(self):
+    if not self.map or not hasattr(self.map, 'getChunkDirectory'):
+      return None
+    dirPath = self.map.getChunkDirectory()
+    if dirPath is None:
+      return None
+    return f"{dirPath}/{self.x}_{self.y}_{self.z}.json"
+  
+  def draw(self):
+    self.vertexBuffer.draw()
+
+  def addEntity(self, localX=0, localY=0, localZ=0):
+    ent = Entity(self, localX, localY, localZ)
+    self.entities[len(self.entities)] = ent
+    self.map.onEntityData.invoke()
+    self.dirty = True
+    return ent
+  
+  def removeEntity(self, entity):
+    for key, val in list(self.entities.items()):
+      if val == entity:
+        del self.entities[key]
+        self.map.onEntityData.invoke()
+        self.dirty = True
+        return True
+    return False

archive/dusk/defs.py

@@ -0,0 +1,49 @@
+from dotenv import load_dotenv, dotenv_values
+import os
+import sys
+
+current_file_path = os.path.abspath(__file__)
+duskDefsPath = os.path.join(os.path.dirname(current_file_path), "..", "..", "src", "duskdefs.env")
+
+# Ensure the .env file exists
+if not os.path.isfile(duskDefsPath):
+  print(f"Error: .env file not found at {duskDefsPath}")
+  sys.exit(1)
+
+load_dotenv(dotenv_path=duskDefsPath)
+defs = {key: os.getenv(key) for key in os.environ.keys()}
+
+fileDefs = dotenv_values(dotenv_path=duskDefsPath)
+
+# Parsed out definitions
+CHUNK_WIDTH = int(defs.get('CHUNK_WIDTH'))
+CHUNK_HEIGHT = int(defs.get('CHUNK_HEIGHT'))
+CHUNK_DEPTH = int(defs.get('CHUNK_DEPTH'))
+CHUNK_TILE_COUNT = CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH
+CHUNK_VERTEX_COUNT_MAX = int(defs.get('CHUNK_VERTEX_COUNT_MAX'))
+
+TILE_WIDTH = float(defs.get('TILE_WIDTH'))
+TILE_HEIGHT = float(defs.get('TILE_HEIGHT'))
+TILE_DEPTH = float(defs.get('TILE_DEPTH'))
+
+RPG_CAMERA_PIXELS_PER_UNIT = float(defs.get('RPG_CAMERA_PIXELS_PER_UNIT'))
+RPG_CAMERA_Z_OFFSET = float(defs.get('RPG_CAMERA_Z_OFFSET'))
+RPG_CAMERA_FOV = float(defs.get('RPG_CAMERA_FOV'))
+
+MAP_WIDTH = 5
+MAP_HEIGHT = 5
+MAP_DEPTH = 3
+MAP_CHUNK_COUNT = MAP_WIDTH * MAP_HEIGHT * MAP_DEPTH
+
+TILE_SHAPES = {}
+for key in defs.keys():
+  if key.startswith('TILE_SHAPE_'):
+    globals()[key] = int(defs.get(key))
+    TILE_SHAPES[key] = int(defs.get(key))
+
+ENTITY_TYPES = {}
+for key in defs.keys():
+  if key.startswith('ENTITY_TYPE_'):
+    globals()[key] = int(defs.get(key))
+    if key != 'ENTITY_TYPE_COUNT':
+      ENTITY_TYPES[key] = int(defs.get(key))

archive/dusk/entity.py

@@ -0,0 +1,90 @@
+from tools.dusk.defs import ENTITY_TYPE_NULL, ENTITY_TYPE_NPC, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
+from tools.editor.map.vertexbuffer import VertexBuffer
+
+class Entity:
+  def __init__(self, chunk, localX=0, localY=0, localZ=0):
+    self.type = ENTITY_TYPE_NPC
+    self.name = "Unititled"
+    self.localX = localX % CHUNK_WIDTH
+    self.localY = localY % CHUNK_HEIGHT
+    self.localZ = localZ % CHUNK_DEPTH
+
+    self.chunk = chunk
+    self.vertexBuffer = VertexBuffer()
+    pass
+
+  def load(self, obj):
+    self.type = obj.get('type', ENTITY_TYPE_NULL)
+    self.localX = obj.get('x', 0)
+    self.localY = obj.get('y', 0)
+    self.localZ = obj.get('z', 0)
+    self.name = obj.get('name', "Untitled")
+    pass
+
+  def save(self, obj):
+    obj['type'] = self.type
+    obj['name'] = self.name
+    obj['x'] = self.localX
+    obj['y'] = self.localY
+    obj['z'] = self.localZ
+    pass
+
+  def setType(self, entityType):
+    if self.type == entityType:
+      return
+    self.type = entityType
+    self.chunk.dirty = True
+    self.chunk.map.onEntityData.invoke()
+
+  def setName(self, name):
+    if self.name == name:
+      return
+    self.name = name
+    self.chunk.dirty = True
+    self.chunk.map.onEntityData.invoke()
+
+  def draw(self):
+    self.vertexBuffer.clear()
+
+    startX = (self.chunk.x * CHUNK_WIDTH + self.localX) * TILE_WIDTH
+    startY = (self.chunk.y * CHUNK_HEIGHT + self.localY) * TILE_HEIGHT
+    startZ = (self.chunk.z * CHUNK_DEPTH + self.localZ) * TILE_DEPTH
+    w = TILE_WIDTH
+    h = TILE_HEIGHT
+    d = TILE_DEPTH
+
+    # Center
+    startX -= w / 2
+    startY -= h / 2
+    startZ -= d / 2
+    
+    # Offset upwards a little
+    startZ += 1
+
+    # Buffer simple quad at current position (need 6 positions)
+    self.vertexBuffer.vertices = [
+      startX,     startY,     startZ,
+      startX + w, startY,     startZ,
+      startX + w, startY + h, startZ,
+      startX,     startY,     startZ,
+      startX + w, startY + h, startZ,
+      startX,     startY + h, startZ,
+    ]
+    self.vertexBuffer.colors = [
+      1.0, 0.0, 1.0, 1.0,
+      1.0, 0.0, 1.0, 1.0,
+      1.0, 0.0, 1.0, 1.0,
+      1.0, 0.0, 1.0, 1.0,
+      1.0, 0.0, 1.0, 1.0,
+      1.0, 0.0, 1.0, 1.0,
+    ]
+    self.vertexBuffer.uvs = [
+      0.0, 0.0,
+      1.0, 0.0,
+      1.0, 1.0,
+      0.0, 0.0,
+      1.0, 1.0,
+      0.0, 1.0,
+    ]
+    self.vertexBuffer.buildData()
+    self.vertexBuffer.draw()

archive/dusk/event.py

@@ -0,0 +1,18 @@
+class Event:
+  def __init__(self):
+    self._subscribers = []
+
+  def sub(self, callback):
+    """Subscribe a callback to the event."""
+    if callback not in self._subscribers:
+      self._subscribers.append(callback)
+
+  def unsub(self, callback):
+    """Unsubscribe a callback from the event."""
+    if callback in self._subscribers:
+      self._subscribers.remove(callback)
+
+  def invoke(self, *args, **kwargs):
+    """Invoke all subscribers with the given arguments."""
+    for callback in self._subscribers:
+      callback(*args, **kwargs)

archive/dusk/map.py

@@ -0,0 +1,259 @@
+import json
+import sys
+from tools.dusk.event import Event
+from PyQt5.QtWidgets import QFileDialog, QMessageBox
+from PyQt5.QtCore import QTimer
+import os
+from tools.dusk.chunk import Chunk
+from tools.dusk.defs import MAP_WIDTH, MAP_HEIGHT, MAP_DEPTH, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH
+import traceback
+
+MAP_DEFAULT_PATH = os.path.join(os.path.dirname(__file__), '../../assets/map/')
+EDITOR_CONFIG_PATH = os.path.join(os.path.dirname(__file__), '.editor')
+
+class Map:
+  def __init__(self, parent):
+    self.parent = parent
+    self.data = {}
+    self.dataOriginal = {}
+    self.position = [None, None, None]  # x, y, z
+    self.topLeftX = None
+    self.topLeftY = None
+    self.topLeftZ = None
+    self.chunks = {}
+    self.onMapData = Event()
+    self.onPositionChange = Event()
+    self.onEntityData = Event()
+    self.mapFileName = None
+    self.lastFile = None
+    self.firstLoad = True
+
+    index = 0
+    for x in range(MAP_WIDTH):
+      for y in range(MAP_HEIGHT):
+        for z in range(MAP_DEPTH):
+          self.chunks[index] = Chunk(self, x, y, z)
+          index += 1
+    
+    # Only in editor instances:
+    self.moveTo(0, 0, 0)
+    if parent is not None:
+      QTimer.singleShot(16, self.loadLastFile)
+
+  def loadLastFile(self):
+    if not os.path.exists(EDITOR_CONFIG_PATH):
+      return
+    try:
+      with open(EDITOR_CONFIG_PATH, 'r') as f:
+        config = json.load(f)
+      lastFile = config.get('lastFile')
+      lastPosition = config.get('lastPosition')
+      leftPanelIndex = config.get('leftPanelIndex')
+      if lastFile and os.path.exists(lastFile):
+        self.load(lastFile)
+      if lastPosition and isinstance(lastPosition, list) and len(lastPosition) == 3:
+        self.moveTo(*lastPosition)
+      if leftPanelIndex is not None:
+        self.parent.leftPanel.tabs.setCurrentIndex(leftPanelIndex)
+    except Exception:
+      traceback.print_exc()
+
+  def updateEditorConfig(self):
+    if self.parent is None:
+      return
+    try:
+      mapFileName = self.getMapFilename()
+      config = {
+        'lastFile': mapFileName if mapFileName else "",
+        'lastPosition': self.position,
+        'leftPanelIndex': self.parent.leftPanel.tabs.currentIndex()
+      }
+      config_dir = os.path.dirname(EDITOR_CONFIG_PATH)
+      if not os.path.exists(config_dir):
+        os.makedirs(config_dir, exist_ok=True)
+      with open(EDITOR_CONFIG_PATH, 'w') as f:
+        json.dump(config, f, indent=2)
+    except Exception:
+      traceback.print_exc()
+
+  def newFile(self):
+    self.data = {}
+    self.dataOriginal = {}
+    self.mapFileName = None
+    self.lastFile = None
+    for chunk in self.chunks.values():
+      chunk.new()
+    self.moveTo(0, 0, 0)
+    self.onMapData.invoke(self.data)
+    self.updateEditorConfig()
+  
+  def save(self, fname=None):
+    if not self.getMapFilename() and fname is None:
+      filePath, _ = QFileDialog.getSaveFileName(None, "Save Map File", MAP_DEFAULT_PATH, "Map Files (*.json)")
+      if not filePath:
+        return
+      self.mapFileName = filePath
+    if fname:
+      self.mapFileName = fname
+    try:
+      with open(self.getMapFilename(), 'w') as f:
+        json.dump(self.data, f, indent=2)
+      self.dataOriginal = json.loads(json.dumps(self.data))  # Deep copy
+      for chunk in self.chunks.values():
+        chunk.save()
+      self.updateEditorConfig()
+    except Exception as e:
+      traceback.print_exc()
+      QMessageBox.critical(None, "Save Error", f"Failed to save map file:\n{e}")
+
+  def load(self, fileName):
+    try:
+      with open(fileName, 'r') as f:
+        self.data = json.load(f)
+      self.mapFileName = fileName
+      self.dataOriginal = json.loads(json.dumps(self.data))  # Deep copy
+      for chunk in self.chunks.values():
+        chunk.load()
+      self.onMapData.invoke(self.data)
+      self.updateEditorConfig()
+    except Exception as e:
+      traceback.print_exc()
+      QMessageBox.critical(None, "Load Error", f"Failed to load map file:\n{e}")
+
+  def isMapFileDirty(self):
+    return json.dumps(self.data, sort_keys=True) != json.dumps(self.dataOriginal, sort_keys=True)
+
+  def isDirty(self):
+    return self.isMapFileDirty() or self.anyChunksDirty()
+
+  def getMapFilename(self):
+    return self.mapFileName if self.mapFileName and os.path.exists(self.mapFileName) else None
+
+  def getMapDirectory(self):
+    if self.mapFileName is None:
+      return None
+    dirname = os.path.dirname(self.mapFileName)
+    return dirname
+  
+  def getChunkDirectory(self):
+    dirName = self.getMapDirectory()
+    if dirName is None:
+      return None
+    return os.path.join(dirName, 'chunks')
+  
+  def anyChunksDirty(self):
+    for chunk in self.chunks.values():
+      if chunk.isDirty():
+        return True
+    return False
+
+  def moveTo(self, x, y, z):
+    if self.position == [x, y, z]:
+      return
+    
+    # We need to decide if the chunks should be unloaded here or not.
+    newTopLeftChunkX = x // CHUNK_WIDTH - (MAP_WIDTH // 2)
+    newTopLeftChunkY = y // CHUNK_HEIGHT - (MAP_HEIGHT // 2)
+    newTopLeftChunkZ = z // CHUNK_DEPTH - (MAP_DEPTH // 2)
+
+    if (newTopLeftChunkX != self.topLeftX or
+        newTopLeftChunkY != self.topLeftY or
+        newTopLeftChunkZ != self.topLeftZ):
+      
+      chunksToUnload = []
+      chunksToKeep = []
+      for chunk in self.chunks.values():
+        chunkWorldX = chunk.x
+        chunkWorldY = chunk.y
+        chunkWorldZ = chunk.z
+        if (chunkWorldX < newTopLeftChunkX or
+            chunkWorldX >= newTopLeftChunkX + MAP_WIDTH or
+            chunkWorldY < newTopLeftChunkY or
+            chunkWorldY >= newTopLeftChunkY + MAP_HEIGHT or
+            chunkWorldZ < newTopLeftChunkZ or
+            chunkWorldZ >= newTopLeftChunkZ + MAP_DEPTH):
+          chunksToUnload.append(chunk)
+        else:
+          chunksToKeep.append(chunk)
+      
+      # Unload chunks that are out of the new bounds.
+      for chunk in chunksToUnload:
+        if chunk.isDirty():
+          print(f"Can't move map, some chunks are dirty: ({chunk.x}, {chunk.y}, {chunk.z})")
+          return
+        
+      # Now we can safely unload the chunks.
+      chunkIndex = 0
+      newChunks = {}
+      for chunk in chunksToKeep:
+        newChunks[chunkIndex] = chunk
+        chunkIndex += 1
+
+      for xPos in range(newTopLeftChunkX, newTopLeftChunkX + MAP_WIDTH):
+        for yPos in range(newTopLeftChunkY, newTopLeftChunkY + MAP_HEIGHT):
+          for zPos in range(newTopLeftChunkZ, newTopLeftChunkZ + MAP_DEPTH):
+            # Check if we already have this chunk.
+            found = False
+            for chunk in chunksToKeep:
+              if chunk.x == xPos and chunk.y == yPos and chunk.z == zPos:
+                found = True
+                break
+            if not found:
+              # Create a new chunk.
+              newChunk = chunksToUnload.pop()
+              newChunk.reload(xPos, yPos, zPos)
+              newChunks[chunkIndex] = newChunk
+              chunkIndex += 1
+
+      self.chunks = newChunks
+      self.topLeftX = newTopLeftChunkX
+      self.topLeftY = newTopLeftChunkY
+      self.topLeftZ = newTopLeftChunkZ
+
+    self.position = [x, y, z]
+    self.onPositionChange.invoke(self.position)
+    if not self.firstLoad:
+      self.updateEditorConfig()
+    self.firstLoad = False
+
+  def moveRelative(self, x, y, z):
+    self.moveTo(
+      self.position[0] + x,
+      self.position[1] + y,
+      self.position[2] + z
+    )
+  
+  def draw(self):
+    for chunk in self.chunks.values():
+      chunk.draw()
+    
+    for chunk in self.chunks.values():
+      for entity in chunk.entities.values():
+        entity.draw()
+
+    # Only render on Region tab
+    if self.parent.leftPanel.tabs.currentWidget() == self.parent.leftPanel.regionPanel:
+      for chunk in self.chunks.values():
+        for region in chunk.regions.values():
+          region.draw()
+
+  def getChunkAtWorldPos(self, x, y, z):
+    chunkX = x // CHUNK_WIDTH
+    chunkY = y // CHUNK_HEIGHT
+    chunkZ = z // CHUNK_DEPTH
+    for chunk in self.chunks.values():
+      if chunk.x == chunkX and chunk.y == chunkY and chunk.z == chunkZ:
+        return chunk
+    return None
+
+  def getTileAtWorldPos(self, x, y, z):
+    chunk = self.getChunkAtWorldPos(x, y, z)
+    if not chunk:
+      print("No chunk found at position:", (x, y, z))
+      return None
+    
+    tileX = x % CHUNK_WIDTH
+    tileY = y % CHUNK_HEIGHT
+    tileZ = z % CHUNK_DEPTH
+    tileIndex = tileX + tileY * CHUNK_WIDTH + tileZ * CHUNK_WIDTH * CHUNK_HEIGHT
+    return chunk.tiles.get(tileIndex)

archive/dusk/region.py

@@ -0,0 +1,141 @@
+from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
+from tools.editor.map.vertexbuffer import VertexBuffer
+from OpenGL.GL import *
+from OpenGL.GLU import *
+
+class Region:
+  def __init__(self, chunk):
+    self.minX = 0
+    self.minY = 0
+    self.minZ = 0
+    self.maxX = 0
+    self.maxY = 0
+    self.maxZ = 0
+    self.chunk = chunk
+    self.vertexBuffer = VertexBuffer()
+    self.color = (1.0, 0.0, 0.0)
+    self.updateVertexs()
+    pass
+
+  def updateVertexs(self):
+    # Draw a quad, semi transparent with solid outlines
+    vminX = (self.minX * CHUNK_WIDTH) * TILE_WIDTH
+    vminY = (self.minY * CHUNK_HEIGHT) * TILE_HEIGHT
+    vminZ = (self.minZ * CHUNK_DEPTH) * TILE_DEPTH
+    vmaxX = (self.maxX * CHUNK_WIDTH) * TILE_WIDTH
+    vmaxY = (self.maxY * CHUNK_HEIGHT) * TILE_HEIGHT
+    vmaxZ = (self.maxZ * CHUNK_DEPTH) * TILE_DEPTH
+    alpha = 0.25
+
+    # Move back half a tile width
+    vminX -= TILE_WIDTH / 2
+    vmaxX -= TILE_WIDTH / 2
+    vminY -= TILE_HEIGHT / 2
+    vmaxY -= TILE_HEIGHT / 2
+    vminZ -= TILE_DEPTH / 2
+    vmaxZ -= TILE_DEPTH / 2
+
+    # Cube (6 verts per face)
+    self.vertexBuffer.vertices = [
+      # Front face
+      vminX, vminY, vmaxZ,
+      vmaxX, vminY, vmaxZ,
+      vmaxX, vmaxY, vmaxZ,
+      vminX, vminY, vmaxZ,
+      vmaxX, vmaxY, vmaxZ,
+      vminX, vmaxY, vmaxZ,
+
+      # Back face
+      vmaxX, vminY, vminZ,
+      vminX, vminY, vminZ,
+      vminX, vmaxY, vminZ,
+      vmaxX, vminY, vminZ,
+      vminX, vmaxY, vminZ,
+      vmaxX, vmaxY, vminZ,
+
+      # Left face
+      vminX, vminY, vminZ,
+      vminX, vminY, vmaxZ,
+      vminX, vmaxY, vmaxZ,
+      vminX, vminY, vminZ,
+      vminX, vmaxY, vmaxZ,
+      vminX, vmaxY, vminZ,
+
+      # Right face
+      vmaxX, vminY, vmaxZ,
+      vmaxX, vminY, vminZ,
+      vmaxX, vmaxY, vminZ,
+      vmaxX, vminY, vmaxZ,
+      vmaxX, vmaxY, vminZ,
+      vmaxX, vmaxY, vmaxZ,
+
+      # Top face
+      vminX, vmaxY, vmaxZ,
+      vmaxX, vmaxY, vmaxZ,
+      vmaxX, vmaxY, vminZ,
+      vminX, vmaxY, vmaxZ,
+      vmaxX, vmaxY, vminZ,
+      vminX, vmaxY, vminZ,
+
+      # Bottom face
+      vminX, vminY, vminZ,
+      vmaxX, vminY, vminZ,
+      vmaxX, vminY, vmaxZ,
+      vminX, vminY, vminZ,
+      vmaxX, vminY, vmaxZ,
+      vminX, vminY, vmaxZ,
+    ]
+
+    self.vertexBuffer.colors = [
+      # Front face
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+
+      # Back face
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+
+      # Left face
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+
+      # Right face
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+
+      # Top face
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+
+      # Bottom face
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+      self.color[0], self.color[1], self.color[2], alpha,
+    ]
+    self.vertexBuffer.buildData()
+
+  def draw(self):
+    self.vertexBuffer.draw()

archive/dusk/tile.py

@@ -0,0 +1,206 @@
+from OpenGL.GL import *
+from tools.dusk.defs import (
+  TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH,
+  CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH,
+  TILE_SHAPE_NULL, TILE_SHAPE_FLOOR,
+  TILE_SHAPE_RAMP_NORTH, TILE_SHAPE_RAMP_SOUTH,
+  TILE_SHAPE_RAMP_EAST, TILE_SHAPE_RAMP_WEST,
+  TILE_SHAPE_RAMP_SOUTHWEST, TILE_SHAPE_RAMP_SOUTHEAST,
+  TILE_SHAPE_RAMP_NORTHWEST, TILE_SHAPE_RAMP_NORTHEAST
+)
+
+def getItem(arr, index, default):
+  if index < len(arr):
+    return arr[index]
+  return default
+
+class Tile:
+  def __init__(self, chunk, x, y, z, tileIndex):
+    self.shape = TILE_SHAPE_NULL
+
+    self.chunk = chunk
+    self.x = x
+    self.y = y
+    self.z = z
+    self.index = tileIndex
+
+    self.posX = x * TILE_WIDTH + chunk.x * CHUNK_WIDTH * TILE_WIDTH
+    self.posY = y * TILE_HEIGHT + chunk.y * CHUNK_HEIGHT * TILE_HEIGHT
+    self.posZ = z * TILE_DEPTH + chunk.z * CHUNK_DEPTH * TILE_DEPTH
+  
+  def chunkReload(self, newX, newY, newZ):
+    self.posX = self.x * TILE_WIDTH + newX * CHUNK_WIDTH * TILE_WIDTH
+    self.posY = self.y * TILE_HEIGHT + newY * CHUNK_HEIGHT * TILE_HEIGHT
+    self.posZ = self.z * TILE_DEPTH + newZ * CHUNK_DEPTH * TILE_DEPTH
+
+  def load(self, chunkData):
+    self.shape = getItem(chunkData['shapes'], self.index, TILE_SHAPE_NULL)
+
+  def setShape(self, shape):
+    if shape == self.shape:
+      return
+    
+    self.shape = shape
+    self.chunk.dirty = True
+    self.chunk.tileUpdateVertices()
+    self.chunk.onChunkData.invoke(self.chunk)
+
+  def getBaseTileModel(self):
+    vertices = []
+    indices = []
+    uvs = []
+    colors = [] 
+
+    if self.shape == TILE_SHAPE_NULL:
+      pass
+
+    elif self.shape == TILE_SHAPE_FLOOR:
+      vertices = [
+        (self.posX, self.posY, self.posZ),
+        (self.posX + TILE_WIDTH, self.posY, self.posZ),
+        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
+        (self.posX, self.posY + TILE_HEIGHT, self.posZ)
+      ]
+      indices = [0, 1, 2, 0, 2, 3]
+      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
+      colors = [ (255, 255, 255, 255) ] * 4
+
+    elif self.shape == TILE_SHAPE_RAMP_NORTH:
+      vertices = [
+        (self.posX, self.posY, self.posZ + TILE_DEPTH),
+        (self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
+        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
+        (self.posX, self.posY + TILE_HEIGHT, self.posZ)
+      ]
+      indices = [0, 1, 2, 0, 2, 3]
+      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
+      colors = [ (255, 0, 0, 255) ] * 4
+
+    elif self.shape == TILE_SHAPE_RAMP_SOUTH:
+      vertices = [
+        (self.posX, self.posY, self.posZ),
+        (self.posX + TILE_WIDTH, self.posY, self.posZ),
+        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
+        (self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
+      ]
+      indices = [0, 1, 2, 0, 2, 3]
+      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
+      colors = [ (0, 255, 0, 255) ] * 4
+
+    elif self.shape == TILE_SHAPE_RAMP_EAST:
+      vertices = [
+        (self.posX, self.posY, self.posZ),
+        (self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
+        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
+        (self.posX, self.posY + TILE_HEIGHT, self.posZ)
+      ]
+      indices = [0, 1, 2, 0, 2, 3]
+      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
+      colors = [ (0, 0, 255, 255) ] * 4
+
+    elif self.shape == TILE_SHAPE_RAMP_WEST:
+      vertices = [
+        (self.posX, self.posY, self.posZ + TILE_DEPTH),
+        (self.posX + TILE_WIDTH, self.posY, self.posZ),
+        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
+        (self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
+      ]
+      indices = [0, 1, 2, 0, 2, 3]
+      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
+      colors = [ (255, 255, 0, 255) ] * 4
+    
+    elif self.shape == TILE_SHAPE_RAMP_SOUTHWEST:
+      vertices = [
+        (self.posX, self.posY, self.posZ + TILE_DEPTH),
+        (self.posX + TILE_WIDTH, self.posY, self.posZ),
+        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
+        (self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
+      ]
+      indices = [0, 1, 2, 0, 2, 3]
+      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
+      colors = [ (255, 128, 0, 255) ] * 4
+
+    elif self.shape == TILE_SHAPE_RAMP_NORTHWEST:
+      vertices = [
+        (self.posX, self.posY, self.posZ + TILE_DEPTH),
+        (self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
+        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ),
+        (self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
+      ]
+      indices = [0, 1, 2, 0, 2, 3]
+      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
+      colors = [ (128, 255, 0, 255) ] * 4
+
+    elif self.shape == TILE_SHAPE_RAMP_NORTHEAST:
+      vertices = [
+        (self.posX, self.posY, self.posZ + TILE_DEPTH),
+        (self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
+        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
+        (self.posX, self.posY + TILE_HEIGHT, self.posZ)
+      ]
+      indices = [0, 1, 2, 0, 2, 3]
+      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
+      colors = [ (0, 255, 128, 255) ] * 4
+      
+    elif self.shape == TILE_SHAPE_RAMP_SOUTHEAST:
+      vertices = [
+        (self.posX, self.posY, self.posZ),
+        (self.posX + TILE_WIDTH, self.posY, self.posZ + TILE_DEPTH),
+        (self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH),
+        (self.posX, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH)
+      ]
+      indices = [0, 1, 2, 0, 2, 3]
+      uvs = [ (0, 0), (1, 0), (1, 1), (0, 1) ]
+      colors = [ (255, 128, 255, 255) ] * 4
+
+    else:
+      # Solid black cube for unknown shape
+      x0, y0, z0 = self.posX, self.posY, self.posZ
+      x1, y1, z1 = self.posX + TILE_WIDTH, self.posY + TILE_HEIGHT, self.posZ + TILE_DEPTH
+      vertices = [
+        (x0, y0, z0), (x1, y0, z0), (x1, y1, z0), (x0, y1, z0), # bottom
+        (x0, y0, z1), (x1, y0, z1), (x1, y1, z1), (x0, y1, z1)  # top
+      ]
+      indices = [
+        0,1,2, 0,2,3,   # bottom
+        4,5,6, 4,6,7,   # top
+        0,1,5, 0,5,4,   # front
+        2,3,7, 2,7,6,   # back
+        1,2,6, 1,6,5,   # right
+        3,0,4, 3,4,7    # left
+      ]
+      uvs = [ (0,0) ] * 8
+      colors = [ (0,0,0,255) ] * 8
+
+    return {
+      'vertices': vertices,
+      'indices': indices,
+      'uvs': uvs,
+      'colors': colors
+    }
+
+  def buffer(self, vertexBuffer):
+    if self.shape == TILE_SHAPE_NULL:
+      return
+
+    # New code:
+    baseData = self.getBaseTileModel()
+
+    # Base data is indiced but we need to buffer unindiced data
+    for index in baseData['indices']:
+      verts = baseData['vertices'][index]
+      uv = baseData['uvs'][index]
+      color = baseData['colors'][index]
+
+      vertexBuffer.vertices.extend([
+        verts[0] - (TILE_WIDTH / 2.0),
+        verts[1] - (TILE_HEIGHT / 2.0),
+        verts[2] - (TILE_DEPTH / 2.0)
+      ])
+
+      vertexBuffer.colors.extend([
+        color[0] / 255.0,
+        color[1] / 255.0,
+        color[2] / 255.0,
+        color[3] / 255.0
+      ])

archive/editor/__main__.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+import sys
+from PyQt5.QtWidgets import (
+  QApplication, QVBoxLayout, QPushButton,
+  QDialog
+)
+from OpenGL.GL import *
+from OpenGL.GLU import *
+from tools.editor.maptool import MapWindow
+from tools.editor.langtool import LangToolWindow
+from tools.editor.cutscenetool import CutsceneToolWindow
+
+DEFAULT_TOOL = None
+DEFAULT_TOOL = "map"
+# DEFAULT_TOOL = "cutscene"
+
+TOOLS = [
+  ("Map Editor", "map", MapWindow),
+  ("Language Editor", "language", LangToolWindow),
+  ("Cutscene Editor", "cutscene", CutsceneToolWindow),
+]
+
+class EditorChoiceDialog(QDialog):
+  def __init__(self):
+    super().__init__()
+    self.setWindowTitle("Choose Tool")
+    layout = QVBoxLayout(self)
+    self.selected = None
+    for label, key, win_cls in TOOLS:
+      btn = QPushButton(label)
+      btn.clicked.connect(lambda checked, w=win_cls: self.choose_tool(w))
+      layout.addWidget(btn)
+
+  def choose_tool(self, win_cls):
+    self.selected = win_cls
+    self.accept()
+
+  def get_choice(self):
+    return self.selected
+
+def main():
+  app = QApplication(sys.argv)
+  tool_map = { key: win_cls for _, key, win_cls in TOOLS }
+  if DEFAULT_TOOL in tool_map:
+    win_cls = tool_map[DEFAULT_TOOL]
+  else:
+    choice_dialog = EditorChoiceDialog()
+    if choice_dialog.exec_() == QDialog.Accepted:
+      win_cls = choice_dialog.get_choice()
+    else:
+      sys.exit(0)
+  win = win_cls()
+  win.show()
+  sys.exit(app.exec_())
+
+if __name__ == "__main__":
+  main()

archive/editor/cutscene/cutsceneitemeditor.py

@@ -0,0 +1,58 @@
+from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLineEdit, QLabel, QSizePolicy, QComboBox, QHBoxLayout, QSpacerItem
+from PyQt5.QtCore import Qt, pyqtSignal
+from .cutscenewait import CutsceneWaitEditor
+from .cutscenetext import CutsceneTextEditor
+
+EDITOR_MAP = (
+  ( "wait", "Wait", CutsceneWaitEditor ),
+  ( "text", "Text", CutsceneTextEditor )
+)
+
+class CutsceneItemEditor(QWidget):
+  def __init__(self, parent=None):
+    super().__init__(parent)
+    self.layout = QVBoxLayout(self)
+    self.layout.setAlignment(Qt.AlignTop | Qt.AlignLeft)
+    self.layout.addWidget(QLabel("Item Properties:"))
+
+    rowLayout = QHBoxLayout()
+    rowLayout.setSpacing(8)
+
+    rowLayout.addWidget(QLabel("Name:"))
+    self.nameInput = QLineEdit()
+    rowLayout.addWidget(self.nameInput)
+
+    rowLayout.addWidget(QLabel("Type:"))
+    self.typeDropdown = QComboBox()
+    self.typeDropdown.addItems([typeName for typeKey, typeName, editorClass in EDITOR_MAP])
+    rowLayout.addWidget(self.typeDropdown)
+    self.layout.addLayout(rowLayout)
+    
+    self.activeEditor = None
+
+    # Events
+    self.nameInput.textChanged.connect(self.onNameChanged)
+    self.typeDropdown.currentTextChanged.connect(self.onTypeChanged)
+
+    # First load
+    self.onNameChanged(self.nameInput.text())
+    self.onTypeChanged(self.typeDropdown.currentText())
+
+  def onNameChanged(self, nameText):
+    pass
+
+  def onTypeChanged(self, typeText):
+    typeKey = typeText.lower()
+    
+    # Remove existing editor
+    if self.activeEditor:
+      self.layout.removeWidget(self.activeEditor)
+      self.activeEditor.deleteLater()
+      self.activeEditor = None
+
+    # Create new editor
+    for key, name, editorClass in EDITOR_MAP:
+      if key == typeKey:
+        self.activeEditor = editorClass()
+        self.layout.addWidget(self.activeEditor)
+        break

archive/editor/cutscene/cutscenemenubar.py

@@ -0,0 +1,54 @@
+from PyQt5.QtWidgets import QMenuBar, QAction, QFileDialog, QMessageBox
+from PyQt5.QtGui import QKeySequence
+
+class CutsceneMenuBar(QMenuBar):
+  def __init__(self, parent):
+    super().__init__(parent)
+    self.parent = parent
+    fileMenu = self.addMenu("File")
+
+    self.newAction = QAction("New", self)
+    self.newAction.setShortcut(QKeySequence.New)
+    self.newAction.triggered.connect(self.newFile)
+    fileMenu.addAction(self.newAction)
+
+    self.openAction = QAction("Open", self)
+    self.openAction.setShortcut(QKeySequence.Open)
+    self.openAction.triggered.connect(self.openFile)
+    fileMenu.addAction(self.openAction)
+
+    self.saveAction = QAction("Save", self)
+    self.saveAction.setShortcut(QKeySequence.Save)
+    self.saveAction.triggered.connect(self.saveFile)
+    fileMenu.addAction(self.saveAction)
+
+    self.saveAsAction = QAction("Save As", self)
+    self.saveAsAction.setShortcut(QKeySequence.SaveAs)
+    self.saveAsAction.triggered.connect(self.saveFileAs)
+    fileMenu.addAction(self.saveAsAction)
+
+  def newFile(self):
+    self.parent.clearCutscene()
+
+  def openFile(self):
+    path, _ = QFileDialog.getOpenFileName(self.parent, "Open Cutscene File", "", "JSON Files (*.json);;All Files (*)")
+    if not path:
+      return
+    
+    # TODO: Load file contents into timeline
+    self.parent.currentFile = path
+    pass
+
+  def saveFile(self):
+    if not self.parent.currentFile:
+      self.saveFileAs()
+      return
+    
+    # TODO: Save timeline to self.parent.currentFile
+    pass
+
+  def saveFileAs(self):
+    path, _ = QFileDialog.getSaveFileName(self.parent, "Save Cutscene File As", "", "JSON Files (*.json);;All Files (*)")
+    if path:
+      self.parent.currentFile = path
+      self.saveFile()

archive/editor/cutscene/cutscenetext.py

@@ -0,0 +1,21 @@
+from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QTextEdit
+from PyQt5.QtCore import Qt
+
+class CutsceneTextEditor(QWidget):
+  def __init__(self, parent=None):
+    super().__init__(parent)
+    layout = QVBoxLayout(self)
+    layout.setContentsMargins(0, 0, 0, 0)
+    layout.setSpacing(0)
+    label = QLabel("Text:")
+    label.setSizePolicy(label.sizePolicy().Expanding, label.sizePolicy().Fixed)
+    layout.addWidget(label)
+    self.textInput = QTextEdit()
+    self.textInput.setSizePolicy(self.textInput.sizePolicy().Expanding, self.textInput.sizePolicy().Expanding)
+    layout.addWidget(self.textInput, stretch=1)
+
+  def setText(self, text):
+    self.textInput.setPlainText(text)
+
+  def getText(self):
+    return self.textInput.toPlainText()

archive/editor/cutscene/cutscenewait.py

@@ -0,0 +1,20 @@
+from PyQt5.QtWidgets import QWidget, QFormLayout, QDoubleSpinBox, QLabel
+
+class CutsceneWaitEditor(QWidget):
+  def __init__(self, parent=None):
+    super().__init__(parent)
+    layout = QFormLayout(self)
+    layout.setContentsMargins(0, 0, 0, 0)
+    layout.setSpacing(0)
+    self.waitTimeInput = QDoubleSpinBox()
+    self.waitTimeInput.setMinimum(0.0)
+    self.waitTimeInput.setMaximum(9999.0)
+    self.waitTimeInput.setDecimals(2)
+    self.waitTimeInput.setSingleStep(0.1)
+    layout.addRow(QLabel("Wait Time (seconds):"), self.waitTimeInput)
+
+  def setWaitTime(self, value):
+    self.waitTimeInput.setValue(value)
+
+  def getWaitTime(self):
+    return self.waitTimeInput.value()

archive/editor/cutscenetool.py

@@ -0,0 +1,101 @@
+from PyQt5.QtWidgets import QMainWindow, QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QListWidget, QListWidgetItem, QMenuBar, QAction, QFileDialog, QMessageBox
+from PyQt5.QtGui import QKeySequence
+from tools.editor.cutscene.cutsceneitemeditor import CutsceneItemEditor
+from tools.editor.cutscene.cutscenemenubar import CutsceneMenuBar
+import sys
+
+class CutsceneToolWindow(QMainWindow):
+  def __init__(self):
+    super().__init__()
+    self.setWindowTitle("Dusk Cutscene Editor")
+    self.setGeometry(100, 100, 800, 600)
+    self.nextItemNumber = 1  # Track next available number
+    self.currentFile = None
+    self.dirty = False  # Track unsaved changes
+
+    # File menu (handled by CutsceneMenuBar)
+    menubar = CutsceneMenuBar(self)
+    self.setMenuBar(menubar)
+
+    # Main layout: horizontal split
+    central = QWidget()
+    mainLayout = QHBoxLayout(central)
+    self.setCentralWidget(central)
+
+    # Timeline
+    leftPanel = QWidget()
+    leftLayout = QVBoxLayout(leftPanel)
+
+    self.timelineList = QListWidget()
+    self.timelineList.setSelectionMode(QListWidget.SingleSelection)
+    leftLayout.addWidget(QLabel("Cutscene Timeline"))
+    leftLayout.addWidget(self.timelineList)
+
+    btnLayout = QHBoxLayout()
+    self.addBtn = QPushButton("Add")
+    self.removeBtn = QPushButton("Remove")
+    btnLayout.addWidget(self.addBtn)
+    btnLayout.addWidget(self.removeBtn)
+    leftLayout.addLayout(btnLayout)
+    mainLayout.addWidget(leftPanel, 2)
+
+    # Property editor
+    self.editorPanel = QWidget()
+    self.editorLayout = QVBoxLayout(self.editorPanel)
+    self.itemEditor = None  # Only create when needed
+    mainLayout.addWidget(self.editorPanel, 3)
+
+    # Events
+    self.timelineList.currentItemChanged.connect(self.onItemSelected)
+    self.addBtn.clicked.connect(self.addCutsceneItem)
+    self.removeBtn.clicked.connect(self.removeCutsceneItem)
+
+  def addCutsceneItem(self):
+    name = f"Cutscene item {self.nextItemNumber}"
+    timelineItem = QListWidgetItem(name)
+    self.timelineList.addItem(timelineItem)
+    self.timelineList.setCurrentItem(timelineItem)
+    self.nextItemNumber += 1
+    self.dirty = True
+
+  def removeCutsceneItem(self):
+    row = self.timelineList.currentRow()
+    if row < 0:
+      return
+    self.timelineList.takeItem(row)
+    self.dirty = True
+
+    # Remove editor if nothing selected
+    if self.timelineList.currentItem() is None or self.itemEditor is None:
+      return
+    
+    self.editorLayout.removeWidget(self.itemEditor)
+    self.itemEditor.deleteLater()
+    self.itemEditor = None
+
+  def clearCutscene(self):
+    self.timelineList.clear()
+    self.nextItemNumber = 1
+    self.currentFile = None
+    self.dirty = False
+    if self.itemEditor:
+      self.editorLayout.removeWidget(self.itemEditor)
+
+  def onItemSelected(self, current, previous):
+    if current:
+      if not self.itemEditor:
+        self.itemEditor = CutsceneItemEditor()
+        self.editorLayout.addWidget(self.itemEditor)
+      return
+    
+    if not self.itemEditor:
+      return
+    self.editorLayout.removeWidget(self.itemEditor)
+    self.itemEditor.deleteLater()
+    self.itemEditor = None
+
+if __name__ == "__main__":
+  app = QApplication(sys.argv)
+  window = CutsceneToolWindow()
+  window.show()
+  sys.exit(app.exec_())

archive/editor/langtool.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+from PyQt5.QtWidgets import QMainWindow, QApplication, QAction, QMenuBar, QMessageBox, QFileDialog, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit, QTableWidget, QTableWidgetItem, QHeaderView, QPushButton, QTabWidget, QFormLayout
+from PyQt5.QtCore import Qt
+import sys
+import os
+import polib
+
+class LangToolWindow(QMainWindow):
+  def __init__(self):
+    super().__init__()
+    self.setWindowTitle("Dusk Language Editor")
+    self.setGeometry(100, 100, 800, 600)
+    self.current_file = None
+    self.dirty = False
+    self.init_menu()
+    self.init_ui()
+
+  def init_ui(self):
+    central = QWidget()
+    layout = QVBoxLayout(central)
+
+    tabs = QTabWidget()
+    # Header Tab
+    header_tab = QWidget()
+    header_layout = QFormLayout(header_tab)
+    self.language_edit = QLineEdit()
+    self.language_edit.setMaximumWidth(220)
+    header_layout.addRow(QLabel("Language:"), self.language_edit)
+    self.plural_edit = QLineEdit()
+    self.plural_edit.setMaximumWidth(320)
+    header_layout.addRow(QLabel("Plural-Forms:"), self.plural_edit)
+    self.content_type_edit = QLineEdit("text/plain; charset=UTF-8")
+    self.content_type_edit.setMaximumWidth(320)
+    header_layout.addRow(QLabel("Content-Type:"), self.content_type_edit)
+    tabs.addTab(header_tab, "Header")
+
+    # Strings Tab
+    strings_tab = QWidget()
+    strings_layout = QVBoxLayout(strings_tab)
+    self.po_table = QTableWidget()
+    self.po_table.setColumnCount(2)
+    self.po_table.setHorizontalHeaderLabels(["msgid", "msgstr"])
+    self.po_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+    self.po_table.verticalHeader().setMinimumWidth(22)
+    self.po_table.verticalHeader().setDefaultAlignment(Qt.AlignRight | Qt.AlignVCenter)
+    strings_layout.addWidget(self.po_table)
+    row_btn_layout = QHBoxLayout()
+    add_row_btn = QPushButton("Add Row")
+    remove_row_btn = QPushButton("Remove Row")
+    row_btn_layout.addWidget(add_row_btn)
+    row_btn_layout.addWidget(remove_row_btn)
+    strings_layout.addLayout(row_btn_layout)
+    tabs.addTab(strings_tab, "Strings")
+
+    layout.addWidget(tabs)
+
+    add_row_btn.clicked.connect(self.add_row)
+    remove_row_btn.clicked.connect(self.remove_row)
+    self.add_row_btn = add_row_btn
+    self.remove_row_btn = remove_row_btn
+
+    self.setCentralWidget(central)
+
+    # Connect edits to dirty flag
+    self.language_edit.textChanged.connect(self.set_dirty)
+    self.plural_edit.textChanged.connect(self.set_dirty)
+    self.content_type_edit.textChanged.connect(self.set_dirty)
+    self.po_table.itemChanged.connect(self.set_dirty)
+
+  def set_dirty(self):
+    self.dirty = True
+    self.update_save_action()
+
+  def init_menu(self):
+    menubar = self.menuBar()
+    file_menu = menubar.addMenu("File")
+
+    new_action = QAction("New", self)
+    open_action = QAction("Open", self)
+    save_action = QAction("Save", self)
+    save_as_action = QAction("Save As", self)
+
+    new_action.triggered.connect(lambda: self.handle_file_action("new"))
+    open_action.triggered.connect(lambda: self.handle_file_action("open"))
+    save_action.triggered.connect(self.handle_save)
+    save_as_action.triggered.connect(self.handle_save_as)
+
+    file_menu.addAction(new_action)
+    file_menu.addAction(open_action)
+    file_menu.addAction(save_action)
+    file_menu.addAction(save_as_action)
+
+    self.save_action = save_action  # Store reference for enabling/disabling
+    self.update_save_action()
+
+  def update_save_action(self):
+    self.save_action.setEnabled(self.current_file is not None)
+
+  def handle_file_action(self, action):
+    if self.dirty:
+      reply = QMessageBox.question(self, "Save Changes?", "Do you want to save changes before proceeding?", QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
+      if reply == QMessageBox.Cancel:
+        return
+      elif reply == QMessageBox.Yes:
+        self.handle_save()
+    if action == "new":
+      self.new_file()
+    elif action == "open":
+      default_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../assets/locale"))
+      file_path, _ = QFileDialog.getOpenFileName(self, "Open Language File", default_dir, "PO Files (*.po)")
+      if file_path:
+        self.open_file(file_path)
+
+  def new_file(self):
+    self.current_file = None
+    self.dirty = False
+    self.language_edit.setText("")
+    self.plural_edit.setText("")
+    self.po_table.setRowCount(0)
+    self.update_save_action()
+
+  def open_file(self, file_path):
+    self.current_file = file_path
+    self.dirty = False
+    self.update_save_action()
+    self.load_po_file(file_path)
+
+  def load_po_file(self, file_path):
+    po = polib.pofile(file_path)
+    language = po.metadata.get('Language', '')
+    plural = po.metadata.get('Plural-Forms', '')
+    content_type = po.metadata.get('Content-Type', 'text/plain; charset=UTF-8')
+    self.language_edit.setText(language)
+    self.plural_edit.setText(plural)
+    self.content_type_edit.setText(content_type)
+    self.po_table.setRowCount(len(po))
+    for row, entry in enumerate(po):
+      self.po_table.setItem(row, 0, QTableWidgetItem(entry.msgid))
+      self.po_table.setItem(row, 1, QTableWidgetItem(entry.msgstr))
+
+  def save_file(self, file_path):
+    po = polib.POFile()
+    po.metadata = {
+      'Language': self.language_edit.text(),
+      'Content-Type': self.content_type_edit.text(),
+      'Plural-Forms': self.plural_edit.text(),
+    }
+    for row in range(self.po_table.rowCount()):
+      msgid_item = self.po_table.item(row, 0)
+      msgstr_item = self.po_table.item(row, 1)
+      msgid = msgid_item.text() if msgid_item else ''
+      msgstr = msgstr_item.text() if msgstr_item else ''
+      if msgid or msgstr:
+        entry = polib.POEntry(msgid=msgid, msgstr=msgstr)
+        po.append(entry)
+    po.save(file_path)
+    self.dirty = False
+    self.update_save_action()
+
+  def handle_save(self):
+    if self.current_file:
+      self.save_file(self.current_file)
+    else:
+      self.handle_save_as()
+
+  def handle_save_as(self):
+    default_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../assets/locale"))
+    file_path, _ = QFileDialog.getSaveFileName(self, "Save Language File As", default_dir, "PO Files (*.po)")
+    if file_path:
+      self.current_file = file_path
+      self.update_save_action()
+      self.save_file(file_path)
+
+  def add_row(self):
+    row = self.po_table.rowCount()
+    self.po_table.insertRow(row)
+    self.po_table.setItem(row, 0, QTableWidgetItem(""))
+    self.po_table.setItem(row, 1, QTableWidgetItem(""))
+    self.po_table.setCurrentCell(row, 0)
+    self.set_dirty()
+
+  def remove_row(self):
+    row = self.po_table.currentRow()
+    if row >= 0:
+      self.po_table.removeRow(row)
+      self.set_dirty()
+
+  def closeEvent(self, event):
+    if self.dirty:
+      reply = QMessageBox.question(self, "Save Changes?", "Do you want to save changes before exiting?", QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
+      if reply == QMessageBox.Cancel:
+        event.ignore()
+        return
+      elif reply == QMessageBox.Yes:
+        self.handle_save()
+    event.accept()
+
+if __name__ == "__main__":
+  app = QApplication(sys.argv)
+  window = LangToolWindow()
+  window.show()
+  sys.exit(app.exec_())

archive/editor/map/camera.py

@@ -0,0 +1,55 @@
+import math
+import time
+from OpenGL.GL import *
+from OpenGL.GLU import *
+from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH, RPG_CAMERA_PIXELS_PER_UNIT, RPG_CAMERA_Z_OFFSET, RPG_CAMERA_FOV
+
+class Camera:
+  def __init__(self, parent):
+    self.parent = parent
+    self.pixelsPerUnit = RPG_CAMERA_PIXELS_PER_UNIT
+    self.yOffset = RPG_CAMERA_Z_OFFSET
+    self.fov = RPG_CAMERA_FOV
+    self.scale = 8.0
+    self.lastTime = time.time()
+    self.lookAtTarget = [0.0, 0.0, 0.0]
+
+  def setup(self, vw, vh, duration=0.1):
+    now = time.time()
+    delta = now - self.lastTime
+    self.lastTime = now
+    # Calculate ease factor for exponential smoothing over 'duration' seconds
+    ease = 1 - math.exp(-delta / duration)
+
+    z = (vh / 2.0) / (
+      (self.pixelsPerUnit * self.scale) * math.tan(math.radians(self.fov / 2.0))
+    )
+    lookAt = [
+      self.parent.map.position[0] * TILE_WIDTH,
+      self.parent.map.position[1] * TILE_HEIGHT,
+      self.parent.map.position[2] * TILE_DEPTH,
+    ]
+    aspectRatio = vw / vh
+
+    # Ease the lookAt target
+    for i in range(3):
+      self.lookAtTarget[i] += (lookAt[i] - self.lookAtTarget[i]) * ease
+
+    # Camera position is now based on the eased lookAtTarget
+    cameraPosition = (
+      self.lookAtTarget[0],
+      self.lookAtTarget[1] + self.yOffset,
+      self.lookAtTarget[2] + z
+    )
+
+    glMatrixMode(GL_PROJECTION)
+    glLoadIdentity()
+    gluPerspective(self.fov, aspectRatio, 0.1, 1000.0)
+    glScalef(1.0, -1.0, 1.0)  # Flip the projection matrix upside down
+    glMatrixMode(GL_MODELVIEW)
+    glLoadIdentity()
+    gluLookAt(
+      cameraPosition[0], cameraPosition[1], cameraPosition[2],
+      self.lookAtTarget[0], self.lookAtTarget[1], self.lookAtTarget[2],
+      0.0, 1.0, 0.0
+    )

archive/editor/map/chunkpanel.py

@@ -0,0 +1,80 @@
+from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QGridLayout, QTreeWidget, QTreeWidgetItem, QComboBox
+from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_SHAPES
+
+class ChunkPanel(QWidget):
+  def __init__(self, parent):
+    super().__init__(parent)
+    self.parent = parent
+    layout = QVBoxLayout(self)
+
+    # Tile shape dropdown
+    self.tileShapeDropdown = QComboBox()
+    self.tileShapeDropdown.addItems(TILE_SHAPES.keys())
+    self.tileShapeDropdown.setToolTip("Tile Shape")
+    layout.addWidget(self.tileShapeDropdown)
+
+    # Add expandable tree list
+    self.tree = QTreeWidget()
+    self.tree.setHeaderLabel("Chunks")
+    self.tree.expandAll()  # Expand by default, remove if you want collapsed
+    layout.addWidget(self.tree)  # Removed invalid stretch factor
+
+    # Add stretch so tree expands
+    layout.setStretchFactor(self.tree, 1)
+
+    # Event subscriptions
+    self.parent.map.onMapData.sub(self.onMapData)
+    self.parent.map.onPositionChange.sub(self.onPositionChange)
+    self.tileShapeDropdown.currentTextChanged.connect(self.onTileShapeChanged)
+
+    # For each chunk
+    for chunk in self.parent.map.chunks.values():
+      # Create tree element
+      item = QTreeWidgetItem(self.tree, ["Chunk ({}, {}, {})".format(chunk.x, chunk.y, chunk.z)])
+      chunk.chunkPanelTree = item
+      chunk.chunkPanelTree.setExpanded(True)
+      item.setData(0, 0, chunk)  # Store chunk reference
+
+      chunk.onChunkData.sub(self.onChunkData)
+
+  def onMapData(self, data):
+    pass
+  
+  def onPositionChange(self, pos):
+    self.updateChunkList()
+
+    tile = self.parent.map.getTileAtWorldPos(*self.parent.map.position)
+    if tile is None:
+      return
+    
+    key = "TILE_SHAPE_NULL"
+    for k, v in TILE_SHAPES.items():
+      if v != tile.shape:
+        continue
+      key = k
+      break
+    self.tileShapeDropdown.setCurrentText(key)
+
+  def onTileShapeChanged(self, shape_key):
+    tile = self.parent.map.getTileAtWorldPos(*self.parent.map.position)
+    
+    if tile is None or shape_key not in TILE_SHAPES:
+      return
+    tile.setShape(TILE_SHAPES[shape_key])
+  
+  def updateChunkList(self):
+    # Clear existing items
+    currentChunk = self.parent.map.getChunkAtWorldPos(*self.parent.map.position)
+
+    # Example tree items
+    for chunk in self.parent.map.chunks.values():
+      title = "Chunk ({}, {}, {})".format(chunk.x, chunk.y, chunk.z)
+      if chunk == currentChunk:
+        title += " [C]"
+      if chunk.isDirty():
+        title += " *"
+      item = chunk.chunkPanelTree
+      item.setText(0, title)
+
+  def onChunkData(self, chunk):
+    self.updateChunkList()

archive/editor/map/entitypanel.py

@@ -0,0 +1,154 @@
+from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QComboBox, QHBoxLayout, QPushButton, QLineEdit, QListWidget, QListWidgetItem
+from PyQt5.QtCore import Qt
+from tools.dusk.entity import Entity
+from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, ENTITY_TYPES, ENTITY_TYPE_NULL
+
+class EntityPanel(QWidget):
+  def __init__(self, parent):
+    super().__init__(parent)
+    self.parent = parent
+    layout = QVBoxLayout(self)
+    self.setLayout(layout)
+
+    # Top panel placeholder
+    topWidget = QLabel("Entity Editor")
+    layout.addWidget(topWidget)
+
+    # Name input
+    nameLayout = QHBoxLayout()
+    nameLabel = QLabel("Name:")
+    self.nameInput = QLineEdit()
+    nameLayout.addWidget(nameLabel)
+    nameLayout.addWidget(self.nameInput)
+    layout.addLayout(nameLayout)
+
+    # Entity Type dropdown (single selection)
+    typeLayout = QHBoxLayout()
+    typeLabel = QLabel("Type:")
+    self.typeDropdown = QComboBox()
+    self.typeDropdown.addItems(ENTITY_TYPES)
+    typeLayout.addWidget(typeLabel)
+    typeLayout.addWidget(self.typeDropdown)
+    layout.addLayout(typeLayout)
+
+    # Entity list and buttons
+    self.entityList = QListWidget()
+    self.entityList.addItems([])
+    layout.addWidget(self.entityList, stretch=1)
+
+    btnLayout = QHBoxLayout()
+    self.btnAdd = QPushButton("Add")
+    self.btnRemove = QPushButton("Remove")
+    btnLayout.addWidget(self.btnAdd)
+    btnLayout.addWidget(self.btnRemove)
+    layout.addLayout(btnLayout)
+
+    # Events
+    self.btnAdd.clicked.connect(self.onAddEntity)
+    self.btnRemove.clicked.connect(self.onRemoveEntity)
+    self.parent.map.onEntityData.sub(self.onEntityData)
+    self.parent.map.onPositionChange.sub(self.onPositionChange)
+    self.entityList.itemClicked.connect(self.onEntityClicked)
+    self.entityList.itemDoubleClicked.connect(self.onEntityDoubleClicked)
+    self.typeDropdown.currentIndexChanged.connect(self.onTypeSelected)
+    self.nameInput.textChanged.connect(self.onNameChanged)
+
+    # Call once to populate
+    self.onEntityData()
+    self.onEntityUnselect()
+
+  def onEntityUnselect(self):
+    self.entityList.setCurrentItem(None)
+    self.nameInput.setText("")
+    self.typeDropdown.setCurrentIndex(ENTITY_TYPE_NULL)
+
+  def onEntitySelect(self, entity):
+    self.entityList.setCurrentItem(entity.item)
+    self.nameInput.setText(entity.name)
+    self.typeDropdown.setCurrentIndex(entity.type)
+
+  def onEntityDoubleClicked(self, item):
+    entity = item.data(Qt.UserRole)
+    chunk = entity.chunk
+    worldX = (chunk.x * CHUNK_WIDTH) + entity.localX
+    worldY = (chunk.y * CHUNK_HEIGHT) + entity.localY
+    worldZ = (chunk.z * CHUNK_DEPTH) + entity.localZ
+    self.parent.map.moveTo(worldX, worldY, worldZ)
+
+  def onEntityClicked(self, item):
+    pass
+
+  def onAddEntity(self):
+    chunk = self.parent.map.getChunkAtWorldPos(*self.parent.map.position)
+    if chunk is None:
+      return
+
+    localX = (self.parent.map.position[0] - (chunk.x * CHUNK_WIDTH)) % CHUNK_WIDTH
+    localY = (self.parent.map.position[1] - (chunk.y * CHUNK_HEIGHT)) % CHUNK_HEIGHT
+    localZ = (self.parent.map.position[2] - (chunk.z * CHUNK_DEPTH)) % CHUNK_DEPTH
+
+    # Make sure there's not already an entity here
+    for ent in chunk.entities.values():
+      if ent.localX == localX and ent.localY == localY and ent.localZ == localZ:
+        print("Entity already exists at this location")
+        return
+
+    ent = chunk.addEntity(localX, localY, localZ)
+
+  def onRemoveEntity(self):
+    item = self.entityList.currentItem()
+    if item is None:
+      return
+    entity = item.data(Qt.UserRole)
+    if entity:
+      chunk = entity.chunk
+      chunk.removeEntity(entity)
+    pass
+
+  def onEntityData(self):
+    self.onEntityUnselect()
+    self.entityList.clear()
+    for chunk in self.parent.map.chunks.values():
+      for id, entity in chunk.entities.items():
+        item = QListWidgetItem(entity.name)
+        item.setData(Qt.UserRole, entity)  # Store the entity object
+        entity.item = item
+        self.entityList.addItem(item)
+
+    # Select if there is something at current position
+    self.onPositionChange(self.parent.map.position)
+
+  def onPositionChange(self, position):
+    self.onEntityUnselect()
+
+    # Get Entity at..
+    chunk = self.parent.map.getChunkAtWorldPos(*position)
+    if chunk is None:
+      return
+
+    localX = (position[0] - (chunk.x * CHUNK_WIDTH)) % CHUNK_WIDTH
+    localY = (position[1] - (chunk.y * CHUNK_HEIGHT)) % CHUNK_HEIGHT
+    localZ = (position[2] - (chunk.z * CHUNK_DEPTH)) % CHUNK_DEPTH
+
+    for ent in chunk.entities.values():
+      if ent.localX != localX or ent.localY != localY or ent.localZ != localZ:
+        continue
+      self.onEntitySelect(ent)
+      self.entityList.setCurrentItem(ent.item)
+      break
+
+  def onTypeSelected(self, index):
+    item = self.entityList.currentItem()
+    if item is None:
+      return
+    entity = item.data(Qt.UserRole)
+    if entity:
+      entity.setType(index)
+
+  def onNameChanged(self, text):
+    item = self.entityList.currentItem()
+    if item is None:
+      return
+    entity = item.data(Qt.UserRole)
+    if entity:
+      entity.setName(text)

archive/editor/map/glwidget.py

@@ -0,0 +1,41 @@
+from PyQt5.QtCore import QTimer
+from PyQt5.QtWidgets import QOpenGLWidget
+from OpenGL.GL import *
+from OpenGL.GLU import *
+
+class GLWidget(QOpenGLWidget):
+  def __init__(self, parent):
+    super().__init__(parent)
+    self.parent = parent
+    self.timer = QTimer(self)
+    self.timer.timeout.connect(self.update)
+    self.timer.start(16)  # ~60 FPS
+
+  def initializeGL(self):
+    glClearColor(0.392, 0.584, 0.929, 1.0)
+    glEnable(GL_DEPTH_TEST)
+    glEnable(GL_BLEND)
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+    glEnable(GL_POLYGON_OFFSET_FILL)
+    glPolygonOffset(1.0, 1.0)
+    glDisable(GL_POLYGON_OFFSET_FILL)
+
+  def resizeGL(self, w, h):
+    pass
+
+  def paintGL(self):
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    glLoadIdentity()
+
+    w = self.width()
+    h = self.height()
+    if h <= 0:
+      h = 1
+    if w <= 0:
+      w = 1
+
+    glViewport(0, 0, w, h)
+    self.parent.camera.setup(w, h)
+    self.parent.grid.draw()
+    self.parent.map.draw()
+    self.parent.selectBox.draw()

archive/editor/map/grid.py

@@ -0,0 +1,46 @@
+from OpenGL.GL import *
+from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
+
+class Grid:
+  def __init__(self, lines=1000):
+    self.cellWidth = TILE_WIDTH
+    self.cellHeight = TILE_HEIGHT
+    self.lines = lines
+    self.enabled = True
+
+  def draw(self):
+    if not self.enabled:
+      return
+    center = [0.01,0.01,0.01]
+    halfWidth = self.cellWidth * self.lines // 2
+    halfHeight = self.cellHeight * self.lines // 2
+    # Draw origin axes
+    glBegin(GL_LINES)
+
+    # X axis - RED
+    glColor3f(1.0, 0.0, 0.0)
+    glVertex3f(center[0] - halfWidth, center[1], center[2])
+    glVertex3f(center[0] + halfWidth, center[1], center[2])
+
+    # Y axis - GREEN
+    glColor3f(0.0, 1.0, 0.0)
+    glVertex3f(center[0], center[1] - halfHeight, center[2])
+    glVertex3f(center[0], center[1] + halfHeight, center[2])
+
+    # Z axis - BLUE
+    glColor3f(0.0, 0.0, 1.0)
+    glVertex3f(center[0], center[1], center[2] - halfWidth)
+    glVertex3f(center[0], center[1], center[2] + halfWidth)
+    glEnd()
+
+    # Draw grid
+    glColor3f(0.8, 0.8, 0.8)
+    glBegin(GL_LINES)
+    for i in range(-self.lines // 2, self.lines // 2 + 1):
+      # Vertical lines
+      glVertex3f(center[0] + i * self.cellWidth, center[1] - halfHeight, center[2])
+      glVertex3f(center[0] + i * self.cellWidth, center[1] + halfHeight, center[2])
+      # Horizontal lines
+      glVertex3f(center[0] - halfWidth, center[1] + i * self.cellHeight, center[2])
+      glVertex3f(center[0] + halfWidth, center[1] + i * self.cellHeight, center[2])
+    glEnd()

archive/editor/map/mapinfopanel.py

@@ -0,0 +1,83 @@
+from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QLineEdit, QPushButton, QHBoxLayout, QMessageBox
+from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH
+
+class MapInfoPanel(QWidget):
+  def __init__(self, parent):
+    super().__init__(parent)
+    self.parent = parent
+
+    # Components
+    layout = QVBoxLayout()
+
+    mapTitleLabel = QLabel("Map Title")
+    self.mapTitleInput = QLineEdit()
+    layout.addWidget(mapTitleLabel)
+    layout.addWidget(self.mapTitleInput)
+
+    tilePositionLabel = QLabel("Tile Position")
+    layout.addWidget(tilePositionLabel)
+    tilePositionRow = QHBoxLayout()
+    self.tileXInput = QLineEdit()
+    self.tileXInput.setPlaceholderText("X")
+    tilePositionRow.addWidget(self.tileXInput)
+    self.tileYInput = QLineEdit()
+    self.tileYInput.setPlaceholderText("Y")
+    tilePositionRow.addWidget(self.tileYInput)
+    self.tileZInput = QLineEdit()
+    self.tileZInput.setPlaceholderText("Z")
+    tilePositionRow.addWidget(self.tileZInput)
+    self.tileGo = QPushButton("Go")
+    tilePositionRow.addWidget(self.tileGo)
+    layout.addLayout(tilePositionRow)
+
+    self.chunkPosLabel = QLabel()
+    layout.addWidget(self.chunkPosLabel)
+    self.chunkLabel = QLabel()
+    layout.addWidget(self.chunkLabel)
+
+    layout.addStretch()
+    self.setLayout(layout)
+
+    # Events
+    self.tileGo.clicked.connect(self.goToPosition)
+    self.tileXInput.returnPressed.connect(self.goToPosition)
+    self.tileYInput.returnPressed.connect(self.goToPosition)
+    self.tileZInput.returnPressed.connect(self.goToPosition)
+    self.parent.map.onPositionChange.sub(self.updatePositionLabels)
+    self.parent.map.onMapData.sub(self.onMapData)
+    self.mapTitleInput.textChanged.connect(self.onMapNameChange)
+
+    # Initial label setting
+    self.updatePositionLabels(self.parent.map.position)
+
+  def goToPosition(self):
+    try:
+      x = int(self.tileXInput.text())
+      y = int(self.tileYInput.text())
+      z = int(self.tileZInput.text())
+      self.parent.map.moveTo(x, y, z)
+    except ValueError:
+      QMessageBox.warning(self, "Invalid Input", "Please enter valid integer coordinates.")
+
+  def updatePositionLabels(self, pos):
+    self.tileXInput.setText(str(pos[0]))
+    self.tileYInput.setText(str(pos[1]))
+    self.tileZInput.setText(str(pos[2]))
+
+    chunkTileX = pos[0] % CHUNK_WIDTH
+    chunkTileY = pos[1] % CHUNK_HEIGHT
+    chunkTileZ = pos[2] % CHUNK_DEPTH
+    chunkTileIndex = chunkTileX + chunkTileY * CHUNK_WIDTH + chunkTileZ * CHUNK_WIDTH * CHUNK_HEIGHT
+    self.chunkPosLabel.setText(f"Chunk Position: {chunkTileX}, {chunkTileY}, {chunkTileZ} ({chunkTileIndex})")
+
+    chunkX = pos[0] // CHUNK_WIDTH
+    chunkY = pos[1] // CHUNK_HEIGHT
+    chunkZ = pos[2] // CHUNK_DEPTH
+    self.chunkLabel.setText(f"Chunk: {chunkX}, {chunkY}, {chunkZ}")
+
+  def onMapData(self, data):
+    self.updatePositionLabels(self.parent.map.position)
+    self.mapTitleInput.setText(data.get("mapName", ""))
+
+  def onMapNameChange(self, text):
+    self.parent.map.data['mapName'] = text

archive/editor/map/mapleftpanel.py

@@ -0,0 +1,51 @@
+from PyQt5.QtWidgets import QWidget, QVBoxLayout, QGridLayout, QPushButton, QTabWidget, QLabel
+from tools.editor.map.chunkpanel import ChunkPanel
+from tools.editor.map.entitypanel import EntityPanel
+from tools.editor.map.regionpanel import RegionPanel
+
+class MapLeftPanel(QWidget):
+  def __init__(self, parent):
+    super().__init__(parent)
+    self.parent = parent
+    layout = QVBoxLayout(self)
+    self.setLayout(layout)
+
+    # Nav buttons
+    self.chunkInfoLabel = QLabel("Tile Information")
+    layout.addWidget(self.chunkInfoLabel)
+    grid = QGridLayout()
+    self.btnUp = QPushButton("U")
+    self.btnN = QPushButton("N")
+    self.btnDown = QPushButton("D")
+    self.btnW = QPushButton("W")
+    self.btnS = QPushButton("S")
+    self.btnE = QPushButton("E")
+
+    grid.addWidget(self.btnUp, 0, 0)
+    grid.addWidget(self.btnN, 0, 1)
+    grid.addWidget(self.btnDown, 0, 2)
+    grid.addWidget(self.btnW, 1, 0)
+    grid.addWidget(self.btnS, 1, 1)
+    grid.addWidget(self.btnE, 1, 2)
+    layout.addLayout(grid)
+
+    # Panels
+    self.chunkPanel = ChunkPanel(self.parent)
+    self.entityPanel = EntityPanel(self.parent)
+    self.regionPanel = RegionPanel(self.parent)
+
+    # Tabs
+    self.tabs = QTabWidget()
+    self.tabs.addTab(self.chunkPanel, "Tiles")
+    self.tabs.addTab(self.entityPanel, "Entities")
+    self.tabs.addTab(self.regionPanel, "Regions")
+    self.tabs.addTab(None, "Triggers")
+    layout.addWidget(self.tabs)
+
+    # Event subscriptions
+    self.btnN.clicked.connect(lambda: self.parent.map.moveRelative(0, -1, 0))
+    self.btnS.clicked.connect(lambda: self.parent.map.moveRelative(0, 1, 0))
+    self.btnE.clicked.connect(lambda: self.parent.map.moveRelative(1, 0, 0))
+    self.btnW.clicked.connect(lambda: self.parent.map.moveRelative(-1, 0, 0))
+    self.btnUp.clicked.connect(lambda: self.parent.map.moveRelative(0, 0, 1))
+    self.btnDown.clicked.connect(lambda: self.parent.map.moveRelative(0, 0, -1))

archive/editor/map/menubar.py

@@ -0,0 +1,46 @@
+import os
+from PyQt5.QtWidgets import QAction, QMenuBar, QFileDialog
+from PyQt5.QtGui import QKeySequence
+from tools.dusk.map import MAP_DEFAULT_PATH
+
+class MapMenubar:
+  def __init__(self, parent):
+    self.parent = parent
+    self.menubar = QMenuBar(parent)
+    parent.setMenuBar(self.menubar)
+
+    self.fileMenu = self.menubar.addMenu("File")
+    self.actionNew = QAction("New", parent)
+    self.actionOpen = QAction("Open", parent)
+    self.actionSave = QAction("Save", parent)
+    self.actionSaveAs = QAction("Save As", parent)
+
+    self.actionNew.setShortcut(QKeySequence("Ctrl+N"))
+    self.actionOpen.setShortcut(QKeySequence("Ctrl+O"))
+    self.actionSave.setShortcut(QKeySequence("Ctrl+S"))
+    self.actionSaveAs.setShortcut(QKeySequence("Ctrl+Shift+S"))
+
+    self.actionNew.triggered.connect(self.newFile)
+    self.actionOpen.triggered.connect(self.openFile)
+    self.actionSave.triggered.connect(self.saveFile)
+    self.actionSaveAs.triggered.connect(self.saveAsFile)
+    self.fileMenu.addAction(self.actionNew)
+    self.fileMenu.addAction(self.actionOpen)
+    self.fileMenu.addAction(self.actionSave)
+    self.fileMenu.addAction(self.actionSaveAs)
+
+  def newFile(self):
+    self.parent.map.newFile()
+
+  def openFile(self):
+    filePath, _ = QFileDialog.getOpenFileName(self.menubar, "Open Map File", MAP_DEFAULT_PATH, "Map Files (*.json)")
+    if filePath:
+      self.parent.map.load(filePath)
+
+  def saveFile(self):
+    self.parent.map.save()
+
+  def saveAsFile(self):
+    filePath, _ = QFileDialog.getSaveFileName(self.menubar, "Save Map File As", MAP_DEFAULT_PATH, "Map Files (*.json)")
+    if filePath:
+      self.parent.map.save(filePath)

archive/editor/map/regionpanel.py

@@ -0,0 +1,15 @@
+from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QComboBox, QHBoxLayout, QPushButton, QLineEdit, QListWidget, QListWidgetItem
+from PyQt5.QtCore import Qt
+from tools.dusk.entity import Entity
+from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, ENTITY_TYPES, ENTITY_TYPE_NULL
+
+class RegionPanel(QWidget):
+  def __init__(self, parent):
+    super().__init__(parent)
+    self.parent = parent
+    layout = QVBoxLayout(self)
+    self.setLayout(layout)
+
+    # Top panel placeholder
+    topWidget = QLabel("Region Editor")
+    layout.addWidget(topWidget)

archive/editor/map/selectbox.py

@@ -0,0 +1,44 @@
+import OpenGL.GL as gl
+from tools.dusk.defs import defs
+import colorsys
+from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
+
+class SelectBox:
+  def __init__(self, parent):
+    self.parent = parent
+    self.hue = 0.0
+
+  def draw(self):
+    position = [
+      self.parent.map.position[0] * TILE_WIDTH - (TILE_WIDTH / 2.0),
+      self.parent.map.position[1] * TILE_HEIGHT - (TILE_HEIGHT / 2.0),
+      self.parent.map.position[2] * TILE_DEPTH - (TILE_DEPTH / 2.0)
+    ]
+
+    vertices = [
+      (position[0], position[1], position[2]),
+      (position[0]+TILE_WIDTH, position[1], position[2]),
+      (position[0]+TILE_WIDTH, position[1]+TILE_HEIGHT, position[2]),
+      (position[0], position[1]+TILE_HEIGHT, position[2]),
+      (position[0], position[1], position[2]+TILE_DEPTH),
+      (position[0]+TILE_WIDTH, position[1], position[2]+TILE_DEPTH),
+      (position[0]+TILE_WIDTH, position[1]+TILE_HEIGHT, position[2]+TILE_DEPTH),
+      (position[0], position[1]+TILE_HEIGHT, position[2]+TILE_DEPTH)
+    ]
+    edges = [
+      (0, 1), (1, 2), (2, 3), (3, 0),  # bottom face
+      (4, 5), (5, 6), (6, 7), (7, 4),  # top face
+      (4, 5), (5, 6), (6, 7), (7, 4),  # top face
+      (0, 4), (1, 5), (2, 6), (3, 7)   # vertical edges
+    ]
+
+    # Cycle hue
+    self.hue = (self.hue + 0.01) % 1.0
+    r, g, b = colorsys.hsv_to_rgb(self.hue, 1.0, 1.0)
+    gl.glColor3f(r, g, b)
+    gl.glLineWidth(2.0)
+    gl.glBegin(gl.GL_LINES)
+    for edge in edges:
+      for vertex in edge:
+        gl.glVertex3f(*vertices[vertex])
+    gl.glEnd()

archive/editor/map/statusbar.py

@@ -0,0 +1,18 @@
+from PyQt5.QtWidgets import QStatusBar, QLabel
+
+class StatusBar(QStatusBar):
+  def __init__(self, parent=None):
+    super().__init__(parent)
+    self.parent = parent
+    self.leftLabel = QLabel("")
+    self.rightLabel = QLabel("")
+    self.addWidget(self.leftLabel, 1)
+    self.addPermanentWidget(self.rightLabel)
+
+    parent.map.onMapData.sub(self.onMapData)
+
+  def setStatus(self, message):
+    self.leftLabel.setText(message)
+
+  def onMapData(self, data):
+    self.rightLabel.setText(self.parent.map.mapFileName if self.parent.map.mapFileName else "Untitled.json")

archive/editor/map/vertexbuffer.py

@@ -0,0 +1,80 @@
+from OpenGL.GL import *
+import array
+
+class VertexBuffer:
+  def __init__(self, componentsPerVertex=3):
+    self.componentsPerVertex = componentsPerVertex
+    self.vertices = []
+    self.colors = []
+    self.uvs = []
+    self.data = None
+    self.colorData = None
+    self.uvData = None
+
+  def buildData(self):
+    hasColors = len(self.colors) > 0
+    hasUvs = len(self.uvs) > 0
+
+    vertexCount = len(self.vertices) // self.componentsPerVertex
+
+    dataList = []
+    colorList = []
+    uvList = []
+
+    for i in range(vertexCount):
+      vStart = i * self.componentsPerVertex
+      dataList.extend(self.vertices[vStart:vStart+self.componentsPerVertex])
+
+      if hasColors:
+        cStart = i * 4  # Assuming RGBA
+        colorList.extend(self.colors[cStart:cStart+4])
+
+      if hasUvs:
+        uStart = i * 2  # Assuming UV
+        uvList.extend(self.uvs[uStart:uStart+2])
+
+    self.data = array.array('f', dataList)
+
+    if hasColors:
+      self.colorData = array.array('f', colorList)
+    else:
+      self.colorData = None
+
+    if hasUvs:
+      self.uvData = array.array('f', uvList)
+    else:
+      self.uvData = None
+
+  def draw(self, mode=GL_TRIANGLES, count=-1):
+    if count == -1:
+      count = len(self.data) // self.componentsPerVertex
+
+    if count == 0:
+      return
+
+    glEnableClientState(GL_VERTEX_ARRAY)
+    glVertexPointer(self.componentsPerVertex, GL_FLOAT, 0, self.data.tobytes())
+
+    if self.colorData:
+      glEnableClientState(GL_COLOR_ARRAY)
+      glColorPointer(4, GL_FLOAT, 0, self.colorData.tobytes())
+
+    if self.uvData:
+      glEnableClientState(GL_TEXTURE_COORD_ARRAY)
+      glTexCoordPointer(2, GL_FLOAT, 0, self.uvData.tobytes())
+
+    glDrawArrays(mode, 0, count)
+
+    glDisableClientState(GL_VERTEX_ARRAY)
+    if self.colorData:
+      glDisableClientState(GL_COLOR_ARRAY)
+    if self.uvData:
+      glDisableClientState(GL_TEXTURE_COORD_ARRAY)
+
+  def clear(self):
+    self.vertices = []
+    self.colors = []
+    self.uvs = []
+    self.data = array.array('f')
+    self.colorData = None
+    self.uvData = None

archive/editor/maptool.py

@@ -0,0 +1,143 @@
+import os
+from PyQt5.QtWidgets import QMainWindow, QWidget, QHBoxLayout, QMessageBox
+from PyQt5.QtCore import Qt
+from tools.editor.map.glwidget import GLWidget
+from tools.editor.map.mapleftpanel import MapLeftPanel
+from tools.editor.map.mapinfopanel import MapInfoPanel
+from tools.editor.map.menubar import MapMenubar
+from tools.editor.map.statusbar import StatusBar
+from tools.dusk.map import Map
+from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_SHAPE_NULL, TILE_SHAPE_FLOOR
+from tools.editor.map.selectbox import SelectBox
+from tools.editor.map.camera import Camera
+from tools.editor.map.grid import Grid
+
+class MapWindow(QMainWindow):
+  def __init__(self):
+    super().__init__()
+
+    self.insertPressed = False
+    self.deletePressed = False
+
+    # Subclasses
+    self.map = Map(self)
+    self.camera = Camera(self)
+    self.grid = Grid()
+    self.selectBox = SelectBox(self)
+
+    # Window setup
+    self.setWindowTitle("Dusk Map Editor")
+    self.resize(1600, 900)
+
+    # Menubar (TESTING)
+    self.menubar = MapMenubar(self)
+
+    central = QWidget()
+    self.setCentralWidget(central)
+    mainLayout = QHBoxLayout(central)
+
+    # Left panel (tabs + nav buttons)
+    self.leftPanel = MapLeftPanel(self)
+    self.leftPanel.setFixedWidth(350)
+    mainLayout.addWidget(self.leftPanel)
+
+    # Center panel (GLWidget + controls)
+    self.glWidget = GLWidget(self)
+    mainLayout.addWidget(self.glWidget, stretch=3)
+
+    # Right panel (MapInfoPanel)
+    self.mapInfoPanel = MapInfoPanel(self)
+    rightWidget = self.mapInfoPanel
+    rightWidget.setFixedWidth(250)
+    mainLayout.addWidget(rightWidget)
+
+    # Status bar
+    self.statusBar = StatusBar(self)
+    self.setStatusBar(self.statusBar)
+
+    self.installEventFilter(self)
+    self.installEventFilterRecursively(self)
+
+  def installEventFilterRecursively(self, widget):
+    for child in widget.findChildren(QWidget):
+      child.installEventFilter(self)
+      self.installEventFilterRecursively(child)
+
+  def closeEvent(self, event):
+    if not self.map.isDirty():
+      event.accept()
+      return
+    
+    reply = QMessageBox.question(
+      self,
+      "Unsaved Changes",
+      "You have unsaved changes. Do you want to save before closing?",
+      QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel,
+      QMessageBox.Save
+    )
+    if reply == QMessageBox.Save:
+      self.map.save()
+    elif reply == QMessageBox.Cancel:
+      event.ignore()
+      return
+    event.accept()
+
+  def eventFilter(self, obj, event):
+    if event.type() == event.KeyPress:
+      amtX, amtY, amtZ = 0, 0, 0
+      
+      key = event.key()
+      if key == Qt.Key_Left:
+        amtX = -1
+      elif key == Qt.Key_Right:
+        amtX = 1
+      elif key == Qt.Key_Up:
+        amtY = -1
+      elif key == Qt.Key_Down:
+        amtY = 1
+      elif key == Qt.Key_PageUp:
+        amtZ = 1
+      elif key == Qt.Key_PageDown:
+        amtZ = -1
+
+      if event.modifiers() & Qt.ShiftModifier:
+        amtX *= CHUNK_WIDTH
+        amtY *= CHUNK_HEIGHT
+        amtZ *= CHUNK_DEPTH
+
+      if amtX != 0 or amtY != 0 or amtZ != 0:
+        self.map.moveRelative(amtX, amtY, amtZ)
+        if self.insertPressed:
+          tile = self.map.getTileAtWorldPos(*self.map.position)
+          if tile is not None and tile.shape == TILE_SHAPE_NULL:
+            tile.setShape(TILE_SHAPE_FLOOR)
+        if self.deletePressed:
+          tile = self.map.getTileAtWorldPos(*self.map.position)
+          if tile is not None:
+            tile.setShape(TILE_SHAPE_NULL)
+        event.accept()
+        return True
+      
+      if key == Qt.Key_Delete:
+        tile = self.map.getTileAtWorldPos(*self.map.position)
+        self.deletePressed = True
+        if tile is not None:
+          tile.setShape(TILE_SHAPE_NULL)
+        event.accept()
+        return True
+      if key == Qt.Key_Insert:
+        tile = self.map.getTileAtWorldPos(*self.map.position)
+        self.insertPressed = True
+        if tile is not None and tile.shape == TILE_SHAPE_NULL:
+          tile.setShape(TILE_SHAPE_FLOOR)
+        event.accept()
+    elif event.type() == event.KeyRelease:
+      key = event.key()
+      if key == Qt.Key_Delete:
+        self.deletePressed = False
+        event.accept()
+        return True
+      if key == Qt.Key_Insert:
+        self.insertPressed = False
+        event.accept()
+    return super().eventFilter(obj, event)

archive/map/CMakeLists.txt

@@ -1,9 +1,6 @@
-# Copyright (c) 2026 Dominic Masters
+# Copyright (c) 2025 Dominic Masters
 # 
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-include(dusktest)
+add_subdirectory(testmap)
-
-# Tests
-dusktest(test_error.c)

archive/map/testmap/CMakeLists.txt

@@ -1,9 +1,6 @@
-# Copyright (c) 2026 Dominic Masters
+# Copyright (c) 2025 Dominic Masters
 # 
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-include(dusktest)
+add_asset(MAP testmap.json)
-
-# Tests
-dusktest(test_thread.c)

archive/map/testmap/chunks/-1_-1_0.json

@@ -0,0 +1 @@
+{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}

archive/map/testmap/chunks/-1_-1_1.json

@@ -0,0 +1 @@
+{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}

archive/map/testmap/chunks/-1_0_0.json

@@ -0,0 +1 @@
+{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}

archive/map/testmap/chunks/-2_1_0.json

@@ -0,0 +1 @@
+{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}

archive/map/testmap/chunks/0_-1_0.json

@@ -0,0 +1 @@
+{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}

archive/map/testmap/chunks/0_-1_1.json

@@ -0,0 +1 @@
+{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}

archive/map/testmap/chunks/0_0_0.json

@@ -0,0 +1 @@
+{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 2, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}

archive/map/testmap/chunks/1_0_0.json

@@ -0,0 +1 @@
+{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}

archive/map/testmap/chunks/2_0_0.json

@@ -0,0 +1 @@
+{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}

archive/map/testmap/chunks/3_0_0.json

@@ -0,0 +1 @@
+{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}

archive/map/testmap/chunks/4_0_0.json

@@ -0,0 +1 @@
+{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "entities": []}

archive/map/testmap/chunks/5_0_0.json

@@ -0,0 +1 @@
+{"shapes": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}

archive/map/testmap/testmap.json

@@ -0,0 +1,3 @@
+{
+  "name": "Test"
+}

archive/modulemap.h

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "script/scriptcontext.h"
+#include "debug/debug.h"
+#include "assert/assert.h"
+#include "rpg/overworld/map.h"
+
+int moduleMapLoad(lua_State *L) {
+  assertNotNull(L, "Lua state cannot be NULL");
+
+  if(!lua_isstring(L, 1)) {
+    luaL_error(L, "Expected string map filename");
+    return 0;
+  }
+
+  // Potentially provide up to 3 params
+  chunkpos_t initial = { .x = 0, .y = 0, .z = 0 };
+  if(lua_isnumber(L, 2)) {
+    initial.x = (chunkunit_t)lua_tonumber(L, 2);
+  }
+  if(lua_isnumber(L, 3)) {
+    initial.y = (chunkunit_t)lua_tonumber(L, 3);
+  }
+  if(lua_isnumber(L, 4)) {
+    initial.z = (chunkunit_t)lua_tonumber(L, 4);
+  }
+
+  // Load the map.
+  errorret_t ret = mapLoad(luaL_checkstring(L, 1), initial);
+  if(ret.code != ERROR_OK) {
+    luaL_error(L, "Failed to load map");
+    errorCatch(errorPrint(ret));
+    return 0;
+  }
+
+  return 0;
+}
+
+void moduleMapSystem(scriptcontext_t *context) {
+  assertNotNull(context, "Script context cannot be NULL");
+
+  lua_register(context->luaState, "mapLoad", moduleMapLoad);
+}

archive/platform/CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright (c) 2026 Dominic Masters
+# Copyright (c) 2025 Dominic Masters
 # 
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
@@ -6,6 +6,7 @@
 # Sources
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
-    shadergl.c
+    sdl2.c
-    shaderunlitgl.c
+    psp.c
+    dolphin.c
 )

archive/platform/dolphin.c

@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dolphin.h"
+
+void displayInitDolphin(void) {
+  VIDEO_Init();
+  DISPLAY.screenMode = VIDEO_GetPreferredMode(NULL);
+  DISPLAY.frameBuffer[0] = MEM_K0_TO_K1(
+    SYS_AllocateFramebuffer(DISPLAY.screenMode)
+  );
+  DISPLAY.frameBuffer[1] = MEM_K0_TO_K1(
+    SYS_AllocateFramebuffer(DISPLAY.screenMode)
+  );
+  VIDEO_Configure(DISPLAY.screenMode);
+
+  VIDEO_SetNextFramebuffer(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer]);
+  // VIDEO_SetPostRetraceCallback(copy_buffers);
+  VIDEO_SetBlack(FALSE);
+  VIDEO_Flush();
+  VIDEO_WaitVSync();
+  if(DISPLAY.screenMode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync();
+
+  DISPLAY.fifoBuffer = memalign(32, DISPLAY_FIFO_SIZE);
+  memoryZero(DISPLAY.fifoBuffer, DISPLAY_FIFO_SIZE);
+
+  GX_Init(DISPLAY.fifoBuffer, DISPLAY_FIFO_SIZE);
+
+  // This seems to be mostly related to interlacing vs progressive
+  GX_SetViewport(
+    0, 0,
+    DISPLAY.screenMode->fbWidth, DISPLAY.screenMode->efbHeight,
+    0, 1
+  );
+  float_t yscale = GX_GetYScaleFactor(
+    DISPLAY.screenMode->efbHeight, DISPLAY.screenMode->xfbHeight
+  );
+  uint32_t xfbHeight = GX_SetDispCopyYScale(yscale);
+  GX_SetScissor(
+    0, 0,
+    DISPLAY.screenMode->fbWidth, DISPLAY.screenMode->efbHeight
+  );
+  GX_SetDispCopySrc(
+    0, 0,
+    DISPLAY.screenMode->fbWidth, DISPLAY.screenMode->efbHeight
+  );
+  GX_SetDispCopyDst(DISPLAY.screenMode->fbWidth, xfbHeight);
+  GX_SetCopyFilter(
+    DISPLAY.screenMode->aa,
+    DISPLAY.screenMode->sample_pattern,
+    GX_TRUE,
+    DISPLAY.screenMode->vfilter
+  );
+  GX_SetFieldMode(
+    DISPLAY.screenMode->field_rendering,
+    (
+      (DISPLAY.screenMode->viHeight == 2 * DISPLAY.screenMode->xfbHeight) ?
+      GX_ENABLE :
+      GX_DISABLE
+    )
+  );
+
+  // Setup cull modes
+  GX_SetCullMode(GX_CULL_NONE);
+  GX_SetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
+  GX_CopyDisp(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer], GX_TRUE);
+  GX_SetDispCopyGamma(GX_GM_1_0);
+
+  GX_ClearVtxDesc();
+  GX_SetVtxDesc(GX_VA_POS,  GX_INDEX16);
+  GX_SetVtxDesc(GX_VA_CLR0, GX_INDEX16);
+  GX_SetVtxDesc(GX_VA_TEX0, GX_INDEX16);
+  GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
+  GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_U8, 0);
+  GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
+}
+
+void displayDolphinSwap(void) {
+  GX_DrawDone();
+
+  DISPLAY.whichFrameBuffer ^= 1;
+  GX_SetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
+  GX_SetColorUpdate(GX_TRUE);
+  GX_CopyDisp(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer], GX_TRUE);
+  VIDEO_SetNextFramebuffer(DISPLAY.frameBuffer[DISPLAY.whichFrameBuffer]);
+  VIDEO_Flush();
+  VIDEO_WaitVSync();
+}

archive/platform/dolphin.h

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+#include "display/displaydefs.h"
+
+typedef struct {
+  void *frameBuffer[2];// Double-Bufferred
+  int whichFrameBuffer;
+  GXRModeObj *screenMode;
+  void *fifoBuffer;
+} displaydolphin_t;
+
+/**
+ * Initializes the display for Dolphin.
+ */
+void displayDolphinInit(void);
+
+/**
+ * Swaps the back buffer to the front for Dolphin.
+ */
+void displayDolphinSwap(void);

archive/platform/psp.c

@@ -5,7 +5,8 @@
  * https://opensource.org/licenses/MIT
  */
 
-#pragma once
+#include "psp.h"
-#include "error/error.h"
 
-typedef union scenedata_u scenedata_t;
+void displayInitPSP(void) {
+  DISPLAY.usingShaderedPalettes = false;
+}

archive/platform/psp.h

@@ -6,6 +6,8 @@
  */
 
 #pragma once
-#include "input/inputlinux.h"
 
-#define inputInitPlatform inputInitLinux
+/**
+ * Initializes the display for PSP.
+ */
+void displayInitPSP(void);

archive/platform/sdl2.c

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "sdl2.h"
+
+void displaySDL2Update(void) {
+}
+
+void displaySDL2Swap(void) {
+  SDL_GL_SwapWindow(DISPLAY.window);
+
+  GLenum err;
+  while((err = glGetError()) != GL_NO_ERROR) {
+    debugPrint("GL Error: %d\n", err);
+  }
+}
+
+void displaySDL2Dispose(void) {
+  if(DISPLAY.glContext) {
+    SDL_GL_DeleteContext(DISPLAY.glContext);
+    DISPLAY.glContext = NULL;
+  }
+  if(DISPLAY.window) {
+    SDL_DestroyWindow(DISPLAY.window);
+    DISPLAY.window = NULL;
+  }
+  SDL_Quit();
+}

archive/platform/sdl2.h

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+
+typedef struct {
+  SDL_Window *window;
+  SDL_GLContext glContext;
+  bool_t usingShaderedPalettes;
+} displaysdl2_t;
+
+/**
+ * Initializes the display for SDL2.
+ */
+void displaySDL2Init(void);
+
+/**
+ * Updates the display for SDL2.
+ */
+void displaySDL2Update(void);
+
+/**
+ * Swaps the display buffers for SDL2.
+ */
+void displaySDL2Swap(void);
+
+/**
+ * Disposes of the display for SDL2.
+ */
+void displaySDL2Dispose(void);

archive/rpg/CMakeLists.txt

@@ -15,6 +15,3 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
 add_subdirectory(cutscene)
 add_subdirectory(entity)
 add_subdirectory(overworld)
-
-add_subdirectory(story)
-add_subdirectory(item)

archive/rpg/entity/CMakeLists.txt

@@ -8,8 +8,7 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     entity.c
     entityanim.c
-    entitydir.c
-    entityinteract.c
     npc.c
     player.c
+    entitydir.c
 )

archive/rpg/entity/entity.c

@@ -12,7 +12,6 @@
 #include "util/math.h"
 #include "rpg/cutscene/cutscenemode.h"
 #include "rpg/overworld/map.h"
-#include "rpg/overworld/tile.h"
 
 entity_t ENTITIES[ENTITY_COUNT];
 
@@ -38,7 +37,15 @@ void entityUpdate(entity_t *entity) {
   assertTrue(entity->type != ENTITY_TYPE_NULL, "Cannot have NULL entity type");
 
   // What state is the entity in?
-  entityAnimUpdate(entity);
+  if(entity->animation != ENTITY_ANIM_IDLE) {
+    // Entity is mid animation, tick it (down).
+    entity->animTime -= TIME.delta;
+    if(entity->animTime <= 0) {
+      entity->animation = ENTITY_ANIM_IDLE;
+      entity->animTime = 0;
+    }
+    return;
+  }
 
   // Movement code.
   if(
@@ -49,34 +56,20 @@ void entityUpdate(entity_t *entity) {
   }
 }
 
-bool_t entityCanTurn(entity_t *entity) {
-  return entity->animation == ENTITY_ANIM_IDLE;
-}
-
-bool_t entityCanWalk(entity_t *entity) {
-  return entity->animation == ENTITY_ANIM_IDLE;
-}
-
-bool_t entityCanRun(entity_t *entity) {
-  return entity->animation == ENTITY_ANIM_IDLE;
-}
-
 void entityTurn(entity_t *entity, const entitydir_t direction) {
-  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) {
-  if(!entityCanWalk(entity)) return;
   // TODO: Animation, delay, etc.
   entity->direction = direction;
 
   // Where are we moving?
   worldpos_t newPos = entity->position;
-  worldunits_t relX, relY;
   {
+    worldunits_t relX, relY;
     entityDirGetRelative(direction, &relX, &relY);
     newPos.x += relX;
     newPos.y += relY;
@@ -186,15 +179,6 @@ void entityWalk(entity_t *entity, const entitydir_t direction) {
   }
 }
 
-void entityRun(entity_t *entity, const entitydir_t direction) {
-  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 * entityGetAt(const worldpos_t position) {
   entity_t *ent = ENTITIES;
   do {

archive/rpg/entity/entity.h

@@ -8,7 +8,6 @@
 #pragma once
 #include "entitydir.h"
 #include "entityanim.h"
-#include "entityinteract.h"
 #include "entitytype.h"
 #include "npc.h"
 
@@ -23,12 +22,9 @@ typedef struct entity_s {
   entitydir_t direction;
   worldpos_t position;
   worldpos_t lastPosition;
-  vec3 renderPosition;
 
   entityanim_t animation;
   float_t animTime;
-
-  entityinteract_t interact;
 } entity_t;
 
 extern entity_t ENTITIES[ENTITY_COUNT];
@@ -48,30 +44,6 @@ 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);
-
 /**
  * Turn an entity to face a new direction.
  * 
@@ -88,14 +60,6 @@ void entityTurn(entity_t *entity, const entitydir_t direction);
  */
 void entityWalk(entity_t *entity, const entitydir_t direction);
 
-/**
- * Make an entity run in a direction.
- *
- * @param entity Pointer to the entity to make run.
- * @param direction The direction to run in.
- */
-void entityRun(entity_t *entity, const entitydir_t direction);
-
 /**
  * Gets the entity at a specific world position.
  * 

archive/rpg/entity/entityanim.c

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "entityanim.h"
+

archive/rpg/entity/entityanim.h

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+
+#define ENTITY_ANIM_TURN_DURATION 0.06f
+#define ENTITY_ANIM_WALK_DURATION 0.1f
+
+typedef enum {
+  ENTITY_ANIM_IDLE,
+  ENTITY_ANIM_TURN,
+  ENTITY_ANIM_WALK,
+} entityanim_t;

archive/rpg/entity/entitydir.c

@@ -30,7 +30,7 @@ void entityDirGetRelative(
   switch(from) {
     case ENTITY_DIR_NORTH:
       *outX = 0;
-      *outY = 1;
+      *outY = -1;
       break;
 
     case ENTITY_DIR_EAST:
@@ -40,7 +40,7 @@ void entityDirGetRelative(
 
     case ENTITY_DIR_SOUTH:
       *outX = 0;
-      *outY = -1;
+      *outY = 1;
       break;
 
     case ENTITY_DIR_WEST:

archive/rpg/entity/entitydir.h

@@ -9,10 +9,6 @@
 #include "rpg/overworld/worldpos.h"
 
 typedef enum {
-  ENTITY_DIR_NORTH,
-  ENTITY_DIR_EAST,
-  ENTITY_DIR_SOUTH,
-  ENTITY_DIR_WEST,
   ENTITY_DIR_UP = ENTITY_DIR_NORTH,
   ENTITY_DIR_DOWN = ENTITY_DIR_SOUTH,
   ENTITY_DIR_LEFT = ENTITY_DIR_WEST,

archive/rpg/entity/entitytype.h

@@ -6,18 +6,10 @@
  */
 
 #pragma once
+#include "duskdefs.h"
 #include "rpg/entity/player.h"
 #include "npc.h"
 
-typedef enum {
-  ENTITY_TYPE_NULL,
-  
-  ENTITY_TYPE_PLAYER,
-  ENTITY_TYPE_NPC,
-
-  ENTITY_TYPE_COUNT
-} entitytype_enum_t;
-
 typedef uint8_t entitytype_t;
 
 typedef union {

archive/rpg/entity/player.c

@@ -10,8 +10,6 @@
 #include "rpg/rpgcamera.h"
 #include "util/memory.h"
 #include "time/time.h"
-#include "ui/focus/uifocus.h"
-#include "ui/frame/uisettings.h"
 
 void playerInit(entity_t *entity) {
   assertNotNull(entity, "Entity pointer cannot be NULL");
@@ -20,19 +18,6 @@ void playerInit(entity_t *entity) {
 void playerInput(entity_t *entity) {
   assertNotNull(entity, "Entity pointer cannot be NULL");
 
-  // Toggle settings on pause
-  if(uiSettingsIsOpen() && inputPressed(INPUT_ACTION_PAUSE)) {
-    uiSettingsClose();
-  } else if(
-    inputPressed(INPUT_ACTION_PAUSE) &&
-    entity->animation == ENTITY_ANIM_IDLE
-  ) {
-    uiSettingsOpen();
-  }
-
-  // Can player act?
-  if(UI_FOCUS.count > 0) return;
-
   // Turn
   const playerinputdirmap_t *dirMap = PLAYER_INPUT_DIR_MAP;
   do {
@@ -41,13 +26,11 @@ void playerInput(entity_t *entity) {
     return entityTurn(entity, dirMap->direction);
   } while((++dirMap)->action != 0xFF);
 
-  // Walk / Run
+  // Walk
-  bool_t running = inputIsDown(INPUT_ACTION_CANCEL);
   dirMap = PLAYER_INPUT_DIR_MAP;
   do {
     if(!inputIsDown(dirMap->action)) continue;
     if(entity->direction != dirMap->direction) continue;
-    if(running) return entityRun(entity, dirMap->direction);
     return entityWalk(entity, dirMap->direction);
   } while((++dirMap)->action != 0xFF);
 
@@ -62,9 +45,10 @@ void playerInput(entity_t *entity) {
       z = entity->position.z;
     }
 
-    entity_t *target = entityGetAt((worldpos_t){ x, y, z });
+    entity_t *interact = entityGetAt((worldpos_t){ x, y, z });
-    if(target == NULL) return;
+    if(interact != NULL && ENTITY_CALLBACKS[interact->type].interact != NULL) {
-    entityInteractWith(entity, target);
+      if(ENTITY_CALLBACKS[interact->type].interact(entity, interact)) return;
+    }
   }
   
 }

archive/rpg/item/inventory.h

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+
+typedef struct {
+  void *nothing;
+} inventory_t;

archive/rpg/overworld/chunk.h

@@ -9,24 +9,14 @@
 #include "rpg/overworld/tile.h"
 #include "worldpos.h"
 #include "display/mesh/quad.h"
-#include "display/spritebatch/spritebatch.h"
-
-// #define CHUNK_MESH_COUNT_MAX 3
-#define CHUNK_VERTEX_COUNT (QUAD_VERTEX_COUNT * CHUNK_WIDTH * CHUNK_HEIGHT * 2)
-#define CHUNK_ENTITY_COUNT_MAX 10
 
 typedef struct chunk_s {
   chunkpos_t position;
   tile_t tiles[CHUNK_TILE_COUNT];
   
-  meshvertex_t vertices[CHUNK_VERTEX_COUNT];
+  uint8_t meshCount;
-  uint32_t vertCount;
+  meshvertex_t vertices[CHUNK_VERTEX_COUNT_MAX];
-  mesh_t mesh;
+  mesh_t meshes[CHUNK_MESH_COUNT_MAX];
-  color_t testColor;
-  
-  // uint8_t meshCount;
-  // meshvertex_t vertices[CHUNK_VERTEX_COUNT_MAX];
-  // mesh_t meshes[CHUNK_MESH_COUNT_MAX];
   uint8_t entities[CHUNK_ENTITY_COUNT_MAX];
 } chunk_t;
 

archive/rpg/overworld/map.c

@@ -11,33 +11,65 @@
 #include "asset/asset.h"
 #include "rpg/entity/entity.h"
 #include "util/string.h"
+#include "script/scriptcontext.h"
 
 map_t MAP;
 
 errorret_t mapInit() {
   memoryZero(&MAP, sizeof(map_t));
-
+  errorOk();
-  // Setup chunk meshes
-  for(chunkindex_t i = 0; i < MAP_CHUNK_COUNT; i++) {
-    chunk_t *chunk = &MAP.chunks[i];
-    errorChain(meshInit(
-      &chunk->mesh,
-      MESH_PRIMITIVE_TYPE_TRIANGLES,
-      CHUNK_VERTEX_COUNT,
-      chunk->vertices
-    ));
 }
 
+bool_t mapIsLoaded() {
+  return MAP.filePath[0] != '\0';
+}
+
+errorret_t mapLoad(const char_t *path, const chunkpos_t position) {
+  assertStrLenMin(path, 1, "Map file path cannot be empty");
+  assertStrLenMax(path, MAP_FILE_PATH_MAX - 1, "Map file path too long");
+
+  if(stringCompare(MAP.filePath, path) == 0) {
+    // Same map, no need to reload
+    errorOk();
+  }
+
+  chunkindex_t i;
+  
+  // Unload all loaded chunks
+  if(mapIsLoaded()) {
+    for(i = 0; i < MAP_CHUNK_COUNT; i++) {
+      mapChunkUnload(&MAP.chunks[i]);
+    }
+  }
+
+  // Store the map file path
+  stringCopy(MAP.filePath, path, MAP_FILE_PATH_MAX);
+
+  // Determine directory path (it is dirname)
+  stringCopy(MAP.dirPath, path, MAP_FILE_PATH_MAX);
+  char_t *last = stringFindLastChar(MAP.dirPath, '/');
+  if(last == NULL) errorThrow("Invalid map file path");
+
+  // Store filename, sans extension
+  stringCopy(MAP.fileName, last + 1, MAP_FILE_PATH_MAX);
+  *last = '\0'; // Terminate to get directory path
+
+  last = stringFindLastChar(MAP.fileName, '.');
+  if(last == NULL) errorThrow("Map file name has no extension");
+  *last = '\0'; // Terminate to remove extension
+
+  // Reset map position
+  MAP.chunkPosition = position;
+
   // Perform "initial load"
-  MAP.loaded = true;
+  i = 0;
-  int32_t i = 0;
   for(chunkunit_t z = 0; z < MAP_CHUNK_DEPTH; z++) {
     for(chunkunit_t y = 0; y < MAP_CHUNK_HEIGHT; y++) {
       for(chunkunit_t x = 0; x < MAP_CHUNK_WIDTH; x++) {
         chunk_t *chunk = &MAP.chunks[i];
-        chunk->position.x = x + MAP.chunkPosition.x;
+        chunk->position.x = x + position.x;
-        chunk->position.y = y + MAP.chunkPosition.y;
+        chunk->position.y = y + position.y;
-        chunk->position.z = z + MAP.chunkPosition.z;
+        chunk->position.z = z + position.z;
         MAP.chunkOrder[i] = chunk;
         errorChain(mapChunkLoad(chunk));
         i++;
@@ -45,68 +77,22 @@ errorret_t mapInit() {
     }
   }
 
+  // Execute map script.
+  char_t scriptPath[MAP_FILE_PATH_MAX + 16];
+  stringFormat(
+    scriptPath, sizeof(scriptPath), "%s/%s.dsf",
+    MAP.dirPath, MAP.fileName
+  );
+  if(assetFileExists(scriptPath)) {
+    scriptcontext_t ctx;
+    errorChain(scriptContextInit(&ctx));
+    errorChain(scriptContextExecFile(&ctx, scriptPath));
+    scriptContextDispose(&ctx);
+  }
+
   errorOk();
 }
 
-bool_t mapIsLoaded() {
-  return MAP.loaded;
-}
-
-// errorret_t mapLoad(const char_t *path, const chunkpos_t position) {
-//   assertStrLenMin(path, 1, "Map file path cannot be empty");
-//   assertStrLenMax(path, MAP_FILE_PATH_MAX - 1, "Map file path too long");
-
-//   if(stringCompare(MAP.filePath, path) == 0) {
-//     // Same map, no need to reload
-//     errorOk();
-//   }
-
-//   chunkindex_t i;
-  
-//   // Unload all loaded chunks
-//   if(mapIsLoaded()) {
-//     for(i = 0; i < MAP_CHUNK_COUNT; i++) {
-//       mapChunkUnload(&MAP.chunks[i]);
-//     }
-//   }
-
-//   // Store the map file path
-//   stringCopy(MAP.filePath, path, MAP_FILE_PATH_MAX);
-
-//   // Determine directory path (it is dirname)
-//   stringCopy(MAP.dirPath, path, MAP_FILE_PATH_MAX);
-//   char_t *last = stringFindLastChar(MAP.dirPath, '/');
-//   if(last == NULL) errorThrow("Invalid map file path");
-
-//   // Store filename, sans extension
-//   stringCopy(MAP.fileName, last + 1, MAP_FILE_PATH_MAX);
-//   *last = '\0'; // Terminate to get directory path
-
-//   last = stringFindLastChar(MAP.fileName, '.');
-//   if(last == NULL) errorThrow("Map file name has no extension");
-//   *last = '\0'; // Terminate to remove extension
-
-//   // Reset map position
-//   MAP.chunkPosition = position;
-
-//   // Perform "initial load"
-//   i = 0;
-//   for(chunkunit_t z = 0; z < MAP_CHUNK_DEPTH; z++) {
-//     for(chunkunit_t y = 0; y < MAP_CHUNK_HEIGHT; y++) {
-//       for(chunkunit_t x = 0; x < MAP_CHUNK_WIDTH; x++) {
-//         chunk_t *chunk = &MAP.chunks[i];
-//         chunk->position.x = x + position.x;
-//         chunk->position.y = y + position.y;
-//         chunk->position.z = z + position.z;
-//         MAP.chunkOrder[i] = chunk;
-//         errorChain(mapChunkLoad(chunk));
-//         i++;
-//       }
-//     }
-//   }
-//   errorOk();
-// }
-
 errorret_t mapPositionSet(const chunkpos_t newPos) {
   if(!mapIsLoaded()) errorThrow("No map loaded");
 
@@ -193,12 +179,10 @@ void mapUpdate() {
   
 }
 
-errorret_t mapDispose() {
+void mapDispose() {
   for(chunkindex_t i = 0; i < MAP_CHUNK_COUNT; i++) {
     mapChunkUnload(&MAP.chunks[i]);
-    errorChain(meshDispose(&MAP.chunks[i].mesh));
   }
-  errorOk();
 }
 
 void mapChunkUnload(chunk_t* chunk) {
@@ -207,79 +191,39 @@ void mapChunkUnload(chunk_t* chunk) {
     entity_t *entity = &ENTITIES[chunk->entities[i]];
     entity->type = ENTITY_TYPE_NULL;
   }
-  chunk->vertCount = 0;
+
+  for(uint8_t i = 0; i < chunk->meshCount; i++) {
+    if(chunk->meshes[i].vertexCount == 0) continue;
+    meshDispose(&chunk->meshes[i]);
+  }
 }
 
 errorret_t mapChunkLoad(chunk_t* chunk) {
   if(!mapIsLoaded()) errorThrow("No map loaded");
 
-  color_t color = COLOR_WHITE;
+  char_t buffer[64];
-  if(chunk->position.y % 2 == 0) {
-    if(chunk->position.x % 2 == 0) {
-      color = COLOR_BLACK;
-    } else {
-      color = COLOR_WHITE;
-    }
-  } else {
-    if(chunk->position.x % 2 == 0) {
-      color = COLOR_WHITE;
-    } else {
-      color = COLOR_BLACK;
-    }
-  }
-  // if(chunk->position.x == 0 && chunk->position.y == 0 && chunk->position.z == 0) {
-  //   color = COLOR_RED;
-  // }
-  chunk->testColor = color;
 
-  memorySet(chunk->tiles, TILE_SHAPE_GROUND, sizeof(chunk->tiles));
+  // TODO: Can probably move this to asset load logic?
+  chunk->meshCount = 0;
+  memoryZero(chunk->meshes, sizeof(chunk->meshes));
   memorySet(chunk->entities, 0xFF, sizeof(chunk->entities));
-  chunk->vertCount = 0;
 
-  if(chunk->position.z != 0) {
+  // Get chunk filepath.
+  snprintf(buffer, sizeof(buffer), "%s/chunks/%d_%d_%d.dmc",
+    MAP.dirPath,
+    chunk->position.x,
+    chunk->position.y,
+    chunk->position.z
+  );
+
+  // Chunk available?
+  if(!assetFileExists(buffer)) {
+    memoryZero(chunk->tiles, sizeof(chunk->tiles));
     errorOk();
   }
 
-  // Set Chunk sprites.
+  // Load.
-  vec3 spriteMin = {
+  errorChain(assetLoad(buffer, chunk));
-    chunk->position.x * CHUNK_WIDTH,
-    chunk->position.y * CHUNK_HEIGHT,
-    chunk->position.z * CHUNK_DEPTH
-  };
-  
-  spritebatchsprite_t sprites[CHUNK_TILE_COUNT];
-  uint32_t i = 0;
-  for(uint8_t x = 0; x < CHUNK_WIDTH; x++) {
-    for(uint8_t y = 0; y < CHUNK_HEIGHT; y++) {
-      glm_vec3_copy(spriteMin, sprites[i].min);
-      glm_vec3_add(
-        sprites[i].min,
-        (vec3){ x, y, 0 },
-        sprites[i].min
-      );
-
-      glm_vec3_copy(sprites[i].min, sprites[i].max);
-      glm_vec3_add(
-        sprites[i].max,
-        (vec3){ 1, 1, 0 },
-        sprites[i].max
-      );
-
-      glm_vec2_copy((vec2){ 0, 0 }, sprites[i].uvMin);
-      glm_vec2_copy((vec2){ 1, 1 }, sprites[i].uvMax);
-
-      i++;
-    }
-  }
-  chunk->vertCount = i * QUAD_VERTEX_COUNT;
-  spriteBatchBufferToMesh(
-    sprites,
-    i,
-    chunk->vertices,
-    chunk->vertCount
-  );
-  errorChain(meshFlush(&chunk->mesh, 0, chunk->vertCount));
-
   errorOk();
 }
 

archive/rpg/overworld/map.h

@@ -11,10 +11,9 @@
 #define MAP_FILE_PATH_MAX 128
 
 typedef struct map_s {
-  // char_t filePath[MAP_FILE_PATH_MAX];
+  char_t filePath[MAP_FILE_PATH_MAX];
-  // char_t dirPath[MAP_FILE_PATH_MAX];
+  char_t dirPath[MAP_FILE_PATH_MAX];
-  // char_t fileName[MAP_FILE_PATH_MAX];
+  char_t fileName[MAP_FILE_PATH_MAX];
-  bool_t loaded;
 
   chunk_t chunks[MAP_CHUNK_COUNT];
   chunk_t *chunkOrder[MAP_CHUNK_COUNT];
@@ -44,10 +43,10 @@ bool_t mapIsLoaded();
  * @param position The initial chunk position.
  * @return An error code.
  */
-// errorret_t mapLoad(
+errorret_t mapLoad(
-//   const char_t *path,
+  const char_t *path,
-//   const chunkpos_t position
+  const chunkpos_t position
-// );
+);
 
 /**
  * Updates the map.
@@ -56,10 +55,8 @@ void mapUpdate();
 
 /**
  * Disposes of the map.
- * 
- * @return An error code.
  */
-errorret_t mapDispose();
+void mapDispose();
 
 /**
  * Sets the map position and updates chunks accordingly.