Refactoring editor

Reviewed-on: #2

.github/workflows/build.yml

@@ -0,0 +1,117 @@
+name: Build Dusk
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+jobs:
+  run-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Run tests in Docker
+        run: ./scripts/test-linux-docker.sh
+
+  build-linux:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build Linux
+        run: ./scripts/build-linux-docker.sh
+      - name: Upload Linux binary
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-linux
+          path: build-linux/Dusk
+          if-no-files-found: error
+
+  build-psp:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build psp
+        run: ./scripts/build-psp-docker.sh
+      - name: Move EBOOT.PBP to Dusk subfolder
+        run: |
+          mkdir -p ./git-artifcats/Dusk/PSP/GAME/Dusk
+          cp build-psp/EBOOT.PBP ./git-artifcats/Dusk/PSP/GAME/Dusk/EBOOT.PBP
+      - name: Upload psp binary
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-psp
+          path: ./git-artifcats/Dusk
+          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:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build GameCube
+        run: ./scripts/build-gamecube-docker.sh
+      - name: Copy output files.
+        run: |
+          mkdir -p ./git-artifcats/Dusk
+          cp build-gamecube/Dusk.dol ./git-artifcats/Dusk/Dusk.dol
+          cp build-gamecube/dusk.dsk ./git-artifcats/Dusk/dusk.dsk
+      - name: Upload GameCube binary
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-gamecube
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-wii:
+    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
+        run: ./scripts/build-wii-docker.sh
+      - name: Copy output files.
+        run: |
+          mkdir -p ./git-artifcats/Dusk/apps/Dusk
+          cp build-wii/Dusk.dol ./git-artifcats/Dusk/apps/Dusk/boot.dol
+          cp build-wii/dusk.dsk ./git-artifcats/Dusk/apps/Dusk/dusk.dsk
+          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

.gitignore

@@ -95,3 +95,13 @@ assets/borrowed
 # /archive
 
 __pycache__
+
+package-lock.json
+yarn-error.log
+yarn.lock
+
+.editor
+.venv
+
+/build2
+/build*

CMakeLists.txt

@@ -4,15 +4,13 @@
 # https://opensource.org/licenses/MIT
 
 # Setup
-cmake_minimum_required(VERSION 3.13)
+cmake_minimum_required(VERSION 3.18)
-set(CMAKE_C_STANDARD 99)
+
+set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
 
-if(NOT DEFINED DUSK_TARGET_SYSTEM)
+option(DUSK_BUILD_TESTS "Enable tests" OFF)
-  # set(DUSK_TARGET_SYSTEM "linux")
-  set(DUSK_TARGET_SYSTEM "psp")
-endif()
 
 # Prep cache
 set(DUSK_CACHE_TARGET "dusk-target")
@@ -21,56 +19,96 @@ set(DUSK_CACHE_TARGET "dusk-target")
 set(DUSK_ROOT_DIR "${CMAKE_SOURCE_DIR}")
 set(DUSK_BUILD_DIR "${CMAKE_BINARY_DIR}")
 set(DUSK_SOURCES_DIR "${DUSK_ROOT_DIR}/src")
+set(DUSK_TEST_DIR "${DUSK_ROOT_DIR}/test")
 set(DUSK_TEMP_DIR "${DUSK_BUILD_DIR}/temp")
 set(DUSK_TOOLS_DIR "${DUSK_ROOT_DIR}/tools")
-# set(DUSK_ASSETS_DIR "${DUSK_ROOT_DIR}/assets")
-# set(DUSK_ASSETS_BUILD_DIR "${DUSK_BUILD_DIR}/assets")
 set(DUSK_DATA_DIR "${DUSK_ROOT_DIR}/data")
+set(DUSK_ASSETS_DIR "${DUSK_ROOT_DIR}/assets")
+set(DUSK_BUILT_ASSETS_DIR "${DUSK_BUILD_DIR}/built_assets" CACHE INTERNAL ${DUSK_CACHE_TARGET})
 set(DUSK_GENERATED_HEADERS_DIR "${DUSK_BUILD_DIR}/generated")
-set(DUSK_TARGET_NAME "Dusk" CACHE INTERNAL ${DUSK_CACHE_TARGET})
 set(DUSK_BUILD_BINARY ${DUSK_BUILD_DIR}/Dusk CACHE INTERNAL ${DUSK_CACHE_TARGET})
 set(DUSK_ASSETS "" CACHE INTERNAL ${DUSK_CACHE_TARGET})
+set(DUSK_LIBRARY_TARGET_NAME "DuskCore" CACHE INTERNAL ${DUSK_CACHE_TARGET})
+set(DUSK_BINARY_TARGET_NAME "Dusk" CACHE INTERNAL ${DUSK_CACHE_TARGET})
+set(DUSK_ASSETS_ZIP "${DUSK_BUILD_DIR}/dusk.dsk" CACHE INTERNAL ${DUSK_CACHE_TARGET})
 
-# Toolchain
+if(NOT DEFINED DUSK_TARGET_SYSTEM)
+  set(DUSK_TARGET_SYSTEM "linux")
+endif()
 
 # Create directories
 file(MAKE_DIRECTORY ${DUSK_GENERATED_HEADERS_DIR})
-file(MAKE_DIRECTORY ${DUSK_ASSETS_BUILD_DIR})
+file(MAKE_DIRECTORY ${DUSK_TEMP_DIR})
+file(MAKE_DIRECTORY ${DUSK_BUILT_ASSETS_DIR})
 
-# Compilers
+# Required build packages
-if(DUSK_TARGET_SYSTEM STREQUAL "psp")
+find_package(Python3 COMPONENTS Interpreter REQUIRED)
-  find_package(pspsdk REQUIRED)
-endif()
 
-# Init Project
+# Init Project.
-project(${DUSK_TARGET_NAME}
+project(${DUSK_LIBRARY_TARGET_NAME}
   VERSION 1.0.0
   LANGUAGES C
 )
 
-# Executable
+# Either, create library and binary separately (used for tests), or make them
-add_executable(${DUSK_TARGET_NAME})
+# one in the same so all code is in the binary only.
+# Binary Executable
+add_executable(${DUSK_BINARY_TARGET_NAME} ${DUSK_SOURCES_DIR}/dusk/null.c)
+
+if(DUSK_BUILD_TESTS)
+  # MainLibrary
+  add_library(${DUSK_LIBRARY_TARGET_NAME} STATIC)
+
+  # Link library to binary
+  target_link_libraries(${DUSK_BINARY_TARGET_NAME}
+    PUBLIC
+      ${DUSK_LIBRARY_TARGET_NAME}
+  )
+else()
+  set(DUSK_LIBRARY_TARGET_NAME "${DUSK_BINARY_TARGET_NAME}" CACHE INTERNAL ${DUSK_CACHE_TARGET})
+endif()
+
+# Definitions
+target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    DUSK_TARGET_SYSTEM="${DUSK_TARGET_SYSTEM}"
+)
+
+# Toolchains
+include(cmake/targets/${DUSK_TARGET_SYSTEM}.cmake)
 
 # Add tools
 add_subdirectory(tools)
 
-# Add code
+# Include generated headers from tools.
-add_subdirectory(src)
+target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
-
-# Include generated headers
-target_include_directories(${DUSK_TARGET_NAME}
-  PUBLIC
   ${DUSK_GENERATED_HEADERS_DIR}
 )
 
-# Postbuild, create PBP file for PSP.
+# Add main code
-if(DUSK_TARGET_SYSTEM STREQUAL "psp")
+add_subdirectory(${DUSK_SOURCES_DIR})
-  create_pbp_file(
+
-    TARGET "${DUSK_TARGET_NAME}"
+# Include generated headers
-    ICON_PATH NULL
+target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
-    BACKGROUND_PATH NULL
+  ${DUSK_GENERATED_HEADERS_DIR}
-    PREVIEW_PATH NULL
-    TITLE "${DUSK_TARGET_NAME}"
-    VERSION 01.00
 )
+
+# Handle tests
+if(DUSK_BUILD_TESTS)
+  enable_testing()
+  add_subdirectory(test)
 endif()
+
+# Build assets
+file(GLOB_RECURSE DUSK_ASSET_FILES CONFIGURE_DEPENDS "${DUSK_ASSETS_DIR}/*")
+add_custom_command(
+  OUTPUT "${DUSK_ASSETS_ZIP}"
+  COMMAND ${CMAKE_COMMAND} -E make_directory "${DUSK_ASSETS_DIR}"
+  COMMAND ${CMAKE_COMMAND} -E rm -f "${DUSK_ASSETS_ZIP}"
+  COMMAND ${CMAKE_COMMAND} -E tar "cf" "${DUSK_ASSETS_ZIP}" --format=zip -- .
+  WORKING_DIRECTORY "${DUSK_ASSETS_DIR}"
+  DEPENDS ${DUSK_ASSET_FILES}
+  VERBATIM
+)
+add_custom_target(DUSK_ASSETS_BUILT DEPENDS "${DUSK_ASSETS_ZIP}")
+add_dependencies(${DUSK_LIBRARY_TARGET_NAME} DUSK_ASSETS_BUILT)

README.md

@@ -0,0 +1,23 @@
+# Dusk
+RPG Game Project, small and able to run on a PSP.
+
+# Building
+Each build target has different requirements. You can take a look at the git
+workflow to see how the builds are done for each target. In addition, for
+accessing the editor and building the game on your host system, install the
+following packages, depending on your system;
+
+Fedora;
+```
+sudo dnf install git make gcc cmake python python-polib python3-pillow python3-dotenv python3-numpy python-qt5 python3-pyopengl SDL2-devel zlib-devel libzip-devel bzip2-devel openssl-devel lzma-sdk-devel xz xz-devel lua-devel
+```
+
+Ubuntu;
+```
+sudo apt-get install git build-essential gcc python python-polib python3-pillow python3-dotenv python3-numpy python3-pyqt5 python3-opengl
+```
+
+Arch Linux;
+```
+sudo pacman -S git base-devel gcc python python-polib python-pillow python-dotenv python-numpy python-pyqt5 python-opengl
+```

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/fixed.c

@@ -1,257 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "fixed.h"
-#include "assert/assert.h"
-
-float_t fx248Fromi32(const int32_t b) {
-  return (float_t)b << FIXED248_FRACTION_BITS;
-}
-
-float_t fx248Fromu32(const uint32_t b) {
-  return (float_t)((int32_t)b << FIXED248_FRACTION_BITS);
-}
-
-float_t fx248Fromf32(const float_t b) {
-  return (float_t)(b * (1 << FIXED248_FRACTION_BITS));
-}
-
-float_t fx248Fromu16(const uint16_t b) {
-  return (float_t)((int32_t)b << FIXED248_FRACTION_BITS);
-}
-
-float_t fx248Fromu8(const uint8_t b) {
-  return (float_t)((int32_t)b << FIXED248_FRACTION_BITS);
-}
-
-
-
-int32_t fx248Toi32(const float_t a) {
-  return a >> FIXED248_FRACTION_BITS;
-}
-
-uint32_t fx248Tou32(const float_t a) {
-  return (uint32_t)(a >> FIXED248_FRACTION_BITS);
-}
-
-float_t fx248Tof32(const float_t a) {
-  return (float_t)a / (1 << FIXED248_FRACTION_BITS);
-}
-
-uint16_t fx248Tou16(const float_t a) {
-  return (uint16_t)(a >> FIXED248_FRACTION_BITS);
-}
-
-uint8_t fx248Tou8(const float_t a) {
-  return (uint8_t)(a >> FIXED248_FRACTION_BITS);
-}
-
-
-
-float_t fx248Addfx248(const float_t a, const float_t b) {
-  return a + b;
-}
-
-float_t fx248Addi32(const float_t a, const int32_t b) {
-  return fx248Addfx248(a, fx248Fromi32(b));
-}
-
-float_t fx248Addu32(const float_t a, const uint32_t b) {
-  return fx248Addfx248(a, fx248Fromu32(b));
-}
-
-float_t fx248Addf32(const float_t a, const float_t b) {
-  return fx248Addfx248(a, fx248Fromf32(b));
-}
-
-
-
-float_t fx248Subfx248(const float_t a, const float_t b) {
-  return a - b;
-}
-
-float_t fx248Subi32(const float_t a, const int32_t b) {
-  return fx248Subfx248(a, fx248Fromi32(b));
-}
-
-float_t fx248Subu32(const float_t a, const uint32_t b) {
-  return fx248Subfx248(a, fx248Fromu32(b));
-}
-
-float_t fx248Subf32(const float_t a, const float_t b) {
-  return fx248Subfx248(a, fx248Fromf32(b));
-}
-
-
-
-float_t fx248Mulfx248(const float_t a, const float_t b) {
-  return (float_t)(((int64_t)a * (int64_t)b) >> FIXED248_FRACTION_BITS);
-}
-
-float_t fx248Muli32(const float_t a, const int32_t b) {
-  return (float_t)(((int64_t)a * (int64_t)b) >> FIXED248_FRACTION_BITS);
-}
-
-float_t fx248Mulu32(const float_t a, const uint32_t b) {
-  return (float_t)(
-    ((int64_t)a * (int64_t)(int32_t)b
-  ) >> FIXED248_FRACTION_BITS);
-}
-
-float_t fx248Mulf32(const float_t a, const float_t b) {
-  return (float_t)((
-    (int64_t)a * (int64_t)(b * (1 << FIXED248_FRACTION_BITS))
-  ) >> FIXED248_FRACTION_BITS);
-}
-
-
-
-float_t fx248Divfx248(const float_t a, const float_t b) {
-  assertFalse(b == 0, "Division by zero in fx248Divfx248");
-  return (float_t)(((int64_t)a << FIXED248_FRACTION_BITS) / (int64_t)b);
-}
-
-float_t fx248Divi32(const float_t a, const int32_t b) {
-  assertFalse(b == 0, "Division by zero in fx248Divi32");
-  return (float_t)(((int64_t)a << FIXED248_FRACTION_BITS) / (int64_t)b);
-}
-
-float_t fx248Divu32(const float_t a, const uint32_t b) {
-  assertFalse(b == 0, "Division by zero in fx248Divu32");
-  return (float_t)(
-    ((int64_t)a << FIXED248_FRACTION_BITS
-  ) / (int64_t)(int32_t)b);
-}
-
-float_t fx248Divf32(const float_t a, const float_t b) {
-  assertFalse(b == 0, "Division by zero in fx248Divf32");
-  return (float_t)((
-    (int64_t)a << FIXED248_FRACTION_BITS
-  ) / (int64_t)(b * (1 << FIXED248_FRACTION_BITS)));
-}
-
-
-
-float_t fx248Floor(const float_t a) {
-  return a & ~((1 << FIXED248_FRACTION_BITS) - 1);
-}
-
-float_t fx248Ceil(const float_t a) {
-  if(a & ((1 << FIXED248_FRACTION_BITS) - 1)) {
-    return (a & ~((1 << FIXED248_FRACTION_BITS) - 1)) + (1 << FIXED248_FRACTION_BITS);
-  }
-  return a;
-}
-
-float_t fx248Round(const float_t a) {
-  if(a & ((1 << (FIXED248_FRACTION_BITS - 1)) - 1)) {
-    return (a & ~((1 << FIXED248_FRACTION_BITS) - 1)) + (1 << FIXED248_FRACTION_BITS);
-  }
-  return a & ~((1 << FIXED248_FRACTION_BITS) - 1);
-}
-
-
-
-uint32_t fx248Flooru32(const float_t a) {
-  return (uint32_t)((a >> FIXED248_FRACTION_BITS) & 0xFFFFFFFF);
-}
-
-uint32_t fx248Ceilu32(const float_t a) {
-  return (uint32_t)(((a + ((1 << FIXED248_FRACTION_BITS) - 1)) >> FIXED248_FRACTION_BITS) & 0xFFFFFFFF);
-}
-
-uint32_t fx248Roundu32(const float_t a) {
-  return (uint32_t)(((a + (1 << (FIXED248_FRACTION_BITS - 1))) >> FIXED248_FRACTION_BITS) & 0xFFFFFFFF);
-}
-
-float_t fx248Sqrt(const float_t a) {
-  if(a == 0) return 0;
-
-  float_t y = a > FIXED248(1, 0) ? a : FIXED248(1, 0);
-  float_t last = 0;
-  int max_iter = 16;
-  while(y != last && max_iter-- > 0) {
-    last = y;
-    int32_t div = (int32_t)(((int64_t)a << FIXED248_FRACTION_BITS) / y);
-    y = (y + div) >> 1;
-  }
-  return y;
-}
-
-
-
-float_t fx248Max(const float_t a, const float_t b) {
-  return (a > b) ? a : b;
-}
-
-float_t fx248Min(const float_t a, const float_t b) {
-  return (a < b) ? a : b;
-}
-
-float_t fx248Clamp(
-  const float_t a,
-  const float_t min,
-  const float_t max
-) {
-  return (a < min) ? min : (a > max) ? max : a;
-}
-
-float_t fx248Abs(const float_t a) {
-  return (a < 0) ? -a : a;
-}
-
-
-
-float_t fx248Atan2(
-  const float_t y,
-  const float_t x
-) {
-  // Handle special cases
-  if (x == 0) {
-    if (y > 0) return FX248_HALF_PI;
-    if (y < 0) return -FX248_HALF_PI;
-    return 0;
-  }
-
-  // Use absolute values for quadrant correction
-  float_t abs_y = y;
-  if (abs_y < 0) abs_y = -abs_y;
-
-  float_t angle;
-  if (abs_y < fx248Abs(x)) {
-    float_t z = fx248Divfx248(y, x);
-    float_t z2 = fx248Mulfx248(z, z);
-    float_t z3 = fx248Mulfx248(z2, z);
-    float_t z5 = fx248Mulfx248(z3, z2);
-    angle = fx248Subfx248(
-      fx248Addfx248(z, fx248Divfx248(z5, fx248Fromi32(5))),
-      fx248Divfx248(z3, fx248Fromi32(3))
-    );
-    if (x < 0) {
-      if (y < 0) {
-        angle -= FX248_PI;
-      } else {
-        angle += FX248_PI;
-      }
-    }
-  } else {
-    float_t z = fx248Divfx248(x, y);
-    float_t z2 = fx248Mulfx248(z, z);
-    float_t z3 = fx248Mulfx248(z2, z);
-    float_t z5 = fx248Mulfx248(z3, z2);
-    angle = fx248Subfx248(
-      fx248Addfx248(z, fx248Divfx248(z5, fx248Fromi32(5))),
-      fx248Divfx248(z3, fx248Fromi32(3))
-    );
-    if (y > 0) {
-      angle = FX248_HALF_PI - angle;
-    } else {
-      angle = -FX248_HALF_PI - angle;
-    }
-  }
-  return angle;
-}

archive/fixed.h

@@ -1,379 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "dusk.h"
-
-typedef int32_t float_t;
-
-#define FIXED248_FRACTION_BITS 8
-#define FIXED248_HIGH_MULTIPLIER (1 << FIXED248_FRACTION_BITS)
-#define FIXED248_MIN INT32_MIN
-#define FIXED248_MAX INT32_MAX
-#define FIXED248(i, f) ((float_t)( \
-  ((i) << FIXED248_FRACTION_BITS) + \
-  (((f) * FIXED248_HIGH_MULTIPLIER) / 100) \
-))
-#define FIXED248_ONE (FIXED248(1, 0))
-#define FIXED248_ZERO (FIXED248(0, 0))
-#define FX248_PI 804
-#define FX248_HALF_PI 402
-#define FX248_3PI_4 603 
-#define FX248_NEG_PI -804
-
-/**
- * Convert an int32_t value to a float_t value.
- * 
- * @param b The int32_t value to convert.
- * @return The converted float_t value.
- */
-float_t fx248Fromi32(const int32_t b);
-
-/**
- * Convert a uint32_t value to a float_t value.
- * 
- * @param b The uint32_t value to convert.
- * @return The converted float_t value.
- */
-float_t fx248Fromu32(const uint32_t b);
-
-/**
- * Convert a float_t value to a float_t value.
- * 
- * @param b The float_t value to convert.
- * @return The converted float_t value.
- */
-float_t fx248Fromf32(const float_t b);
-
-/**
- * Convert a uint16_t value to a float_t value.
- * 
- * @param b The uint16_t value to convert.
- * @return The converted float_t value.
- */
-float_t fx248Fromu16(const uint16_t b);
-
-/**
- * Convert a uint8_t value to a float_t value.
- * 
- * @param b The uint8_t value to convert.
- * @return The converted float_t value.
- */
-float_t fx248Fromu8(const uint8_t b);
-
-
-
-/**
- * Convert a float_t value to an int32_t value.
- * 
- * @param a The float_t value to convert.
- * @return The converted int32_t value.
- */
-int32_t fx248Toi32(const float_t a);
-
-/**
- * Convert a float_t value to a uint32_t value.
- * 
- * @param a The float_t value to convert.
- * @return The converted uint32_t value.
- */
-uint32_t fx248Tou32(const float_t a);
-
-/**
- * Convert a float_t value to a float_t value.
- * 
- * @param a The float_t value to convert.
- * @return The converted float_t value.
- */
-float_t fx248Tof32(const float_t a);
-
-/**
- * Convert a float_t value to a uint16_t value.
- * 
- * @param a The float_t value to convert.
- * @return The converted uint16_t value.
- */
-uint16_t fx248Tou16(const float_t a);
-
-/**
- * Convert a float_t value to an uint8_t value.
- * 
- * @param a The float_t value to convert.
- * @return The converted uint8_t value.
- */
-uint8_t fx248Tou8(const float_t a);
-
-
-
-/**
- * Add a float_t value to another float_t value.
- * 
- * @param a First float_t value.
- * @param b Second float_t value to add to the first value.
- * @return The result of the addition as a float_t value.
- */
-float_t fx248Addfx248(const float_t a, const float_t b);
-
-/**
- * Add an int32_t value to a float_t value.
- * 
- * @param a The float_t value to which the int32_t will be added.
- * @param b The int32_t value to add to the float_t value.
- * @return The result of the addition as a float_t value.
- */
-float_t fx248Addi32(const float_t a, const int32_t b);
-
-/**
- * Add a uint32_t value to a float_t value.
- * 
- * @param a The float_t value to which the uint32_t will be added.
- * @param b The uint32_t value to add to the float_t value.
- * @return The result of the addition as a float_t value.
- */
-float_t fx248Addu32(const float_t a, const uint32_t b);
-
-/**
- * Add a float_t value to a float_t value.
- * 
- * @param a Pointer to the float_t value (will be modified).
- * @param b The float_t value to add to the float_t value.
- * @return The result of the addition as a float_t value.
- */
-float_t fx248Addf32(const float_t a, const float_t b);
-
-
-
-/**
- * Subtract a float_t value from another float_t value.
- * 
- * @param a First float_t value.
- * @param b The float_t value to subtract from the first value.
- * @return The result of the subtraction as a float_t value.
- */
-float_t fx248Subfx248(const float_t a, const float_t b);
-
-/**
- * Subtract an int32_t value from a float_t value.
- * 
- * @param a The float_t value from which the int32_t will be subtracted.
- * @param b The int32_t value to subtract from the float_t value.
- * @return The result of the subtraction as a float_t value.
- */
-float_t fx248Subi32(const float_t a, const int32_t b);
-
-/**
- * Subtract a uint32_t value from a float_t value.
- * 
- * @param a The float_t value from which the uint32_t will be subtracted.
- * @param b The uint32_t value to subtract from the float_t value.
- * @return The result of the subtraction as a float_t value.
- */
-float_t fx248Subu32(const float_t a, const uint32_t b);
-
-/**
- * Subtract a float_t value from a float_t value.
- * 
- * @param a The float_t value from which the float_t will be subtracted.
- * @param b The float_t value to subtract from the float_t value.
- * @return The result of the subtraction as a float_t value.
- */
-float_t fx248Subf32(const float_t a, const float_t b);
-
-
-
-/**
- * Multiply two float_t values.
- * 
- * @param a First float_t value.
- * @param b Second float_t value to multiply with the first value.
- * @return The result of the multiplication as a float_t value.
- */
-float_t fx248Mulfx248(const float_t a, const float_t b);
-
-/**
- * Multiply a float_t value by an int32_t value.
- * 
- * @param a The float_t value to multiply.
- * @param b The int32_t value to multiply with the float_t value.
- * @return The result of the multiplication as a float_t value.
- */
-float_t fx248Muli32(const float_t a, const int32_t b);
-
-/**
- * Multiply a float_t value by a uint32_t value.
- * 
- * @param a The float_t value to multiply.
- * @param b The uint32_t value to multiply with the float_t value.
- * @return The result of the multiplication as a float_t value.
- */
-float_t fx248Mulu32(const float_t a, const uint32_t b);
-
-/**
- * Multiply a float_t value by a float_t value.
- * 
- * @param a The float_t value to multiply.
- * @param b The float_t value to multiply with the float_t value.
- * @return The result of the multiplication as a float_t value.
- */
-float_t fx248Mulf32(const float_t a, const float_t b);
-
-
-
-/**
- * Divide two float_t values.
- * 
- * @param a The float_t value to be divided.
- * @param b The float_t value to divide by.
- * @return The result of the division as a float_t value.
- */
-float_t fx248Divfx248(const float_t a, const float_t b);
-
-/**
- * Divide a float_t value by an int32_t value.
- * 
- * @param a The float_t value to be divided.
- * @param b The int32_t value to divide by.
- * @return The result of the division as a float_t value.
- */
-float_t fx248Divi32(const float_t a, const int32_t b);
-
-/**
- * Divide a float_t value by a uint32_t value.
- * 
- * @param a The float_t value to be divided.
- * @param b The uint32_t value to divide by.
- * @return The result of the division as a float_t value.
- */
-float_t fx248Divu32(const float_t a, const uint32_t b);
-
-/**
- * Divide a float_t value by a float_t value.
- * 
- * @param a The float_t value to be divided.
- * @param b The float_t value to divide by.
- * @return The result of the division as a float_t value.
- */
-float_t fx248Divf32(const float_t a, const float_t b);
-
-
-
-/**
- * Convert a float_t value to an int32_t value, rounding towards zero.
- * 
- * @param a The float_t value to convert.
- * @return The converted int32_t value.
- */
-float_t fx248Floor(const float_t a);
-
-/**
- * Convert a float_t value to an int32_t value, rounding towards positive
- * infinity.
- * 
- * @param a The float_t value to convert.
- * @return The converted int32_t value.
- */
-float_t fx248Ceil(const float_t a);
-
-/**
- * Convert a float_t value to an int32_t value, rounding to the nearest
- * integer.
- * 
- * @param a The float_t value to convert.
- * @return The converted int32_t value.
- */
-float_t fx248Round(const float_t a);
-
-
-
-/**
- * Convert a float_t value to a uint32_t value, rounding towards zero.
- * 
- * @param a The float_t value to convert.
- * @return The converted uint32_t value.
- */
-uint32_t fx248Flooru32(const float_t a);
-
-/**
- * Convert a float_t value to a uint32_t value, rounding towards positive
- * infinity.
- * 
- * @param a The float_t value to convert.
- * @return The converted uint32_t value.
- */
-uint32_t fx248Ceilu32(const float_t a);
-
-/**
- * Convert a float_t value to a uint32_t value, rounding to the nearest
- * integer.
- * 
- * @param a The float_t value to convert.
- * @return The converted uint32_t value.
- */
-uint32_t fx248Roundu32(const float_t a);
-
-/**
- * Returns the square root of a float_t value.
- * 
- * @param a The float_t value to calculate the square root of.
- */
-float_t fx248Sqrt(const float_t a);
-
-
-
-/**
- * Returns the maximum of two float_t values.
- * 
- * @param a First float_t value.
- * @param b Second float_t value.
- * @return The maximum of the two values.
- */
-float_t fx248Max(const float_t a, const float_t b);
-
-/**
- * Returns the minimum of two float_t values.
- * 
- * @param a First float_t value.
- * @param b Second float_t value.
- * @return The minimum of the two values.
- */
-float_t fx248Min(const float_t a, const float_t b);
-
-/**
- * Clamp a float_t value between a minimum and maximum value.
- * 
- * @param a The float_t value to clamp.
- * @param min The minimum value to clamp to.
- * @param max The maximum value to clamp to.
- * @return The clamped float_t value.
- */
-float_t fx248Clamp(
-  const float_t a,
-  const float_t min,
-  const float_t max
-);
-
-/**
- * Returns the absolute value of a float_t value.
- * 
- * @param a The float_t value to calculate the absolute value of.
- * @return The absolute value as a float_t value.
- */
-float_t fx248Abs(const float_t a);
-
-
-
-/**
- * Calculate the arctangent of a float_t value.
- * 
- * @param y Y coordinate value.
- * @param x X coordinate value.
- * @return The arctangent of the value as a float_t value.
- */
-float_t fx248Atan2(
-  const float_t y,
-  const float_t x
-);

archive/map/CMakeLists.txt

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

archive/map/testmap/CMakeLists.txt

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

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

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

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

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "psp.h"
+
+void displayInitPSP(void) {
+  DISPLAY.usingShaderedPalettes = false;
+}

archive/platform/psp.h

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+
+/**
+ * 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

@@ -0,0 +1,17 @@
+# Copyright (c) 2025 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    rpg.c
+    rpgcamera.c
+    rpgtextbox.c
+)
+
+# Subdirs
+add_subdirectory(cutscene)
+add_subdirectory(entity)
+add_subdirectory(overworld)

archive/rpg/cutscene/CMakeLists.txt

@@ -0,0 +1,14 @@
+# Copyright (c) 2025 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    cutscenesystem.c
+    cutscenemode.c
+)
+
+# Subdirs
+add_subdirectory(item)

archive/rpg/cutscene/cutscene.h

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "rpg/cutscene/item/cutsceneitem.h"
+
+typedef struct cutscene_s {
+  const cutsceneitem_t *items;
+  uint8_t itemCount;
+} cutscene_t;

archive/rpg/cutscene/cutscenemode.c

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "rpg/cutscene/cutscenesystem.h"
+
+bool_t cutsceneModeIsInputAllowed() {
+  switch(CUTSCENE_SYSTEM.mode) {
+    case CUTSCENE_MODE_FULL_FREEZE:
+    case CUTSCENE_MODE_INPUT_FREEZE:
+      return false;
+      
+    default:
+      return true;
+  }
+}

archive/rpg/cutscene/cutscenemode.h

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+
+typedef enum {
+  CUTSCENE_MODE_NONE,
+  CUTSCENE_MODE_FULL_FREEZE,
+  CUTSCENE_MODE_INPUT_FREEZE,
+  CUTSCENE_MODE_GAMEPLAY
+} cutscenemode_t;
+
+// Default mode for all cutscenes.
+#define CUTSCENE_MODE_INITIAL CUTSCENE_MODE_INPUT_FREEZE
+
+/**
+ * Check if input is allowed in the current cutscene mode.
+ * 
+ * @return true if input is allowed, false otherwise.
+ */
+bool_t cutsceneModeIsInputAllowed();

archive/rpg/cutscene/cutscenesystem.c

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "cutscenesystem.h"
+#include "util/memory.h"
+
+cutscenesystem_t CUTSCENE_SYSTEM;
+
+void cutsceneSystemInit() {
+  memoryZero(&CUTSCENE_SYSTEM, sizeof(cutscenesystem_t));
+}
+
+void cutsceneSystemStartCutscene(const cutscene_t *cutscene) {
+  CUTSCENE_SYSTEM.scene = cutscene;
+  CUTSCENE_SYSTEM.mode = CUTSCENE_MODE_INITIAL;
+  CUTSCENE_SYSTEM.currentItem = 0xFF;// Set to 0xFF so start wraps.
+  cutsceneSystemNext();
+}
+
+void cutsceneSystemUpdate() {
+  if(CUTSCENE_SYSTEM.scene == NULL) return;
+
+  const cutsceneitem_t *item = cutsceneSystemGetCurrentItem();
+  cutsceneItemUpdate(item, &CUTSCENE_SYSTEM.data);
+}
+
+void cutsceneSystemNext() {
+  if(CUTSCENE_SYSTEM.scene == NULL) return;
+
+  CUTSCENE_SYSTEM.currentItem++;
+
+  // End of the cutscene?
+  if(
+    CUTSCENE_SYSTEM.currentItem >= CUTSCENE_SYSTEM.scene->itemCount
+  ) {
+    CUTSCENE_SYSTEM.scene = NULL;
+    CUTSCENE_SYSTEM.currentItem = 0xFF;
+    CUTSCENE_SYSTEM.mode = CUTSCENE_MODE_NONE;
+    return;
+  }
+
+  // Start item.
+  const cutsceneitem_t *item = cutsceneSystemGetCurrentItem();
+  memset(&CUTSCENE_SYSTEM.data, 0, sizeof(CUTSCENE_SYSTEM.data));
+  cutsceneItemStart(item, &CUTSCENE_SYSTEM.data);
+}
+
+const cutsceneitem_t * cutsceneSystemGetCurrentItem() {
+  if(CUTSCENE_SYSTEM.scene == NULL) return NULL;
+
+  return &CUTSCENE_SYSTEM.scene->items[CUTSCENE_SYSTEM.currentItem];
+}

archive/rpg/cutscene/cutscenesystem.h

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "cutscene.h"
+#include "cutscenemode.h"
+
+typedef struct {
+  const cutscene_t *scene;
+  uint8_t currentItem;
+
+  // Data (used by the current item).
+  cutsceneitemdata_t data;
+  cutscenemode_t mode;
+} cutscenesystem_t;
+
+extern cutscenesystem_t CUTSCENE_SYSTEM;
+
+/**
+ * Initialize the cutscene system.
+ */
+void cutsceneSystemInit();
+
+/**
+ * Start a cutscene.
+ * 
+ * @param cutscene Pointer to the cutscene to start.
+ */
+void cutsceneSystemStartCutscene(const cutscene_t *cutscene);
+
+/**
+ * Advance to the next item in the cutscene.
+ */
+void cutsceneSystemNext();
+
+/**
+ * Update the cutscene system for one frame.
+ */
+void cutsceneSystemUpdate();
+
+/**
+ * Get the current cutscene item.
+ * 
+ * @return Pointer to the current cutscene item.
+ */
+const cutsceneitem_t * cutsceneSystemGetCurrentItem();

archive/rpg/cutscene/item/CMakeLists.txt

@@ -4,8 +4,7 @@
 # https://opensource.org/licenses/MIT
 
 # Sources
-target_sources(${DUSK_TARGET_NAME}
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PRIVATE
+  PUBLIC
-    chunk.c
+    cutsceneitem.c
-    overworld.c
 )

archive/rpg/cutscene/item/cutscenecallback.h

@@ -6,4 +6,6 @@
  */
 
 #pragma once
-#include "ui/fontdata.h"
+#include "dusk.h"
+
+typedef void (*cutscenecallback_t)(void);

archive/rpg/cutscene/item/cutsceneitem.c

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "rpg/cutscene/cutscenesystem.h"
+#include "input/input.h"
+#include "time/time.h"
+
+void cutsceneItemStart(const cutsceneitem_t *item, cutsceneitemdata_t *data) {
+  switch(item->type) {
+    case CUTSCENE_ITEM_TYPE_TEXT: {
+      rpgTextboxShow(
+        item->text.position,
+        item->text.text
+      );
+      break;
+    }
+
+    case CUTSCENE_ITEM_TYPE_WAIT:
+      data->wait = item->wait;
+      break;
+
+    case CUTSCENE_ITEM_TYPE_CALLBACK:
+      if(item->callback != NULL) item->callback();
+      break;
+
+    case CUTSCENE_ITEM_TYPE_CUTSCENE:
+      if(item->cutscene != NULL) cutsceneSystemStartCutscene(item->cutscene);
+      break;
+
+    default:
+      break;
+  }
+}
+
+void cutsceneItemUpdate(const cutsceneitem_t *item, cutsceneitemdata_t *data) {
+  switch(item->type) {
+    case CUTSCENE_ITEM_TYPE_TEXT:
+      if(rpgTextboxIsVisible()) return;
+      cutsceneSystemNext();
+      break;
+
+    case CUTSCENE_ITEM_TYPE_WAIT:
+      data->wait -= TIME.delta;
+      if(data->wait <= 0) cutsceneSystemNext();
+      break;
+
+    default:
+      break;
+  }
+}

archive/rpg/cutscene/item/cutsceneitem.h

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "cutscenewait.h"
+#include "cutscenecallback.h"
+#include "cutscenetext.h"
+
+typedef struct cutscene_s cutscene_t;
+
+typedef enum {
+  CUTSCENE_ITEM_TYPE_NULL,
+  CUTSCENE_ITEM_TYPE_TEXT,
+  CUTSCENE_ITEM_TYPE_CALLBACK,
+  CUTSCENE_ITEM_TYPE_WAIT,
+  CUTSCENE_ITEM_TYPE_CUTSCENE
+} cutsceneitemtype_t;
+
+typedef struct cutsceneitem_s {
+  cutsceneitemtype_t type;
+
+  // Arguments/Data that will be used when this item is invoked.
+  union {
+    cutscenetext_t text;
+    cutscenecallback_t callback;
+    cutscenewait_t wait;
+    const cutscene_t *cutscene;
+  };
+} cutsceneitem_t;
+
+typedef union {
+  cutscenewaitdata_t wait;
+} cutsceneitemdata_t;
+
+/**
+ * Start the given cutscene item.
+ * 
+ * @param item The cutscene item to start.
+ * @param data The cutscene item data storage.
+ */
+void cutsceneItemStart(const cutsceneitem_t *item, cutsceneitemdata_t *data);
+
+/**
+ * Tick the given cutscene item (one frame).
+ * 
+ * @param item The cutscene item to tick.
+ * @param data The cutscene item data storage.
+ */
+void cutsceneItemUpdate(const cutsceneitem_t *item, cutsceneitemdata_t *data);

archive/rpg/cutscene/item/cutscenetext.h

@@ -6,9 +6,9 @@
  */
 
 #pragma once
-#include "eventitem.h"
+#include "rpg/rpgtextbox.h"
 
 typedef struct {
-  uint8_t itemCount;
+  char_t text[RPG_TEXTBOX_MAX_CHARS];
-  eventitem_t items[EVENT_ITEM_COUNT_MAX];
+  rpgtextboxpos_t position;
-} eventdata_t;
+} cutscenetext_t;

archive/rpg/cutscene/item/cutscenewait.h

@@ -7,7 +7,6 @@
 
 #pragma once
 #include "dusk.h"
-#include <pspkernel.h>
+
-#include <pspdebug.h>
+typedef float_t cutscenewait_t;
-#include <pspdisplay.h>
+typedef float_t cutscenewaitdata_t;
-#include <pspctrl.h>

archive/rpg/cutscene/scene/testcutscene.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "rpg/cutscene/cutscenesystem.h"
+
+static const cutsceneitem_t TEST_CUTSCENE_ONE_ITEMS[] = {
+  { .type = CUTSCENE_ITEM_TYPE_TEXT, .text = { .text = "This is a test cutscene.", .position = RPG_TEXTBOX_POS_BOTTOM } },
+  { .type = CUTSCENE_ITEM_TYPE_WAIT, .wait = 2.0f },
+  { .type = CUTSCENE_ITEM_TYPE_TEXT, .text = { .text = "It has multiple lines of text.\nAnd waits in between.", .position = RPG_TEXTBOX_POS_TOP } },
+};
+
+static const cutscene_t TEST_CUTSCENE_ONE = {
+  .items = TEST_CUTSCENE_ONE_ITEMS,
+  .itemCount = sizeof(TEST_CUTSCENE_ONE_ITEMS) / sizeof(cutsceneitem_t)
+};
+
+static const cutsceneitem_t TEST_CUTSCENE_TWO_ITEMS[] = {
+  { .type = CUTSCENE_ITEM_TYPE_WAIT, .wait = 1.0f },
+  { .type = CUTSCENE_ITEM_TYPE_CUTSCENE, .cutscene = &TEST_CUTSCENE_ONE },
+};
+
+static const cutscene_t TEST_CUTSCENE = {
+  .items = TEST_CUTSCENE_TWO_ITEMS,
+  .itemCount = sizeof(TEST_CUTSCENE_TWO_ITEMS) / sizeof(cutsceneitem_t)
+};

archive/rpg/entity/CMakeLists.txt

@@ -4,9 +4,11 @@
 # https://opensource.org/licenses/MIT
 
 # Sources
-target_sources(${DUSK_TARGET_NAME}
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
-  PRIVATE
+  PUBLIC
     entity.c
-    player.c
+    entityanim.c
     npc.c
+    player.c
+    entitydir.c
 )

archive/rpg/entity/entity.c

@@ -0,0 +1,200 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "entity.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "time/time.h"
+#include "util/math.h"
+#include "rpg/cutscene/cutscenemode.h"
+#include "rpg/overworld/map.h"
+
+entity_t ENTITIES[ENTITY_COUNT];
+
+void entityInit(entity_t *entity, const entitytype_t type) {
+  assertNotNull(entity, "Entity pointer cannot be NULL");
+  assertTrue(type < ENTITY_TYPE_COUNT, "Invalid entity type");
+  assertTrue(type != ENTITY_TYPE_NULL, "Cannot have NULL entity type");
+  assertTrue(
+    entity >= ENTITIES && entity < ENTITIES + ENTITY_COUNT,
+    "Entity pointer is out of bounds"
+  );
+
+  memoryZero(entity, sizeof(entity_t));
+  entity->id = (uint8_t)(entity - ENTITIES);
+  entity->type = type;
+
+  if(ENTITY_CALLBACKS[type].init != NULL) ENTITY_CALLBACKS[type].init(entity);
+}
+
+void entityUpdate(entity_t *entity) {
+  assertNotNull(entity, "Entity pointer cannot be NULL");
+  assertTrue(entity->type < ENTITY_TYPE_COUNT, "Invalid entity type");
+  assertTrue(entity->type != ENTITY_TYPE_NULL, "Cannot have NULL entity type");
+
+  // What state is the entity in?
+  if(entity->animation != ENTITY_ANIM_IDLE) {
+    // Entity is mid animation, tick it (down).
+    entity->animTime -= TIME.delta;
+    if(entity->animTime <= 0) {
+      entity->animation = ENTITY_ANIM_IDLE;
+      entity->animTime = 0;
+    }
+    return;
+  }
+
+  // Movement code.
+  if(
+    cutsceneModeIsInputAllowed() &&
+    ENTITY_CALLBACKS[entity->type].movement != NULL
+  ) {
+    ENTITY_CALLBACKS[entity->type].movement(entity);
+  }
+}
+
+void entityTurn(entity_t *entity, const entitydir_t direction) {
+  entity->direction = direction;
+  entity->animation = ENTITY_ANIM_TURN;
+  entity->animTime = ENTITY_ANIM_TURN_DURATION;
+}
+
+void entityWalk(entity_t *entity, const entitydir_t direction) {
+  // TODO: Animation, delay, etc.
+  entity->direction = direction;
+
+  // Where are we moving?
+  worldpos_t newPos = entity->position;
+  {
+    worldunits_t relX, relY;
+    entityDirGetRelative(direction, &relX, &relY);
+    newPos.x += relX;
+    newPos.y += relY;
+  }
+
+  // Get tile under foot
+  tile_t tileCurrent = mapGetTile(entity->position);
+  tile_t tileNew = mapGetTile(newPos);
+  bool_t fall = false;
+  bool_t raise = false;
+
+  // Are we walking up a ramp?
+  if(
+    tileIsRamp(tileCurrent) &&
+    (
+      // Can only walk UP the direction the ramp faces.
+      (direction+TILE_SHAPE_RAMP_SOUTH) == tileCurrent ||
+      // If diagonal ramp, can go up one of two ways only.
+      (
+        (
+          tileCurrent == TILE_SHAPE_RAMP_SOUTHEAST &&
+          (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_EAST)
+        ) ||
+        (
+          tileCurrent == TILE_SHAPE_RAMP_SOUTHWEST &&
+          (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_WEST)
+        ) ||
+        (
+          tileCurrent == TILE_SHAPE_RAMP_NORTHEAST &&
+          (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_EAST)
+        ) ||
+        (
+          tileCurrent == TILE_SHAPE_RAMP_NORTHWEST &&
+          (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_WEST)
+        )
+      )
+    // Must be able to walk up.
+    )
+  ) {
+    tileNew = TILE_SHAPE_NULL;// Force check for ramp above.
+    worldpos_t abovePos = newPos;
+    abovePos.z += 1;
+    tile_t tileAbove = mapGetTile(abovePos);
+
+    if(tileAbove != TILE_SHAPE_NULL && tileIsWalkable(tileAbove)) {
+      // We can go up the ramp.
+      raise = true;
+    }
+  } else if(tileNew == TILE_SHAPE_NULL && newPos.z > 0) {
+    // Falling down?
+    worldpos_t belowPos = newPos;
+    belowPos.z -= 1;
+    tile_t tileBelow = mapGetTile(belowPos);
+    if(
+      tileBelow != TILE_SHAPE_NULL &&
+      tileIsRamp(tileBelow) &&
+      (
+        // This handles regular cardinal ramps
+        (entityDirGetOpposite(direction)+TILE_SHAPE_RAMP_SOUTH) == tileBelow ||
+        // This handles diagonal ramps
+        (
+          (
+            tileBelow == TILE_SHAPE_RAMP_SOUTHEAST &&
+            (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_WEST)
+          ) ||
+          (
+            tileBelow == TILE_SHAPE_RAMP_SOUTHWEST &&
+            (direction == ENTITY_DIR_NORTH || direction == ENTITY_DIR_EAST)
+          ) ||
+          (
+            tileBelow == TILE_SHAPE_RAMP_NORTHEAST &&
+            (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_WEST)
+          ) ||
+          (
+            tileBelow == TILE_SHAPE_RAMP_NORTHWEST &&
+            (direction == ENTITY_DIR_SOUTH || direction == ENTITY_DIR_EAST)
+          )
+        )
+      )
+    ) {
+      // We will fall to this tile.
+      fall = true;
+    }
+  }
+
+  // Can we walk here?
+  if(!raise && !fall && !tileIsWalkable(tileNew)) return;// Blocked
+
+  // Entity in way?
+  entity_t *other = ENTITIES;
+  do {
+    if(other == entity) continue;
+    if(other->type == ENTITY_TYPE_NULL) continue;
+    if(!worldPosIsEqual(other->position, newPos)) continue;
+    return;// Blocked
+  } while(++other, other < &ENTITIES[ENTITY_COUNT]);
+
+  entity->lastPosition = entity->position;
+  entity->position = newPos;
+  entity->animation = ENTITY_ANIM_WALK;
+  entity->animTime = ENTITY_ANIM_WALK_DURATION;// TODO: Running vs walking
+
+  if(raise) {
+    entity->position.z += 1;
+  } else if(fall) {
+    entity->position.z -= 1;
+  }
+}
+
+entity_t * entityGetAt(const worldpos_t position) {
+  entity_t *ent = ENTITIES;
+  do {
+    if(ent->type == ENTITY_TYPE_NULL) continue;
+    if(!worldPosIsEqual(ent->position, position)) continue;
+    return ent;
+  } while(++ent, ent < &ENTITIES[ENTITY_COUNT]);
+
+  return NULL;
+}
+
+uint8_t entityGetAvailable() {
+  entity_t *ent = ENTITIES;
+  do {
+    if(ent->type == ENTITY_TYPE_NULL) return ent - ENTITIES;
+  } while(++ent, ent < &ENTITIES[ENTITY_COUNT]);
+
+  return 0xFF;
+}

archive/rpg/entity/entity.h

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "entitydir.h"
+#include "entityanim.h"
+#include "entitytype.h"
+#include "npc.h"
+
+typedef struct map_s map_t;
+
+typedef struct entity_s {
+  uint8_t id;
+  entitytype_t type;
+  entitytypedata_t data;
+
+  // Movement
+  entitydir_t direction;
+  worldpos_t position;
+  worldpos_t lastPosition;
+
+  entityanim_t animation;
+  float_t animTime;
+} entity_t;
+
+extern entity_t ENTITIES[ENTITY_COUNT];
+
+/**
+ * Initializes an entity structure.
+ * 
+ * @param entity Pointer to the entity structure to initialize.
+ * @param type The type of the entity.
+ */
+void entityInit(entity_t *entity, const entitytype_t type);
+
+/**
+ * Updates an entity.
+ * 
+ * @param entity Pointer to the entity structure to update.
+ */
+void entityUpdate(entity_t *entity);
+
+/**
+ * Turn an entity to face a new direction.
+ * 
+ * @param entity Pointer to the entity to turn.
+ * @param direction The direction to face.
+ */
+void entityTurn(entity_t *entity, const entitydir_t direction);
+
+/**
+ * Make an entity walk in a direction.
+ * 
+ * @param entity Pointer to the entity to make walk.
+ * @param direction The direction to walk in.
+ */
+void entityWalk(entity_t *entity, const entitydir_t direction);
+
+/**
+ * Gets the entity at a specific world position.
+ * 
+ * @param map Pointer to the map to check.
+ * @param pos The world position to check.
+ * @return Pointer to the entity at the position, or NULL if none.
+ */
+entity_t *entityGetAt(const worldpos_t pos);
+
+/**
+ * Gets an available entity index.
+ * 
+ * @return The index of an available entity, or 0xFF if none are available.
+ */
+uint8_t entityGetAvailable();

archive/rpg/entity/entityanim.c

@@ -5,4 +5,5 @@
  * https://opensource.org/licenses/MIT
  */
 
-#include "display/render.h"
+#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

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "entitydir.h"
+#include "assert/assert.h"
+
+entitydir_t entityDirGetOpposite(const entitydir_t dir) {
+  switch(dir) {
+    case ENTITY_DIR_NORTH: return ENTITY_DIR_SOUTH;
+    case ENTITY_DIR_SOUTH: return ENTITY_DIR_NORTH;
+    case ENTITY_DIR_EAST:  return ENTITY_DIR_WEST;
+    case ENTITY_DIR_WEST:  return ENTITY_DIR_EAST;
+    default: return dir;
+  }
+}
+
+void entityDirGetRelative(
+  const entitydir_t from,
+  worldunits_t *outX,
+  worldunits_t *outY
+) {
+  assertValidEntityDir(from, "Invalid direction provided");
+  assertNotNull(outX, "Output X pointer cannot be NULL");
+  assertNotNull(outY, "Output Y pointer cannot be NULL");
+
+  switch(from) {
+    case ENTITY_DIR_NORTH:
+      *outX = 0;
+      *outY = -1;
+      break;
+
+    case ENTITY_DIR_EAST:
+      *outX = 1;
+      *outY = 0;
+      break;
+
+    case ENTITY_DIR_SOUTH:
+      *outX = 0;
+      *outY = 1;
+      break;
+
+    case ENTITY_DIR_WEST:
+      *outX = -1;
+      *outY = 0;
+      break;
+  }
+}

archive/rpg/entity/entitydir.h

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "rpg/overworld/worldpos.h"
+
+typedef enum {
+  ENTITY_DIR_UP = ENTITY_DIR_NORTH,
+  ENTITY_DIR_DOWN = ENTITY_DIR_SOUTH,
+  ENTITY_DIR_LEFT = ENTITY_DIR_WEST,
+  ENTITY_DIR_RIGHT = ENTITY_DIR_EAST,
+} entitydir_t;
+
+/**
+ * Gets the opposite direction of a given direction.
+ * 
+ * @param dir The direction to get the opposite of.
+ * @return entitydir_t The opposite direction.
+ */
+entitydir_t entityDirGetOpposite(const entitydir_t dir);
+
+/**
+ * Asserts a given direction is valid.
+ * 
+ * @param dir The direction to validate.
+ * @param msg The message to display if the assertion fails.
+ */
+#define assertValidEntityDir(dir, msg) \
+  assertTrue( \
+    (dir) == ENTITY_DIR_NORTH || \
+    (dir) == ENTITY_DIR_EAST || \
+    (dir) == ENTITY_DIR_SOUTH || \
+    (dir) == ENTITY_DIR_WEST, \
+    msg \
+  )
+
+/**
+ * Gets the relative x and y offsets for a given direction.
+ * 
+ * @param dir The direction to get offsets for.
+ * @param relX Pointer to store the relative x offset.
+ * @param relY Pointer to store the relative y offset.
+ */
+void entityDirGetRelative(
+  const entitydir_t dir, worldunits_t *relX, worldunits_t *relY
+);

archive/rpg/entity/entitytype.h

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "duskdefs.h"
+#include "rpg/entity/player.h"
+#include "npc.h"
+
+typedef uint8_t entitytype_t;
+
+typedef union {
+  player_t player;
+  npc_t npc;
+} entitytypedata_t;
+
+typedef struct {
+  /**
+   * Initialization callback for the entity type.
+   * @param entity Pointer to the entity to initialize.
+   */
+  void (*init)(entity_t *entity);
+
+  /**
+   * Movement callback for the entity type.
+   * @param entity Pointer to the entity to move.
+   */
+  void (*movement)(entity_t *entity);
+
+  /**
+   * Interaction callback for the entity type.
+   * @param player Pointer to the player entity.
+   * @param entity Pointer to the entity to interact with.
+   * @return True if the entity handled the interaction, false otherwise.
+   */
+  bool_t (*interact)(entity_t *player, entity_t *entity);
+} entitycallback_t;
+
+static const entitycallback_t ENTITY_CALLBACKS[ENTITY_TYPE_COUNT] = {
+  [ENTITY_TYPE_NULL] = { NULL },
+  
+  [ENTITY_TYPE_PLAYER] = {
+    .init = playerInit,
+    .movement = playerInput
+  },
+
+  [ENTITY_TYPE_NPC] = {
+    .init = npcInit,
+    .movement = npcMovement,
+    .interact = npcInteract
+  }
+};

archive/rpg/entity/npc.c

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "entity.h"
+#include "assert/assert.h"
+
+#include "rpg/cutscene/scene/testcutscene.h"
+#include "rpg/rpgtextbox.h"
+
+void npcInit(entity_t *entity) {
+  assertNotNull(entity, "Entity pointer cannot be NULL");
+}
+
+void npcMovement(entity_t *entity) {
+  assertNotNull(entity, "Entity pointer cannot be NULL");
+}
+
+bool_t npcInteract(entity_t *player, entity_t *npc) {
+  assertNotNull(player, "Player entity pointer cannot be NULL");
+  assertNotNull(npc, "NPC entity pointer cannot be NULL");
+
+  cutsceneSystemStartCutscene(&TEST_CUTSCENE);
+  
+  // rpgTextboxShow(RPG_TEXTBOX_POS_BOTTOM, "Hello World!");
+
+  return false;
+};

archive/rpg/entity/npc.h

@@ -0,0 +1,37 @@
+/**
+ * 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 entity_s entity_t;
+
+typedef struct {
+  void *nothing;
+} npc_t;
+
+/**
+ * Initializes an NPC entity.
+ * 
+ * @param entity Pointer to the entity structure to initialize.
+ */
+void npcInit(entity_t *entity);
+
+/**
+ * Updates an NPC entity.
+ * 
+ * @param entity Pointer to the entity structure to update.
+ */
+void npcMovement(entity_t *entity);
+
+/**
+ * Handles interaction with an NPC entity.
+ * 
+ * @param player Pointer to the player entity.
+ * @param npc Pointer to the NPC entity.
+ */
+bool_t npcInteract(entity_t *player, entity_t *npc);

archive/rpg/entity/player.c

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "entity.h"
+#include "assert/assert.h"
+#include "rpg/rpgcamera.h"
+#include "util/memory.h"
+#include "time/time.h"
+
+void playerInit(entity_t *entity) {
+  assertNotNull(entity, "Entity pointer cannot be NULL");
+}
+
+void playerInput(entity_t *entity) {
+  assertNotNull(entity, "Entity pointer cannot be NULL");
+
+  // Turn
+  const playerinputdirmap_t *dirMap = PLAYER_INPUT_DIR_MAP;
+  do {
+    if(!inputIsDown(dirMap->action)) continue;
+    if(entity->direction == dirMap->direction) continue;
+    return entityTurn(entity, dirMap->direction);
+  } while((++dirMap)->action != 0xFF);
+
+  // Walk
+  dirMap = PLAYER_INPUT_DIR_MAP;
+  do {
+    if(!inputIsDown(dirMap->action)) continue;
+    if(entity->direction != dirMap->direction) continue;
+    return entityWalk(entity, dirMap->direction);
+  } while((++dirMap)->action != 0xFF);
+
+  // Interaction
+  if(inputPressed(INPUT_ACTION_ACCEPT)) {
+    worldunit_t x, y, z;
+    {
+      worldunits_t relX, relY;
+      entityDirGetRelative(entity->direction, &relX, &relY);
+      x = entity->position.x + relX;
+      y = entity->position.y + relY;
+      z = entity->position.z;
+    }
+
+    entity_t *interact = entityGetAt((worldpos_t){ x, y, z });
+    if(interact != NULL && ENTITY_CALLBACKS[interact->type].interact != NULL) {
+      if(ENTITY_CALLBACKS[interact->type].interact(entity, interact)) return;
+    }
+  }
+  
+}

archive/rpg/entity/player.h

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "input/input.h"
+
+typedef struct entity_s entity_t;
+
+typedef struct {
+  void *nothing;
+} player_t;
+
+typedef struct {
+  inputaction_t action;
+  entitydir_t direction;
+} playerinputdirmap_t;
+
+static const playerinputdirmap_t PLAYER_INPUT_DIR_MAP[] = {
+  { INPUT_ACTION_UP, ENTITY_DIR_NORTH },
+  { INPUT_ACTION_DOWN, ENTITY_DIR_SOUTH },
+  { INPUT_ACTION_LEFT, ENTITY_DIR_WEST },
+  { INPUT_ACTION_RIGHT, ENTITY_DIR_EAST },
+
+  { 0xFF, 0xFF }
+};
+
+/**
+ * Initializes a player entity.
+ * 
+ * @param entity Pointer to the entity structure to initialize.
+ */
+void playerInit(entity_t *entity);
+
+/**
+ * Handles movement logic for the player entity.
+ * 
+ * @param entity Pointer to the player entity structure.
+ */
+void playerInput(entity_t *entity);

archive/rpg/item/inventory.h

@@ -6,9 +6,8 @@
  */
 
 #pragma once
-#include "itemtype.h"
+#include "dusk.h"
 
 typedef struct {
-  itemtype_t type;
+  void *nothing;
-  uint8_t count;
+} inventory_t;
-} itemstack_t;

archive/rpg/overworld/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Copyright (c) 2025 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    chunk.c
+    map.c
+    worldpos.c
+    tile.c
+)

archive/rpg/overworld/chunk.c

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "chunk.h"
+
+uint32_t chunkGetTileIndex(const chunkpos_t position) {
+  return (
+    (position.z * CHUNK_WIDTH * CHUNK_HEIGHT) +
+    (position.y * CHUNK_WIDTH) +
+    position.x
+  );
+}
+
+bool_t chunkPositionIsEqual(const chunkpos_t a, const chunkpos_t b) {
+  return (a.x == b.x) && (a.y == b.y) && (a.z == b.z);
+}

archive/rpg/overworld/chunk.h

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "rpg/overworld/tile.h"
+#include "worldpos.h"
+#include "display/mesh/quad.h"
+
+typedef struct chunk_s {
+  chunkpos_t position;
+  tile_t tiles[CHUNK_TILE_COUNT];
+  
+  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;
+
+/**
+ * Gets the tile index for a tile position within a chunk.
+ *
+ * @param position The position within the chunk.
+ * @return The tile index within the chunk.
+ */
+uint32_t chunkGetTileIndex(const chunkpos_t position);
+
+/**
+ * Checks if two chunk positions are equal.
+ * 
+ * @param a The first chunk position.
+ * @param b The second chunk position.
+ * @return true if equal, false otherwise.
+ */
+bool_t chunkPositionIsEqual(const chunkpos_t a, const chunkpos_t b);

archive/rpg/overworld/map.c

@@ -0,0 +1,269 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "map.h"
+#include "util/memory.h"
+#include "assert/assert.h"
+#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();
+}
+
+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"
+  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++;
+      }
+    }
+  }
+
+  // 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();
+}
+
+errorret_t mapPositionSet(const chunkpos_t newPos) {
+  if(!mapIsLoaded()) errorThrow("No map loaded");
+
+  const chunkpos_t curPos = MAP.chunkPosition;
+  if(chunkPositionIsEqual(curPos, newPos)) {
+    errorOk();
+  }
+
+  // Determine which chunks remain loaded
+  chunkindex_t chunksRemaining[MAP_CHUNK_COUNT] = {0};
+  chunkindex_t chunksFreed[MAP_CHUNK_COUNT] = {0};
+
+  uint32_t remainingCount = 0;
+  uint32_t freedCount = 0;
+
+  for(chunkindex_t i = 0; i < MAP_CHUNK_COUNT; i++) {
+    // Will this chunk remain loaded?
+    chunk_t *chunk = &MAP.chunks[i];
+    if(
+      chunk->position.x >= newPos.x &&
+      chunk->position.x < newPos.x + MAP_CHUNK_WIDTH &&
+
+      chunk->position.y >= newPos.y &&
+      chunk->position.y < newPos.y + MAP_CHUNK_HEIGHT &&
+
+      chunk->position.z >= newPos.z &&
+      chunk->position.z < newPos.z + MAP_CHUNK_DEPTH
+    ) {
+      // Stays loaded
+      chunksRemaining[remainingCount++] = i;
+      continue;
+    }
+
+    // Not remaining loaded
+    chunksFreed[freedCount++] = i;
+  }
+
+  // Unload the freed chunks
+  for(chunkindex_t i = 0; i < freedCount; i++) {
+    chunk_t *chunk = &MAP.chunks[chunksFreed[i]];
+    mapChunkUnload(chunk);
+  }
+
+  // This can probably be optimized later, for now we check each chunk and see
+  // if it needs loading or not, and update the chunk order
+  chunkindex_t orderIndex = 0;
+  for(chunkunit_t zOff = 0; zOff < MAP_CHUNK_DEPTH; zOff++) {
+    for(chunkunit_t yOff = 0; yOff < MAP_CHUNK_HEIGHT; yOff++) {
+      for(chunkunit_t xOff = 0; xOff < MAP_CHUNK_WIDTH; xOff++) {
+        const chunkpos_t newChunkPos = {
+          newPos.x + xOff, newPos.y + yOff, newPos.z + zOff
+        };
+        
+        // Is this chunk already loaded (was not unloaded earlier)?
+        chunkindex_t chunkIndex = -1;
+        for(chunkindex_t i = 0; i < remainingCount; i++) {
+          chunk_t *chunk = &MAP.chunks[chunksRemaining[i]];
+          if(!chunkPositionIsEqual(chunk->position, newChunkPos)) continue;
+          chunkIndex = chunksRemaining[i];
+          break;
+        }
+
+        // Need to load this chunk
+        if(chunkIndex == -1) {
+          // Find a freed chunk to reuse
+          chunkIndex = chunksFreed[--freedCount];
+          chunk_t *chunk = &MAP.chunks[chunkIndex];
+          chunk->position = newChunkPos;
+          errorChain(mapChunkLoad(chunk));
+        }
+
+        MAP.chunkOrder[orderIndex++] = &MAP.chunks[chunkIndex];
+      }
+    }
+  }
+
+  // Update map position
+  MAP.chunkPosition = newPos;
+
+  errorOk();
+}
+
+void mapUpdate() {
+  
+}
+
+void mapDispose() {
+  for(chunkindex_t i = 0; i < MAP_CHUNK_COUNT; i++) {
+    mapChunkUnload(&MAP.chunks[i]);
+  }
+}
+
+void mapChunkUnload(chunk_t* chunk) {
+  for(uint8_t i = 0; i < CHUNK_ENTITY_COUNT_MAX; i++) {
+    if(chunk->entities[i] == 0xFF) break;
+    entity_t *entity = &ENTITIES[chunk->entities[i]];
+    entity->type = ENTITY_TYPE_NULL;
+  }
+
+  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");
+
+  char_t buffer[64];
+
+  // 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));
+
+  // 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();
+  }
+
+  // Load.
+  errorChain(assetLoad(buffer, chunk));
+  errorOk();
+}
+
+chunkindex_t mapGetChunkIndexAt(const chunkpos_t position) {
+  if(!mapIsLoaded()) return -1;
+
+  chunkpos_t relPos = {
+    position.x - MAP.chunkPosition.x,
+    position.y - MAP.chunkPosition.y,
+    position.z - MAP.chunkPosition.z
+  };
+
+  if(
+    relPos.x < 0 || relPos.y < 0 || relPos.z < 0 ||
+    relPos.x >= MAP_CHUNK_WIDTH ||
+    relPos.y >= MAP_CHUNK_HEIGHT ||
+    relPos.z >= MAP_CHUNK_DEPTH
+  ) {
+    return -1;
+  }
+
+  return chunkPosToIndex(&relPos);
+}
+
+chunk_t* mapGetChunk(const uint8_t index) {
+  if(index >= MAP_CHUNK_COUNT) return NULL;
+  if(!mapIsLoaded()) return NULL;
+  return MAP.chunkOrder[index];
+}
+
+tile_t mapGetTile(const worldpos_t position) {
+  if(!mapIsLoaded()) return TILE_SHAPE_NULL;
+
+  chunkpos_t chunkPos;
+  worldPosToChunkPos(&position, &chunkPos);
+  chunkindex_t chunkIndex = mapGetChunkIndexAt(chunkPos);
+  if(chunkIndex == -1) return TILE_SHAPE_NULL;
+
+  chunk_t *chunk = mapGetChunk(chunkIndex);
+  assertNotNull(chunk, "Chunk pointer cannot be NULL");
+  chunktileindex_t tileIndex = worldPosToChunkTileIndex(&position);
+  return chunk->tiles[tileIndex];
+}