Godot Genre Tower Defense

Core Loop

1. Prepare: Build/upgrade towers with available currency
2. Wave: Enemies spawn and traverse path toward goal
3. Defend: Towers auto-target and damage enemies
4. Reward: Kills grant currency
5. Escalate: Waves increase in difficulty/complexity

NEVER Do (Expert Anti-Patterns)

Design & Strategy

• NEVER make all towers have the same niche; strictly ensure distinct specialties: Aura Slow, Armor Piercing, Anti-Air, Burst Sniper, and Splash Damage.
• NEVER allow a "Death Spiral" with no exit; strictly provide small comeback bonuses or interest on saved gold to prevent early inevitable failure.
• NEVER make early waves feel like busywork; strictly provide an "Early Call" bonus to skip wait times and accelerate engagement.
• NEVER trust client-side economy updates; strictly require the authoritative server to validate currency addition and tower purchases in co-op.

Pathing & Placement

• NEVER allow the player to "Seal" the exit in mazing games; strictly validate path existence with NavigationServer2D.map_get_path() before finalizing tower placement.
• NEVER use synchronous bake_navigation_polygon() for mazing; strictly offload to a worker thread to prevent 100ms+ frame hitches during placement.
• NEVER use global coordinates for grid logic; strictly convert to Vector2i/Vector3i to ensure pixel-perfect tower alignment.

Performance & Systems

• NEVER call get_overlapping_bodies() every frame; strictly use signals (body_entered/body_exited) to maintain a local target cache.
• NEVER use _process() for projectile movement if count > 500; strictly use the PhysicsServer2D/3D directly for high-performance bullet-hell tiers.
• NEVER spawn hundreds of projectiles as full Nodes; strictly use Object Pooling to reuse resources and avoid garbage collection stutters.
• NEVER use standard Strings for priorities; strictly use StringName (&"first", &"strongest") for O(1) hash comparisons in targeting loops.
• NEVER ignore the progress property on PathFollow nodes; strictly use it as the O(1) way to identify the target closest to exit.
• NEVER process tower search logic every frame; strictly throttle ACQUIRE searches (e.g., every 5-10 frames) to save significant CPU cycles.
• NEVER scale Tower CollisionShape non-uniformly; strictly adjust the radius property of the Shape resource to preserve collision math.
• NEVER delete enemies immediately on death; strictly use set_deferred("disabled", true) and wait one frame to prevent physics server crashes.
• NEVER hardcode waves in huge switch statements; strictly use Custom Resources (.tres) for clean balancing and sequence editing.

---

🛠 Expert Components (scripts/)

Original Expert Patterns

• wave_manager.gd - Professional wave orchestrator with Resource-based enemy composition and cleanup.
• tower.gd - Base turret class with FSM state management and firing logic.
• tower_targeting_system.gd - Autonomous priority logic (First/Last/Strongest/Weakest) for efficient targeting.

Modular Components

• tower_defense_patterns.gd - Collection of patterns for furthest-target logic and PhysicsServer projectile optimization.

Decision Trees (MANDATORY script reads)

Path style

Targeting priority

Use signal-cached range Area enter/exit + frame-sliced acquire (acquire_interval_frames). Never get_overlapping_bodies() every frame.

Economy

PhysicsServer Projectile Golden Path

When count > ~500:

1. MANDATORY tower_defense_patterns.gd spawn_fast_bullet (PhysicsServer3D kinematic RIDs).
2. Pool RIDs; AoE via intersect_shape; defer collision disable on death.
3. Modest counts: homing_projectile_3d.gd / pooled Nodes OK.