New ramp types

Reviewed-on: #5

.ci/dolphin/Dockerfile

@@ -1,5 +0,0 @@
-FROM devkitpro/devkitppc
-
-RUN apt update && \
-    apt install -y python3 python3-pip python3-polib python3-pil python3-dotenv python3-pyqt5 python3-opengl && \
-    dkp-pacman -S --needed --noconfirm gamecube-sdl2 ppc-liblzma ppc-libzip

.ci/dolphin/build-gamecube.sh

@@ -1,13 +0,0 @@
-#!/bin/bash
-docker build -t myapp:latest -f .ci/dolphin/Dockerfile .
-docker run -it -v ./:/workdir myapp:latest /bin/bash -c ' \
-  export PATH="$DEVKITPPC/bin:$PATH" && \
-  cd /workdir && \
-  rm -rf build-gamecube && \
-  mkdir -p build-gamecube && \
-  # cmake -S. -Bbuild-gamecube -DDUSK_TARGET_SYSTEM=gamecube -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/GameCube.cmake" && \
-  cmake -S. -Bbuild-gamecube -DDUSK_TARGET_SYSTEM=wii -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/Wii.cmake" && \
-  cd build-gamecube && \
-  make -j$(nproc) VERBOSE=1 && \
-  cp ./Dusk.dol ./boot.dol
-'

.ci/dolphin/build-wii.sh

@@ -1,13 +0,0 @@
-#!/bin/bash
-docker build -t myapp:latest -f .ci/dolphin/Dockerfile .
-docker run -v ./:/workdir myapp:latest /bin/bash -c ' \
-  export PATH="$DEVKITPPC/bin:$PATH" && \
-  cd /workdir && \
-  rm -rf build-wii && \
-  mkdir -p build-wii && \
-  cmake -S. -Bbuild-wii -DDUSK_TARGET_SYSTEM=wii -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/Wii.cmake" && \
-  cd build-wii && \
-  make -j$(nproc) VERBOSE=1 && \
-  mv ./Dusk.dol ./boot.dol
-'
-# docker run -it -v ./:/workdir myapp:latest /bin/bash

.ci/dolphin/meta.xml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<app version="1">
-	<name>Dusk</name>
-	<version>1.00</version>
-	<release_date></release_date>
-	<coder>YouWish</coder>
-	<short_description>Dusk game</short_description>
-	<long_description>No description yet.</long_description>
-  <ahb_access/>
-</app>

.ci/psp/build-psp.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-mkdir -p build-psp
-cd build-psp
-cmake .. -DDUSK_TARGET_SYSTEM=psp
-make -j$(nproc)

.gitea/workflows/build.yml

@@ -1,156 +0,0 @@
-name: Build Dusk
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  run-tests:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: https://git.wish.moe/YourWishes/checkout@main
-      - 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 liblua5.3-dev
-      - name: Configure CMake for tests
-        run: cmake -S . -B build -DDUSK_BUILD_TESTS=ON -DDUSK_TARGET_SYSTEM=linux
-      - name: Build tests
-        run: cmake --build build -- -j$(nproc)
-      - name: Run tests
-        run: ctest --output-on-failure --test-dir build
-
-  build-linux:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: https://git.wish.moe/YourWishes/checkout@main
-      - 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 liblua5.3-dev
-      - 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: https://git.wish.moe/YourWishes/upload-artifact@v3/node20
-        with:
-          name: dusk-linux
-          path: build/Dusk
-          if-no-files-found: error
-
-  build-psp:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: https://git.wish.moe/YourWishes/checkout@main
-      - 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 liblua5.3-dev
-      - name: Configure CMake
-        run: cmake -S . -B build -DDUSK_TARGET_SYSTEM=psp -DENABLE_TESTS=OFF
-      - 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: https://git.wish.moe/YourWishes/upload-artifact@v3/node20
-        with:
-          name: dusk-psp
-          path: build/gitea/
-          if-no-files-found: error
-    
-  build-dolphin:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: https://git.wish.moe/YourWishes/checkout@main
-      - name: Install dependencies
-        run: |
-          # Install devkit pacman
-          if ! [ $(id -u) = 0 ]; then
-            echo "Need root privilege to install!"
-            exit 1
-          fi
-
-          # ensure apt is set up to work with https sources
-          apt-get install apt-transport-https
-
-          # Store devkitPro gpg key locally if we don't have it already
-          if ! [ -f /usr/share/keyring/devkitpro-pub.gpg ]; then
-            mkdir -p /usr/share/keyring/
-            wget -U "dkp apt" -O /usr/share/keyring/devkitpro-pub.gpg https://apt.devkitpro.org/devkitpro-pub.gpg
-          fi
-
-          # Add the devkitPro apt repository if we don't have it set up already
-          if ! [ -f /etc/apt/sources.list.d/devkitpro.list ]; then
-            echo "deb [signed-by=/usr/share/keyring/devkitpro-pub.gpg] https://apt.devkitpro.org stable main" > /etc/apt/sources.list.d/devkitpro.list
-          fi
-          apt-get update
-          apt-get install devkitpro-pacman --yes
-          apt-get install --yes build-essential cmake python3 python3-pip python3-polib python3-pil python3-dotenv python3-pyqt5 python3-opengl
-
-          sudo dkp-pacman -Syu --noconfirm
-          sudo dkp-pacman -S gamecube-dev wii-dev ppc-liblzma ppc-libzip --needed --noconfirm
-
-      - name: Build GameCube
-        run: |
-          export DEVKITPRO=/opt/devkitpro
-          export DEVKITPPC=/opt/devkitpro/devkitPPC
-          export PATH="$DEVKITPPC/bin:$DEVKITPRO/tools/bin:$PATH"
-          mkdir -p build-gamecube
-          cmake -S. -Bbuild-gamecube -DDUSK_TARGET_SYSTEM=gamecube -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/GameCube.cmake"
-          cd build-gamecube
-          make -j$(nproc) VERBOSE=1
-
-      - name: Copy GameCube
-        run: |
-          ls -l
-          mkdir -p build/gitea/GameCube/Dusk
-          mv build-gamecube/Dusk.dol build/gitea/GameCube/Dusk/Dusk.dol
-          mv build-gamecube/dusk.dsk build/gitea/GameCube/Dusk/dusk.dsk
-      
-      - name: Upload GameCube Binary
-        uses: https://git.wish.moe/YourWishes/upload-artifact@v3/node20
-        with:
-          name: dusk-gamecube
-          path: build/gitea/GameCube
-          if-no-files-found: error
-
-      - name: Build Wii
-        run: |
-          export DEVKITPRO=/opt/devkitpro
-          export DEVKITPPC=/opt/devkitpro/devkitPPC
-          export PATH="$DEVKITPPC/bin:$DEVKITPRO/tools/bin:$PATH"
-          mkdir -p build-wii
-          cmake -S. -Bbuild-wii -DDUSK_TARGET_SYSTEM=wii -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/Wii.cmake"
-          cd build-wii
-          make -j$(nproc) VERBOSE=1
-
-      - name: Copy Wii
-        run: |
-          ls -l
-          mkdir -p build/gitea/Wii/apps/Dusk
-          mv build-wii/Dusk.dol build/gitea/Wii/apps/Dusk/boot.dol
-          mv build-wii/dusk.dsk build/gitea/Wii/apps/Dusk/dusk.dsk
-          cp .ci/dolphin/meta.xml build/gitea/Wii/apps/Dusk/meta.xml
-
-      - name: Upload Wii Binary
-        uses: https://git.wish.moe/YourWishes/upload-artifact@v3/node20
-        with:
-          name: dusk-wii
-          path: build/gitea/Wii
-          if-no-files-found: error

.github/actions/setup-devkitpro/action.yml

@@ -0,0 +1,49 @@
+name: Setup devkitPro
+description: Install devkitPro with GameCube/Wii packages on an Ubuntu runner
+
+runs:
+  using: composite
+  steps:
+    - name: Install apt dependencies
+      shell: bash
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y \
+          cmake \
+          python3 \
+          python3-pip \
+          python3-polib \
+          python3-pil \
+          python3-dotenv \
+          python3-pyqt5 \
+          python3-opengl \
+          xorriso
+    - name: Install devkitPro pacman
+      shell: bash
+      run: |
+        sudo ln -sf /proc/self/mounts /etc/mtab
+        wget https://apt.devkitpro.org/install-devkitpro-pacman \
+          -O /tmp/install-devkitpro-pacman
+        echo "=== installer script contents ==="
+        cat /tmp/install-devkitpro-pacman
+        echo "================================="
+        chmod +x /tmp/install-devkitpro-pacman
+        sudo /tmp/install-devkitpro-pacman
+        echo "DEVKITPRO=/opt/devkitpro" >> $GITHUB_ENV
+        echo "DEVKITPPC=/opt/devkitpro/devkitPPC" >> $GITHUB_ENV
+        echo "/opt/devkitpro/tools/bin" >> $GITHUB_PATH
+        echo "/opt/devkitpro/devkitPPC/bin" >> $GITHUB_PATH
+    - name: Install devkitPro GameCube/Wii packages
+      shell: bash
+      run: |
+        sudo dkp-pacman -S --needed --noconfirm \
+          gamecube-dev \
+          gamecube-sdl2 \
+          ppc-liblzma \
+          ppc-libzip \
+          libogc2 \
+          gamecube-tools \
+          ppc-libmad \
+          ppc-zlib-ng \
+          ppc-bzip2 \
+          ppc-zstd

.github/actions/setup-pspdev/action.yml

@@ -0,0 +1,20 @@
+name: Setup pspdev
+description: Install the pspdev PSP toolchain on an Ubuntu runner
+
+runs:
+  using: composite
+  steps:
+    - name: Install dependencies
+      shell: bash
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y cmake python3 python3-pip python3-dotenv
+    - name: Install pspdev toolchain
+      shell: bash
+      run: |
+        wget -q \
+          https://github.com/pspdev/pspdev/releases/latest/download/pspdev-ubuntu-latest-x86_64.tar.gz \
+          -O /tmp/pspdev.tar.gz
+        sudo tar -xzf /tmp/pspdev.tar.gz -C /usr/local
+        echo "PSPDEV=/usr/local/pspdev" >> $GITHUB_ENV
+        echo "/usr/local/pspdev/bin" >> $GITHUB_PATH

.github/workflows/build.yml

@@ -0,0 +1,277 @@
+name: Build Dusk
+on:
+  push:
+    tags:
+      - '*'
+jobs:
+  run-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo 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 \
+            xz-utils \
+            liblzma-dev \
+            libbz2-dev \
+            zlib1g-dev \
+            git \
+            libssl-dev
+      - name: Run tests
+        run: ./scripts/test-linux.sh
+
+  build-linux:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo 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 \
+            xz-utils \
+            liblzma-dev \
+            libbz2-dev \
+            zlib1g-dev \
+            git \
+            libssl-dev
+      - name: Build Linux
+        run: ./scripts/build-linux.sh
+      - name: Upload Linux binary
+        uses: actions/upload-artifact@v3
+        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@v4
+      - name: Setup pspdev
+        uses: ./.github/actions/setup-pspdev
+      - name: Build PSP
+        run: ./scripts/build-psp.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@v3
+        with:
+          name: dusk-psp
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-knulli:
+    runs-on: ubuntu-latest
+    container:
+      image: debian:trixie
+    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install dependencies
+        run: |
+          dpkg --add-architecture arm64
+          apt-get update
+          apt-get install -y --no-install-recommends \
+            crossbuild-essential-arm64 \
+            ca-certificates \
+            pkg-config \
+            cmake \
+            make \
+            ninja-build \
+            git \
+            file \
+            python3 \
+            python3-pip \
+            python3-polib \
+            python3-pil \
+            python3-dotenv \
+            python3-pyqt5 \
+            python3-opengl \
+            liblua5.4-dev:arm64 \
+            xz-utils:arm64 \
+            libbz2-dev:arm64 \
+            zlib1g-dev:arm64 \
+            libzip-dev:arm64 \
+            libssl-dev:arm64 \
+            libsdl2-dev:arm64 \
+            liblzma-dev:arm64 \
+            libopengl0:arm64 \
+            libgl1:arm64 \
+            libegl1:arm64 \
+            libgles2:arm64 \
+            libgl1-mesa-dev:arm64
+      - name: Build Knulli
+        run: ./scripts/build-knulli.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@v3
+        with:
+          name: dusk-knulli
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-gamecube:
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/extremscorner/libogc2:latest
+    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install additional dependencies
+        run: |
+          apt-get install -y \
+            python3-pip python3-polib python3-pil \
+            python3-dotenv python3-pyqt5 python3-opengl
+          dkp-pacman -Syu --noconfirm
+          dkp-pacman -S --needed --noconfirm \
+            gamecube-sdl2 ppc-liblzma ppc-libzip \
+            gamecube-tools ppc-libmad ppc-zlib-ng ppc-bzip2 ppc-zstd
+      - name: Build GameCube
+        run: ./scripts/build-gamecube.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@v3
+        with:
+          name: dusk-gamecube
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-gamecube-iso:
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/extremscorner/libogc2:latest
+    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install additional dependencies
+        run: |
+          apt-get install -y \
+            python3-pip python3-polib python3-pil \
+            python3-dotenv python3-pyqt5 python3-opengl xorriso
+          dkp-pacman -Syu --noconfirm
+          dkp-pacman -S --needed --noconfirm \
+            gamecube-sdl2 ppc-liblzma ppc-libzip \
+            gamecube-tools ppc-libmad ppc-zlib-ng ppc-bzip2 ppc-zstd
+      - name: Build GameCube ISO
+        run: ./scripts/build-gamecube-iso.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@v3
+        with:
+          name: dusk-gamecube-iso
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-wii:
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/extremscorner/libogc2:latest
+    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install additional dependencies
+        run: |
+          apt-get install -y \
+            python3-pip python3-polib python3-pil \
+            python3-dotenv python3-pyqt5 python3-opengl
+          dkp-pacman -Syu --noconfirm
+          dkp-pacman -S --needed --noconfirm \
+            gamecube-sdl2 ppc-liblzma ppc-libzip \
+            gamecube-tools ppc-libmad ppc-zlib-ng ppc-bzip2 ppc-zstd
+      - name: Build Wii
+        run: ./scripts/build-wii.sh
+      - name: Copy output files
+        run: |
+          mkdir -p ./git-artifcats/Dusk/apps/Dusk
+          cp build-wii/boot.dol ./git-artifcats/Dusk/apps/Dusk/boot.dol
+          cp build-wii/dusk.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@v3
+        with:
+          name: dusk-wii
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-wii-iso:
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/extremscorner/libogc2:latest
+    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install additional dependencies
+        run: |
+          apt-get install -y \
+            python3-pip python3-polib python3-pil \
+            python3-dotenv python3-pyqt5 python3-opengl xorriso
+          dkp-pacman -Syu --noconfirm
+          dkp-pacman -S --needed --noconfirm \
+            gamecube-sdl2 ppc-liblzma ppc-libzip \
+            gamecube-tools ppc-libmad ppc-zlib-ng ppc-bzip2 ppc-zstd
+      - name: Build Wii ISO
+        run: ./scripts/build-wii-iso.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@v3
+        with:
+          name: dusk-wii-iso
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error

.gitignore

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

CLAUDE.md

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

CMakeLists.txt

@@ -4,13 +4,20 @@
 # https://opensource.org/licenses/MIT
 
 # Setup
-cmake_minimum_required(VERSION 3.18)
+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)
 
-option(ENABLE_TESTS "Enable tests" OFF)
+option(DUSK_BUILD_TESTS "Enable tests" OFF)
+
+set(DUSK_GAME_NAME "Dusk" CACHE STRING "Game display name")
+set(DUSK_GAME_AUTHOR "YourWishes" CACHE STRING "Game author / coder")
+set(DUSK_GAME_SHORT_DESCRIPTION "Dusk game" CACHE STRING "One-line description")
+set(DUSK_GAME_LONG_DESCRIPTION  "No description yet." CACHE STRING "Full description")
 
 # Prep cache
 set(DUSK_CACHE_TARGET "dusk-target")
@@ -32,17 +39,18 @@ 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})
 
-# Create directories
-file(MAKE_DIRECTORY ${DUSK_GENERATED_HEADERS_DIR})
-
-# Find packages
-find_package(Python3 COMPONENTS Interpreter REQUIRED)
-
-# Set target system, default to linux if not set.
 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})
+
+# Required build packages
+find_package(Python3 COMPONENTS Interpreter REQUIRED)
+
 # Init Project.
 project(${DUSK_LIBRARY_TARGET_NAME}
   VERSION 1.0.0
@@ -50,14 +58,14 @@ project(${DUSK_LIBRARY_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.
-if(ENABLE_TESTS)
+# 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)
 
-  # Binary Executable
-  add_executable(${DUSK_BINARY_TARGET_NAME} ${DUSK_SOURCES_DIR}/null.c)
-
   # Link library to binary
   target_link_libraries(${DUSK_BINARY_TARGET_NAME}
     PUBLIC
@@ -65,16 +73,35 @@ if(ENABLE_TESTS)
   )
 else()
   set(DUSK_LIBRARY_TARGET_NAME "${DUSK_BINARY_TARGET_NAME}" CACHE INTERNAL ${DUSK_CACHE_TARGET})
-  add_executable(${DUSK_BINARY_TARGET_NAME} ${DUSK_SOURCES_DIR}/null.c)
 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/configure/${DUSK_TARGET_SYSTEM}.cmake)
+include(cmake/targets/${DUSK_TARGET_SYSTEM}.cmake)
 
 # Add tools
 add_subdirectory(tools)
 
-# Add code
+# Include generated headers from tools.
+target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
+  ${DUSK_GENERATED_HEADERS_DIR}
+)
+
+# Add main code
 add_subdirectory(${DUSK_SOURCES_DIR})
 
 # Include generated headers
@@ -83,7 +110,7 @@ target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
 )
 
 # Handle tests
-if(ENABLE_TESTS)
+if(DUSK_BUILD_TESTS)
   enable_testing()
   add_subdirectory(test)
 endif()
@@ -101,24 +128,3 @@ add_custom_command(
 )
 add_custom_target(DUSK_ASSETS_BUILT DEPENDS "${DUSK_ASSETS_ZIP}")
 add_dependencies(${DUSK_LIBRARY_TARGET_NAME} DUSK_ASSETS_BUILT)
-
-# Postbuild
-if(DUSK_TARGET_SYSTEM STREQUAL "psp")
-  create_pbp_file(
-    TARGET "${DUSK_BINARY_TARGET_NAME}"
-    ICON_PATH NULL
-    BACKGROUND_PATH NULL
-    PREVIEW_PATH NULL
-    TITLE "${DUSK_BINARY_TARGET_NAME}"
-    PSAR_PATH ${DUSK_ASSETS_ZIP}
-    VERSION 01.00
-  )
-elseif(DUSK_TARGET_SYSTEM STREQUAL "gamecube" OR DUSK_TARGET_SYSTEM STREQUAL "wii")
-  set(DUSK_BINARY_TARGET_NAME_DOL "${DUSK_BUILD_DIR}/Dusk.dol")
-  add_custom_command(TARGET ${DUSK_BINARY_TARGET_NAME} POST_BUILD
-    COMMAND elf2dol
-            "$<TARGET_FILE:${DUSK_BINARY_TARGET_NAME}>"
-            "${DUSK_BINARY_TARGET_NAME_DOL}"
-    COMMENT "Generating ${DUSK_BINARY_TARGET_NAME_DOL} from ${DUSK_BINARY_TARGET_NAME}"
-  )
-endif()

archive/asset/args.py

@@ -1,12 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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

@@ -1,228 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,178 +0,0 @@
-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/dusk/chunk.py

@@ -1,158 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,259 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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

@@ -1,206 +0,0 @@
-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

@@ -1,57 +0,0 @@
-#!/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

@@ -1,58 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,202 +0,0 @@
-#!/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

@@ -1,55 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

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

archive/map/CMakeLists.txt

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

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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

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

archive/modulemap.h

@@ -1,49 +0,0 @@
-/**
- * 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/rpg/entity/entityanim.h

@@ -1,18 +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"
-
-#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/npc.c

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,37 +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 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

@@ -1,54 +0,0 @@
-/**
- * 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/overworld/map.c

@@ -1,269 +0,0 @@
-/**
- * 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];
-}

archive/rpg/overworld/worldpos.h

@@ -1,75 +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"
-#include "duskdefs.h"
-
-#define CHUNK_TILE_COUNT (CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH)
-
-#define MAP_CHUNK_WIDTH 3
-#define MAP_CHUNK_HEIGHT 3
-#define MAP_CHUNK_DEPTH 3
-#define MAP_CHUNK_COUNT (MAP_CHUNK_WIDTH * MAP_CHUNK_HEIGHT * MAP_CHUNK_DEPTH)
-
-typedef int16_t worldunit_t;
-typedef int16_t chunkunit_t;
-typedef int16_t chunkindex_t;
-typedef uint32_t chunktileindex_t;
-
-typedef int32_t worldunits_t;
-typedef int32_t chunkunits_t;
-
-typedef struct worldpos_s {
-  worldunit_t x, y, z;
-} worldpos_t;
-
-typedef struct chunkpos_t {
-  chunkunit_t x, y, z;
-} chunkpos_t;
-
-/**
- * Compares two world positions for equality.
- * 
- * @param a The first world position.
- * @param b The second world position.
- * @return true if equal, false otherwise.
- */
-bool_t worldPosIsEqual(const worldpos_t a, const worldpos_t b);
-
-/**
- * Converts a world position to a chunk position.
- * 
- * @param worldPos The world position.
- * @param out The output chunk position.
- */
-void chunkPosToWorldPos(const chunkpos_t* chunkPos, worldpos_t* out);
-
-/**
- * Converts a chunk position to a world position.
- * 
- * @param worldPos The world position.
- * @param out The output chunk position.
- */
-void worldPosToChunkPos(const worldpos_t* worldPos, chunkpos_t* out);
-
-/**
- * Converts a position in world-space to an index inside a chunk that the tile
- * resides in.
- * 
- * @param worldPos The world position.
- * @return The tile index within the chunk.
- */
-chunktileindex_t worldPosToChunkTileIndex(const worldpos_t* worldPos);
-
-/**
- * Converts a chunk position to a world position.
- * 
- * @param worldPos The world position.
- * @param out The output chunk position.
- */
-chunkindex_t chunkPosToIndex(const chunkpos_t* pos);

archive/rpg/rpg.c

@@ -1,66 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "rpg.h"
-#include "entity/entity.h"
-#include "rpg/overworld/map.h"
-#include "rpg/cutscene/cutscenesystem.h"
-#include "time/time.h"
-#include "rpgcamera.h"
-#include "rpgtextbox.h"
-#include "util/memory.h"
-#include "assert/assert.h"
-
-errorret_t rpgInit(void) {
-  memoryZero(ENTITIES, sizeof(ENTITIES));
-
-  // Init cutscene subsystem
-  cutsceneSystemInit();
-
-  errorChain(mapInit());
-
-  rpgCameraInit();
-  rpgTextboxInit();
-
-  // TEST: Create some entities.
-  // uint8_t entIndex = entityGetAvailable();
-  // assertTrue(entIndex != 0xFF, "No available entity slots!.");
-  // entity_t *ent = &ENTITIES[entIndex];
-  // entityInit(ent, ENTITY_TYPE_PLAYER);
-  // RPG_CAMERA.mode = RPG_CAMERA_MODE_FOLLOW_ENTITY;
-  // RPG_CAMERA.followEntity.followEntityId = ent->id;
-  // ent->position.x = 2, ent->position.y = 2;
-
-  // All Good!
-  errorOk();
-}
-
-errorret_t rpgUpdate(void) {
-  #if TIME_FIXED == 0
-    if(TIME.dynamicUpdate) {
-      errorOk();
-    }
-  #endif
-
-  // TODO: Do not update if the scene is not the map scene?
-  mapUpdate();
-
-  // Update overworld ents.
-  entity_t *ent = &ENTITIES[0];
-  do {
-    if(ent->type == ENTITY_TYPE_NULL) continue;
-    entityUpdate(ent);
-  } while(++ent < &ENTITIES[ENTITY_COUNT]);
-
-  cutsceneSystemUpdate();
-  errorChain(rpgCameraUpdate());
-  errorOk();
-}
-
-void rpgDispose(void) {
-  mapDispose();
-}

archive/scene/CMakeLists.txt

@@ -1,13 +0,0 @@
-# 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
-    scenemanager.c
-)
-
-# Subdirs
-add_subdirectory(scene)

archive/scene/scene.h

@@ -1,24 +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"
-#include "error/error.h"
-#include "display/color.h"
-
-#define SCENE_FLAG_INITIALIZED (1 << 0)
-
-typedef struct scenedata_s scenedata_t;
-
-typedef struct {
-  const char_t *name;
-  errorret_t (*init)(scenedata_t *data);
-  void (*update)(scenedata_t *data);
-  void (*render)(scenedata_t *data);
-  void (*dispose)(scenedata_t *data);
-  uint8_t flags;
-} scene_t;

archive/scene/scene/CMakeLists.txt

@@ -1,13 +0,0 @@
-# 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
-    scenetest.c
-    scenemap.c
-)
-
-# Subdirs

archive/scene/scene/scenemap.c

@@ -1,212 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "scenemap.h"
-#include "scene/scenedata.h"
-#include "display/spritebatch.h"
-#include "assert/assert.h"
-#include "asset/asset.h"
-#include "rpg/entity/entity.h"
-#include "rpg/overworld/map.h"
-#include "display/screen.h"
-#include "rpg/rpgcamera.h"
-#include "util/memory.h"
-#include "duskdefs.h"
-
-errorret_t sceneMapInit(scenedata_t *data) {
-  // Init the camera.
-  cameraInitPerspective(&data->sceneMap.camera);
-  data->sceneMap.camera.projType = CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED;
-  data->sceneMap.camera.viewType = CAMERA_VIEW_TYPE_LOOKAT_PIXEL_PERFECT;
-  glm_vec3_zero(data->sceneMap.camera.lookatPixelPerfect.offset);
-  data->sceneMap.camera.lookatPixelPerfect.offset[1] = RPG_CAMERA_Z_OFFSET;
-  glm_vec3_copy(
-    (vec3){ 0.0f, 0.0f, 0.0f },
-    data->sceneMap.camera.lookatPixelPerfect.target
-  );
-  glm_vec3_copy(
-    (vec3){ 0.0f, 1.0f, 0.0f },
-    data->sceneMap.camera.lookatPixelPerfect.up
-  );
-  data->sceneMap.camera.lookatPixelPerfect.pixelsPerUnit = (
-    RPG_CAMERA_PIXELS_PER_UNIT
-  );
-  data->sceneMap.camera.perspective.fov = glm_rad(RPG_CAMERA_FOV);
-
-  errorOk();
-}
-
-void sceneMapUpdate(scenedata_t *data) {
-  
-}
-
-void sceneMapGetWorldPosition(const worldpos_t pos, vec3 outPosition) {
-  assertNotNull(outPosition, "Output position cannot be NULL");
-
-  outPosition[0] = pos.x * TILE_WIDTH;
-  outPosition[1] = pos.y * TILE_HEIGHT;
-  outPosition[2] = pos.z * TILE_DEPTH;
-
-  // Handle stair tiles.
-  tile_t tile = mapGetTile(pos);
-  if(tileIsRamp(tile)) {
-    outPosition[2] += TILE_DEPTH / 2.0f;
-  }
-}
-
-void sceneMapEntityGetPosition(const entity_t *entity, vec3 outPosition) {
-  assertNotNull(entity, "Entity cannot be NULL");
-  assertNotNull(outPosition, "Output position cannot be NULL");
-
-  // Get position
-  sceneMapGetWorldPosition(entity->position, outPosition);
-
-  // Add a small offset so we render above the tile
-  outPosition[2] += 0.1f;
-
-  // Add animation offset(s)
-  switch(entity->animation) {
-    case ENTITY_ANIM_WALK: {
-      float_t animPercentage = entity->animTime / ENTITY_ANIM_WALK_DURATION;
-
-      vec3 lastPosition;
-      sceneMapGetWorldPosition(entity->lastPosition, lastPosition);
-
-      vec3 offset;
-      glm_vec3_sub(outPosition, lastPosition, offset);
-      glm_vec3_scale(offset, -animPercentage, offset);
-      glm_vec3_add(outPosition, offset, outPosition);
-      break;
-    }
-
-    default:
-      break;
-  }
-}
-
-void sceneMapRender(scenedata_t *data) {
-  if(!mapIsLoaded()) return;
-  
-  // Look at target.
-  vec3 cameraTarget;
-  switch(RPG_CAMERA.mode) {
-    case RPG_CAMERA_MODE_FREE:
-      sceneMapGetWorldPosition(RPG_CAMERA.free, cameraTarget);
-      break;
-
-    case RPG_CAMERA_MODE_FOLLOW_ENTITY: {
-      const entity_t *ent = &ENTITIES[RPG_CAMERA.followEntity.followEntityId];
-      sceneMapEntityGetPosition(ent, cameraTarget);
-      break;
-    }
-
-    default:
-      glm_vec3_zero(cameraTarget);
-      break;
-  }
-
-  glm_vec3_copy(
-    cameraTarget,
-    data->sceneMap.camera.lookatPixelPerfect.target
-  );
-
-  // Push camera
-  cameraPushMatrix(&data->sceneMap.camera);
-
-  // Render map probably.
-  sceneMapRenderMap();
-
-  // Render ents
-  entity_t *ent = ENTITIES;
-  do {
-    sceneMapRenderEntity(ent);
-  } while(++ent, ent < &ENTITIES[ENTITY_COUNT]);
-  spriteBatchFlush();
-
-  // Finished, pop back camera.
-  cameraPopMatrix();
-}
-
-void sceneMapRenderEntity(entity_t *entity) {
-  assertNotNull(entity, "Entity cannot be NULL");
-
-  if(entity->type == ENTITY_TYPE_NULL) return;
-
-  vec3 posMin, posMax;
-  vec3 size = { TILE_WIDTH, TILE_HEIGHT, TILE_DEPTH };
-  sceneMapEntityGetPosition(entity, posMin);
-  glm_vec3_add(posMin, size, posMax);
-
-  // TEST: Change color depending on dir.
-  color_t testColor;
-  switch(entity->direction) {
-    case ENTITY_DIR_NORTH:
-      testColor = COLOR_BLUE;
-      break;
-    case ENTITY_DIR_EAST:
-      testColor = COLOR_GREEN;
-      break;
-    case ENTITY_DIR_SOUTH:
-      testColor = COLOR_CYAN;
-      break;
-    case ENTITY_DIR_WEST:
-      testColor = COLOR_YELLOW;
-      break;
-    default:
-      testColor = COLOR_WHITE;
-      break;
-  }
-
-  vec2 uv0 = { 0.0f, 0.0f };
-  vec2 uv1 = { 1.0f, 1.0f };
-
-  spriteBatchPush3D(NULL, posMin, posMax, testColor, uv0, uv1);
-}
-
-void sceneMapRenderMap() {
-  assertTrue(mapIsLoaded(), "No map loaded to render");
-
-  // For each chunk.
-  for(uint32_t i = 0; i < MAP_CHUNK_COUNT; i++) {
-    chunk_t *chunk = MAP.chunkOrder[i];
-
-    for(uint8_t j = 0; j < chunk->meshCount; j++) {
-      mesh_t *mesh = &chunk->meshes[j];
-      if(mesh->vertexCount == 0) continue;
-      textureBind(NULL);
-      meshDraw(mesh, -1, -1);
-    }
-
-    // vec3 min, max;
-    // min[0] = chunk->position.x * CHUNK_WIDTH * TILE_WIDTH;
-    // min[1] = chunk->position.y * CHUNK_HEIGHT * TILE_HEIGHT;
-    // min[2] = chunk->position.z * CHUNK_DEPTH * TILE_DEPTH;
-
-    // max[0] = min[0] + (CHUNK_WIDTH * TILE_WIDTH);
-    // max[1] = min[1] + (CHUNK_HEIGHT * TILE_HEIGHT);
-    // max[2] = min[2];
-
-    // color_t color = COLOR_WHITE;
-    // if(chunk->position.x % 2 == 0) {
-    //   color = (chunk->position.y % 2 == 0) ? COLOR_BLACK : COLOR_WHITE;
-    // } else {
-    //   color = (chunk->position.y % 2 == 0) ? COLOR_WHITE : COLOR_BLACK;
-    // }
-
-    // spriteBatchPush3D(
-    //   NULL,
-    //   min,
-    //   max,
-    //   color,
-    //   (vec2){ 0.0f, 0.0f },
-    //   (vec2){ 1.0f, 1.0f }
-    // );
-  }
-}
-
-void sceneMapDispose(scenedata_t *data) {
-}

archive/scene/scene/scenemap.h

@@ -1,32 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "scene/scene.h"
-#include "rpg/entity/entity.h"
-#include "display/camera/camera.h"
-#include "asset/asset.h"
-
-typedef struct {
-  camera_t camera;
-} scenemap_t;
-
-errorret_t sceneMapInit(scenedata_t *data);
-void sceneMapUpdate(scenedata_t *data);
-void sceneMapRender(scenedata_t *data);
-void sceneMapRenderEntity(entity_t *entity);
-void sceneMapRenderMap();
-void sceneMapDispose(scenedata_t *data);
-
-static scene_t SCENE_MAP = {
-  .name = "map",
-  .init = sceneMapInit,
-  .update = sceneMapUpdate,
-  .render = sceneMapRender,
-  .dispose = sceneMapDispose,
-  .flags = 0
-};

archive/scene/scene/scenetest.c

@@ -1,26 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "scenetest.h"
-#include "scene/scenedata.h"
-
-errorret_t sceneTestInit(scenedata_t *data) {
-  data->sceneTest.nothing = 0;
-  errorOk();
-}
-
-void sceneTestUpdate(scenedata_t *data) {
-
-}
-
-void sceneTestRender(scenedata_t *data) {
-
-}
-
-void sceneTestDispose(scenedata_t *data) {
-
-}

archive/scene/scene/scenetest.h

@@ -1,27 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "scene/scene.h"
-
-typedef struct {
-  int32_t nothing;
-} scenetest_t;
-
-errorret_t sceneTestInit(scenedata_t *data);
-void sceneTestUpdate(scenedata_t *data);
-void sceneTestRender(scenedata_t *data);
-void sceneTestDispose(scenedata_t *data);
-
-static scene_t SCENE_TEST = {
-  .name = "test",
-  .init = sceneTestInit,
-  .update = sceneTestUpdate,
-  .render = sceneTestRender,
-  .dispose = sceneTestDispose,
-  .flags = 0
-};

archive/scene/scenedata.h

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

archive/scene/scenemanager.c

@@ -1,119 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "scenemanager.h"
-#include "util/memory.h"
-#include "assert/assert.h"
-#include "display/framebuffer.h"
-#include "util/string.h"
-#include "asset/asset.h"
-#include "script/scriptmanager.h"
-
-scenemanager_t SCENE_MANAGER;
-
-errorret_t sceneManagerInit(void) {
-  memoryZero(&SCENE_MANAGER, sizeof(scenemanager_t));
-
-  sceneManagerRegisterScene(&SCENE_TEST);
-  sceneManagerRegisterScene(&SCENE_MAP);
-  
-  errorOk();
-}
-
-scene_t * sceneManagerGetSceneByName(const char_t *name) {
-  assertNotNull(name, "Name is null");
-
-  for(uint8_t i = 0; i < SCENE_MANAGER.sceneCount; i++) {
-    if(strcmp(SCENE_MANAGER.scenes[i]->name, name) != 0) continue;
-    return SCENE_MANAGER.scenes[i];
-  }
-
-  return NULL;
-}
-
-void sceneManagerRegisterScene(scene_t *scene) {
-  assertNotNull(scene, "Scene is null");
-  assertTrue(
-    SCENE_MANAGER.sceneCount < SCENE_MANAGER_SCENE_COUNT_MAX,
-    "Scene count exceeded max"
-  );
-  assertNotNull(scene->name, "Scene name is null");
-  assertNull(
-    sceneManagerGetSceneByName(scene->name), "Scene name already registered"
-  );
-
-  SCENE_MANAGER.scenes[SCENE_MANAGER.sceneCount++] = scene;
-}
-
-errorret_t sceneManagerSetScene(scene_t *scene) {
-  if(
-    SCENE_MANAGER.current &&
-    (SCENE_MANAGER.current->flags & SCENE_FLAG_INITIALIZED) != 0
-  ) {
-    SCENE_MANAGER.current->flags &= ~SCENE_FLAG_INITIALIZED;
-    if(SCENE_MANAGER.current->dispose) {
-      SCENE_MANAGER.current->dispose(&SCENE_MANAGER.sceneData);
-    }
-  }
-  
-  SCENE_MANAGER.current = scene;
-
-  if(scene && (scene->flags & SCENE_FLAG_INITIALIZED) == 0) {
-    scene->flags |= SCENE_FLAG_INITIALIZED;
-
-    if(scene->init) errorChain(scene->init(&SCENE_MANAGER.sceneData));
-
-    // Execute scene script if it exists
-    char_t buffer[256];
-    snprintf(buffer, sizeof(buffer), "scene/%s.dsf", scene->name);
-    if(assetFileExists(buffer)) {
-      scriptcontext_t ctx;
-      scriptContextInit(&ctx);
-      errorChain(scriptContextExecFile(&ctx, buffer));
-      scriptContextDispose(&ctx);
-    }
-  }
-
-  errorOk();
-}
-
-void sceneManagerUpdate(void) {
-  if(!SCENE_MANAGER.current) return;
-
-  assertTrue(
-    SCENE_MANAGER.current->flags & SCENE_FLAG_INITIALIZED,
-    "Current scene not initialized"
-  );
-
-  if(SCENE_MANAGER.current->update) {
-    SCENE_MANAGER.current->update(&SCENE_MANAGER.sceneData);
-  }
-}
-
-void sceneManagerRender(void) {
-  if(!SCENE_MANAGER.current) return;
-
-  assertTrue(
-    SCENE_MANAGER.current->flags & SCENE_FLAG_INITIALIZED,
-    "Current scene not initialized"
-  );
-
-  if(SCENE_MANAGER.current->render) {
-    SCENE_MANAGER.current->render(&SCENE_MANAGER.sceneData);
-  }
-}
-
-void sceneManagerDispose(void) {
-  for(uint8_t i = 0; i < SCENE_MANAGER.sceneCount; i++) {
-    scene_t *scene = SCENE_MANAGER.scenes[i];
-    if(scene->flags & SCENE_FLAG_INITIALIZED) {
-      scene->dispose(&SCENE_MANAGER.sceneData);
-    }
-  }
-
-  SCENE_MANAGER.sceneCount = 0;
-}

archive/scene/scenemanager.h

@@ -1,63 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "scene.h"
-#include "scenedata.h"
-
-#define SCENE_MANAGER_SCENE_COUNT_MAX 16
-
-typedef struct {
-  scene_t *current;
-  scene_t *scenes[SCENE_MANAGER_SCENE_COUNT_MAX];
-  uint8_t sceneCount;
-} scenemanager_t;
-
-extern scenemanager_t SCENE_MANAGER;
-
-/**
- * Initializes the scene manager and the initial scene.
- */
-errorret_t sceneManagerInit(void);
-
-/**
- * Retrieves a registered scene by its name.
- * 
- * @param name The name of the scene to retrieve.
- * @return The scene with the specified name, or NULL if not found.
- */
-scene_t * sceneManagerGetSceneByName(const char_t *name);
-
-/**
- * Registers a scene with the scene manager.
- * 
- * @param scene The scene to register.
- */
-void sceneManagerRegisterScene(scene_t *scene);
-
-/**
- * Sets the current active scene.
- * 
- * @param scene The scene to set as current.
- * @return An error code indicating success or failure.
- */
-errorret_t sceneManagerSetScene(scene_t *scene);
-
-/**
- * Updates all active scenes.
- */
-void sceneManagerUpdate(void);
-
-/**
- * Renders all visible scenes.
- */
-void sceneManagerRender(void);
-
-/**
- * Disposes of all scenes.
- */
-void sceneManagerDispose(void);

archive/scriptfuncentity.h

@@ -1,134 +0,0 @@
-/**
- * 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 "rpg/entity/entity.h"
-#include "assert/assert.h"
-
-int scriptFuncEntityAdd(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-  assertTrue(lua_isnumber(L, 1), "Expected integer entity type");
-
-  entitytype_t entityType = (entitytype_t)luaL_checknumber(L, 1);
-  assertTrue(
-    entityType >= ENTITY_TYPE_NULL && entityType < ENTITY_TYPE_COUNT,
-    "Invalid entity type passed to scriptFuncEntityAdd"
-  );
-
-  // Pop entity
-  uint8_t available = entityGetAvailable();
-  if(available == 0xFF) {
-    lua_pushnil(L);
-    return 1;
-  }
-
-  entity_t *ent = &ENTITIES[available];
-  entityInit(ent, (entitytype_t)entityType);
-
-  // May include X, Y and/or Z
-  if(lua_isinteger(L, 2)) {
-    lua_Integer xPos = luaL_checkinteger(L, 2);
-    ent->position.x = (int32_t)xPos;
-  }
-  if(lua_isinteger(L, 3)) {
-    lua_Integer yPos = luaL_checkinteger(L, 3);
-    ent->position.y = (int32_t)yPos;
-  }
-  if(lua_isinteger(L, 4)) {
-    lua_Integer zPos = luaL_checkinteger(L, 4);
-    ent->position.z = (int32_t)zPos;
-  }
-
-  // Send entity id.
-  lua_pushinteger(L, ent->id);
-  return 1;
-}
-
-int scriptFuncEntitySetX(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  assertTrue(lua_isinteger(L, 1), "Expected integer entity id");
-  assertTrue(lua_isinteger(L, 2), "Expected integer x position");
-
-  lua_Integer entityId = luaL_checkinteger(L, 1);
-  lua_Integer xPos = luaL_checkinteger(L, 2);
-
-  assertTrue(
-    entityId >= 0 && entityId < ENTITY_COUNT,
-    "Invalid entity id passed to scriptFuncEntitySetX"
-  );
-
-  entity_t *ent = &ENTITIES[entityId];
-  assertTrue(
-    ent->type != ENTITY_TYPE_NULL,
-    "Cannot set position of NULL entity in scriptFuncEntitySetX"
-  );
-
-  ent->position.x = (int32_t)xPos;
-
-  return 0;
-}
-
-int scriptFuncEntitySetY(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  assertTrue(lua_isinteger(L, 1), "Expected integer entity id");
-  assertTrue(lua_isinteger(L, 2), "Expected integer y position");
-
-  lua_Integer entityId = luaL_checkinteger(L, 1);
-  lua_Integer yPos = luaL_checkinteger(L, 2);
-
-  assertTrue(
-    entityId >= 0 && entityId < ENTITY_COUNT,
-    "Invalid entity id passed to scriptFuncEntitySetY"
-  );
-
-  entity_t *ent = &ENTITIES[entityId];
-  assertTrue(
-    ent->type != ENTITY_TYPE_NULL,
-    "Cannot set position of NULL entity in scriptFuncEntitySetY"
-  );
-
-  ent->position.y = (int32_t)yPos;
-
-  return 0;
-}
-
-int scriptFuncEntitySetZ(lua_State *L) {
-  assertNotNull(L, "Lua state cannot be NULL");
-
-  assertTrue(lua_isinteger(L, 1), "Expected integer entity id");
-  assertTrue(lua_isinteger(L, 2), "Expected integer z position");
-
-  lua_Integer entityId = luaL_checkinteger(L, 1);
-  lua_Integer zPos = luaL_checkinteger(L, 2);
-
-  assertTrue(
-    entityId >= 0 && entityId < ENTITY_COUNT,
-    "Invalid entity id passed to scriptFuncEntitySetZ"
-  );
-
-  entity_t *ent = &ENTITIES[entityId];
-  assertTrue(
-    ent->type != ENTITY_TYPE_NULL,
-    "Cannot set position of NULL entity in scriptFuncEntitySetZ"
-  );
-
-  ent->position.z = (int32_t)zPos;
-
-  return 0;
-}
-
-void scriptFuncEntity(scriptcontext_t *context) {
-  assertNotNull(context, "Script context cannot be NULL");
-
-  lua_register(context->luaState, "entityAdd", scriptFuncEntityAdd);
-  lua_register(context->luaState, "entitySetX", scriptFuncEntitySetX);
-  lua_register(context->luaState, "entitySetY", scriptFuncEntitySetY);
-  lua_register(context->luaState, "entitySetZ", scriptFuncEntitySetZ);
-}

archive/ui/CMakeLists.txt

@@ -1,17 +0,0 @@
-# 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
-    ui.c
-    uitext.c
-    uidebug.c
-    uiframe.c
-    uitextbox.c
-)
-
-# Subdirs
-add_subdirectory(element)

archive/ui/element/uielementtype.h

@@ -1,16 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-
-typedef enum {
-  UI_ELEMENT_TYPE_NULL,
-
-  UI_ELEMENT_TYPE_TEXT,
-
-  UI_ELEMENT_TYPE_COUNT,
-} uielementtype_t;

archive/ui/ui.c

@@ -1,67 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "ui.h"
-#include "assert/assert.h"
-#include "ui/uidebug.h"
-#include "util/memory.h"
-#include "display/tileset/tileset_minogram.h"
-#include "display/screen.h"
-// #include "ui/uitextbox.h"
-
-ui_t UI;
-
-errorret_t uiInit(void) {
-  memoryZero(&UI, sizeof(ui_t));
-
-  cameraInitOrthographic(&UI.camera);
-
-  // Initialize UI components here
-  uiSetFont(&TILESET_MINOGRAM);
-
-  errorOk();
-}
-
-void uiUpdate(void) {
-  // Update UI state here
-  UI.camera.orthographic.left = 0;
-  UI.camera.orthographic.right = SCREEN.width;
-  UI.camera.orthographic.top = 0;
-  UI.camera.orthographic.bottom = SCREEN.height;
-
-  // uiTextboxUpdate();
-}
-
-void uiRender(void) {
-  cameraPushMatrix(&UI.camera);
-  
-  // Render UI elements here
-  if(UI.fontTexture.width > 0) {
-    uiDebugRender(UI.fontTileset, &UI.fontTexture);
-  }
-  cameraPopMatrix();
-}
-
-errorret_t uiSetFont(const tileset_t *fontTileset) {
-  if(UI.fontTexture.width > 0) {
-    textureDispose(&UI.fontTexture);
-    UI.fontTexture.width = -1;
-  }
-
-  assertNotNull(fontTileset, "Font tileset cannot be NULL.");
-  
-  UI.fontTileset = fontTileset;
-  errorChain(assetLoad(UI.fontTileset->image, &UI.fontTexture));
-  errorOk();
-}
-
-void uiDispose(void) {
-  if(UI.fontTexture.width > 0) {
-    textureDispose(&UI.fontTexture);
-    UI.fontTexture.width = -1;
-  }
-}

archive/ui/ui.h

@@ -1,51 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "asset/asset.h"
-#include "display/texture.h"
-#include "display/tileset/tileset.h"
-#include "display/camera/camera.h"
-
-typedef struct {
-  camera_t camera;
-  texture_t fontTexture;
-  const tileset_t *fontTileset;
-} ui_t;
-
-extern ui_t UI;
-
-/**
- * Initializes the UI system, loading necessary resources.
- * 
- * @return An errorret_t indicating success or failure.
- */
-errorret_t uiInit(void);
-
-/**
- * Updates the UI state, handling user interactions and animations.
- */
-void uiUpdate(void);
-
-/**
- * Renders the UI elements to the screen.
- */
-void uiRender(void);
-
-/**
- * Sets the font tileset for UI text rendering.
- * 
- * @param fontTileset Pointer to the tileset to use for UI fonts.
- * 
- * @return An errorret_t indicating success or failure.
- */
-errorret_t uiSetFont(const tileset_t *fontTileset);
-
-/**
- * Cleans up and frees all UI resources.
- */
-void uiDispose(void);

archive/ui/uidebug.c

@@ -1,98 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "uidebug.h"
-#include "time/time.h"
-#include "util/string.h"
-#include "ui/uitext.h"
-#include "display/screen.h"
-#include "display/spritebatch.h"
-// #include "rpg/entity/entity.h"
-
-bool_t UI_DEBUG_DRAW = true;
-
-void uiDebugRender(const tileset_t *tileset, texture_t *texture) {
-  if(!UI_DEBUG_DRAW) return;
-
-  char_t buffer[128];
-  color_t color;
-  int32_t w, h, hOffset = 0;
-
-  // FPS Meter
-  #if TIME_FIXED == 0
-    float_t fpsDynamic = TIME.dynamicDelta > 0.0f ? (1.0f / TIME.dynamicDelta) : 0.0f;
-    float_t fpsFixed = TIME.delta > 0.0f ? (1.0f / TIME.delta) : 0.0f;
-    snprintf(
-      buffer,
-      sizeof(buffer),
-      "%.2f/%.2f/%d/%d",
-      TIME.dynamicDelta * 1000.0f,
-      TIME.delta * 1000.0f,
-      TIME.dynamicUpdate,
-      (int32_t)fpsDynamic
-    );
-
-    color = (
-      fpsDynamic >= 50.0f ? COLOR_GREEN :
-      fpsDynamic >= 30.0f ? COLOR_YELLOW :
-      COLOR_RED
-    );
-  #else 
-    float_t fps = TIME.delta > 0.0f ? (1.0f / TIME.delta) : 0.0f;
-    snprintf(
-      buffer,
-      sizeof(buffer),
-      "%.2f/%d/FXD",
-      TIME.delta * 1000.0f,
-      (int32_t)fps
-    );
-    
-    color = (
-      fps >= 50.0f ? COLOR_GREEN :
-      fps >= 30.0f ? COLOR_YELLOW :
-      COLOR_RED
-    );
-  #endif
-  
-  uiTextMeasure(buffer, tileset, &w, &h);
-  uiTextDraw(
-    SCREEN.width - w, hOffset,
-    buffer, color, tileset, texture
-  );
-  hOffset += h;
-
-
-  // Player position
-  // entity_t *player = NULL;
-  // for(uint8_t i = 0; i < ENTITY_COUNT; i++) {
-  //   if(ENTITIES[i].type != ENTITY_TYPE_PLAYER) continue;
-  //   player = &ENTITIES[i];
-  //   break;
-  // }
-  // if(player == NULL) {
-  //   snprintf(buffer, sizeof(buffer), "Player: N/A");
-  // } else {
-  //   snprintf(
-  //     buffer,
-  //     sizeof(buffer),
-  //     "%d,%d,%d/%d/%d",
-  //     player->position.x,
-  //     player->position.y,
-  //     player->position.z,
-  //     (int32_t)player->direction,
-  //     (int32_t)player->animation
-  //   );
-  // }
-  // uiTextMeasure(buffer, tileset, &w, &h);
-  // uiTextDraw(
-  //   SCREEN.width - w, hOffset,
-  //   buffer, COLOR_GREEN, tileset, texture
-  // );
-  // hOffset += h;
-
-  spriteBatchFlush();
-}

archive/ui/uidebug.h

@@ -1,18 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "display/tileset/tileset.h"
-#include "display/texture.h"
-
-/**
- * Renders the debug information UI element.
- * 
- * @param tileset The tileset to use for rendering text.
- * @param texture The texture associated with the tileset.
- */
-void uiDebugRender(const tileset_t *tileset, texture_t *texture);

archive/ui/uiframe.c

@@ -1,390 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "uiframe.h"
-#include "display/spritebatch.h"
-#include "assert/assert.h"
-#include "util/math.h"
-
-void uiFrameDraw(
-  const float_t x,
-  const float_t y,
-  const float_t width,
-  const float_t height,
-  const tileset_t *tileset,
-  const uint16_t column,
-  const uint16_t row,
-  const bool_t drawInner,
-  texture_t *texture
-) {
-  assertNotNull(tileset, "Tileset cannot be NULL");
-  assertNotNull(texture, "Texture cannot be NULL");
-
-  if(height <= 0 || width <= 0) return;
-
-  // Top-Left
-  vec4 uv;
-
-  tilesetPositionGetUV(
-    tileset,
-    column,
-    row,
-    uv
-  );
-  spriteBatchPush(
-    texture,
-    x, y,
-    x + tileset->tileWidth,
-    y + tileset->tileHeight,
-    COLOR_WHITE,
-    uv[0], uv[1], uv[2], uv[3]
-  );
-
-  // Top-Center
-  tilesetPositionGetUV(
-    tileset,
-    column + 1,
-    row,
-    uv
-  );
-  spriteBatchPush(
-    texture,
-    x + tileset->tileWidth, y,
-    x + width - tileset->tileWidth, y + tileset->tileHeight,
-    COLOR_WHITE,
-    uv[0], uv[1], uv[2], uv[3]
-  );
-
-  // Top-Right
-  tilesetPositionGetUV(
-    tileset,
-    column + 2,
-    row,
-    uv
-  );
-  spriteBatchPush(
-    texture,
-    x + width - tileset->tileWidth, y,
-    x + width, y + tileset->tileHeight,
-    COLOR_WHITE,
-    uv[0], uv[1], uv[2], uv[3]
-  ); 
-
-  // Middle-Left
-  tilesetPositionGetUV(
-    tileset,
-    column,
-    row + 1,
-    uv
-  );
-  spriteBatchPush(
-    texture,
-    x, y + tileset->tileHeight,
-    x + tileset->tileWidth, y + height - tileset->tileHeight,
-    COLOR_WHITE,
-    uv[0], uv[1], uv[2], uv[3]
-  ); 
-
-  // Middle-Center
-  if(drawInner) {
-    tilesetPositionGetUV(
-      tileset,
-      column + 1,
-      row + 1,
-      uv
-    );
-    spriteBatchPush(
-      texture,
-      x + tileset->tileWidth, y + tileset->tileHeight,
-      x + width - tileset->tileWidth, y + height - tileset->tileHeight,
-      COLOR_WHITE,
-      uv[0], uv[1], uv[2], uv[3]
-    );
-  }
-
-  // Middle-Right
-  tilesetPositionGetUV(
-    tileset,
-    column + 2,
-    row + 1,
-    uv
-  );
-  spriteBatchPush(
-    texture,
-    x + width - tileset->tileWidth, y + tileset->tileHeight,
-    x + width, y + height - tileset->tileHeight,
-    COLOR_WHITE,
-    uv[0], uv[1], uv[2], uv[3]
-  );
-
-  // Bottom-Left
-  tilesetPositionGetUV(
-    tileset,
-    column,
-    row + 2,
-    uv
-  );
-  spriteBatchPush(
-    texture,
-    x, y + height - tileset->tileHeight,
-    x + tileset->tileWidth, y + height,
-    COLOR_WHITE,
-    uv[0], uv[1], uv[2], uv[3]
-  );
-
-  // Bottom-Center
-  tilesetPositionGetUV(
-    tileset,
-    column + 1,
-    row + 2,
-    uv
-  );
-  spriteBatchPush(
-    texture,
-    x + tileset->tileWidth, y + height - tileset->tileHeight,
-    x + width - tileset->tileWidth, y + height,
-    COLOR_WHITE,
-    uv[0], uv[1], uv[2], uv[3]
-  );
-
-  // Bottom-Right
-  tilesetPositionGetUV(
-    tileset,
-    column + 2,
-    row + 2,
-    uv
-  );
-  spriteBatchPush(
-    texture,
-    x + width - tileset->tileWidth, y + height - tileset->tileHeight,
-    x + width, y + height,
-    COLOR_WHITE,
-    uv[0], uv[1], uv[2], uv[3]
-  );
-}
-
-void uiFrameDrawTiled(
-  const float_t x,
-  const float_t y,
-  const float_t width,
-  const float_t height,
-  const tileset_t *tileset,
-  const uint16_t column,
-  const uint16_t row,
-  const bool_t drawInner,
-  texture_t *texture
-) {
-  assertNotNull(tileset, "Tileset cannot be NULL");
-  assertNotNull(texture, "Texture cannot be NULL");
-
-  if(height <= 0 || width <= 0) return;
-  
-  uint32_t segmentsX, segmentsY;
-  float_t remainderX, remainderY;
-  segmentsX = (width - (tileset->tileWidth * 2)) / tileset->tileWidth;
-  segmentsY = (height - (tileset->tileHeight * 2)) / tileset->tileHeight;
-  remainderX = fmodf(width - (tileset->tileWidth * 2), tileset->tileWidth);
-  remainderY = fmodf(height - (tileset->tileHeight * 2), tileset->tileHeight);
-
-  // Corners
-  vec4 uv;
-
-  // Top-Left
-  tilesetPositionGetUV(
-    tileset,
-    column,
-    row,
-    uv
-  );
-  spriteBatchPush(
-    texture,
-    x, y,
-    x + tileset->tileWidth,
-    y + tileset->tileHeight,
-    COLOR_WHITE,
-    uv[0], uv[1], uv[2], uv[3]
-  );
-
-  // Top-Right
-  tilesetPositionGetUV(
-    tileset,
-    column + 2,
-    row,
-    uv
-  );
-  spriteBatchPush(
-    texture,
-    x + width - tileset->tileWidth, y,
-    x + width, y + tileset->tileHeight,
-    COLOR_WHITE,
-    uv[0], uv[1], uv[2], uv[3]
-  );
-
-  // Bottom-Left
-  tilesetPositionGetUV(
-    tileset,
-    column,
-    row + 2,
-    uv
-  );
-  spriteBatchPush(
-    texture,
-    x, y + height - tileset->tileHeight,
-    x + tileset->tileWidth, y + height,
-    COLOR_WHITE,
-    uv[0], uv[1], uv[2], uv[3]
-  );
-
-  // Bottom-Right
-  tilesetPositionGetUV(
-    tileset,
-    column + 2,
-    row + 2,
-    uv
-  );
-  spriteBatchPush(
-    texture,
-    x + width - tileset->tileWidth, y + height - tileset->tileHeight,
-    x + width, y + height,
-    COLOR_WHITE,
-    uv[0], uv[1], uv[2], uv[3]
-  );
-
-  // Top and Bottom Edges (Tiled)
-  tilesetPositionGetUV(tileset, column + 1, row, uv); // Top edge
-  float_t edgeX = x + tileset->tileWidth;
-  for(uint32_t i = 0; i < segmentsX; ++i, edgeX += tileset->tileWidth) {
-    spriteBatchPush(
-      texture,
-      edgeX, y,
-      edgeX + tileset->tileWidth, y + tileset->tileHeight,
-      COLOR_WHITE,
-      uv[0], uv[1], uv[2], uv[3]
-    );
-  }
-  if(remainderX) {
-    spriteBatchPush(
-      texture,
-      edgeX, y,
-      edgeX + remainderX, y + tileset->tileHeight,
-      COLOR_WHITE,
-      uv[0], uv[1], uv[2], uv[3]
-    );
-  }
-
-  tilesetPositionGetUV(tileset, column + 1, row + 2, uv); // Bottom edge
-  edgeX = x + tileset->tileWidth;
-  for(uint32_t i = 0; i < segmentsX; ++i, edgeX += tileset->tileWidth) {
-    spriteBatchPush(
-      texture,
-      edgeX, y + height - tileset->tileHeight,
-      edgeX + tileset->tileWidth, y + height,
-      COLOR_WHITE,
-      uv[0], uv[1], uv[2], uv[3]
-    );
-  }
-  if(remainderX) {
-    spriteBatchPush(
-      texture,
-      edgeX, y + height - tileset->tileHeight,
-      edgeX + remainderX, y + height,
-      COLOR_WHITE,
-      uv[0], uv[1], uv[2], uv[3]
-    );
-  }
-
-  // Left and Right Edges (Tiled)
-  tilesetPositionGetUV(tileset, column, row + 1, uv); // Left edge
-  float_t edgeY = y + tileset->tileHeight;
-  for(uint32_t i = 0; i < segmentsY; ++i, edgeY += tileset->tileHeight) {
-    spriteBatchPush(
-      texture,
-      x, edgeY,
-      x + tileset->tileWidth, edgeY + tileset->tileHeight,
-      COLOR_WHITE,
-      uv[0], uv[1], uv[2], uv[3]
-    );
-  }
-  if(remainderY) {
-    spriteBatchPush(
-      texture,
-      x, edgeY,
-      x + tileset->tileWidth, edgeY + remainderY,
-      COLOR_WHITE,
-      uv[0], uv[1], uv[2], uv[3]
-    );
-  }
-
-  tilesetPositionGetUV(tileset, column + 2, row + 1, uv); // Right edge
-  edgeY = y + tileset->tileHeight;
-  for(uint32_t i = 0; i < segmentsY; ++i, edgeY += tileset->tileHeight) {
-    spriteBatchPush(
-      texture,
-      x + width - tileset->tileWidth, edgeY,
-      x + width, edgeY + tileset->tileHeight,
-      COLOR_WHITE,
-      uv[0], uv[1], uv[2], uv[3]
-    );
-  }
-  if(remainderY) {
-    spriteBatchPush(
-      texture,
-      x + width - tileset->tileWidth, edgeY,
-      x + width, edgeY + remainderY,
-      COLOR_WHITE,
-      uv[0], uv[1], uv[2], uv[3]
-    );
-  }
-
-  // Center (Tiled)
-  if(!drawInner) return;
-  
-  tilesetPositionGetUV(tileset, column + 1, row + 1, uv); // Center tile
-  float_t centerY = y + tileset->tileHeight;
-  for(uint32_t j = 0; j < segmentsY; ++j, centerY += tileset->tileHeight) {
-    float_t centerX = x + tileset->tileWidth;
-    for(uint32_t i = 0; i < segmentsX; ++i, centerX += tileset->tileWidth) {
-      spriteBatchPush(
-        texture,
-        centerX, centerY,
-        centerX + tileset->tileWidth, centerY + tileset->tileHeight,
-        COLOR_WHITE,
-        uv[0], uv[1], uv[2], uv[3]
-      );
-    }
-    if(remainderX) {
-      spriteBatchPush(
-        texture,
-        centerX, centerY,
-        centerX + remainderX, centerY + tileset->tileHeight,
-        COLOR_WHITE,
-        uv[0], uv[1], uv[2], uv[3]
-      );
-    }
-  }
-  if(remainderY) {
-    float_t centerX = x + tileset->tileWidth;
-    for(uint32_t i = 0; i < segmentsX; ++i, centerX += tileset->tileWidth) {
-      spriteBatchPush(
-        texture,
-        centerX, centerY,
-        centerX + tileset->tileWidth, centerY + remainderY,
-        COLOR_WHITE,
-        uv[0], uv[1], uv[2], uv[3]
-      );
-    }
-    if(remainderX) {
-      spriteBatchPush(
-        texture,
-        centerX, centerY,
-        centerX + remainderX, centerY + remainderY,
-        COLOR_WHITE,
-        uv[0], uv[1], uv[2], uv[3]
-      );
-    }
-  }
-}

archive/ui/uiframe.h

@@ -1,61 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "display/tileset/tileset.h"
-#include "display/texture.h"
-
-/**
- * Draw a UI Frame (using the 9-slice technique).
- * 
- * @param x The x position to draw the frame at.
- * @param y The y position to draw the frame at.
- * @param width The width of the frame.
- * @param height The height of the frame.
- * @param tileset The tileset to use for rendering the frame.
- * @param column The column in the tileset to use for the frame.
- * @param row The row in the tileset to use for the frame.
- * @param drawInner Whether to draw the inner area.
- * @param texture The texture associated with the tileset.
- */
-void uiFrameDraw(
-  const float_t x,
-  const float_t y,
-  const float_t width,
-  const float_t height,
-  const tileset_t *tileset,
-  const uint16_t column,
-  const uint16_t row,
-  const bool_t drawInner,
-  texture_t *texture
-);
-
-/**
- * Draw a tiled UI Frame (using the 9-slice technique). This will tile the 
- * center components to allow them to repeat without distortion.
- *
- * @param x The x position to draw the frame at.
- * @param y The y position to draw the frame at.
- * @param width The width of the frame.
- * @param height The height of the frame.
- * @param tileset The tileset to use for rendering the frame.
- * @param column The column in the tileset to use for the frame.
- * @param row The row in the tileset to use for the frame.
- * @param drawInner Whether to draw the inner tiled area.
- * @param texture The texture associated with the tileset.
- */
-void uiFrameDrawTiled(
-  const float_t x,
-  const float_t y,
-  const float_t width,
-  const float_t height,
-  const tileset_t *tileset,
-  const uint16_t column,
-  const uint16_t row,
-  const bool_t drawInner,
-  texture_t *texture
-);

archive/ui/uitext.c

@@ -1,111 +0,0 @@
-// /**
-//  * Copyright (c) 2025 Dominic Masters
-//  * 
-//  * This software is released under the MIT License.
-//  * https://opensource.org/licenses/MIT
-//  */
-
-#include "uitext.h"
-#include "assert/assert.h"
-#include "util/memory.h"
-#include "display/spritebatch.h"
-
-void uiTextDrawChar(
-  const float_t x,
-  const float_t y,
-  const char_t c,
-  const color_t color,
-  const tileset_t *tileset,
-  texture_t *texture
-) {
-  int32_t tileIndex = (int32_t)(c) - UI_TEXT_CHAR_START;
-  if(tileIndex < 0 || tileIndex >= tileset->tileCount) {
-    tileIndex = ((int32_t)'@') - UI_TEXT_CHAR_START;
-  }
-
-  assertTrue(
-    tileIndex >= 0 && tileIndex <= tileset->tileCount,
-    "Character is out of bounds for font tiles"
-  );
-
-  vec4 uv;
-  tilesetTileGetUV(tileset, tileIndex, uv);
-
-  spriteBatchPush(
-    texture,
-    x, y,
-    x + tileset->tileWidth,
-    y + tileset->tileHeight,
-    color,
-    uv[0], uv[1], uv[2], uv[3]
-  );
-}
-
-void uiTextDraw(
-  const float_t x,
-  const float_t y,
-  const char_t *text,
-  const color_t color,
-  const tileset_t *tileset,
-  texture_t *texture
-) {
-  assertNotNull(text, "Text cannot be NULL");
-
-  float_t posX = x;
-  float_t posY = y;
-
-  char_t c;
-  int32_t i = 0;
-  while((c = text[i++]) != '\0') {
-    if(c == '\n') {
-      posX = x;
-      posY += tileset->tileHeight;
-      continue;
-    }
-
-    if(c == ' ') {
-      posX += tileset->tileWidth;
-      continue;
-    }
-
-    uiTextDrawChar(posX, posY, c, color, tileset, texture);
-    posX += tileset->tileWidth;
-  }
-}
-
-void uiTextMeasure(
-  const char_t *text,
-  const tileset_t *tileset,
-  int32_t *outWidth,
-  int32_t *outHeight
-) {
-  assertNotNull(text, "Text cannot be NULL");
-  assertNotNull(outWidth, "Output width pointer cannot be NULL");
-  assertNotNull(outHeight, "Output height pointer cannot be NULL");
-
-  int32_t width = 0;
-  int32_t height = tileset->tileHeight;
-  int32_t lineWidth = 0;
-
-  char_t c;
-  int32_t i = 0;
-  while((c = text[i++]) != '\0') {
-    if(c == '\n') {
-      if(lineWidth > width) {
-        width = lineWidth;
-      }
-      lineWidth = 0;
-      height += tileset->tileHeight;
-      continue;
-    }
-
-    lineWidth += tileset->tileWidth;
-  }
-
-  if(lineWidth > width) {
-    width = lineWidth;
-  }
-
-  *outWidth = width;
-  *outHeight = height;
-}

archive/ui/uitext.h

@@ -1,66 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "asset/asset.h"
-#include "display/texture.h"
-#include "display/tileset/tileset_minogram.h"
-
-#define UI_TEXT_CHAR_START '!'
-
-/**
- * Draws a single character at the specified position.
- * 
- * @param x The x-coordinate to draw the character at.
- * @param y The y-coordinate to draw the character at.
- * @param c The character to draw.
- * @param color The color to draw the character in.
- * @param tileset Font tileset to use for rendering.
- * @param texture Texture containing the font tileset image.
- */
-void uiTextDrawChar(
-  const float_t x,
-  const float_t y,
-  const char_t c,
-  const color_t color,
-  const tileset_t *tileset,
-  texture_t *texture
-);
-
-/**
- * Draws a string of text at the specified position.
- * 
- * @param x The x-coordinate to draw the text at.
- * @param y The y-coordinate to draw the text at.
- * @param text The null-terminated string of text to draw.
- * @param color The color to draw the text in.
- * @param tileset Font tileset to use for rendering.
- * @param texture Texture containing the font tileset image.
- */
-void uiTextDraw(
-  const float_t x,
-  const float_t y,
-  const char_t *text,
-  const color_t color,
-  const tileset_t *tileset,
-  texture_t *texture
-);
-
-/**
- * Measures the width and height of the given text string when rendered.
- * 
- * @param text The null-terminated string of text to measure.
- * @param tileset Font tileset to use for measurement.
- * @param outWidth Pointer to store the measured width in pixels.
- * @param outHeight Pointer to store the measured height in pixels.
- */
-void uiTextMeasure(
-  const char_t *text,
-  const tileset_t *tileset,
-  int32_t *outWidth,
-  int32_t *outHeight
-);

archive/ui/uitextbox.c

@@ -1,45 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "uitextbox.h"
-#include "ui/ui.h"
-#include "ui/uitext.h"
-// #include "rpg/rpgtextbox.h"
-#include "display/screen.h"
-#include "display/spritebatch.h"
-#include "input/input.h"
-
-// void uiTextboxUpdate() {
-//   if(!rpgTextboxIsVisible()) return;
-
-//   if(inputPressed(INPUT_ACTION_ACCEPT)) {
-//     rpgTextboxHide();
-//   }
-// }
-
-// void uiTextboxRender() {
-//   if(!rpgTextboxIsVisible()) return;
-
-//   const char_t *text = RPG_TEXTBOX.text;
-//   int32_t textWidth, textHeight;
-  
-//   uiTextMeasure(text, UI.fontTileset, &textWidth, &textHeight);
-
-//   float_t y = 0;
-//   if(RPG_TEXTBOX.position == RPG_TEXTBOX_POS_BOTTOM) {
-//     y = SCREEN.height - (float_t)textHeight;
-//   }
-
-//   spriteBatchPush(
-//     NULL,
-//     0.0f, y,
-//     (float_t)SCREEN.width, (float_t)(y + textHeight),
-//     COLOR_BLACK,
-//     0.0f, 0.0f, 1.0f, 1.0f
-//   );
-//   uiTextDraw(0, y, text, COLOR_RED, UI.fontTileset, &UI.fontTexture);
-// }

archive/ui/uitextbox.h

@@ -1,19 +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"
-
-/**
- * Updates the RPG textbox state.
- */
-void uiTextboxUpdate();
-
-/**
- * Draws the RPG textbox if it is visible.
- */
-void uiTextboxRender();

archive/ui2/ui2.h

@@ -1,10 +0,0 @@
-// Copyright (c) 2026 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "dusk.h"
-
-// Two kinds of UI elements, those that are scripted (with a state, logic, etc)
-// and those that are draw only (rectangle, text, etc).