Merge pull request '[AI Docs] Phase 7 Release Preparation' (#11) from akettel/AI-docs into develop

Reviewed-on: #11

AI Docs/PLAN.md

@@ -0,0 +1,72 @@
+Here’s a phased development roadmap for **YeetGeese**, structured around indie pacing and optimized for Godot 4.x workflows. Each phase includes core deliverables, Godot-specific implementation notes, and how the first-person TD + goose-throwing twist is handled.
+
+---
+
+### Phase 1: Pre-Production & Design (Weeks 1–3)
+**Goal:** Lock scope, define the loop, set up the project structure.
+- **Core Loop Doc:** Spawn wave → position/aim → throw geese → defend choke point/base → upgrade/reward → next wave.
+- **Art/Tone Direction:** Stylized low-poly or cartoonish (eases iteration). Geese should read clearly in motion.
+- **Technical Spec:** Node hierarchy, scene boundaries, data flow (Resource-driven balance tables recommended).
+- **Godot Setup:**
+  - Project structure: `res://src/`, `res://art/`, `res://audio/`, `res://scenes/` with clear naming (`goose.tscn`, `enemy_spawner.gd`).
+  - Use Godot’s built-in version control integration or Git + `.gdignore`.
+  - Set up export templates early (itch.io web build for playtests, Windows/Linux for QA).
+
+---
+
+### Phase 2: Core Prototype (Weeks 4–6)
+**Goal:** Playable loop with no art polish. Prove the throw mechanic & TD flow work in first-person.
+- **FPS Controller:** `CharacterBody3D` + mouse look (`Input.mouse_mode = Input.MOUSE_MODE_CAPTURED`). Add walk/run, crouch if needed for aiming stability.
+- **Goose Throw System:**
+  - Instantiation: `var g = preload("res://scenes/goose.tscn").instantiate()` → add to a dedicated `ProjectileLayer` node so geese don’t collide with each other or the player.
+  - Physics/projectile logic: Apply initial velocity + gravity via `_physics_process()`, or use `RigidBody3D` for bouncy, chaotic honking (lean into it).
+  - Aim assist/crosshair via a fixed `Sprite3D` in front of the camera.
+- **Enemy Pathing:** `NavigationRegion3D` on level geometry → enemies inherit `NavigationAgent3D` to route toward your base/heart node.
+- **Wave Manager:** Autoload or scene-local manager that tracks spawn timers, enemy count, and triggers UI/audio events via signals.
+- **Godot Tip:** Use **Signals** everywhere (`goose_impact`, `wave_cleared`) to keep systems decoupled. Balance numbers live in a `.tres` Resource file so you can tweak mid-playtest without touching code.
+
+---
+
+### Phase 3: Vertical Slice & Systems (Weeks 7–10)
+**Goal:** One polished, complete level with full UI/audio/save functionality.
+- **HUD/UI:** `CanvasLayer` for health bar, score, throw cooldown/charge meter. Use Godot’s control nodes + anchors; test on multiple resolutions early.
+- **Progression/Upsell:** Goose powerups (bigger honk radius, sticky geese, flock shot) stored in a player stat Resource.
+- **Audio Pipeline:** `AudioStreamPlayer3D` for spatialized throws/honks, `AudioBus` layout for SFX/music/Master so you can mix per platform.
+- **Save System:** Serialize wave progress/unlocks to JSON or a Godot `ResourceSaver` file in `user://`. Load on startup via an autoload `GameManager`.
+- **Playtesting Loop:** Build → share itch web build → iterate cooldowns/damage/spawn curves using your balance Resource.
+- **Godot Tip:** Use the **Debugger > Profiler** to watch FPS/memory while waves scale up. Enable `Rendering > Quality > VoxelGI` or baked lighting if you go 3D art-heavy, but keep it lightweight for indie budgets.
+
+---
+
+### Phase 4: Content Production & Levels (Weeks 11–16)
+**Goal:** Ship the full game scope. Multiple arenas, enemy variety, upgrade tree.
+- **Level Design:** Build 5–8 distinct arenas using modular `GridMap` or instanced scene pieces. Vary choke points to force different throw angles/strategies.
+- **Enemy Types:** Rushers, tanks that absorb hits before routing, splitters, maybe a "farmer" enemy that drops currency you can grab between waves.
+- **Goose Synergy:** Add placement-style mechanics if desired (e.g., drop a `GooseNest.tscn` that auto-throws weak geese while you aim heavy throws). Keep the first-person perspective central to aiming.
+- **Polish Systems:** Screen shake on big hits, hit markers, dynamic music intensity tied to wave danger level.
+- **Godot Tip:** Preload heavy scenes with `ResourceLoader.load_threaded_request()` if levels are large. Use `Object.set_physics_process_group()` for systems that need to run independently of the main loop (rare but useful for spawners).
+
+---
+
+### Phase 5: Polish, QA & Launch Prep (Weeks 17–20)
+**Goal:** Stable, performant, release-ready build.
+- **QA & Optimization:** Fix collision layer conflicts, clamp delta time drift, profile with Godot’s built-in profiler. Enable `Editor > Project Settings > Rendering > Quality` scaling for low-end PCs.
+- **Input/Accessibility:** Remappable controls via `ProjectSettings.input_map`, colorblind-safe UI, volume sliders tied to your AudioBus layout.
+- **Export & Distribution:** Test each export template on target OS. Set up itch.io page + demo build (Godot’s one-click web export is perfect here).
+- **Launch Assets:** Record gameplay in Godot with `Movie Maker` mode or external software, cut a trailer, write store description focusing on the "first-person TD + thrown geese" hook.
+
+---
+
+### Godot Architecture Recommendations for YeetGeese
+1. **Scene-First Design:** Every entity is its own `.tscn` + `.gd`. Player, Goose, Enemy, Spawner, HUD each encapsulated.
+2. **Data-Driven Balance:** All numbers (throw cooldown, goose mass, enemy HP/spawn rate) live in `Resource` files or JSON autoloads. Swap balance tables without recompiling.
+3. **Signal Bus Pattern:** A lightweight autoload (`Signals.gd`) holding global events (`wave_started`, `enemy_died`, `base_hit`) keeps your manager code clean and UI/audio reactive.
+4. **Collision Layers:** Player/Geese on layer 1, Enemies on 2, Base on 3. Geese mask enemies+base only → no self-collision or environment clutter hits.
+
+---
+
+### Immediate Next Steps
+1. Block out the scene hierarchy in Godot: `Main.tscn` → `Player`, `WaveManager`, `HUD`.
+2. Implement the goose throw prototype with a placeholder `RigidBody3D` + gravity + damage on collision.
+3. Wire one enemy using `NavigationAgent3D` toward your base node.
+4. Get the web export working and share a raw prototype build to test aiming feel in first-person.