Godot Genre Open World

NEVER Do (Expert Anti-Patterns)

World & Persistence

• NEVER prioritize Map Size over Density; empty landscapes are poor design. Strictly focus on Points of Interest (POIs) within every 30 seconds of travel.
• NEVER save the entire world state; strictly use Delta Persistence to record only unique changes (chopped trees, looted chests) to prevent massive save files.
• NEVER load large chunks or scenes synchronously; strictly use ResourceLoader.load_threaded_request() to prevent "Loading Hitches" and frame freezes.
• NEVER manipulate the active SceneTree directly from a background thread; strictly use call_deferred() to safely apply background thread chunk instantiations back to the main thread.
• NEVER keep distant, unloaded chunks in memory; strictly queue_free() and nullify references to prevent Out-Of-Memory (OOM) crashes.
• NEVER bake massive collision into one mesh; strictly break the world into chunks with local collision regions for efficient physics queries.
• NEVER save high-volume entity states in text formats (.tscn/.json); strictly use Binary Serialization (store_var) for high-speed I/O.

Physics & Performance

• NEVER ignore the "Floating Origin" jitter beyond 8,192 units; strictly implement a World-Shift system or enable Large World Coordinates (Double Precision) in project settings.
• NEVER process physics or AI at extreme distances; strictly use Spatial Partitioning to disable logic for entities in far-away, inactive chunks.
• NEVER calculate physics-sensitive state in _process(); strictly use _physics_process() for deterministic interaction at fluctuating framerates.
• NEVER spawn individual MeshInstance3D nodes for massive foliage; strictly use MultiMeshInstance3D to batch hundreds of thousands of meshes into a single GPU draw call.
• NEVER move OccluderInstance3D nodes at runtime; this forces a CPU BVH rebuild and causes severe micro-stuttering.
• NEVER leave CSGShape3D nodes active in exported builds; strictly bake them into static ArrayMesh geometry before shipping.
• NEVER compile complex shaders during gameplay; strictly perform "warm-up" during loading or enable project-wide caching.
• NEVER rely solely on automatic mesh decimation; strictly use VisibilityRange (HLOD) to substitute complex materials with cheap imposters or completely hide objects at extreme distances.

Logic & Architecture

• NEVER perform global A* searches across the entire massive world; strictly use NavigationPathQueryParameters3D to limit pathfinding to localized active regions.
• NEVER use find_child() or deep tree iteration for global state (e.g., Time of Day); strictly use Scene Groups (call_group()) for optimized broadcasting.
• NEVER synchronize complex Resource types over the network; strictly serialize world changes into primitive Dictionaries or PackedByteArrays.
• NEVER spawn raw Thread.new() for chunk I/O when ResourceLoader.load_threaded_request() already covers scene streaming — prefer ResourceLoader; custom threads only for non-Resource work with deferred SceneTree apply.

---

🛠 Expert Components (scripts/)

MANDATORY by concern (read before implementing):

• Streaming → world_streamer.gd + async_chunk_loader.gd
• Origin → choose one shifter (see decision tree) — floating_origin_shifter.gd or world_origin_shifter.gd
• HLOD → hlod_visibility_config.gd only (no phantom configurator)
• Far logic gate → lod_logic_enabler.gd

Original Expert Patterns

• world_streamer.gd - Professional-grade chunk management and streaming engine with background threading.
• floating_origin_shifter.gd - Group-based world-offset correction for float precision jitter.

Modular Components

• async_chunk_loader.gd - Background world streaming system using threaded resource loading.
• world_origin_shifter.gd - Root+player shift with reset_physics_interpolation + shader world_offset uniform.
• hlod_visibility_config.gd - Distance-based geometry swapping using VisibilityRange (HLOD).
• lod_logic_enabler.gd - Enable/disable AI/physics processing by distance/chunk activity.
• multimesh_foliage_manager.gd - Server-side GPU batching for thousands of landscape entities.
• binary_save_manager.gd - High-performance serialization for large-scale world persistence.
• chunk_limited_pathfinder.gd - NavigationServer-level query limits to optimize AI in dense worlds.
• server_prop_spawner.gd - Extreme optimization using RenderingServer RIDs to bypass SceneTree.
• dynamic_lod_adjuster.gd - Real-time adaptive performance scaling for global mesh LOD.
• group_weather_broadcaster.gd - Efficient decoupled environmental updates using SceneTree grouping.
• landscape_height_query.gd - Nodeless physics floor-height queries for large-scale landscapes.
• global_state.gd - Chunk-keyed delta persistence (set_entity_dead pattern).

---

Core Loop

Traverse → Discover POIs → Quest/travel → Persist deltas → Weather/day cycle immersion.

Decision Tree: Streamer / Origin / HLOD

Pick one origin strategy — do not dual-own floating_origin_shifter and world_origin_shifter on the same world root.

---