No need for asset batching on text.c

This reverts commit efd31237be.

.gitea/workflows/build.yml

@@ -1,58 +0,0 @@
-name: Build Dusk
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  build-linux:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-      - name: Install dependencies
-        run: |
-          apt-get update
-          apt-get install -y build-essential cmake python3 python3-pip python3-polib python3-pil libsdl2-dev libgl1-mesa-dev libzip-dev python3-dotenv python3-pyqt5 python3-opengl
-      - name: Configure CMake
-        run: cmake -S . -B build -DDUSK_TARGET_SYSTEM=linux
-      - name: Build
-        run: cmake --build build -- -j$(nproc)
-      - name: List build output
-        run: ls -lh build
-      - name: Upload Linux binary
-        uses: actions/upload-artifact@v3
-        with:
-          name: dusk-linux
-          path: build/Dusk
-          if-no-files-found: error
-
-  build-psp:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-      - name: Install dependencies
-        run: |
-          apt-get update
-          apt-get install -y build-essential cmake python3 python3-pip python3-polib python3-pil libsdl2-dev libgl1-mesa-dev libzip-dev python3-dotenv python3-pyqt5 python3-opengl
-      - name: Configure CMake
-        run: cmake -S . -B build -DDUSK_TARGET_SYSTEM=psp
-      - name: Build
-        run: cmake --build build -- -j$(nproc)
-      - name: Move EBOOT.PBP to Dusk subfolder
-        run: |
-          mkdir -p build/gitea/Dusk
-          mv build/EBOOT.PBP build/gitea/Dusk/EBOOT.PBP
-      - name: List build output
-        run: ls -lh build/gitea/Dusk
-      - name: Upload PSP binary
-        uses: actions/upload-artifact@v3
-        with:
-          name: dusk-psp
-          path: build/gitea/
-          if-no-files-found: error

.github/workflows/build.yml

@@ -0,0 +1,177 @@
+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-vita:
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - name: Checkout repository
+  #       uses: actions/checkout@v6
+  #     - name: Set up Docker
+  #       uses: docker/setup-docker-action@v5
+  #     - name: Build Vita
+  #       run: ./scripts/build-vita-docker.sh
+  #     - name: Upload Vita binary
+  #       uses: actions/upload-artifact@v6
+  #       with:
+  #         name: dusk-vita
+  #         path: build-vita/Dusk.vpk
+  #         if-no-files-found: error
+
+  build-knulli:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build knulli
+        run: ./scripts/build-knulli-docker.sh
+      - name: Move output to Dusk subfolder
+        run: |
+          mkdir -p ./git-artifcats/Dusk
+          cp -r build-knulli/dusk ./git-artifcats/Dusk
+      - name: Upload knulli binary
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-knulli
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-gamecube:
+    runs-on: ubuntu-latest
+    steps:
+      - 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-gamecube-iso:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build GameCube ISO
+        run: ./scripts/build-gamecube-iso-docker.sh
+      - name: Copy output files.
+        run: |
+          mkdir -p ./git-artifcats/Dusk
+          cp build-gamecube-iso/Dusk-NTSC-J.iso ./git-artifcats/Dusk/Dusk-NTSC-J.iso
+          cp build-gamecube-iso/Dusk-NTSC-U.iso ./git-artifcats/Dusk/Dusk-NTSC-U.iso
+          cp build-gamecube-iso/Dusk-PAL.iso    ./git-artifcats/Dusk/Dusk-PAL.iso
+      - name: Upload GameCube ISO
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-gamecube-iso
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-wii:
+    runs-on: ubuntu-latest
+    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 build-wii/meta.xml ./git-artifcats/Dusk/apps/Dusk/meta.xml
+      - name: Upload Wii binary
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-wii
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-wii-iso:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build Wii ISO
+        run: ./scripts/build-wii-iso-docker.sh
+      - name: Copy output files.
+        run: |
+          mkdir -p ./git-artifcats/Dusk
+          cp build-wii-iso/Dusk-NTSC-J.iso ./git-artifcats/Dusk/Dusk-NTSC-J.iso
+          cp build-wii-iso/Dusk-NTSC-U.iso ./git-artifcats/Dusk/Dusk-NTSC-U.iso
+          cp build-wii-iso/Dusk-PAL.iso    ./git-artifcats/Dusk/Dusk-PAL.iso
+      - name: Upload Wii ISO
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-wii-iso
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error

.gitignore

@@ -83,7 +83,6 @@ assets/borrowed
 .VSCode*
 
 /vita
-
 ._*
 
 *~
@@ -101,4 +100,9 @@ yarn-error.log
 yarn.lock
 
 .editor
-.venv
+.venv
+
+/build2
+/build*
+/assets/test
+/tools_old

CMakeLists.txt

@@ -5,14 +5,20 @@
 
 # Setup
 cmake_minimum_required(VERSION 3.13)
+
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
+cmake_policy(SET CMP0079 NEW)
+# set(FETCHCONTENT_UPDATES_DISCONNECTED ON)
 
-if(NOT DEFINED DUSK_TARGET_SYSTEM)
-  set(DUSK_TARGET_SYSTEM "linux")
-  #set(DUSK_TARGET_SYSTEM "psp")
-endif()
+option(DUSK_BUILD_TESTS "Enable tests" OFF)
+
+# Game identity — override these per-project
+set(DUSK_GAME_NAME              "Dusk"               CACHE STRING "Game display name")
+set(DUSK_GAME_AUTHOR            "YouWish"             CACHE STRING "Game author / coder")
+set(DUSK_GAME_SHORT_DESCRIPTION "Dusk game"           CACHE STRING "One-line description")
+set(DUSK_GAME_LONG_DESCRIPTION  "No description yet." CACHE STRING "Full description")
 
 # Prep cache
 set(DUSK_CACHE_TARGET "dusk-target")
@@ -21,100 +27,105 @@ 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_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})
+
+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_TEMP_DIR})
+file(MAKE_DIRECTORY ${DUSK_BUILT_ASSETS_DIR})
 
-# Find packages
+# Required build packages
 find_package(Python3 COMPONENTS Interpreter REQUIRED)
 
-# Toolchains
-if(DUSK_TARGET_SYSTEM STREQUAL "psp")
-  find_package(pspsdk REQUIRED)
-endif()
-
-# Init Project
-project(${DUSK_TARGET_NAME}
+# Init Project.
+project(${DUSK_LIBRARY_TARGET_NAME}
   VERSION 1.0.0
   LANGUAGES C
 )
 
-# Executable
-add_executable(${DUSK_TARGET_NAME})
+# Either, create library and binary separately (used for tests), or make them
+# 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()
+
+if(NOT DEFINED DUSK_VERSION)
+  string(TIMESTAMP DUSK_VERSION "debug-%y%m%d%H%M%S")
+endif()
+
+# Definitions
+target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    DUSK_TARGET_SYSTEM="${DUSK_TARGET_SYSTEM}"
+    DUSK_GAME_NAME="${DUSK_GAME_NAME}"
+    DUSK_GAME_AUTHOR="${DUSK_GAME_AUTHOR}"
+    DUSK_GAME_SHORT_DESCRIPTION="${DUSK_GAME_SHORT_DESCRIPTION}"
+    DUSK_GAME_LONG_DESCRIPTION="${DUSK_GAME_LONG_DESCRIPTION}"
+    DUSK_VERSION="${DUSK_VERSION}"
+)
+
+# Toolchains
+include(cmake/targets/${DUSK_TARGET_SYSTEM}.cmake)
 
 # Add tools
 add_subdirectory(tools)
 
-# Assets
-add_subdirectory(assets)
-
-# Add libraries
-if(DUSK_TARGET_SYSTEM STREQUAL "linux")
-  find_package(SDL2 REQUIRED)
-  find_package(OpenGL REQUIRED)
-  target_link_libraries(${DUSK_TARGET_NAME} PRIVATE 
-    SDL2
-    OpenGL::GL
-    GL
-  )
-
-elseif(DUSK_TARGET_SYSTEM STREQUAL "psp")
-  find_package(SDL2 REQUIRED)
-  find_package(OpenGL REQUIRED)
-  target_link_libraries(${DUSK_TARGET_NAME} PUBLIC
-    ${SDL2_LIBRARIES}
-    SDL2
-    OpenGL::GL
-    zip
-    bz2
-    z
-    mbedtls
-    mbedcrypto
-    lzma
-  )
-  target_include_directories(${DUSK_TARGET_NAME} PRIVATE
-    ${SDL2_INCLUDE_DIRS}
-  )
-endif()
-
-# Add code
-add_subdirectory(src)
-
-# Build assets
-add_custom_target(DUSK_ASSETS_BUILT ALL
-  COMMAND
-    ${Python3_EXECUTABLE} ${DUSK_TOOLS_DIR}/assettool.py
-      --assets ${DUSK_GAME_ASSETS_DIR}
-      --output-assets ${DUSK_BUILT_ASSETS_DIR}
-      --output-file ${DUSK_BUILD_DIR}/dusk.dsk
-      --headers-dir ${DUSK_GENERATED_HEADERS_DIR}
-      --input ${DUSK_ASSETS}
-)
-add_dependencies(${DUSK_TARGET_NAME} DUSK_ASSETS_BUILT)
-
-# Include generated headers
-target_include_directories(${DUSK_TARGET_NAME} PUBLIC
+# Include generated headers from tools.
+target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   ${DUSK_GENERATED_HEADERS_DIR}
 )
 
-# Postbuild
-if(DUSK_TARGET_SYSTEM STREQUAL "psp")
-  create_pbp_file(
-    TARGET "${DUSK_TARGET_NAME}"
-    ICON_PATH NULL
-    BACKGROUND_PATH NULL
-    PREVIEW_PATH NULL
-    TITLE "${DUSK_TARGET_NAME}"
-    PSAR_PATH ${DUSK_BUILD_DIR}/dusk.dsk
-    VERSION 01.00
-  )
+# Add main code
+add_subdirectory(${DUSK_SOURCES_DIR})
+
+# Include generated headers
+target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
+  ${DUSK_GENERATED_HEADERS_DIR}
+)
+
+# 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

@@ -9,7 +9,7 @@ following packages, depending on your system;
 
 Fedora;
 ```
-sudo dnf install git make gcc python python-polib python3-pillow python3-dotenv python3-numpy python-qt5 python3-pyopengl
+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;

archive/asset/bundle/__main__.py

@@ -1,10 +1,10 @@
 import sys, os
-from assetstool.args import args
-from assetstool.processasset import processAsset
-from assetstool.processpalette import processPaletteList
-from assetstool.processtileset import processTilesetList
-from assetstool.processlanguage import processLanguageList
-from assetstool.assethelpers import getBuiltAssetsRelativePath
+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.

archive/asset/path.py

@@ -1,5 +1,5 @@
 import os
-from assetstool.args import args
+from tools.asset.args import args
 
 def getAssetRelativePath(fullPath):
   # Get the relative path to the asset

archive/asset/process/asset.py

@@ -1,11 +1,11 @@
 import sys
 # from processtileset import processTileset
-from assetstool.processimage import processImage
-from assetstool.processpalette import processPalette
-from assetstool.processtileset import processTileset
-from assetstool.processmap import processMap
-from assetstool.processlanguage import processLanguage
-from assetstool.processscript import processScript
+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 = []
 

archive/asset/process/image.py

@@ -1,10 +1,10 @@
 import os
 import sys
 from PIL import Image
-from assetstool.processpalette import extractPaletteFromImage, palettes
-from assetstool.args import args
-from assetstool.assethelpers import getAssetRelativePath
-from assetstool.assetcache import assetGetCache, assetCache
+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 = []
 
@@ -35,10 +35,24 @@ def processPalettizedImage(asset):
   imagePalette = extractPaletteFromImage(image)
 
   # Find palette that contains every color
-  for palette in palettes:
-    if all(color in palette['pixels'] for color in imagePalette):
+  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
-  else:
+    
+  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

archive/asset/process/language.py

@@ -1,9 +1,9 @@
 import sys
 import os
-from assetstool.args import args
-from assetstool.assetcache import assetCache, assetGetCache
-from assetstool.assethelpers import getAssetRelativePath
-from dusk.defs import defs
+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
 
@@ -141,14 +141,49 @@ def processLanguageList():
     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
   }

archive/asset/process/map.py

@@ -2,12 +2,12 @@ import struct
 import sys
 import os
 import json
-from assetstool.args import args
-from assetstool.assetcache import assetCache, assetGetCache
-from assetstool.assethelpers import getAssetRelativePath
-from dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, CHUNK_TILE_COUNT
-from dusk.map import Map
-from dusk.chunk import Chunk
+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 
@@ -51,7 +51,7 @@ def processChunk(chunk):
 
   # Generate binary buffer for efficient output
   buffer = bytearray()
-  buffer.extend(b'DCF')# Header
+  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
@@ -92,7 +92,7 @@ def processChunk(chunk):
   # 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}.dcf")
+  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:
@@ -111,11 +111,11 @@ def processMap(asset):
 
   map = Map(None)
   map.load(asset['path'])
-  dir = map.getMapDirectory()
+  chunksDir = map.getChunkDirectory()
 
-  files = os.listdir(dir)
+  files = os.listdir(chunksDir)
   if len(files) == 0:
-    print(f"Error: No chunk files found in map directory {dir}.")
+    print(f"Error: No chunk files found in {chunksDir}.")
     sys.exit(1)
 
   chunkFiles = []
@@ -133,21 +133,22 @@ def processMap(asset):
     result = processChunk(chunk)
     chunkFiles.extend(result['files'])
 
-  outMap = {
-    'files': chunkFiles
-  }
-  return assetCache(asset['path'], outMap)
-
-  # List files
-  chunkFiles = []
-  for fileName in os.listdir(asset['path']):
-    if not fileName.endswith('.json'):
-      continue
-    result = processChunk(os.path.join(asset['path'], fileName))
-    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

@@ -1,8 +1,9 @@
+import json
 import os
 from PIL import Image
 import datetime
-from assetstool.args import args
-from assetstool.assetcache import assetCache, assetGetCache
+from tools.asset.args import args
+from tools.asset.cache import assetCache, assetGetCache
 
 palettes = []
 
@@ -78,6 +79,7 @@ def processPalette(asset):
 
 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"

archive/asset/process/script.py

@@ -1,9 +1,9 @@
 import sys
 import os
-from assetstool.args import args
-from assetstool.assetcache import assetCache, assetGetCache
-from assetstool.assethelpers import getAssetRelativePath
-from dusk.defs import defs
+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'])
@@ -16,6 +16,10 @@ def processScript(asset):
     
   # 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"

archive/asset/process/tileset.py

@@ -3,10 +3,10 @@ import sys
 import os
 import datetime
 from xml.etree import ElementTree
-from assetstool.processimage import processImage
-from assetstool.assethelpers import getAssetRelativePath
-from assetstool.args import args
-from assetstool.assetcache import assetGetCache, assetCache
+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 = []
 
@@ -126,6 +126,7 @@ def processTileset(asset):
   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"

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/camera/CMakeLists.txt

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

archive/camera/camera.c

@@ -0,0 +1,107 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "camera.h"
+#include "display/display.h"
+#include "assert/assert.h"
+#include "display/framebuffer/framebuffer.h"
+#include "display/screen/screen.h"
+
+void cameraInit(camera_t *camera) {
+  cameraInitPerspective(camera);
+}
+
+void cameraInitPerspective(camera_t *camera) {
+  assertNotNull(camera, "Not a camera component");
+
+  camera->projType = CAMERA_PROJECTION_TYPE_PERSPECTIVE;
+  camera->perspective.fov = glm_rad(45.0f);
+  camera->nearClip = 0.1f;
+  camera->farClip = 10000.0f;
+
+  camera->viewType = CAMERA_VIEW_TYPE_LOOKAT;
+  glm_vec3_copy((vec3){ 5.0f, 5.0f, 5.0f }, camera->lookat.position);
+  glm_vec3_copy((vec3){ 0.0f, 1.0f, 0.0f }, camera->lookat.up);
+  glm_vec3_copy((vec3){ 0.0f, 0.0f, 0.0f }, camera->lookat.target);
+}
+
+void cameraInitOrthographic(camera_t *camera) {
+  assertNotNull(camera, "Not a camera component");
+
+  camera->projType = CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC;
+  camera->orthographic.left = 0.0f;
+  camera->orthographic.right = SCREEN.width;
+  camera->orthographic.top = SCREEN.height;
+  camera->orthographic.bottom = 0.0f;
+  camera->nearClip = 0.1f;
+  camera->farClip = 1.0f;
+
+  camera->viewType = CAMERA_VIEW_TYPE_2D;
+  glm_vec2_copy((vec2){ 0.0f, 0.0f }, camera->_2d.position);
+  camera->_2d.zoom = 1.0f;
+}
+
+void cameraGetProjectionMatrix(camera_t *camera, mat4 dest) {
+  assertNotNull(camera, "Not a camera component");
+  assertNotNull(dest, "Destination matrix must not be null");
+
+  if(
+    camera->projType == CAMERA_PROJECTION_TYPE_PERSPECTIVE ||
+    camera->projType == CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED
+  ) {
+    glm_mat4_identity(dest);
+    glm_perspective(
+      camera->perspective.fov,
+      SCREEN.aspect,
+      camera->nearClip,
+      camera->farClip,
+      dest
+    );
+
+    if(camera->projType == CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED) {
+      dest[1][1] *= -1.0f;
+    }
+  } else if(camera->projType == CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC) {
+    glm_mat4_identity(dest);
+    glm_ortho(
+      camera->orthographic.left,
+      camera->orthographic.right,
+      camera->orthographic.top,
+      camera->orthographic.bottom,
+      camera->nearClip,
+      camera->farClip,
+      dest
+    );
+  }
+}
+
+void cameraGetViewMatrix(camera_t *camera, mat4 dest) {
+  assertNotNull(camera, "Not a camera component");
+  assertNotNull(dest, "Destination matrix must not be null");
+
+  if(camera->viewType == CAMERA_VIEW_TYPE_MATRIX) {
+    glm_mat4_ucopy(camera->view, dest);
+  } else if(camera->viewType == CAMERA_VIEW_TYPE_LOOKAT) {
+    glm_mat4_identity(dest);
+    glm_lookat(
+      camera->lookat.position,
+      camera->lookat.target,
+      camera->lookat.up,
+      dest
+    );
+  } else if(camera->viewType == CAMERA_VIEW_TYPE_2D) {
+    glm_mat4_identity(dest);
+    glm_lookat(
+      (vec3){ camera->_2d.position[0], camera->_2d.position[1], 0.5f },
+      (vec3){ camera->_2d.position[0], camera->_2d.position[1], 0.0f },
+      (vec3){ 0.0f, 1.0f, 0.0f },
+      dest
+    );
+  } else if(camera->viewType == CAMERA_VIEW_TYPE_LOOKAT_PIXEL_PERFECT) {
+    assertUnreachable("LOOKAT_PIXEL_PERFECT view type is not implemented yet");
+  }
+}

archive/camera/camera.h

@@ -8,14 +8,12 @@
 #pragma once
 #include "dusk.h"
 #include "display/color.h"
+#include "display/camera/cameraplatform.h"
 
-#define CAMERA_COUNT_MAX 4
+#ifndef cameraPushMatrixPlatform
+  #error "cameraPushMatrixPlatform must be defined"
+#endif
 
-typedef enum {
-  CAMERA_PROJECTION_TYPE_PERSPECTIVE,
-  CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED,
-  CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC
-} cameraprojectiontype_t;
 
 typedef enum {
   CAMERA_VIEW_TYPE_MATRIX,
@@ -24,28 +22,25 @@ typedef enum {
   CAMERA_VIEW_TYPE_LOOKAT_PIXEL_PERFECT
 } cameraviewtype_t;
 
-typedef struct {
-  cameraprojectiontype_t projType;
-  cameraviewtype_t viewType;
-
+typedef struct camera_s {
   union {
     mat4 view;
 
     struct {
-      float_t position[3];
-      float_t target[3];
-      float_t up[3];
+      vec3 position;
+      vec3 target;
+      vec3 up;
     } lookat;
 
     struct {
-      float_t offset[3];
-      float_t target[3];
-      float_t up[3];
+      vec3 offset;
+      vec3 target;
+      vec3 up;
       float_t pixelsPerUnit;
     } lookatPixelPerfect;
 
     struct {
-      float_t position[2];
+      vec2 position;
       float_t zoom;
     } _2d;
   };
@@ -65,6 +60,9 @@ typedef struct {
   
   float_t nearClip;
   float_t farClip;
+  
+  cameraprojectiontype_t projType;
+  cameraviewtype_t viewType;
 } camera_t;
 
 /**
@@ -83,13 +81,17 @@ void cameraInitPerspective(camera_t *camera);
 void cameraInitOrthographic(camera_t *camera);
 
 /**
- * Pushes the camera's view matrix onto the matrix stack.
+ * Gets the projection matrix for a camera.
  * 
- * @param id The ID of the camera entity to use.
+ * @param camera Camera to get the projection matrix for
+ * @param dest Matrix to store the projection matrix in
  */
-void cameraPushMatrix(camera_t* camera);
+void cameraGetProjectionMatrix(camera_t *camera, mat4 dest);
 
 /**
- * Pops the camera's view matrix off the matrix stack.
+ * Gets the view matrix for a camera.
+ * 
+ * @param camera Camera to get the view matrix for
+ * @param dest Matrix to store the view matrix in
  */
-void cameraPopMatrix(void);
+void cameraGetViewMatrix(camera_t *camera, mat4 dest);

archive/dusk/chunk.py

@@ -1,11 +1,11 @@
 import json
 import os
-from dusk.event import Event
-from dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, CHUNK_VERTEX_COUNT_MAX, TILE_SHAPE_NULL
-from dusk.tile import Tile
-from dusk.entity import Entity
-from dusk.region import Region
-from editortool.map.vertexbuffer import VertexBuffer
+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:
@@ -131,12 +131,12 @@ class Chunk:
     return self.dirty
 
   def getFilename(self):
-    if not self.map or not hasattr(self.map, 'getMapDirectory'):
+    if not self.map or not hasattr(self.map, 'getChunkDirectory'):
       return None
-    dir_path = self.map.getMapDirectory()
-    if dir_path is None:
+    dirPath = self.map.getChunkDirectory()
+    if dirPath is None:
       return None
-    return f"{dir_path}/{self.x}_{self.y}_{self.z}.json"
+    return f"{dirPath}/{self.x}_{self.y}_{self.z}.json"
   
   def draw(self):
     self.vertexBuffer.draw()

archive/dusk/defs.py

@@ -1,4 +1,4 @@
-from dotenv import load_dotenv
+from dotenv import load_dotenv, dotenv_values
 import os
 import sys
 
@@ -13,6 +13,8 @@ if not os.path.isfile(duskDefsPath):
 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'))

archive/dusk/entity.py

@@ -1,5 +1,5 @@
-from dusk.defs import ENTITY_TYPE_NULL, ENTITY_TYPE_NPC, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
-from editortool.map.vertexbuffer import VertexBuffer
+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):

archive/dusk/map.py

@@ -1,10 +1,11 @@
 import json
-from dusk.event import Event
+import sys
+from tools.dusk.event import Event
 from PyQt5.QtWidgets import QFileDialog, QMessageBox
 from PyQt5.QtCore import QTimer
 import os
-from dusk.chunk import Chunk
-from dusk.defs import MAP_WIDTH, MAP_HEIGHT, MAP_DEPTH, CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH
+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/')
@@ -129,11 +130,17 @@ class Map:
     return self.mapFileName if self.mapFileName and os.path.exists(self.mapFileName) else None
 
   def getMapDirectory(self):
-    fname = self.getMapFilename()
-    if not fname or not fname.endswith('.json'):
+    if self.mapFileName is None:
       return None
-    return fname[:-5]  # Remove '.json' extension
-
+    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():
@@ -149,7 +156,7 @@ class Map:
     newTopLeftChunkY = y // CHUNK_HEIGHT - (MAP_HEIGHT // 2)
     newTopLeftChunkZ = z // CHUNK_DEPTH - (MAP_DEPTH // 2)
 
-    if (newTopLeftChunkX != self.topLeftX or
+    if(newTopLeftChunkX != self.topLeftX or
         newTopLeftChunkY != self.topLeftY or
         newTopLeftChunkZ != self.topLeftZ):
       
@@ -159,7 +166,7 @@ class Map:
         chunkWorldX = chunk.x
         chunkWorldY = chunk.y
         chunkWorldZ = chunk.z
-        if (chunkWorldX < newTopLeftChunkX or
+        if(chunkWorldX < newTopLeftChunkX or
             chunkWorldX >= newTopLeftChunkX + MAP_WIDTH or
             chunkWorldY < newTopLeftChunkY or
             chunkWorldY >= newTopLeftChunkY + MAP_HEIGHT or

archive/dusk/region.py

@@ -1,5 +1,5 @@
-from dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
-from editortool.map.vertexbuffer import VertexBuffer
+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 *
 

archive/dusk/tile.py

@@ -1,5 +1,5 @@
 from OpenGL.GL import *
-from dusk.defs import (
+from tools.dusk.defs import (
   TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH,
   CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH,
   TILE_SHAPE_NULL, TILE_SHAPE_FLOOR,

archive/editor/__main__.py

@@ -6,9 +6,9 @@ from PyQt5.QtWidgets import (
 )
 from OpenGL.GL import *
 from OpenGL.GLU import *
-from editortool.maptool import MapWindow
-from editortool.langtool import LangToolWindow
-from editortool.cutscenetool import CutsceneToolWindow
+from tools.editor.maptool import MapWindow
+from tools.editor.langtool import LangToolWindow
+from tools.editor.cutscenetool import CutsceneToolWindow
 
 DEFAULT_TOOL = None
 DEFAULT_TOOL = "map"

archive/editor/cutscenetool.py

@@ -1,7 +1,7 @@
 from PyQt5.QtWidgets import QMainWindow, QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QListWidget, QListWidgetItem, QMenuBar, QAction, QFileDialog, QMessageBox
 from PyQt5.QtGui import QKeySequence
-from editortool.cutscene.cutsceneitemeditor import CutsceneItemEditor
-from editortool.cutscene.cutscenemenubar import CutsceneMenuBar
+from tools.editor.cutscene.cutsceneitemeditor import CutsceneItemEditor
+from tools.editor.cutscene.cutscenemenubar import CutsceneMenuBar
 import sys
 
 class CutsceneToolWindow(QMainWindow):

archive/editor/map/camera.py

@@ -2,7 +2,7 @@ import math
 import time
 from OpenGL.GL import *
 from OpenGL.GLU import *
-from dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH, RPG_CAMERA_PIXELS_PER_UNIT, RPG_CAMERA_Z_OFFSET, RPG_CAMERA_FOV
+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):

archive/editor/map/chunkpanel.py

@@ -1,5 +1,5 @@
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QGridLayout, QTreeWidget, QTreeWidgetItem, QComboBox
-from dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_SHAPES
+from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_SHAPES
 
 class ChunkPanel(QWidget):
   def __init__(self, parent):

archive/editor/map/entitypanel.py

@@ -1,7 +1,7 @@
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QComboBox, QHBoxLayout, QPushButton, QLineEdit, QListWidget, QListWidgetItem
 from PyQt5.QtCore import Qt
-from dusk.entity import Entity
-from dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, ENTITY_TYPES, ENTITY_TYPE_NULL
+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):

archive/editor/map/grid.py

@@ -1,5 +1,5 @@
 from OpenGL.GL import *
-from dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
+from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
 
 class Grid:
   def __init__(self, lines=1000):

archive/editor/map/mapinfopanel.py

@@ -1,5 +1,5 @@
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QLineEdit, QPushButton, QHBoxLayout, QMessageBox
-from dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH
+from tools.dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH
 
 class MapInfoPanel(QWidget):
   def __init__(self, parent):

archive/editor/map/mapleftpanel.py

@@ -1,7 +1,7 @@
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QGridLayout, QPushButton, QTabWidget, QLabel
-from editortool.map.chunkpanel import ChunkPanel
-from editortool.map.entitypanel import EntityPanel
-from editortool.map.regionpanel import RegionPanel
+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):

archive/editor/map/menubar.py

@@ -1,7 +1,7 @@
 import os
 from PyQt5.QtWidgets import QAction, QMenuBar, QFileDialog
 from PyQt5.QtGui import QKeySequence
-from dusk.map import MAP_DEFAULT_PATH
+from tools.dusk.map import MAP_DEFAULT_PATH
 
 class MapMenubar:
   def __init__(self, parent):

archive/editor/map/regionpanel.py

@@ -1,7 +1,7 @@
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel, QComboBox, QHBoxLayout, QPushButton, QLineEdit, QListWidget, QListWidgetItem
 from PyQt5.QtCore import Qt
-from dusk.entity import Entity
-from dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, ENTITY_TYPES, ENTITY_TYPE_NULL
+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):

archive/editor/map/selectbox.py

@@ -1,7 +1,7 @@
 import OpenGL.GL as gl
-from dusk.defs import defs
+from tools.dusk.defs import defs
 import colorsys
-from dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
+from tools.dusk.defs import TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH
 
 class SelectBox:
   def __init__(self, parent):

archive/editor/maptool.py

@@ -1,16 +1,16 @@
 import os
 from PyQt5.QtWidgets import QMainWindow, QWidget, QHBoxLayout, QMessageBox
 from PyQt5.QtCore import Qt
-from editortool.map.glwidget import GLWidget
-from editortool.map.mapleftpanel import MapLeftPanel
-from editortool.map.mapinfopanel import MapInfoPanel
-from editortool.map.menubar import MapMenubar
-from editortool.map.statusbar import StatusBar
-from dusk.map import Map
-from dusk.defs import CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, TILE_SHAPE_NULL, TILE_SHAPE_FLOOR
-from editortool.map.selectbox import SelectBox
-from editortool.map.camera import Camera
-from editortool.map.grid import Grid
+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):

archive/loader/CMakeLists.txt

@@ -4,12 +4,10 @@
 # https://opensource.org/licenses/MIT
 
 # Sources
-target_sources(${DUSK_TARGET_NAME}
-  PRIVATE
-    assetalphaimage.c
-    assetpaletteimage.c
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    assettexture.c
+    assettileset.c
     assetlanguage.c
-    assetmap.c
-    assetchunk.c
     assetscript.c
 )

archive/loader/assetlanguage.c

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "asset/asset.h"
+#include "assert/assert.h"
+#include "locale/localemanager.h"
+
+errorret_t assetLanguageHandler(assetcustom_t custom) {
+  assertNotNull(custom.zipFile, "Custom asset zip file cannot be NULL");
+  assertNotNull(custom.output, "Custom asset output cannot be NULL");
+
+  assetlanguage_t *lang = (assetlanguage_t *)custom.output;
+  errorChain(assetLanguageInit(lang, custom.zipFile));
+
+  errorOk();
+}
+
+errorret_t assetLanguageInit(
+  assetlanguage_t *lang,
+  zip_file_t *zipFile
+) {
+  errorThrow("Language asset initialization is not yet implemented.");
+}
+
+errorret_t assetLanguageRead(
+  assetlanguage_t *lang,
+  const uint32_t key,
+  char_t *buffer,
+  const uint32_t bufferSize,
+  uint32_t *outLength
+) {
+  errorThrow("Language string reading is not yet implemented.");
+}
+
+void assetLanguageDispose(assetlanguage_t *lang) {
+  assertNotNull(lang, "Language asset cannot be NULL");
+
+  if(lang->zip) {
+    zip_fclose(lang->zip);
+  }
+}

archive/loader/assetlanguage.h

@@ -6,39 +6,13 @@
  */
 
 #pragma once
-#include "locale/language/keys.h"
 #include "error/error.h"
 #include "duskdefs.h"
 #include <zip.h>
 
-#define ASSET_LANG_CHUNK_CACHE 4 // Number of chunks to cache in memory
-
-#pragma pack(push, 1)
-typedef char assetlanguagechunk_t[ASSET_LANG_CHUNK_CHAR_COUNT];
-#pragma pack(pop)
-
-#pragma pack(push, 1)
-typedef struct {
-  uint32_t chunk;
-  uint32_t offset;
-  uint32_t length;
-} assetlanguagestring_t;
-#pragma pack(pop)
-
-#pragma pack(push, 1)
-typedef struct {
-  assetlanguagestring_t strings[LANG_KEY_COUNT];
-} assetlanguageheader_t;
-#pragma pack(pop)
-
 typedef struct {
   zip_file_t *zip;
-  assetlanguageheader_t header;
   zip_int64_t chunksOffset;
-
-  // Chunk cache
-  assetlanguagechunk_t chunks[ASSET_LANG_CHUNK_CACHE];
-  uint32_t chunkIndices[ASSET_LANG_CHUNK_CACHE];
 } assetlanguage_t;
 
 typedef struct assetcustom_s assetcustom_t;

archive/loader/assetscript.h

@@ -9,7 +9,7 @@
 #include "error/error.h"
 #include "duskdefs.h"
 #include <zip.h>
-#include <lua.h>
+#include "script/scriptcontext.h"
 
 #define ASSET_SCRIPT_BUFFER_SIZE 1024
 

archive/loader/assettexture.c

@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assettexture.h"
+#include "asset/assettype.h"
+#include "assert/assert.h"
+#include "display/texture/texture.h"
+#include "util/endian.h"
+
+errorret_t assetTextureLoad(assetentire_t entire) {
+  assertNotNull(entire.data, "Data pointer cannot be NULL.");
+  assertNotNull(entire.output, "Output pointer cannot be NULL.");
+
+  assettexture_t *assetData = (assettexture_t *)entire.data;
+  texture_t *texture = (texture_t *)entire.output;
+
+  // Read header and version (first 4 bytes)
+  if(
+    assetData->header[0] != 'D' || 
+    assetData->header[1] != 'T' ||
+    assetData->header[2] != 'X'
+  ) {
+    errorThrow("Invalid texture header");
+  }
+  
+  // Version (can only be 1 atm)
+  if(assetData->version != 0x01) {
+    errorThrow("Unsupported texture version");
+  }
+
+  // Fix endian
+  assetData->width = endianLittleToHost32(assetData->width);
+  assetData->height = endianLittleToHost32(assetData->height);
+
+  // Check dimensions.
+  if(
+    assetData->width == 0 || assetData->width > ASSET_TEXTURE_WIDTH_MAX ||
+    assetData->height == 0 || assetData->height > ASSET_TEXTURE_HEIGHT_MAX
+  ) {
+    errorThrow("Invalid texture dimensions");
+  }
+
+  // Validate format
+  textureformat_t format;
+  texturedata_t data;
+
+  switch(assetData->type) {
+    case 0x00: // RGBA8888
+      format = TEXTURE_FORMAT_RGBA;
+      data.rgbaColors = (color_t *)assetData->data;
+      break;
+
+    // case 0x01:
+    //   format = TEXTURE_FORMAT_RGB;
+    //   break;
+    
+    // case 0x02:
+    //   format = TEXTURE_FORMAT_RGB565;
+    //   break;
+
+    // case 0x03:
+    //   format = TEXTURE_FORMAT_RGB5A3;
+    //   break;
+
+    default:
+      errorThrow("Unsupported texture format");
+  }
+
+  errorChain(textureInit(
+    texture, assetData->width, assetData->height, format, data
+  ));
+
+  errorOk();
+}

archive/loader/assettexture.h

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "display/color.h"
+
+#define ASSET_TEXTURE_WIDTH_MAX 2048
+#define ASSET_TEXTURE_HEIGHT_MAX 2048
+#define ASSET_TEXTURE_SIZE_MAX ( \
+  ASSET_TEXTURE_WIDTH_MAX * ASSET_TEXTURE_HEIGHT_MAX \
+)
+
+typedef struct assetentire_s assetentire_t;
+
+#pragma pack(push, 1)
+typedef struct {
+  char_t header[3];
+  uint8_t version;
+  uint8_t type;
+  uint32_t width;
+  uint32_t height;
+  uint8_t data[ASSET_TEXTURE_SIZE_MAX * sizeof(color4b_t)];
+} assettexture_t;
+#pragma pack(pop)
+
+/**
+ * Loads a palettized texture from the given data pointer into the output
+ * texture.
+ *
+ * @param data Pointer to the raw assettexture_t data.
+ * @param output Pointer to the texture_t to load the image into.
+ * @return An error code.
+ */
+errorret_t assetTextureLoad(assetentire_t entire);

archive/loader/assettileset.c

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "asset/asset.h"
+#include "assert/assert.h"
+#include "display/texture/tileset.h"
+#include "util/memory.h"
+#include "util/endian.h"
+
+errorret_t assetTilesetLoad(assetentire_t entire) {
+  assertNotNull(entire.data, "Asset data cannot be null");
+  assertNotNull(entire.output, "Asset output cannot be null");
+
+  assettileset_t *tilesetData = (assettileset_t *)entire.data;
+  tileset_t *tileset = (tileset_t *)entire.output;
+
+  if(
+    tilesetData->header[0] != 'D' || 
+    tilesetData->header[1] != 'T' ||
+    tilesetData->header[2] != 'F'
+  ) {
+    errorThrow("Invalid tileset header");
+  }
+
+  if(tilesetData->version != 0x00) {
+    errorThrow("Unsupported tileset version");
+  }
+
+  // Fix endianness
+  tilesetData->tileWidth = endianLittleToHost16(tilesetData->tileWidth);
+  tilesetData->tileHeight = endianLittleToHost16(tilesetData->tileHeight);
+  tilesetData->columnCount = endianLittleToHost16(tilesetData->columnCount);
+  tilesetData->rowCount = endianLittleToHost16(tilesetData->rowCount);
+  tilesetData->right = endianLittleToHost16(tilesetData->right);
+  tilesetData->bottom = endianLittleToHost16(tilesetData->bottom);
+
+  if(tilesetData->tileWidth == 0) {
+    errorThrow("Tile width cannot be 0");
+  }
+  if(tilesetData->tileHeight == 0) {
+    errorThrow("Tile height cannot be 0");
+  }
+  if(tilesetData->columnCount == 0) {
+    errorThrow("Column count cannot be 0");
+  }
+  if(tilesetData->rowCount == 0) {
+    errorThrow("Row count cannot be 0");
+  }
+
+  tilesetData->u0 = endianLittleToHostFloat(tilesetData->u0);
+  tilesetData->v0 = endianLittleToHostFloat(tilesetData->v0);
+
+  if(tilesetData->v0 < 0.0f || tilesetData->v0 > 1.0f) {
+    errorThrow("Invalid v0 value in tileset");
+  }
+
+  // Setup tileset
+  tileset->tileWidth = tilesetData->tileWidth;
+  tileset->tileHeight = tilesetData->tileHeight;
+  tileset->tileCount = tilesetData->columnCount * tilesetData->rowCount;
+  tileset->columns = tilesetData->columnCount;
+  tileset->rows = tilesetData->rowCount;
+  tileset->uv[0] = tilesetData->u0;
+  tileset->uv[1] = tilesetData->v0;
+  errorOk();
+}

archive/loader/assettileset.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+
+#pragma pack(push, 1)
+typedef struct {
+  char_t header[3];
+  uint8_t version;
+  uint16_t tileWidth;
+  uint16_t tileHeight;
+  uint16_t columnCount;
+  uint16_t rowCount;
+  uint16_t right;
+  uint16_t bottom;
+  float_t u0;
+  float_t v0;
+} assettileset_t;
+#pragma pack(pop)
+
+/**
+ * Loads a tileset from the given data pointer into the output tileset.
+ *
+ * @param entire Data received from the asset loader system.
+ * @return An error code.
+ */
+errorret_t assetTilesetLoad(assetentire_t entire);

archive/map/CMakeLists.txt

@@ -3,4 +3,4 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-add_asset(MAP map.json)
+add_subdirectory(testmap)

archive/map/testmap/CMakeLists.txt

@@ -3,4 +3,4 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-add_asset(SCRIPT test.lua)
+add_asset(MAP testmap.json)

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

@@ -4,8 +4,8 @@
 # https://opensource.org/licenses/MIT
 
 # Sources
-target_sources(${DUSK_TARGET_NAME}
-  PRIVATE
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
     rpg.c
     rpgcamera.c
     rpgtextbox.c
@@ -14,4 +14,4 @@ target_sources(${DUSK_TARGET_NAME}
 # Subdirs
 add_subdirectory(cutscene)
 add_subdirectory(entity)
-add_subdirectory(world)
+add_subdirectory(overworld)

archive/rpg/cutscene/CMakeLists.txt

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

archive/rpg/cutscene/item/CMakeLists.txt

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

archive/rpg/cutscene/item/cutsceneitem.h

@@ -9,7 +9,8 @@
 #include "cutscenewait.h"
 #include "cutscenecallback.h"
 #include "cutscenetext.h"
-#include "cutscenecutscene.h"
+
+typedef struct cutscene_s cutscene_t;
 
 typedef enum {
   CUTSCENE_ITEM_TYPE_NULL,
@@ -27,7 +28,7 @@ typedef struct cutsceneitem_s {
     cutscenetext_t text;
     cutscenecallback_t callback;
     cutscenewait_t wait;
-    const cutscenecutscene_t cutscene;
+    const cutscene_t *cutscene;
   };
 } cutsceneitem_t;
 

archive/rpg/entity/CMakeLists.txt

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

archive/rpg/entity/entity.c

@@ -11,7 +11,7 @@
 #include "time/time.h"
 #include "util/math.h"
 #include "rpg/cutscene/cutscenemode.h"
-#include "rpg/world/map.h"
+#include "rpg/overworld/map.h"
 
 entity_t ENTITIES[ENTITY_COUNT];
 

archive/rpg/entity/entity.h

@@ -16,7 +16,7 @@ typedef struct map_s map_t;
 typedef struct entity_s {
   uint8_t id;
   entitytype_t type;
-  entitytypedata_t;
+  entitytypedata_t data;
 
   // Movement
   entitydir_t direction;