Expert blueprint for MOBA games including lane logic (minion wave spawning every 30s), tower aggro priority (hero attacking ally over minion over hero), click-to-move controls (RTS-style raycasting), hero ability systems (QWER cooldowns, mana cost), fog of war (SubViewport projections), and authoritative networking (server validates damage). Use for competitive 5v5 or arena games. Trigger keywords: MOBA, lane_manager, minion_waves, tower_aggro, click_to_move, ability_cooldowns, fog_of_war, comeback_mechanics.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Expert blueprint for MOBA games including lane logic (minion wave spawning every 30s), tower aggro priority (hero attacking ally over minion over hero), click-to-move controls (RTS-style raycasting), hero ability systems (QWER cooldowns, mana cost), fog of war (SubViewport projections), and authoritative networking (server validates damage). Use for competitive 5v5 or arena games. Trigger keywords: MOBA, lane_manager, minion_waves, tower_aggro, click_to_move, ability_cooldowns, fog_of_war, comeback_mechanics.
NEVER Do (Expert Anti-Patterns)
Networking & Authority
NEVER trust the client for damage calculation or resource costs; strictly validate mana, ranges, and hit detection on the authoritative server using multiplayer.is_server().
NEVER use TRANSFER_MODE_RELIABLE for continuous movement; strictly use UNRELIABLE or UNRELIABLE_ORDERED for position/velocity to prevent network congestion.
NEVER sync units at 60Hz; strictly use a lower tick rate (10-20Hz) via MultiplayerSynchronizer and implement Interp/Client-Side Prediction for visual smoothness.
NEVER attach individual synchronizers to hundreds of minions; strictly batch state updates into compressed byte arrays via a central manager.
NEVER synchronize complex Engine objects directly; strictly serialize state into primitive properties or Dictionaries for reliable peer-to-peer sync.
AI & Pathfinding
NEVER use expensive pathfinding for all minions every frame; strictly use Time Slicing to spread get_next_path_position() calls across multiple frames.
NEVER query NavigationAgent paths inside _process(); strictly use _physics_process() to interact with the navigation server and avoidance systems.
NEVER use complex visual geometry for NavMesh baking; parse simple primitives to avoid stalling the RenderingServer or crashing the engine.
NEVER set path_search_max_polygons too low in large maps; agents will stop or walk incorrectly if the limit is reached before the destination.
NEVER use Area2D for high-performance Fog of War LOS; strictly use nodeless physics queries (intersect_ray) to bypass node overhead.
Gameplay & Balancing
NEVER forget Tower "Dive" protection; towers MUST switch targets immediately if an enemy Hero damages an allied Hero within range (Priority: Hero attacking Ally > Minion > Hero).
NEVER allow "Snowballing" without counter-play; strictly implement Comeback Mechanisms (Kill Bounties, Catch-up XP) to maintain competitive tension.
NEVER manage hero stats as standard Node variables; strictly use custom Resource scripts for data separation and memory efficiency.
NEVER forget to call duplicate(true) on shared ability Resources; modifying a buff on a shared resource will affect all heroes globally.
Technical & Performance
NEVER use standard strings for status checks (e.g., "stunned"); strictly use StringName (&"stunned") for pointer-speed comparisons.
NEVER loop over massive Fog of War grids with floats; strictly use Vector2i and TileMapLayer to prevent precision jitter.
NEVER execute heavy world/minimap logic on the main thread; strictly offload complex array math to WorkerThreadPool to maintain 60+ FPS.
NEVER rigidly couple UI cooldowns to Hero scripts; strictly use a Signal Bus or Callable bindings for decoupled architecture.
NEVER evaluate exact floating-point equality (==); strictly use is_equal_approx() for range, cooldown, and mana validations.
Decision Tree: Solo prototype vs authoritative 5v5
Goal
Load first
Skip / defer
Solo lane prototype (1 hero, local waves, no peers)
Inventing a second networking stack inside this genre skill
🛠 Expert Components (scripts/)
Original Expert Patterns
skill_shot_indicator.gd - Mouse-driven targeting system for range, width, and direction visualization.
tower_priority_aggro.gd - Advanced AI for defensive towers following competitive priority rules. MANDATORY for tower dive/priority.
Modular Components
server_minion_sync.gd - Authoritative sync for high-count units using compressed byte arrays. MANDATORY for 5v5 waves (not one synchronizer per minion).
fog_visibility_check.gd - Physics raycasting for high-performance Line-of-Sight checks. MANDATORY before fog mask painting.
fog_grid_mask.gd - TileMap-driven visibility masking system using Vector2i grid logic.
minion_worker_pathfinder.gd - When to load: WorkerThreadPool path batches when wave size leaves _physics_process pathfinding. Prefer over per-minion full A* every frame.
weighted_target_selector.gd - When to load: hero/minion/tower acquisition with group-weighted priority (AA and simple aggro). Pair with tower_priority for dive rules.
synced_ability_controller.gd - When to load: QWER casts under authority — client predicts cooldown UI, server validates. Skip for offline prototypes.
status_effect_data.gd - Lightweight Resource container for defining buffs, debuffs, and stuns.
status_effect_manager.gd - Modular logic for applying and managing unique status effect instances.
Recovery: Brief backswing animation where movement/casting is locked.
Key Mechanics Implementation
Click-to-Move (RTS Style)
Raycasting from camera to terrain.
func _unhandled_input(event: InputEvent) -> void:
if event.is_action_pressed("move"):
var result = raycast_from_mouse()
if result:
nav_agent.target_position = result.position
Ability System (Data Driven)
Defining "Fireball" or "Hook" without unique scripts for everything.
# ability_data.gd
class_name Ability extends Resource
@export var cooldown: float
@export var mana_cost: float
@export var damage: float
@export var effect_scene: PackedScene
Godot-Specific Tips
NavigationAgent3D: Use avoidance_enabled for minions so they flow around each other like water, rather than stacking.
MultiplayerSynchronizer: Sync Health, Mana, and Cooldowns. Do NOT sync position every frame if using Client-Side Prediction (advanced).
Fog of War: Use a SubViewport with a fog texture. Paint "holes" in the texture where allies are. Project this texture onto the terrain shader.
Common Pitfalls
Snowballing: Winning team gets too strong too fast. Fix: Implement "Comeback XP/Gold" mechanisms (bounties).
Pathfinding Lag: 100 minions pathing every frame. Fix: Distribute pathfinding updates over multiple frames (Time Slicing).
Hacking: Client says "I dealt 1000 damage". Fix: Client says "I cast Spell Q at Direction V". Server calculates damage.
Advanced MOBA Meta-Systems
Professional implementation of match playback, network smoothing, and advanced jungle AI.
1. Match Replay System (Binary Serialization)
For high-performance match recording, use var_to_bytes() to serialize state dictionaries into a compressed binary format. Avoid JSON for replays to minimize disk I/O and file size.
class_name ReplayManager extends Node
var frame_history: Array[PackedByteArray] = []
func record_frame(state: Dictionary) -> void:
# Efficiently convert data to bytes
frame_history.append(var_to_bytes(state))
func save_replay(match_id: String) -> void:
var file := FileAccess.open("user://replays/" + match_id + ".dat", FileAccess.WRITE)
if file:
file.store_var(frame_history) # Stores the whole array as a variant
file.close()
func play_frame(frame_index: int) -> Dictionary:
return bytes_to_var(frame_history[frame_index])
2. Networked Interpolated Sync
Use Godot 4.x's built-in physics interpolation to mask network jitter. Combined with MultiplayerSynchronizer, this provides smooth hero movement even at low tick rates (15-20Hz).
class_name HeroNetSync extends CharacterBody3D
func _ready() -> void:
# Enable native engine interpolation for visual smoothness
physics_interpolation_mode = Node.PHYSICS_INTERPOLATION_MODE_ON
if is_multiplayer_authority():
setup_synchronizer()
func setup_synchronizer() -> void:
var sync := $MultiplayerSynchronizer
var config := SceneReplicationConfig.new()
# Sync position/rotation via unreliable ordered packets
config.add_property(NodePath(".:global_position"))
sync.replication_config = config
3. Jungle-AI (Camp Leashing)
Implement a state machine for jungle monsters that monitors distance from their spawn point. If a hero draws them too far, they enter a "Leashing" state, becoming invulnerable and returning home.
class_name JungleCreep extends CharacterBody3D
@export var leash_radius: float = 12.0
@onready var spawn_pos := global_position
func _physics_process(_delta: float) -> void:
var dist_from_home := global_position.distance_to(spawn_pos)
match state:
State.CHASING:
if dist_from_home > leash_radius:
state = State.LEASHING
State.LEASHING:
# Move back to spawn_pos using NavigationAgent3D
nav_agent.target_position = spawn_pos
if global_position.distance_to(spawn_pos) < 1.0:
state = State.IDLE
health = max_health # Reset health on return
Expert Tip: Always use NavigationServer3D.map_get_iteration_id() to ensure the navigation map is fully synced before allowing AI to pathfind after spawning.
MANDATORY for depth beyond decision trees and script catalog: moba-meta-systems-deep.md. Do NOT Load on first-pass wiring — use bundled scripts/ first.
Reference
Progressive disclosure: open Official Documentation links only when researching a specific API;
load Related Skills when routing work to a peer domain — do not preload the whole lattice.
Official Documentation
High-level multiplayer — Authority, RPCs, and transfer modes for server-validated casts and unreliable movement.
MultiplayerSynchronizer — Property replication for hero health/mana/cooldowns without per-minion synchronizer spam.
SceneReplicationConfig — Which properties replicate and how often when pairing with low tick-rate hero sync.
Using NavigationAgents — Click-to-move, minion march, and avoidance for lane flow without stacking.
Using navigation meshes — Baking lanes/jungle/bases and async rebake when arena geometry changes.
