Update to Unity

{
  "description": "Guides creating a new Unity project, gathering concept, platforms, and monetization before setting up the project, source control, and packages. Use when the user asks to start a new game or prototype.",
  "included_files": [],
  "name": "new-unity-project",
  "skill_md_contents": "---\nname: new-unity-project\ndescription: Guides creating a new Unity project, gathering concept, platforms, and monetization before setting up the project, source control, and packages. Use when the user asks to start a new game or prototype.\nallowed-tools:\n  - Bash\n  - Read\n  - Write\n  - Edit\n  - AskUserQuestion\n---\n\n# New Unity Project\n\nA guided flow from an idea to a running, version-controlled Unity project. This skill owns the\n**flow** — the questions, their ordering, running slow installs in the background while you ask,\nand the handoffs. It deliberately does **not** re-document commands; it delegates the mechanics\nto other skills.\n\n**Delegates to (read these for the actual commands — don't reinvent them):**\n- **`unity-cli`** — CLI install, auth/license, Editor install, project creation, source control,\n  opening the project. Its \"Bootstrap a new project from scratch\" workflow is the backbone here.\n- **`unity-package-management`** — installing packages via the C# PackageManager Client API, and\n  choosing packages by genre / platform / monetization.\n- **`urp-postprocessing`**, **`ui`**, **`2d-pixel-perfect`** — the visual baseline (Step 6):\n  post-processing volume setup, HUD framework choice, pixel-perfect 2D.\n- **`implement-in-app-purchases`**, **`levelplay-unity-integration`**, **`build-live-game`** —\n  monetization / backend *integration* (invoked at the end).\n\n**Work one step at a time.** Ask only the current step's questions and wait for the user before\nmoving on — platform and monetization answers change what you install, so don't gather everything\nup front or scaffold before they're settled.\n\n## The flow — and where the parallelism is\n\n1. **Concept** — what they're building.\n2. **Platforms & monetization** — then, as soon as platforms are known, **kick off the Editor\n   install in the background** (it takes minutes) and keep talking.\n3. **(joins)** Editor + platform modules finish installing.\n4. **Project + source control** — create from a **URP** template matching 2D/3D; init git.\n5. **Packages** — install via the C# Client API.\n6. **Visual baseline** — post-processing, camera, quality tier, UI stack, pipeline-correct\n   shaders, so the first frame doesn't look like an untouched template.\n7. **Save & first commit.**\n8. **Hand off** monetization / backend.\n\nThe whole point of a guided flow over a raw recipe: the multi-minute Editor install overlaps the\nminutes the user spends answering concept questions, so setup feels instant.\n\n## Step 1 — Concept\n\nUse `AskUserQuestion` so the user can pick fast, but let them answer freely too. Cover:\n\n- **Genre / core loop** — platformer, top-down shooter, puzzle, idle, RPG, racing, card, tower\n  defense, sim, hyper-casual, first-person, etc.\n- **Dimension & look** — 2D or 3D; art style (pixel, low-poly, stylized, realistic, UI-only).\n- **Gameplay** — the one-sentence \"what the player does moment to moment.\"\n- **Scope** — single-screen prototype vs. multi-scene game; single-player or multiplayer.\n\nAlso settle on a **project name**. Write a 2–4 line **project brief**, read it back to confirm.\nThe brief drives template choice (Step 4), packages (Step 5) and the visual baseline (Step 6):\nnote the palette / mood words the user gives, and whether the look is pixel art.\n\n## Step 2 — Platforms & monetization, then start installing\n\nTwo decisions, because both change what you install:\n\n- **Target platforms** (multi-select): Desktop (Win/macOS/Linux), Mobile (iOS/Android), WebGL,\n  Console. These map to Editor **modules** (Step 3) and argue for leaner packages on mobile/WebGL.\n- **Monetization**: none / premium / in-app purchases / ads / mix. This only decides which\n  handoff skill you invoke in Step 8 — don't integrate it now.\n\nConfirm the Editor version to use (**default: latest LTS** — see `unity-cli` for the LTS vs. Tech\nvs. beta trade-off). Ask this *now*, before kicking off the install, so you don't install the\nwrong one.\n\nThen confirm prerequisites and **launch the Editor install as a background task** so it runs while\nyou continue. See the `unity-cli` skill for exact syntax, module names per platform, and auth /\nlicense setup:\n\n```bash\nunity --version\nunity auth status --format json      # if signed out:  unity auth login\nunity license status --format json   # if none active: unity license activate\n\n# Start in the BACKGROUND, then go straight back to the conversation. Module names per platform\n# (android / ios / webgl / …) are in the unity-cli skill.\nunity install lts --module <platform-modules> --yes --accept-eula\n```\n\nRun that install as a **background task** (don't block on it). If you have nothing left to ask,\nit's fine to just wait — the parallelism only helps when there's a conversation to overlap.\n\n## Step 3 — Join: Editor ready\n\nBefore creating the project, confirm the background install finished:\n\n```bash\nunity editors --installed --format json\n```\n\nIf it failed, surface the error (see `unity-cli` troubleshooting) and stop — nothing downstream\nworks without an Editor.\n\n## Step 4 — Create the project + source control\n\nFollow the **`unity-cli`** \"Bootstrap a new project from scratch\" workflow verbatim:\n\n- List the **real** template ids the Editor offers (`unity templates list --type core`) and pick by\n  **render pipeline**, not just 2D/3D — don't guess ids. **Default to URP:**\n  `com.unity.template.urp-blank` (\"Universal 3D\") for 3D, `com.unity.template.universal-2d`\n  (\"Universal 2D\") for 2D. `com.unity.template.3d` / `com.unity.template.2d` are the **Built-in\n  Render Pipeline** templates — deprecated from Unity 6.5, removed in 6.7 — so choose them only\n  when the user explicitly asks for Built-in. Confirm the pick against the JSON `renderPipeline`\n  field (blank for universal-2d on current releases, so match that one by id).\n- Create with `unity projects create \"<Name>\" --path <dir> --editor-version <v> --template <id>`.\n- Set up source control — **ask the user which they want**, don't assume: Git (GitHub / GitLab;\n  add `--git-lfs` for asset-heavy games) or **Unity Version Control** (`--vcs uvcs`, which handles\n  large binary assets natively — no LFS), or a purely local `git init` + Unity `.gitignore`.\n  Publish in one step with `unity projects create --vcs … --git-token-stdin --no-initial-commit`\n  (tokens on stdin). Pass **`--no-initial-commit`** so the CLI doesn't commit the bare project\n  before packages and `.meta` files exist — you make the real first commit/check-in in Step 7.\n  See the `unity-cli` workflow for exact flags.\n\n## Step 5 — Packages\n\nMap the brief to a concrete package list and install it via the **`unity-package-management`**\nskill (C# PackageManager Client API — **never** hand-edit `manifest.json`). Read that skill for\nthe genre/platform/monetization → package mapping, the installer script, and the `-quit` gotcha.\nThe template already provides the render pipeline — never add `com.unity.render-pipelines.universal`\nto a Built-in template project (nothing assigns a URP asset; materials go pink) or vice versa.\nRead the final list back to the user before installing; verify `manifest.json` afterward.\n\n## Step 6 — Visual baseline\n\nA fresh template renders correctly but looks like a default: no tonemapping, untouched quality\ntier, flat colors. Left there, agents reach for `OnGUI` and guess shader names, which is where\nwashed-out or magenta materials come from. Apply this floor **before** any gameplay work.\n\n**First, `unity pipeline install --project-path \"<project-path>\"`, before opening the\nEditor.** Running C# in the Editor, and `unity command screenshot` below, both need the\nproject's `com.unity.pipeline` package. A project created in Step 4 does not have it, and Step 5\ndoes not add it: that step installs packages by launching the Editor binary with\n`-batchmode -executeMethod`, which never touches the package. Installing before the open is the\nsupported order — the install updates `Packages/manifest.json`, which Unity reads at project\nload. Run it against an already-open project and the CLI reports\n`PIPELINE_MANIFEST_WRITE_FAILED`; ask the user to close the Editor and re-run. Without the\npackage, everything below fails to connect, which looks like the Safe Mode failure `unity-cli`\ndescribes but has a different cause.\n\n**Then** `unity open \"<project-path>\"` (also what Step 7 needs), wait until `unity status`\nreports the Editor ready, and apply each item below by running C# in it. **`unity-cli` owns\nthose commands and their syntax** — don't re-derive them here.\n\n**Items 1, 2, 5 and 6 assume a URP template**, which is the Step 4 default. If the user\nexplicitly chose Built-in, don't run them as written: `UniversalAdditionalCameraData`, `Light2D`,\nthe `urp-postprocessing` volume framework and every `Universal Render Pipeline/*` shader are URP\ntypes that do not exist there, so the generated C# won't compile. On Built-in, items 3 and 4\nstill apply as written, post-processing means the legacy Post Processing Stack, and the shader\nnames are `Standard` / `Unlit/Color`. Don't reach for `migrate-birp-to-urp` — the user asked for\nBuilt-in.\n\n1. **Post-processing.** Global Volume with Tonemapping (ACES), low Bloom (intensity 0.5–1,\n   threshold 0.9) and a subtle Vignette (≈ 0.25); set `renderPostProcessing = true` on the main\n   camera's `UniversalAdditionalCameraData`. **REQUIRED SUB-SKILL:** `urp-postprocessing` — its\n   code templates create the volume and check HDR and the Volume layer mask.\n2. **Camera and light.** 2D → orthographic, solid background color from the brief's palette, and\n   a `Light2D` of type Global in the scene if the template scene has none (the Sprite-Lit shaders\n   render black without one). 3D → perspective; keep the template's directional light and skybox,\n   main-light shadows on.\n3. **Quality tier.** Read `QualitySettings.names` first — tier names differ per template — then\n   `QualitySettings.SetQualityLevel` to the one matching the primary target: the highest tier for\n   desktop, the lowest for mobile/WebGL. Leave color space Linear and the Input System as the\n   template set them.\n4. **UI stack.** HUD and menus use a uGUI Canvas + TextMeshPro or UI Toolkit — **never `OnGUI`**.\n   **REQUIRED SUB-SKILL:** `ui` picks between them for the project.\n5. **Materials and shaders.** Under URP use `Universal Render Pipeline/Lit`, `…/Unlit`,\n   `…/2D/Sprite-Lit-Default` or `…/2D/Sprite-Unlit-Default`. `Standard` and `Unlit/Color` render\n   pink or washed out under URP. Prefer `GraphicsSettings.currentRenderPipeline.defaultMaterial`\n   / `.default2DMaterial` over `Shader.Find`, and treat a `null` from `Shader.Find` as an error.\n   `currentRenderPipeline`, not `defaultRenderPipeline`: a quality tier can carry its own pipeline\n   asset, and item 3 above just set the tier.\n6. **Pixel art only.** Point filter mode on sprites and a Pixel Perfect Camera — see\n   `2d-pixel-perfect`.\n\nSave the scene, then confirm both of these. **Not with `unity logs`** — that reads the CLI's own\nlog, never the Editor's, so it reports clean whatever the scene looks like:\n\n- No render-pipeline or shader errors Editor-side. Read the Editor console through `unity-cli`,\n  or read `Editor.log` directly — that skill's \"Recovering from Safe Mode\" section has the\n  per-platform paths.\n- `unity command screenshot --output baseline.png` looks lit and tonemapped rather than flat\n  gray.\n\n## Step 7 — Save & first commit\n\nThe project is already open from Step 6, so `.meta` files exist. Make the first commit **with\nwhichever VCS you set up in Step 4**:\n\n```bash\nunity open \"<project-path>\"     # only if not already open; for headless/CI use the\n                                # \"Import & save headlessly\" method in unity-package-management\n```\n\n- **Git (GitHub / GitLab / local):**\n  ```bash\n  cd \"<project-path>\"\n  git add -A\n  git status                    # Library/ Temp/ obj/ Build/ must NOT be staged\n  git commit -m \"Initial Unity project: <Name>\"\n  ```\n  Every `.cs`/asset must be committed together with its `.meta`.\n- **Unity Version Control (UVCS):** check in through your UVCS client/workspace (created during\n  Step 4) — there's no `git` step. Generated folders are still excluded by the ignore rules.\n\nIf you published via `--vcs` in Step 4 **without** `--no-initial-commit`, the CLI already made an\ninitial commit of the bare project — add a follow-up commit here rather than double-committing.\n\n## Step 8 — Hand off\n\nBased on Step 2 monetization, invoke the matching skill for the actual integration:\n- IAP → **implement-in-app-purchases**\n- Ads → **levelplay-unity-integration**\n- Accounts / cloud save / economy / remote config / leaderboards → **build-live-game**\n\nReport the project path, Editor version, render pipeline and template, installed packages, the\nvisual baseline applied, and next steps.\n\n## Scope — what this skill does NOT do\n\n- **No gameplay scaffolding.** It gets you to a running, wired project with a visual floor;\n  building the actual game (scenes, controllers, art) is the next conversation — iterate there\n  with the Editor via the `unity-cli` MCP server and the Package Manager. Generic genre skeletons\n  tend to produce throwaway mocked primitives, so this skill intentionally stops at a clean\n  starting point. The visual baseline (Step 6) is settings, not content.\n- **No command reference.** Syntax lives in `unity-cli` / `unity-package-management`.\n\n## Checklist\n\n- [ ] Concept brief captured and confirmed (genre, look, gameplay, scope, name)\n- [ ] Platforms + monetization recorded; Editor version chosen\n- [ ] Editor + platform modules installed (started in the background during Step 2)\n- [ ] Project created from a **URP** template (`urp-blank` / `universal-2d`) unless Built-in was\n      explicitly requested; git initialized with a Unity `.gitignore`\n- [ ] Packages installed via the C# Client API; `manifest.json` verified; no render-pipeline package added on top of the template\n- [ ] Visual baseline applied: global Volume (tonemapping, bloom, vignette) + camera post-processing on,\n      quality tier set for the target, UI stack chosen (no `OnGUI`), URP shader names, screenshot checked\n- [ ] Project opened/saved so `.meta` files exist; first commit made; `Library/` excluded\n- [ ] Handed off to the monetization/backend skill if applicable\n\n## Common mistakes\n\n- **Blocking on the Editor install** instead of backgrounding it while you ask questions.\n- **Installing the wrong Editor** because the version wasn't confirmed before the background install.\n- **Gathering all questions up front** — platform/monetization answers change the modules and packages.\n- **Hand-editing `manifest.json`** instead of using the Client API (see `unity-package-management`).\n- **Committing `Library/`/`Temp/`/`obj/`/`Build/`**, or scripts without their `.meta` files.\n- **Missing Editor modules** — a mobile target needs `android`/`ios`; WebGL needs `webgl`.\n- **Picking `com.unity.template.2d` / `.3d` because the name matches** — those are the Built-in\n  pipeline templates. Use `universal-2d` / `urp-blank`.\n- **Skipping the visual baseline** and shipping the template's flat defaults, then building the\n  HUD with `OnGUI` and materials with `Shader.Find(\"Standard\")` under URP.\n"
}