tower-lane

# Tower Lane

A tower-defense is a planning puzzle on a path, not a shooter with free aim. Enemies walk a lane (or a maze that must never fully block); waves are data; towers auto-acquire by priority; gold from kills and clear bonuses funds the next placement; leaks cost lives *and* bounty. If HP grows slower than income, the game goes soft. If one tower answers every enemy type, there is no decision.

Inspired by gamedev-skills/awesome-gamedev-agent-skills tower-defense (Apache-2.0). Original Grok remake. Complements gold-sink (loot tables / shop sinks — not kill bounty curves), pawn-mind (creature brains beyond path-follow), room-flow (authored room pacing), hud-stack (lives/gold/wave chrome), juice-pass (fire/hit/leak feel), save-slot (persist map+towers+wave index), stick-map (build/select input), tick-mass (projectile feel), seed-map (procgen maps). Not craft-loop. Not a Godot tutor.

Read `references/lane-rails.md` before you design. Fill the three templates under `templates/`.

## When to use

- Tower defense / wave defense: place towers that auto-fire at enemies on a path
- Lane waypoints or maze TD with path recompute and no softlock block
- Wave composition, pacing (spike → breather → spike), next-wave telegraph
- Tower identity: range, fire rate, damage, splash, cost, targeting priority
- Economy: kill bounty, wave-clear bonus, upgrade vs build, sell refund
- Lives / leak model; prep phase and optional early-wave bonus

## When NOT to use

- Player-controlled shooter / twin-stick → different genre (not this skill)
- Survival gather-craft-base ladder → craft-loop
- Loot tables, shops, meta sinks → gold-sink
- Full NPC/creature AI beyond path-follow + leak → pawn-mind
- Authored room beat sheets without a TD loop → room-flow
- World / heightmap procgen → seed-map
- Persist schema / slot files → save-slot
- HUD layout for lives/gold → hud-stack
- Fire/hit/leak juice → juice-pass
- Build/select rebind → stick-map
- Projectile rigid-body feel → tick-mass
- Godot/Unity APIs, copied GDScript/C# → godot-teacher
- Cheats, aimbots, wallhacks, malware, CSAM

## Inputs

- Fantasy in their words (classic lane, maze-builder, sci-fi rail, mix — name the mix last)
- Path model: fixed waypoints / grid maze / hybrid
- Win goal (survive N waves, clear a campaign map, hold until boss)
- Starting gold, starting lives, sell refund fraction
- Tower archetypes they named (or a labeled `[GUESS]` set: cheap-wide, mid, expensive-tall, splash, anti-air)
- Enemy variety they care about (fast, armored, flying, swarm, boss — do not invent a sixth without asking)
- Whether maze placement can reshape the path (must forbid full block)
- What later systems consume (gold-sink, hud-stack, save-slot, pawn-mind, juice-pass)

## Procedure

1. Read `references/lane-rails.md`. Refuse cheats, aimbots, wallhacks, malware, CSAM, copied GDScript/C#, and Godot/Unity API tours. Hand off: gold-sink (loot/shops), pawn-mind (brains), room-flow (authored rooms), hud-stack (chrome), juice-pass (FX), save-slot (persist), stick-map (input), tick-mass (physics), seed-map (procgen), craft-loop (survival), godot-teacher (node APIs).
2. Fill `templates/lane-card.md`. Lock path model, lives, prep phase, win goal. Fixed waypoints are authored lanes; maze TD recomputes path when towers change and rejects placements that sever spawn→goal.
3. Fill `templates/wave-economy.md`. Waves are data: `(enemy_type, count, spacing)` lists with geometric HP growth (~1.1–1.2× as a starting knob). Towers name range, DPS pieces, cost, and targeting mode (first / last / closest / strongest / weakest). Economy: kill bounty + clear bonus vs tower/upgrade spend; leaks lose bounty too. Run the "can this lane hold?" sanity: summed damage while in range ≥ HP, accounting for single-target focus.
4. Enemy variety must counter one-build wins (armor vs low-damage rapid, flying vs ground-only, swarm vs single-target). Upgrade returns diminish so tall competes with wide.
5. Pace waves: spike → breather → spike. Telegraph flying/boss one wave ahead. Optional early-start bonus for confident players.
6. Movement and fire intervals scale with *dt*. Persist map + tower placements + wave index + gold + lives via save-slot — this skill names *what*, not the file format.
7. Fill `templates/verify-lane.md`. Prove: path never softlocks, waves are data, targeting modes differ, HP vs income curves, leak costs lives+bounty, telegraph exists, *dt* scaling, no god-tower monopoly.
8. Tiny original engine-neutral notes only if useful. No copied tutorial snippets. No cheat overlays.
9. Deliver the three templates. One closing line: this is a tower-lane worksheet; not a Godot tutor or a loot table.

## Output format

- Lane card (path model, lives, prep, win goal, placement rules)
- Wave-economy card (waves as data, towers, targeting, DPS hold check, income vs spend)
- Verify-lane checklist (no softlock, curves, leak penalty, telegraph, *dt*, no monopoly)
- One line: tower-lane worksheet; not a Godot tutor or a loot table

## Safety

- Follow `references/lane-rails.md` with no exceptions.
- Gaming design only. Engine-neutral notes. Not a Godot tutor.
- No cheats, aimbots, wallhacks, malware, or exploit kits.
- No CSAM in enemy/tower names, flavor text, or mock waves.
- No copied GDScript/C# or vendor TD dumps. Tiny original notes only.

## Stop conditions

- Three templates delivered, or refused for cheats / wallhacks / godot-teacher API tours / loot tables (gold-sink) / survival craft (craft-loop) / creature AI (pawn-mind) / room beats (room-flow) / procgen (seed-map) / persist schema (save-slot) / HUD chrome (hud-stack) / juice FX (juice-pass) / input map (stick-map) / physics feel (tick-mass) / player-aim shooter / copied vendor dumps