Tekton Dash Armageddon

🛠️ Developer Workflows

Creating a Skin Material

To create dynamic, color-maskable 3D materials for new character skins:

• Open the Skin Shader Generator tool in the editor: res://scenes/tools/skin_shader_generator.tscn
• Run the scene.
• Import your base albedo and mask textures.
• Use the UI to visualize UV overlays and adjust color channels (Red, Green, Blue, Alpha masks).
• Export the configured material as a .tres file into the assets/materials/skins/ directory.

Adding a Skin to the Shop

Once your material is ready, you need to update the game's catalog and deploy the changes to the Nakama server.

Using the Catalog Editor Tool

• Open the Skin Catalog Editor tool in the Godot Editor: res://scenes/tools/skin_catalog_editor.tscn
• Press F6 (or Right-click -> Run Current Scene).
• Manage Skins:
  • Click "＋ New Skin" to create a new entry.
  • Fill in the ID, Name, Category, and Price (Gold/Stars).
  • Assign the .tres material path generated in Step 1.
• Click "💾 Save & Generate". This automatically rewrites:
  • res://scripts/managers/skin_manager.gd (Local catalog)
  • res://server/nakama/tekton_admin.js (Server-side shop logic)

Nakama VPS Deployment

After generating the updated tekton_admin.js locally, you must sync it with your remote server.

• Copy the latest script: Open server/nakama/tekton_admin.js locally and copy its updated contents (including your new skin).
• Connect to your VPS via SSH.
• Create/Edit the file on the remote server:

  nano ~/tekton_admin.js
  # Or use micro (recommended): micro ~/tekton_admin.js
  

  Paste the copied contents and save the file.
• Find your Nakama Container ID: It is highly recommended to use lazydocker to manage containers. (To install on Ubuntu: curl https://raw.githubusercontent.com/jesseduffield/lazydocker/master/scripts/install_update_linux.sh | bash) Open lazydocker or run docker ps to find the Container ID for your Nakama server.
• Copy the file into the Nakama container:

  # Replace ed21ac5d442a with your actual Container ID
  docker cp ~/tekton_admin.js ed21ac5d442a:/nakama/data/modules/tekton_admin.js
  

• Restart the container (via lazydocker or docker restart <Container ID>) for Nakama to load the new modules. Live game clients will fetch this new catalog automatically upon booting.

🎨 Skin Creation & Deployment Flow

flowchart TD
    %% Creation Phase
    subgraph phase1 [Skin Material Creation]
        A[Albedo & Mask Textures] --> B{Skin Shader Generator}
        B -->|Export| C[material.tres]
    end

    %% Catalog Phase
    subgraph phase2 [Catalog Definition]
        C --> D{Skin Catalog Editor}
        D -->|Save & Generate| E[tekton_admin.js]
        D -->|Save & Generate| F[skin_manager.gd]
    end

    %% Deployment Phase (Dual Path)
    subgraph phase3 ["Shop Backend (VPS)"]
        E -->|SSH & nano| G[VPS: ~/tekton_admin.js]
        G -->|docker cp| H[Nakama Container]
        H -->|Restart| I[Live Shop Logic Sync]
    end

    subgraph phase4 ["Asset Delivery (CI/CD)"]
        C --> J[Git Push]
        F --> J
        J -->|GitHub Actions| K[patch.pck]
        K -->|Automatic Download| L[Player Client Assets Sync]
    end

Pushing a New Version (Automated Patching)

When you're ready to deploy new features or assets to players:

• Document your changes in CHANGELOG_DRAFT.md using player-friendly language.
• Run the version generation script from the terminal:

  python generate_version_json.py --bump patch
  

  (Use --bump minor or --bump major for larger updates.)
• Commit and push your changes to the main branch on GitHub:

  git add .
  git commit -m "Release version X.Y.Z"
  git push origin main
  

• The GitHub Actions Workflow (deploy_patch.yml) will automatically detect the push, build the patch manifest (version.json), and deploy it to the public gh-pages branch.
• Live game clients will detect the new version on boot, download the updated files, and apply the patch seamlessly.

Local Testing & Understanding the Patch System

When a player (or you) downloads an in-game patch, Godot downloads a patch.pck file to the system's user:// directory.

• Virtual File System: Godot mounts this .pck file over the res:// directory purely in memory. It does not physically overwrite your local source files (like assets/data/version.json).
• Editor Bypass: When testing locally in the Godot Editor, the BootScreen is configured to skip the remote network download and instead automatically parse your local assets/data/version.json.
• Previewing Changelogs: To preview how your changelog will look before pushing to GitHub:
  • Add your notes under the ## [NEXT] section in CHANGELOG_DRAFT.md.
  • Run py tools/generate_version_json.py from the terminal.
  • Run the BootScreen scene in the Godot Editor. It will instantly display the updated local UI!
• Syncing: After the GitHub Actions CI builds a release online, remember to run git pull origin main to sync your local project files with the CI-generated files.

🗺️ Architecture Flowchart

flowchart TD
    %% Local Dev Flow
    subgraph Local Dev Environment
        A[📝 CHANGELOG_DRAFT.md] -->|py tools/generate_version_json.py| B[(📄 version.json)]
        B -.->|Test in Editor| C{BootScreen}
        C -- Editor Bypass --> D[Reads Local version.json directly]
    end

    %% CI Pipeline
    subgraph "CI/CD Pipeline"
        B -->|git push| E[⚡ GitHub Actions]
        E -->|Compiles & Builds| F[📦 patch.pck]
        F -->|Deploys| G((🌍 Public Repository))
    end

    %% Live Client Flow
    subgraph Player Client
        G -.->|HTTP Download on Boot| H[📂 user://patch.pck]
        H -->|ProjectSettings.load_resource_pack| I[🧠 Godot Virtual File System]
        I -.->|Overrides res:// in Memory| J[Game Starts Updated!]
    end

---

🚀 Ongoing Features (Incoming)

🎰 Gacha System Backend Editor

Currently in development: A dedicated backend editor tool (similar to skin_catalog_editor.tscn) specifically for managing the Gacha System.

• Nakama Syncing: Will allow developers to push updated gacha pools, rates, and fragment costs directly to Nakama Storage.
• Dynamic Banners: Will support updating specific slots on the gacha banner dynamically.
• Seasonal Rotations: Will introduce automated scheduling so banners rotate based on active seasons and automatically remove themselves when the season ends.