97 lines
5.0 KiB
Markdown
97 lines
5.0 KiB
Markdown
# Tekton Dash Armageddon
|
|
|
|
|
|
## 🛠️ Developer Workflows
|
|
|
|
### 1. Creating a Skin Material
|
|
To create dynamic, color-maskable 3D materials for new character skins:
|
|
1. Open the **Skin Shader Generator** tool in the editor: `res://scenes/tools/skin_shader_generator.tscn`
|
|
2. Run the scene.
|
|
3. Import your base albedo and mask textures.
|
|
4. Use the UI to visualize UV overlays and adjust color channels (Red, Green, Blue, Alpha masks).
|
|
5. Export the configured material as a `.tres` file into the `assets/materials/skins/` directory.
|
|
|
|
### 2. Adding a Skin to the Shop
|
|
Once your material is ready, you need to add it to the game's economy so players can buy and equip it. This is done by updating the Nakama backend module.
|
|
|
|
1. **Copy the latest script:** Open `server/nakama/tekton_admin.js` locally and copy its updated contents (including your new skin).
|
|
2. **Connect to your VPS** via SSH.
|
|
3. **Create/Edit the file on the remote server:**
|
|
```bash
|
|
nano ~/tekton_admin.js
|
|
# Or use micro (recommended): micro ~/tekton_admin.js
|
|
```
|
|
Paste the copied contents and save the file.
|
|
4. **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.
|
|
5. **Copy the file into the Nakama container:**
|
|
```bash
|
|
# Replace ed21ac5d442a with your actual Container ID
|
|
docker cp ~/tekton_admin.js ed21ac5d442a:/nakama/data/modules/tekton_admin.js
|
|
```
|
|
6. **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.
|
|
|
|
### 3. Pushing a New Version (Automated Patching)
|
|
When you're ready to deploy new features or assets to players:
|
|
1. Document your changes in `CHANGELOG_DRAFT.md` using player-friendly language.
|
|
2. Run the version generation script from the terminal:
|
|
```bash
|
|
python generate_version_json.py --bump patch
|
|
```
|
|
*(Use `--bump minor` or `--bump major` for larger updates.)*
|
|
3. Commit and push your changes to the `main` branch on GitHub:
|
|
```bash
|
|
git add .
|
|
git commit -m "Release version X.Y.Z"
|
|
git push origin main
|
|
```
|
|
4. 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.
|
|
5. Live game clients will detect the new version on boot, download the updated files, and apply the patch seamlessly.
|
|
|
|
### 4. 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:
|
|
1. Add your notes under the `## [NEXT]` section in `CHANGELOG_DRAFT.md`.
|
|
2. Run `py tools/generate_version_json.py` from the terminal.
|
|
3. 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
|
|
```mermaid
|
|
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.
|