Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

project-scaffold

/project-scaffold

Generuje nowy projekt gry w Godot ze standardową strukturą ECS i narzędziami, gdy plan gry jest zatwierdzony albo podano nazwę gry i gatunek.

Repozytorium
godotmaker ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
23.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
11
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 23.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Generuje nowy projekt gry w Godot ze standardową strukturą ECS i narzędziami, gdy plan gry jest zatwierdzony albo podano nazwę gry i gatunek.

Wyzwalacze z opisu

create a projectset up a new gamescaffoldinitializenew projectstart buildingletmake me a new Godot project
Oryginalny opis (EN)

Generate a new Godot game project with standardized ECS structure and tooling. Use when starting a new game: "create a project", "set up a new game", "scaffold", "initialize", "new project", "start building", "let's make it". Triggers after game-planner produces a confirmed plan, or when the user provides a game name + genre directly. Even for simple requests like "make me a new Godot project", use this skill to ensure proper ECS structure. Creates directory structure, project.godot, CLAUDE.md, gecs World setup, addon stubs, and template source files based on the game plan or user input.

Jak działa

  1. Step 1 — Gather Variables
  2. Step 2 — Create Directory Structure
  3. .tscn Generation Rules
  4. Step 3 — Fill Templates
  5. Step 4 — Genre Adaptations
  6. Step 5 — Post-Scaffold Steps
  7. Report
  8. What This Skill Does NOT Do
Sekcje z nagłówków SKILL.md, w oryginale · 182 linii, 1 074 słów
Podgląd SKILL.md
---
name: project-scaffold
description: |
  Generate a new Godot game project with standardized ECS structure and tooling.
  Use when starting a new game: "create a project", "set up a new game",
  "scaffold", "initialize", "new project", "start building", "let's make it".
  Triggers after game-planner produces a confirmed plan, or when the user
  provides a game name + genre directly. Even for simple requests like
  "make me a new Godot project", use this skill to ensure proper ECS structure.
  Creates directory structure, project.godot, CLAUDE.md, gecs World setup,
  addon stubs, and template source files based on the game plan or user input.
---

# Project Scaffold

$ARGUMENTS

Generate a new Godot game project with GodotMaker's ECS architecture.
Read templates from this skill's `templates/` directory, fill `{{placeholders}}`
with values from the game plan or user input, and write results to the target.

## Step 1 — Gather Variables

If a confirmed Game Plan exists in the conversation (from game-planner), extract
variables from it. Otherwise, ask the user for **game name** and **genre** at
minimum — use genre defaults for everything else.

| Variable | Source | Default |
|----------|--------|---------|
| `{{game_name}}` | user input, snake_case, used as directory name | *required* |
| `{{game_title}}` | user input or Title Case of game_name | *required* |
| `{{genre}}` | Game Plan "Genre" or user | `"platformer"` |
| `{{perspective}}` | Fixed framework target | `"2D"` |
| `{{viewport_width}}` | genre defaults table | `1280` |
| `{{viewport_height}}` | genre defaults table | `720` |
| `{{rendering_method}}` | fixed 2D renderer | `"gl_compatibility"` |
| `{{root_node_type}}` | fixed 2D root | `"Node2D"` |
| `{{camera_type}}` | fixed 2D camera | `"Camera2D"` |
| `{{game_description}}` | Game Plan summary or one-line from user | genre name + " game" |

**Genre defaults:**

| Genre | Viewport | Gravity | Input Actions |
|-------|----------|---------|---------------|
| Platformer | 1280x720 | 980.0 | move_left, move_right, jump |
| Top-down | 1280x720 | none | move_up, move_down, move_left, move_right |
| Puzzle | 1280x720 | none | select, confirm, cancel |
| Endless runner | 720x1280 | 980.0 | jump |

## Step 2 — Create Directory Structure

Create the project root and all subdirectories:

```
{{game_name}}/
├── project.godot
├── CLAUDE.md
├── .gitignore
├── src/
│   ├── components/          # C_ prefixed component scripts
│   ├── systems/             # NameSystem scripts
│   ├── entities/            # Entity scene definitions
│   └── ui/                  # UI scenes and scripts
├── scenes/
│   ├── main.tscn            # Entry point scene
│   └── game_world.tscn      # Gameplay scene with camera
├── test/
│   └── test_example.gd      # gdUnit4 test template
├── e2e/
│   └── conftest.py           # E2E test config (GODOT_PROJECT = "..")
├── assets/
│   ├── sprites/
│   ├── audio/
│   ├── fonts/
│   └── ui/
├── references/              # Optional user-provided style or identity images
└── addons/                  # gecs + gdUnit4 + godot_e2e installed here
```

## .tscn Generation Rules

When writing `.tscn` files (from templates or manually), follow these rules strictly:

1. **No UID references** — use `res://path/to/script.gd` paths, never `uid://xxx`. UID references fail in headless/CI environments because `uid_cache.bin` cannot be rebuilt.
2. **load_steps formula** — `load_steps = ext_resource_count + sub_resource_count + 1`. Count carefully; mismatch causes parse errors.
3. **parent attribute required** — only the root `[node]` omits `parent`. Every other node MUST have `parent="."` (direct child of root) or `parent="path/to/parent"`.
4. **World node setup** — always set `system_nodes_root = NodePath(".")` and `entity_nodes_root = NodePath(".")` when using SystemGroups.

## Step 3 — Fill Templates

Read each template from `templates/`, replace all `{{placeholders}}`, write output.
Remove any template comments (lines starting with `; TEMPLATE:`) from the output.

| Template | Output Path | Notes |
|----------|------------|-------|
| `project.godot.tmpl` | `project.godot` | Must be valid Godot ConfigFile |
| `claude.md.tmpl` | `CLAUDE.md` | Fill game info + ECS reference |
| `gitignore.tmpl` | `.gitignore` | Use as-is, no placeholders |
| `main_scene.tmpl` | `scenes/main.tscn` | Use a 2D root node |
| `world_scene.tmpl` | `scenes/game_world.tscn` | Use 2D node + camera types; gameplay scene gets a World child node added during `/gm-build` |
| `test_example.tmpl` | `test/test_example.gd` | Replace `{{GameNamePascal}}` |
| `component.tmpl` | `src/components/c_example.gd` | Example stub |
| `system.tmpl` | `src/systems/example_system.gd` | Example stub |

### gecs World setup

gecs v7.1.0 ships `class_name World` in `addons/gecs/ecs/world.gd`. The
canonical scene-node pattern:

- Add a `Node` child to your gameplay scene with
  `script = res://addons/gecs/ecs/world.gd`, named `World`, with
  `system_nodes_root = NodePath("Systems")` and
  `entity_nodes_root = NodePath("Entities")`.
- The main scene script wires it up:
  `@onready var world: World = $World` then `ECS.world = world` in `_ready()`.
- Drive systems via `world.process(delta, "gameplay")` /
  `world.process(delta, "physics")` from `_process` / `_physics_process`.

Scaffold leaves the World node out — gameplay scene structure is filled in
during `/gm-build`. See the gecs skill for the full World API.

### Game Plan ECS stubs

If the Game Plan includes an ECS Architecture section with components and systems:

- **Components**: for each planned component (e.g., `C_Velocity`), create a file in
  `src/components/` based on `component.tmpl`. Fill the class name and add `@export`
  vars from the plan.
- **Systems**: for each planned system (e.g., `MovementSystem`), create a file in
  `src/systems/` based on `system.tmpl`. Fill the class name and `query()` with
  the required components.
- **World**: register systems by adding them as children of the gameplay
  scene's `World` node — see "gecs World setup" above for the full pattern.

## Step 4 — Genre Adaptations

After writing base template files, apply genre-specific modifications to `project.godot`:

**Platformer / Endless runner** (gravity games):
- Add `[physics]` section: `2d/default_gravity=980.0`
- Add `[input]` section with move + jump actions

**Top-down**:
- No `[physics]` section
- Add `[input]` section with 4-directional movement

For input action serialization format, read `references/project_settings.md`
— it has the exact Object() syntax and key code table.

## Step 5 — Post-Scaffold Steps

After all files are written, tell the user what to do next:

1. **Deploy GodotMaker skills** to the new project:
   ```bash
   bash <godotmaker_repo>/shell/publish.sh {{game_name}}/
   ```
   This copies skills to `.claude/skills/`, creates `godotmaker.yaml`
   (prompts for Godot executable path on first run), and creates
   `.godotmaker/config.yaml` with default project settings.

2. **Install addons** — pick the row matching your Godot version from the
   active runtime's `config/addon_versions.json` (the source of truth for repo,
   tag, and install path), then install addon-only directories:
   - gecs -> `addons/gecs/`
   - gdUnit4 -> `addons/gdUnit4/`
   - godot_e2e -> `addons/godot_e2e/`

   `tools/check_project.py --e2e` and the gm-* skills expect those
   exact paths (note `gdUnit4/` is capital U — matches the upstream
   repo layout). See `references/addons.md` for the step-by-step
   installation contract.

3. **Register godot-mcp** for runtime debugging:
   ```bash
   claude mcp add godot -e GODOT_PATH="<godot_path>" -- npx @coding-solo/godot-mcp
   ```

4. **Verify** with headless-build: `godot --headless --quit 2>&1`

## Report

After scaffold completes, output:
- Project path (absolute)
- File tree listing
- Checklist of pending post-scaffold steps

## What This Skill Does NOT Do

- Does not implement game logic — only creates the starting structure
- Does not install addons — provides instructions in references/addons.md
- Does not run game-planner — expects a plan or minimal user input already
- Does not deploy skills — that is publish.sh's job
Pliki w paczce (11)
  • SKILL.md 8 KB
  • references/addons.md 3 KB
  • references/project_settings.md 3 KB
  • templates/claude.md.tmpl 3 KB
  • templates/component.tmpl 1 KB
  • templates/gitignore.tmpl 1 KB
  • templates/main_scene.tmpl 1 KB
  • templates/project.godot.tmpl 1 KB
  • templates/system.tmpl 1 KB
  • templates/test_example.tmpl 1 KB
  • templates/world_scene.tmpl 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · randallliuxin/godotmaker100Apache-2.0
Rene-Roscher/skills100Apache-2.0
nealcaren/social-data-analysis100MIT
kjgarza/marketplace-claude100MIT

Migawka bazy z 13.11.2026 · wersja paczki 611d4436bedc (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 2 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 84init
    Zakłada nowy projekt ze standardową strukturą katalogów, plikami szablonowymi i repozytorium git.
  • 100new
    Zakłada nową grę w Godot 4 z szablonu godot-kit, z testami skryptów, zrzutami ekranu i odtwarzaniem wejścia od pierwszej minuty.
  • 100gecs
    Opisuje API frameworka ECS gecs dla Godot 4.x: Entity, Component, System, World, QueryBuilder, Relationship, Observer, CommandBuffer i SystemTimer oraz zapytania po składzie komponentów.
  • 100godot-project-setup
    Zakłada nowy projekt Godot 4.x z zalecaną strukturą katalogów, ustawieniami projektu, autoloadami i plikiem .gitignore.
  • 100project-setup
    Zakłada nowy projekt ze standardową strukturą, gitem, README, CLAUDE.md i konfiguracją serwera deweloperskiego.
  • 100project-create
    Inicjuje nowy projekt od zera: struktura repozytorium, dokumentacja, narzędzia jakości i CI/CD.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.