YeetGeese/AI Docs/PLAN.md

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.