GameBlocks — Architecture Overview


Concise, self-explanatory building blocks that let AI coding agents prototype browser-based 3D games without re-deriving 3D spatial mechanics from scratch.

Contents

Overview

69GitHub stars
79source files
6module categories
2AI integrations

GameBlocks is a JavaScript library targeting the stateful layer of a 3D game world — coordinate frames, actor motion, physics integration, AI navigation, and gameplay rules — rather than visual rendering aesthetics. It is designed specifically so that AI coding agents (Claude Code, OpenAI Codex) can inspect, copy, and compose working implementations instead of synthesising 3D mechanics purely from natural language descriptions, which struggle to convey precise spatial behaviour.

The core insight: natural language cannot reliably specify 3D spatial logic. Inspectable, well-named code can. GameBlocks is a curated vocabulary of such code.

Dependencies

Three.js v0.161 — scene graph, math, rendering

Rapier3D v0.14 — rigid-body physics

Coordinate System

Right-handed: +x right, +y up, -z forward. Configurable via WorldBasis.

Skill Installation

Copy gameblocks/ to ~/.claude/skills/gameblocks/ or ~/.codex/skills/gameblocks/. Invoke via /gameblocks.


Main Control Flow — Agent Harness System

This is the top-level picture. An AI agent receives a 3D game development task, the GameBlocks skill is loaded, the agent browses the module catalog, selects and adapts existing blocks, and ships a working browser prototype. Each box is expanded in its own section below.

flowchart TD
    Dev["Developer\nor AI Agent"] --> Task["3D game prototype task\nreceived"]
    Task --> Trigger["Skill auto-triggered\nor /gameblocks invoked"]
    Trigger --> SkillCtx["SKILL.md injected\ninto agent context"]
    SkillCtx --> Browse["Agent reads summary.md\nbrowse module catalog"]
    Browse --> Select["Select modules\nmatching game type"]
    Select --> Strategy{"Reuse\nstrategy?"}
    Strategy -->|"full match"| CopyUnchanged["Copy module unchanged\npreserve import paths"]
    Strategy -->|"partial match"| Modify["Modify existing\nimplementation"]
    Strategy -->|"no match"| Derive["Derive from scratch\nusing WorldBasis as anchor"]
    CopyUnchanged --> Docs["Create gameblocks_usage.md\nrecord choices and mods"]
    Modify --> Docs
    Derive --> Docs
    Docs --> Proto["Browser 3D Game\nThree.js + Rapier3D"]
          
drag to pan · scroll to zoom
Fig 1. End-to-end agent harness control flow.

Agent Integration Subsystem

GameBlocks ships a SKILL.md file that becomes the skill's system prompt when the agent triggers it. The skill instructs the agent to consult summary.md first, prioritise existing modules, preserve directory structure for import paths, and document every decision in gameblocks_usage.md.

Installation & Invocation Flow

flowchart LR
    Repo["GameBlocks repo\ncloned locally"] --> Install["cp -R gameblocks/.\n~/.claude/skills/gameblocks/\nor ~/.codex/skills/gameblocks/"]
    Install --> Restart["Restart agent app\n(optional)"]
    Restart --> Ready["Skill available"]
    Ready --> ManualCmd["/gameblocks\nor $gameblocks\nmanual invocation"]
    Ready --> AutoLoad["Agent auto-loads\nwhen task description matches"]
    ManualCmd --> SkillFile["SKILL.md loaded\ninto agent context window"]
    AutoLoad --> SkillFile
          
drag to pan · scroll to zoom
Fig 2. Installation and invocation flow for Claude Code and Codex.

Skill Execution Protocol

flowchart TD
    SkillFile["SKILL.md in context\nPrimary directive: use GameBlocks\nbefore inventing from scratch"] --> ReadSummary["Read summary.md\nidentify candidate modules"]
    ReadSummary --> WorldBasisCheck["WorldBasis.js is\ncoordinate authority\nconsult for ALL spatial logic"]
    WorldBasisCheck --> ModuleLoop["For each game system needed"]
    ModuleLoop --> Found{"Module\nexists?"}
    Found -->|"Yes — fully fits"| CopyDirect["Copy unchanged\npreserve dir structure"]
    Found -->|"Yes — partial"| AdaptMod["Modify existing code\ndo not rebuild from scratch"]
    Found -->|"No"| NewCode["Write new code\nanchor to WorldBasis types"]
    CopyDirect --> UsageDoc["gameblocks_usage.md\nmodule + purpose +\nreuse status + mods"]
    AdaptMod --> UsageDoc
    NewCode --> UsageDoc
    UsageDoc --> Integrate["Integrate into\ngame prototype"]
          
drag to pan · scroll to zoom
Fig 3. Skill execution decision protocol.

SKILL.md

System-level instructions for the agent. Sets WorldBasis.js as coordinate authority and mandates documentation of module choices.

summary.md

Human+agent-readable catalog of all 38 modules with their purpose, dependencies, and configuration options.

gameblocks_usage.md

Agent-created file in the target project. Records chosen modules, modifications, and integration rationale.


Module Architecture — Six Subsystems

All 79 files live under gameblocks/modules/ in six functional categories. Math is the foundation everything else depends on. World aggregates outputs from all other layers into a renderable scene.

flowchart TD
    Math["Math\nWorldBasis · VectorUtils\nScalarUtils · RandomUtils · TimeUtils"]
    Math --> Motion["Actor Motion\n16 modules\nCharacter · Vehicle · Aircraft · Snake"]
    Math --> Camera["Camera\n5 modules\nBaseCameraRig · FP · Follow · LookOffset"]
    Math --> Behavior["Behavior\n6 modules\nPathPlanner · Navigator · Avoidance\nCombatDirector · WaypointDriver"]
    Motion --> Gameplay["Gameplay\n8 modules\nCombatPlay · FlightPlay · RacePlay\nSnakePlay · WaveSpawnDirector"]
    Behavior --> Gameplay
    UI["User Interface\n8 modules\nDomHudRenderer · Minimap\nNotificationQueue · SettingsStore"]
    Gameplay --> World["World\n18 modules\nEnvironments · Objects · Factories · VFX"]
    Camera --> World
    UI --> World
    World --> Output["Rendered Browser Game\nThree.js WebGLRenderer"]
          
drag to pan · scroll to zoom
Fig 4. Module dependency graph across the six subsystems.
Category Files Key classes External deps
math/5WorldBasis, Vector3Utils, ScalarUtils, RandomUtils, TimeUtilsThree.js
actor-motion/16BaseCharacterMotionController, ArcadeCarMotionController, AirplaneMotionController, KinematicBatchResolverThree.js, Rapier3D
behavior/6GridPathPlanner, AgentPathNavigator, NearbyAvoidanceSteering, CombatBehaviorDirector, WaypointDriverThree.js
camera/5BaseCameraRig, FirstPersonCameraRig, PoseFollowCameraRig, LookOffsetCameraRigThree.js
gameplay/8CombatPlay, FlightPlay, RaceCheckpointLapPlay, SnakePlay, WaveSpawnDirector, ProjectileWeaponSystemThree.js
user-interface/8DomHudRenderer, MinimapProjector2D, NotificationQueue, UiStateModel, StorageSettingsStoreDOM API
world/18ArenaEnvironment, NaturalEnvironment, TerrainMeshFactory, PickupObject, ProjectileObject, WeaponEffectsSystemThree.js, Rapier3D

Actor Motion Subsystem

The motion subsystem translates raw input signals into physics-ready position and orientation updates. WorldBasis normalises directional input across coordinate conventions. BaseCharacterMotionController owns the core kinematic state; specialised subclasses handle different input schemes. KinematicBatchResolver submits the resolved intent to Rapier and reads back the collider-corrected position.

flowchart TD
    Input["Raw Input\nleft · right · up · down\nforward · backward · sprint · jump"]
    Input --> WB["WorldBasis.controlSignal()\nmap directional tokens to\nsigned scalar magnitudes"]
    WB --> Base["BaseCharacterMotionController\nposition · velocity · yaw · pitch\nwalkSpeed · jumpVelocity · gravity\naccelerationLag · decelerationLag"]
    Base --> HeadRel["HeadingRelativeCharacterMotionController\nmovement relative to facing yaw\nfirst-person strafe style"]
    Base --> WorldCard["WorldCardinalCharacterMotionController\nmovement in world X/Z axes\ntop-down style"]
    Base --> WorldTarget["WorldTargetCharacterMotionController\nmove toward 3D click target\nRTS / isometric style"]
    Base --> MouseLook["MouseLookCharacterMotionController\nmouse delta drives yaw+pitch\nFPS camera coupling"]
    HeadRel --> KinBatch
    WorldCard --> KinBatch
    WorldTarget --> KinBatch
    MouseLook --> KinBatch
    KinBatch["KinematicBatchResolver\nsubmit to Rapier character controller\nread back corrected position\nhandle slope/step/slope limits"]
    KinBatch --> Pose["Character Pose\nfinal position + quaternion\nfor scene graph"]
    Pose --> VehicleLayer["Ground Vehicle Controllers\nArcadeCarMotionController\nDynamicCarMotionController\nDriftingPlugin"]
    Pose --> AircraftLayer["Aircraft Controllers\nAirplaneMotionController\nAirplaneModelController"]
    Pose --> SpecialLayer["Special Controllers\nSnakeMotionController\nPlateTiltController\nGeneralVehicleMotionController"]
          
drag to pan · scroll to zoom
Fig 5. Actor motion pipeline from raw input to final scene-graph pose.

Vehicle vs Character Comparison

ControllerPhysics modelInputRapier body
BaseCharacterMotionControllerKinematic characterWASD + mouseKinematicPositionBased
ArcadeCarMotionControllerSimplified arcadeThrottle + steerDynamic rigid body
DynamicCarMotionControllerWheel-based simThrottle + steer + brakeDynamic + wheel joints
AirplaneMotionControllerFixed-wing aeroPitch + roll + throttleDynamic rigid body
SnakeMotionControllerGrid discreteDirectional stepNone (positional)

Behavior & AI Subsystem

The behavior layer gives non-player actors autonomous movement and combat logic. GridPathPlanner produces discrete waypoint sequences via A*. AgentPathNavigator converts the next waypoint into a speed+direction intent each frame. NearbyAvoidanceSteering perturbs that intent to avoid neighbours. CombatBehaviorDirector overlays high-level tactical decisions on top.

flowchart LR
    Grid["GridPathPlanner\nA-star on discrete grid\nreturns waypoint list"]
    Grid --> WP["Waypoint sequence\nworld-space positions"]
    WP --> WaypointDriver["WaypointDriver\nadvance index on arrival\ntrigger callbacks"]
    WP --> Progress["WaypointProgressTracker\ntrack lap / progress fraction\nused by race mode"]
    WaypointDriver --> Navigator["AgentPathNavigator\nflattens to planar plane\narrival deceleration\nreturns direction + desiredSpeed"]
    Navigator --> Avoidance["NearbyAvoidanceSteering\nquery nearby agents\nsteer around neighbours"]
    Avoidance --> Intent["Movement intent\ndirection · desiredSpeed"]
    CombatDir["CombatBehaviorDirector\ncombat state machine\npursue / attack / retreat\nwhen to fire weapon"]
    CombatDir --> Intent
    Intent --> MotionCtrl["Motion Controller\ncommitMovement(intent)"]
          
drag to pan · scroll to zoom
Fig 6. Behavior and AI pipeline from path planning to motion intent.
AgentPathNavigator.step() outputswaypoint · direction · desiredSpeed · distance
Arrival thresholdarriveRadius (default 1.25 units) — begins deceleration
Avoidance strategyNearbyAvoidanceSteering — local reactive, no replanning

Gameplay State Machine

Each gameplay module encapsulates the rules and state for one game genre. They share a common lifecycle: WAITING → STARTED → FINISHED → reset. CombatPlay is the most detailed example; other modes follow the same pattern.

CombatPlay State Machine

stateDiagram-v2
    [*] --> WAITING : initial
    WAITING --> WAITING : addPlayer() registers combatants
    WAITING --> STARTED : startGame()
    STARTED --> STARTED : damage(id, amount)\nheal(id, amount)\naddArmor(id, amount)
    STARTED --> STARTED : step() drains event queue\nemits PLAYER_KILLED events
    STARTED --> FINISHED : step() detects\nsingle team alive\nemits COMBAT_FINISHED
    FINISHED --> WAITING : reset() restores\ndefault stats
          
drag to pan · scroll to zoom
Fig 7. CombatPlay three-state lifecycle with event emission.

Gameplay Mode Comparison

flowchart TD
    GameplayLayer["Gameplay Layer\nOrchestrates rules, tracks state, emits events"]
    GameplayLayer --> CombatPlay["CombatPlay\nhealth · armor · teams\nkill events · WAITING/STARTED/FINISHED"]
    GameplayLayer --> FlightPlay["FlightPlay\naltitude · speed envelope\nstall · crash detection"]
    GameplayLayer --> RacePlay["RaceCheckpointLapPlay\ncheckpoint sequence\nlap counting · finish line"]
    GameplayLayer --> SnakePlay["SnakePlay\ngrid segments · growth\ncollision with self or wall"]
    GameplayLayer --> WaveDir["WaveSpawnDirector\nspawn enemies in waves\ndelay between waves\nescalating difficulty"]
    WaveDir --> SpawnArea["SpawnAreaSampler\nnon-overlapping random\nspawn positions"]
    CombatPlay --> WeaponSys["ProjectileWeaponSystem\ncooldown · ammo · fire\nrecoil model"]
    WeaponSys --> ProjMgr["ProjectileManager\npool + lifetime\ncollision check"]
    ProjMgr --> AimRes["AimResolver\nauto-aim angle\nlead calculation"]
          
drag to pan · scroll to zoom
Fig 8. Gameplay modes and their sub-systems.

Camera System

BaseCameraRig holds position, lookAt, and forward/right/up frame vectors. It offers two rotation modes: lookAt (Three.js native) and frame (explicit matrix). Subclasses override update() to compute the desired pose each frame; smoothVector() applies exponential lag interpolation before calling applyToCamera().

flowchart TD
    ActorPose["Actor Pose\nposition · quaternion · forward"]
    ActorPose --> Base["BaseCameraRig\nposition · lookAt · forward/right/up\nrotationMode: lookAt or frame\nsmoothVector() exponential lag"]
    Base --> FP["FirstPersonCameraRig\nattach to actor head bone\noffset by eye height\npitch-clamped"]
    Base --> PosFollow["PositionFollowCameraRig\nfollow actor position\noffset above + behind\nlookAt actor"]
    Base --> PoseFollow["PoseFollowCameraRig\nfollow position AND orientation\nfor vehicle cockpit views"]
    Base --> LookOffset["LookOffsetCameraRig\noffset the lookAt point\nfor over-shoulder style"]
    FP --> ApplyFn["applyToCamera()\nwrite to THREE.Camera\nposition + quaternion"]
    PosFollow --> ApplyFn
    PoseFollow --> ApplyFn
    LookOffset --> ApplyFn
    ApplyFn --> ThreeCam["THREE.PerspectiveCamera\nused by WebGLRenderer"]
          
drag to pan · scroll to zoom
Fig 9. Camera rig hierarchy and apply path to Three.js camera.

World Construction Subsystem

World modules build the renderable, physics-enabled game environment. Environment classes own the scene group and create static Rapier colliders. Visual factories create Three.js meshes for recurring object types. World objects (pickups, projectiles) carry both a mesh and physics state. Visual effects systems respond to gameplay events.

flowchart LR
    Env["Environment builders"]
    Env --> Arena["ArenaEnvironment\nground · grid · walls\ncylindrical pillars · ramps\nRapier static bodies"]
    Env --> Natural["NaturalEnvironment\nterrain mesh · sky\nplant placement"]
    Env --> Race["RaceTrackEnvironment\nclosed track geometry\ncheckpoint triggers"]
    Env --> Board["BoardEnvironment\ngrid-aligned flat tiles\nfor strategy/puzzle games"]
    Natural --> Terrain["TerrainMeshFactory\nheightmap geometry\nTerrainSampler for height queries\nWorldBoundsColliderFactory"]
    Arena --> Spawn["SpawnAreaSampler\ntest clearance via\nisPlanarPointBlockedByGeometry()\nnon-overlapping spawn set"]
    Natural --> Spawn

    Factories["Visual Factories"]
    Factories --> CarVF["CarVisualFactory\nboxes for body + wheels"]
    Factories --> AirVF["AirplaneVisualFactory\nwings + fuselage geometry"]
    Factories --> ProjVF["ProjectileVisualFactory\nsmall sphere / capsule"]
    Factories --> PlantVF["PlantVisualFactory\nbillboard or simple mesh"]

    WorldObjects["World Objects"]
    WorldObjects --> Pickup["PickupObject\nmesh + trigger zone\ncollect on overlap"]
    WorldObjects --> Projectile["ProjectileObject\nlifetime · velocity\ncollision response"]
    WorldObjects --> FpsVM["FpsWeaponViewModel\nlocal weapon mesh\nbob + sway animation"]
    WorldObjects --> HealthBar["HealthBarView\nbillboard sprite\nscales with HP ratio"]

    VFX["Visual Effects"]
    VFX --> JetFlame["JetFlame\nparticle emitter\nthrust-proportional"]
    VFX --> TireMark["VehicleTireMarkRenderer\ndecal strips on ground"]
    VFX --> WeaponFX["WeaponEffectsSystem\nmuzzle flash · hit sparks"]
    VFX --> ClickFX["GroundClickIndicator\ncircle on click target"]
          
drag to pan · scroll to zoom
Fig 10. World construction: environments, factories, objects, and VFX.

Per-Frame Game Loop Integration

This is how all subsystems wire together inside requestAnimationFrame. The order matters: input → physics → gameplay rules → AI behavior → camera → HUD → render.

flowchart LR
    RAF["requestAnimationFrame\ndelta time computed"] --> Input["Input Handler\nkeyboard · mouse · gamepad\ncollect pressed keys + axes"]
    Input --> MotionStep["Motion Controllers\nstep(input, delta)\nvelocity integration\njump / gravity / sprint"]
    MotionStep --> RapierStep["Rapier Physics\nworld.step()\ncollider correction\ncontact events"]
    RapierStep --> GameplayStep["Gameplay Rules\nCombatPlay.step()\nRaceCheckpointLapPlay.step()\nWaveSpawnDirector.step()\ndrain event queues"]
    GameplayStep --> WeaponStep["Weapon Systems\nProjectileWeaponSystem.step()\nProjectileManager update\ncooldown timers"]
    WeaponStep --> BehaviorStep["NPC Behavior\nAgentPathNavigator.step()\nNearbyAvoidanceSteering.step()\nCombatBehaviorDirector.step()"]
    BehaviorStep --> CameraStep["Camera Rig\nupdate(actorPose)\nsmoothVector lag\napplyToCamera()"]
    CameraStep --> HUDStep["HUD\nDomHudRenderer.update()\nMinimapProjector2D.update()\nNotificationQueue.step()"]
    HUDStep --> VFXStep["Visual Effects\nJetFlame.update()\nTireMarkRenderer.update()\nWeaponEffectsSystem.update()"]
    VFXStep --> RenderStep["THREE.WebGLRenderer\nrender(scene, camera)"]
    RenderStep --> RAF
          
drag to pan · scroll to zoom
Fig 11. Per-frame game loop with all GameBlocks subsystems in update order.

File Catalog

All 79 files in the repository, sortable by category. Click column headers to sort.

File Category Purpose
gameblocks/SKILL.mdMetaAgent skill instructions and usage protocol
gameblocks/summary.mdMetaHuman+agent module catalog with descriptions
README.mdMetaProject overview, installation, strategic vision
modules/math/WorldBasis.jsMathCoordinate system abstraction — directional axes, control signals, planar ops
modules/math/Vector3Utils.jsMathVector helpers, toVec3, normalization utilities
modules/math/ScalarUtils.jsMathclamp, lerp, and scalar helpers
modules/math/RandomUtils.jsMathDeterministic and seeded random generation
modules/math/TimeUtils.jsMathDelta-time and timer helpers
modules/actor-motion/BaseCharacterMotionController.jsActor MotionCore kinematic character — position, velocity, jump, gravity
modules/actor-motion/character/HeadingRelativeCharacterMotionController.jsActor MotionMove relative to yaw (FPS strafe style)
modules/actor-motion/character/WorldCardinalCharacterMotionController.jsActor MotionMove in world X/Z axes (top-down)
modules/actor-motion/character/WorldTargetCharacterMotionController.jsActor MotionMove toward 3D click target (RTS style)
modules/actor-motion/character/MouseLookCharacterMotionController.jsActor MotionMouse delta drives yaw+pitch
modules/actor-motion/KinematicBatchResolver.jsActor MotionSubmit to Rapier character controller, read corrected position
modules/actor-motion/GeneralObjectModelController.jsActor MotionApply any motion state to a Three.js object
modules/actor-motion/GeneralVehicleMotionController.jsActor MotionSix-axis vehicle motion abstraction
modules/actor-motion/PlateTiltController.jsActor MotionTilt a platform based on load
modules/actor-motion/SnakeMotionController.jsActor MotionGrid-discrete snake movement
modules/actor-motion/ground-vehicle/ArcadeCarMotionController.jsActor MotionSimple arcade car physics
modules/actor-motion/ground-vehicle/DynamicCarMotionController.jsActor MotionWheel-joint dynamic car simulation
modules/actor-motion/ground-vehicle/CarModelController.jsActor MotionApply car state to wheel meshes
modules/actor-motion/ground-vehicle/DriftingPlugin.jsActor MotionFriction override for drift mechanic
modules/actor-motion/ground-vehicle/DynamicCarBatchResolver.jsActor MotionRapier rigid-body batch update for cars
modules/actor-motion/ground-vehicle/DynamicCarRapierConfig.jsActor MotionRapier collider and joint config for dynamic cars
modules/actor-motion/aircraft/AirplaneMotionController.jsActor MotionFixed-wing aerodynamics — lift, drag, stall
modules/actor-motion/aircraft/AirplaneModelController.jsActor MotionApply flight state to airplane mesh
modules/behavior/GridPathPlanner.jsBehaviorA* on discrete grid, returns waypoint list
modules/behavior/AgentPathNavigator.jsBehaviorPer-frame speed+direction toward next waypoint with arrival decel
modules/behavior/WaypointDriver.jsBehaviorAdvances waypoint index on arrival
modules/behavior/WaypointProgressTracker.jsBehaviorFractional progress along waypoint path
modules/behavior/NearbyAvoidanceSteering.jsBehaviorLocal steering to avoid nearby agents
modules/behavior/CombatBehaviorDirector.jsBehaviorTactical state machine — pursue / attack / retreat
modules/camera/BaseCameraRig.jsCameraCore camera with smoothVector lag and two rotation modes
modules/camera/FirstPersonCameraRig.jsCameraAttach to actor head, pitch-clamped FPS view
modules/camera/PositionFollowCameraRig.jsCameraFollow actor position with offset
modules/camera/PoseFollowCameraRig.jsCameraFollow actor position and orientation
modules/camera/LookOffsetCameraRig.jsCameraOffset lookAt point — over-shoulder style
modules/gameplay/CombatPlay.jsGameplayHealth/armor/teams state machine, kill/finish events
modules/gameplay/FlightPlay.jsGameplayAltitude and speed envelope rules
modules/gameplay/RaceCheckpointLapPlay.jsGameplayCheckpoint sequence and lap counting
modules/gameplay/SnakePlay.jsGameplaySnake grid segments, growth, self-collision
modules/gameplay/WaveSpawnDirector.jsGameplayEnemy waves with delay and escalation
modules/gameplay/AimResolver.jsGameplayAuto-aim angle and lead calculation
modules/gameplay/combat/ProjectileWeaponSystem.jsGameplayCooldown, ammo, fire, recoil model
modules/gameplay/combat/ProjectileManager.jsGameplayProjectile pool, lifetime, collision check
modules/user-interface/DomHudRenderer.jsUIUpdate DOM elements from game state
modules/user-interface/FlightHud.jsUIAltitude, speed, heading display
modules/user-interface/HeadingRelativeRadar.jsUIRadar that rotates with player heading
modules/user-interface/MinimapProjector2D.jsUIProject world positions to 2D minimap canvas
modules/user-interface/RaceMinimap.jsUIRace-specific minimap with checkpoint marks
modules/user-interface/NotificationQueue.jsUITimed on-screen message queue
modules/user-interface/UiStateModel.jsUIObservable UI state (score, health display value)
modules/user-interface/StorageSettingsStore.jsUIPersist player settings to localStorage
modules/world/Object3DUtils.jsWorldThree.js Object3D manipulation helpers
modules/world/environment/ArenaEnvironment.jsWorldGround, walls, pillars, ramps + Rapier statics
modules/world/environment/NaturalEnvironment.jsWorldTerrain mesh, sky, vegetation placement
modules/world/environment/RaceTrackEnvironment.jsWorldClosed track geometry + checkpoint triggers
modules/world/environment/BoardEnvironment.jsWorldGrid-aligned flat tile environment
modules/world/environment/TerrainMeshFactory.jsWorldHeightmap-based terrain mesh builder
modules/world/environment/TerrainSampler.jsWorldQuery terrain height at arbitrary XZ
modules/world/environment/PlanarUtils.jsWorld2D polygon / planar geometry helpers
modules/world/environment/SpawnAreaSampler.jsWorldNon-overlapping random spawn positions
modules/world/environment/WorldBoundsColliderFactory.jsWorldInvisible boundary colliders at world edges
modules/world/object/PickupObject.jsWorldCollectible item with mesh and trigger zone
modules/world/object/ProjectileObject.jsWorldProjectile with lifetime and collision
modules/world/object/FpsWeaponViewModel.jsWorldLocal weapon mesh with bob and sway
modules/world/object/HealthBarView.jsWorldBillboard health bar scaling with HP ratio
modules/world/object/factory/CarVisualFactory.jsWorldCar body and wheel mesh builder
modules/world/object/factory/AirplaneVisualFactory.jsWorldWings and fuselage geometry
modules/world/object/factory/ProjectileVisualFactory.jsWorldSmall sphere/capsule projectile mesh
modules/world/object/factory/PlantVisualFactory.jsWorldBillboard or simple plant mesh
modules/world/object/factory/PickupVisualFactory.jsWorldCollectible item appearance
modules/world/object/factory/RockVisualFactory.jsWorldRock geometry for environment decoration
modules/world/visual-effects/JetFlame.jsWorldParticle emitter proportional to thrust
modules/world/visual-effects/VehicleTireMarkRenderer.jsWorldDecal strips on ground from tire slip
modules/world/visual-effects/WeaponEffectsSystem.jsWorldMuzzle flash and hit sparks
modules/world/visual-effects/GroundClickIndicator.jsWorldCircle indicator at RTS click target

GameBlocks by xt4d — MIT License — Report generated 2026-07-02