@directivegames/genesys.js 3.1.24

package/dist/src/game/World.js

@@ -0,0 +1,1467 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var _a;
+/**
+ * World represents the entire runtime scene and all systems that operate within it.
+ *
+ * Detailed explanation:
+ * - Owns the Three.js scene graph, manages arrays of actors and coordinates their lifecycles.
+ * - Creates and controls global services including input, timers, physics, navigation and networking.
+ * - The tick method advances simulation, handles network replication and processes queued actor removals.
+ * - Supports serialization via WorldSerializer and produces debug nodes for editor tooling.
+ * - Manages camera references for rendering and exposes helpers to spawn basic shapes and geometry.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Instantiate a World in your game loop with physics and navigation options suited to the project.
+ * - Add or remove actors using the provided methods instead of manipulating the scene directly.
+ * - Query actors with getActors or getFirstActor when implementing gameplay logic.
+ * - Avoid spawning player controllers before beginPlay since they rely on world initialization.
+ */
+import * as THREE from 'three';
+import { Actor } from '../actors/Actor.js';
+import { GlobalParticleManager } from '../actors/GlobalParticleManager.js';
+import { PlayerController } from '../actors/PlayerController.js';
+import { GLTFMeshComponent, LightComponent } from '../components/index.js';
+import { MeshComponent } from '../components/visual/MeshComponent.js';
+import { ENABLE_LIGHTMAPS } from '../const.js';
+import { ManifoldWrapper } from '../csg/ManifoldWrapper.js';
+import { NetWorld } from '../multiplayer/index.js';
+import { createNavigationServer } from '../navigation/NavigationServer.js';
+import { createPhysicsEngine } from '../physics/PhysicsEngine.js';
+import { PhysicsMotionType } from '../physics/PhysicsTypes.js';
+import { LightmapManager } from '../render/lightmapping/LightmapManager.js';
+import { PostProcessManager } from '../render/PostProcessManager.js';
+import { PluginManager } from '../scripting/PluginManager.js';
+import { ClassRegistry, EngineClass } from '../systems/ClassRegistry.js';
+import { ConsoleCommand, ConsoleManager } from '../systems/ConsoleManager.js';
+import { ConsoleVariableHandler } from '../systems/ConsoleVariableHandler.js';
+import { InputManager } from '../systems/InputManager.js';
+import { ObjectNamingSystem } from '../systems/ObjectNamingSystem.js';
+import { StatsDisplay } from '../systems/Stats.js';
+import { TimerSystem } from '../systems/TimerSystem.js';
+import { TweenManager } from '../systems/TweenManager.js';
+import { WorldSerializer } from '../systems/WorldSerialization.js';
+import { UIManager } from '../ui/UIManager.js';
+import { GlobalAudioManager } from '../utils/GlobalAudioManager.js';
+import { resourceManager } from '../utils/ResourceManager.js';
+import { SceneGraphUtils } from '../utils/SceneGraphUtils.js';
+import { ISerializableObjectTag } from '../utils/serialization/serializable.js';
+import { isNode } from '../utils/Utils.js';
+import { ensure, shortUUID } from '../utils/Utils.js';
+import { GameMode } from './GameMode.js';
+import { Playable, PlayState } from './Playable.js';
+let World = class World extends Playable {
+    /**
+       * Creates a new World instance
+       * @param options - Configuration options for the world including:
+       *                  - rendererDomElement: HTML element to attach the renderer to
+       *                  - backgroundColor: Optional background color for the scene
+       *                  - physicsOptions: Configuration for the physics engine
+       */
+    constructor(options) {
+        super();
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "postProcessManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new PostProcessManager()
+        });
+        Object.defineProperty(this, "uuid", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: shortUUID()
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "scene", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inputManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "consoleManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "timerSystem", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tweenManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "uiManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gameMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pluginManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lastCameraWarningTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "netWorld", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "audioListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "globalAudioManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "globalParticleManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "editorData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "isEditorWorld", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "sceneResources", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "postProcessConfiguration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "actors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "playerControllers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "physicsEngine", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "navigationServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "manifold", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "lightmapManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "navigationMeshVisualization", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // if valid for physics engine to be null if the user doesn't want it, so use a separate flag to track
+        Object.defineProperty(this, "navigationServerCreated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "physicsEngineCreated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "manifoldCreated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lightmapManagerCreated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "isTicking", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "actorsToRemove", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "hiddenInGameActors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "hiddenInGameSceneComponents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "isPaused", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "slomo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "gameTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "overrideCamera", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // the camera actor that is used for rendering the world
+        Object.defineProperty(this, "skyboxComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "renderWindowSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "nextTickFunctions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "statsDisplay", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * The camera used for rendering the world
+         */
+        Object.defineProperty(this, "camera", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /**
+         * A fallback camera used when no active camera is available
+         */
+        Object.defineProperty(this, "fallbackCamera", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        //====================================================================================================
+        // Editor Functions
+        //====================================================================================================
+        Object.defineProperty(this, "onEditorActorAddToWorld", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "onEditorActorRemoveFromWorld", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.netWorld = new NetWorld(this, options.gameId ?? 'default');
+        this.name = ObjectNamingSystem.generateName(this);
+        this.scene = new THREE.Scene();
+        this.scene.setWorld(this);
+        this.scene.background = new THREE.Color(options.backgroundColor);
+        this.actors = [];
+        this.inputManager = new InputManager({
+            rendererDomElement: options.rendererDomElement,
+            gameContainer: options.gameContainer,
+            world: new WeakRef(this),
+            enableGamepad: options.enableGamepad
+        });
+        this.timerSystem = new TimerSystem({
+            world: this
+        });
+        this.tweenManager = new TweenManager(this);
+        this.consoleManager = new ConsoleManager();
+        this.inputManager.addInputHandler(this.consoleManager);
+        // Register console variable handler for CVar system
+        this.consoleManager.addCommandHandler(new ConsoleVariableHandler());
+        // Register stats console handler
+        this.statsDisplay = new StatsDisplay(options.gameContainer);
+        this.uiManager = new UIManager({
+            container: options.gameContainer
+        });
+        this.inputManager.addInputHandler(this.uiManager);
+        this.gameMode = options.gameMode ?? new GameMode({});
+        this.gameMode.setWorld(this);
+        this.audioListener = !isNode() ? new THREE.AudioListener() : null;
+        this.globalAudioManager = GlobalAudioManager.getInstance();
+        this.globalAudioManager.setWorld(this);
+        // the global particle manager is never saved
+        this.globalParticleManager = new GlobalParticleManager();
+        this.globalParticleManager.setTransient(true);
+        this.addActors(this.globalParticleManager);
+        this.fallbackCamera = new THREE.PerspectiveCamera(75, 1, 0.1, 1000);
+        // Position the fallback camera at a reasonable default location
+        this.fallbackCamera.position.set(0, 5, 10);
+        this.fallbackCamera.lookAt(0, 0, 0);
+        this.pluginManager = new PluginManager(new WeakRef(this));
+    }
+    export(context, includeDefaults) {
+        return {
+            class: ClassRegistry.getClassNameChecked(this),
+            uuid: this.uuid,
+            ctor: context.exportObject(this.options, includeDefaults),
+            actors: this.actors.map(actor => context.exportObject(actor, includeDefaults)).filter(actor => !!actor),
+            resources: this.sceneResources ?? undefined,
+            properties: {
+                editorData: this.editorData,
+                postProcessConfiguration: this.postProcessConfiguration
+            }
+        };
+    }
+    serialize(dumper) {
+        dumper.dumpValue('$uuid', this.uuid);
+        dumper.dumpValue('actors', this.actors.filter(actor => !!actor));
+        dumper.dumpValue('resources', this.sceneResources);
+        dumper.dumpValue('editorData', this.editorData);
+        dumper.dumpValue('postProcessConfiguration', this.postProcessConfiguration);
+        dumper.dumpProperties(this);
+    }
+    deserialize(loader) {
+        this.uuid = loader.loadValue('$uuid') ?? this.uuid;
+        this.sceneResources = loader.loadValue('resources', this.sceneResources);
+        this.editorData = loader.loadValue('editorData', this.editorData);
+        this.postProcessConfiguration = loader.loadValue('postProcessConfiguration', this.postProcessConfiguration);
+        // I could do,
+        // ```
+        // const actors = [...this.actors];
+        // loader.loadValue('actors', actors);
+        // ```
+        // expecting the loader to populate into some existing actor, but let's assume that world is clean when loaded for now
+        const actors = loader.loadValue('actors');
+        const newlyLoadedActors = actors.filter(actor => actor && !this.actors.includes(actor));
+        this.addActors(...newlyLoadedActors);
+        loader.loadProperties(this);
+    }
+    /**
+     * The container element that holds the game UI and game content
+     */
+    get gameContainer() {
+        return this.options.gameContainer;
+    }
+    /**
+     * Gets the game loop
+     * @returns The game loop
+     */
+    get gameLoop() {
+        return this.options.gameLoop?.deref() ?? null;
+    }
+    /**
+     * Gets the render window size
+     * @returns The render window size
+     */
+    getRenderWindowSize() {
+        return this.renderWindowSize;
+    }
+    /**
+     * Sets the lightmap resource references for this scene.
+     * Used by external tools to configure lightmap file paths.
+     */
+    setLightmapResources(metadataPath, texturePath) {
+        this.sceneResources ??= {};
+        this.sceneResources.lightmap = {
+            metadataPath,
+            texturePath
+        };
+    }
+    /**
+     * Sets the NavMesh resource reference for this scene.
+     * Used by external tools to configure NavMesh file path.
+     */
+    setNavMeshResource(path) {
+        this.sceneResources ??= {};
+        this.sceneResources.navMesh = {
+            path
+        };
+    }
+    /**
+     * Clears lightmap resource references for this scene.
+     */
+    clearLightmapResources() {
+        if (this.sceneResources) {
+            this.sceneResources.lightmap = undefined;
+        }
+    }
+    /**
+     * Clears NavMesh resource reference for this scene.
+     */
+    clearNavMeshResource() {
+        if (this.sceneResources) {
+            this.sceneResources.navMesh = undefined;
+        }
+    }
+    /**
+     * Gets the current scene resource configuration.
+     */
+    getSceneResources() {
+        return this.sceneResources;
+    }
+    /**
+     * Gets the current post-processing configuration.
+     */
+    getPostProcessConfiguration() {
+        return this.postProcessConfiguration;
+    }
+    /**
+     * Sets the post-processing configuration (merges with defaults).
+     * @param config - The post-processing configuration to set
+     */
+    setPostProcessConfiguration(config) {
+        this.postProcessConfiguration = config;
+        if (config) {
+            this.postProcessManager.setConfiguration(config);
+        }
+    }
+    /**
+     * Updates the post-processing configuration (merges with current).
+     * @param config - The post-processing configuration to update
+     */
+    updatePostProcessConfiguration(config) {
+        if (this.postProcessConfiguration) {
+            // Merge with existing configuration
+            const mergedEffects = [...this.postProcessConfiguration.effects];
+            for (const newEffect of config.effects) {
+                const existingIndex = mergedEffects.findIndex(e => e.type === newEffect.type);
+                if (existingIndex >= 0) {
+                    mergedEffects[existingIndex] = { ...mergedEffects[existingIndex], ...newEffect };
+                }
+                else {
+                    mergedEffects.push(newEffect);
+                }
+            }
+            this.postProcessConfiguration = { effects: mergedEffects };
+        }
+        else {
+            this.postProcessConfiguration = config;
+        }
+        this.postProcessManager.updateConfiguration(config);
+    }
+    /**
+     * Adds an actor to the world
+     * @param actor The actor to add
+     * @returns This world instance for method chaining
+     */
+    addActor(actor) {
+        return this.addActors(actor);
+    }
+    /**
+     * Adds one or more actors to the world
+     * @param actors The actors to add
+     * @returns This world instance for method chaining
+     */
+    addActors(...actors) {
+        if (!ensure(!this.isPlayEnded())) {
+            return this;
+        }
+        actors.forEach(actor => {
+            if (!ensure(!this.actors.includes(actor))) {
+                return;
+            }
+            this.actors.push(actor);
+            actor.setWorld(this);
+            this.scene.add(actor.rootComponent);
+            if (this.isPlaying()) {
+                actor.beginPlay();
+            }
+            if (actor instanceof PlayerController) {
+                if (this.playerControllers.length) {
+                    throw new Error('Only one player controller is allowed in the world');
+                }
+                this.playerControllers.push(actor);
+            }
+            if (this.isEditorWorld) {
+                actor.onEditorAddToWorld();
+                this.onEditorActorAddToWorld?.(actor);
+            }
+        });
+        return this;
+    }
+    /**
+       * Gets the current physics engine instance
+       * @returns The physics engine instance if available, otherwise null
+       */
+    getPhysicsEngine() {
+        return this.physicsEngine;
+    }
+    getNavigationServer() {
+        return this.navigationServer;
+    }
+    /**
+     * Creates a navigation mesh from the current scene.
+     * This method waits for both the scene to be fully loaded and all GLTF meshes to be loaded
+     * before generating the navigation mesh from actors with GLTFMeshComponents that are set to static motion type.
+     */
+    async createNavigationMeshFromScene() {
+        if (!this.navigationServerCreated) {
+            throw new Error('[Navigation Server] Navigation server not created');
+        }
+        const navigationServer = this.getNavigationServer();
+        if (!navigationServer) {
+            console.error('[Navigation Server] createNavigationMeshFromScene: Navigation server not available');
+            return;
+        }
+        const meshes = [];
+        // gather all the relevant gltf mesh components
+        let gltfMeshComponents = [];
+        for (const actor of this.actors) {
+            gltfMeshComponents.push(...actor.getComponents(GLTFMeshComponent));
+        }
+        gltfMeshComponents = gltfMeshComponents.filter(component => component.getPhysicsOptions()?.motionType === PhysicsMotionType.Static && !component.options.excludeFromNavigation);
+        if (gltfMeshComponents.length > 0) {
+            // wait for all the models to be loaded
+            await Promise.all(Object.values(resourceManager.getCachedModels()));
+            // Extract meshes from GLTFMeshComponents
+            for (const component of gltfMeshComponents) {
+                meshes.push(...component.getAllMeshes());
+            }
+        }
+        // gather all the relevant mesh components
+        let meshComponents = [];
+        for (const actor of this.actors) {
+            meshComponents.push(...actor.getComponents(MeshComponent));
+        }
+        meshComponents = meshComponents.filter(component => component.getPhysicsOptions()?.motionType === PhysicsMotionType.Static && !component.options.excludeFromNavigation);
+        for (const component of meshComponents) {
+            meshes.push(component.getMesh());
+        }
+        if (meshes.length === 0) {
+            console.warn('[Navigation Server] No meshes found for navigation mesh generation');
+            return;
+        }
+        const success = await navigationServer.createNavigationMeshFromMeshes(meshes);
+        if (success) {
+            console.log('[Navigation Server] Navigation mesh created successfully');
+        }
+        else {
+            console.error('[Navigation Server] Failed to create navigation mesh');
+        }
+    }
+    /**
+     * Export the current navigation mesh to a binary file
+     * @param scenePath The path to the scene file (used to determine navmesh file path)
+     * @returns Promise resolving to export result with data and filename
+     */
+    async exportNavigationMesh(scenePath) {
+        const navigationServer = this.getNavigationServer();
+        if (!navigationServer) {
+            console.error('[World] exportNavigationMesh: Navigation server not available');
+            return { success: false };
+        }
+        return await navigationServer.exportNavigationMesh(scenePath);
+    }
+    /**
+     * Import a navigation mesh from a binary file
+     * @param scenePath The path to the scene file (used to determine navmesh file path)
+     * @returns Promise resolving to success/failure
+     */
+    async importNavigationMesh(scenePath) {
+        const navigationServer = this.getNavigationServer();
+        if (!navigationServer) {
+            console.error('[World] importNavigationMesh: Navigation server not available');
+            return false;
+        }
+        return await navigationServer.importNavigationMesh(scenePath);
+    }
+    /**
+     * Import a navigation mesh from binary data directly
+     * @param navMeshData The NavMesh binary data as ArrayBuffer
+     * @returns Promise resolving to success/failure
+     */
+    async importNavigationMeshFromData(navMeshData) {
+        const navigationServer = this.getNavigationServer();
+        if (!navigationServer) {
+            console.error('[World] importNavigationMeshFromData: Navigation server not available');
+            return false;
+        }
+        return await navigationServer.importNavigationMeshFromData(navMeshData);
+    }
+    /**
+     * Clear the current navigation mesh
+     */
+    clearNavigationMesh() {
+        const navigationServer = this.getNavigationServer();
+        if (!navigationServer) {
+            console.error('[World] clearNavigationMesh: Navigation server not available');
+            return;
+        }
+        navigationServer.clearNavigationMesh();
+    }
+    getManifold() {
+        return this.manifold;
+    }
+    /**
+     * Removes an actor from the world
+     * @param actor The actor to remove
+     * @returns This world instance for method chaining
+     */
+    removeActor(actor) {
+        return this.removeActors(actor);
+    }
+    /**
+     * Removes one or more actors from the world
+     * @param actors - The actors to remove
+     * @returns This world instance for method chaining
+     */
+    removeActors(...actors) {
+        if (!ensure(!this.isPlayEnded())) {
+            return this;
+        }
+        if (this.isTicking) {
+            this.actorsToRemove.push(...actors);
+            return this;
+        }
+        actors.forEach(actor => {
+            const index = this.actors.indexOf(actor);
+            if (ensure(index !== -1, `${actor.getPathName()} not found in world`)) {
+                if (this.isPlaying()) {
+                    actor.endPlay();
+                }
+                if (this.isEditorWorld) {
+                    actor.onEditorRemoveFromWorld();
+                    this.onEditorActorRemoveFromWorld?.(actor);
+                }
+                actor.setWorld(null);
+                this.actors.splice(index, 1);
+                this.scene.remove(actor.rootComponent);
+                if (actor instanceof PlayerController) {
+                    const index = this.playerControllers.indexOf(actor);
+                    if (index !== -1) {
+                        this.playerControllers.splice(index, 1);
+                    }
+                }
+            }
+        });
+        return this;
+    }
+    /**
+     * Schedules a function to be executed at the beginning of the next tick
+     * @param fn - The function to execute next tick
+     */
+    runInNextTick(fn) {
+        this.nextTickFunctions.push(fn);
+    }
+    /**
+       * Updates the world state for the current frame
+       * @param deltaTime - Time elapsed since last frame in seconds
+       */
+    tick(deltaTime) {
+        deltaTime *= this.slomo;
+        if (this.playState !== PlayState.Playing) {
+            return;
+        }
+        if (this.isPaused) {
+            return;
+        }
+        if (deltaTime <= 0) {
+            return;
+        }
+        this.gameTime += deltaTime;
+        this.isTicking = true;
+        // Execute functions scheduled for this tick
+        if (this.nextTickFunctions.length > 0) {
+            const functionsToExecute = [...this.nextTickFunctions];
+            this.nextTickFunctions = [];
+            for (const fn of functionsToExecute) {
+                try {
+                    fn();
+                }
+                catch (error) {
+                    console.error('Error executing next tick function:', error);
+                }
+            }
+        }
+        // Process timer events before physics
+        this.timerSystem.tick(deltaTime);
+        // Update all managed tweens
+        this.tweenManager.update(deltaTime);
+        this.gameMode.tick(deltaTime);
+        for (const actor of this.actors) {
+            actor.tickPrePhysics(deltaTime);
+        }
+        if (this.physicsEngine) {
+            this.physicsEngine.tick(deltaTime);
+        }
+        for (const actor of this.actors) {
+            actor.tickPostPhysics(deltaTime);
+        }
+        this.netWorld.tick(deltaTime);
+        this.statsDisplay.tick();
+        // Ensure the audio listener is attached to the correct camera
+        const camera = this.getActiveCamera();
+        if (camera && this.audioListener && this.audioListener.parent != camera) {
+            camera.add(this.audioListener);
+            camera.getActor()?.onPreEndPlay.add((cameraActor) => {
+                this.audioListener?.removeFromParent();
+            });
+        }
+        this.isTicking = false;
+        this.removeActors(...this.actorsToRemove);
+        this.actorsToRemove = [];
+    }
+    /**
+     * Creates the physics engine
+     * @returns A promise that resolves when the physics engine is created
+     */
+    async createPhysicsEngine() {
+        if (this.physicsEngineCreated) {
+            throw new Error('Physics engine already created');
+        }
+        this.physicsEngine = await createPhysicsEngine(this.options.physicsOptions, this);
+        console.log('Physics engine created:', ClassRegistry.getClassOrConstructorName(this.physicsEngine));
+        this.physicsEngineCreated = true;
+    }
+    async createManifold() {
+        if (this.manifoldCreated) {
+            throw new Error('Manifold already created');
+        }
+        if (!this.options.useManifold) {
+            return;
+        }
+        this.manifold = new ManifoldWrapper();
+        await this.manifold?.initManifold();
+        this.manifoldCreated = true;
+    }
+    async createNavigationServer() {
+        if (this.navigationServerCreated) {
+            throw new Error('Navigation server already created');
+        }
+        this.navigationServer = await createNavigationServer(this.options.navigationOptions);
+        console.log('Navigation server created:', this.navigationServer);
+        this.navigationServerCreated = true;
+    }
+    /**
+     * Creates the lightmap manager
+     * @returns A promise that resolves when the lightmap manager is created
+     */
+    async createLightmapManager(renderer) {
+        if (this.lightmapManagerCreated || !ENABLE_LIGHTMAPS) {
+            return; // Already created, just return
+        }
+        try {
+            if (!renderer) {
+                console.warn('No renderer provided for lightmap manager creation');
+                return;
+            }
+            this.lightmapManager = new LightmapManager(this, renderer, {
+                autoApply: true,
+                progressiveBaking: true,
+            });
+            await this.lightmapManager.initialize();
+            console.log('Lightmap manager created and initialized');
+            this.lightmapManagerCreated = true;
+        }
+        catch (error) {
+            console.warn('Failed to create lightmap manager:', error);
+            // Don't set lightmapManagerCreated to true if initialization failed
+            this.lightmapManager = null;
+        }
+    }
+    /**
+     * Gets the lightmap manager
+     * @returns The lightmap manager if created, otherwise null
+     */
+    getLightmapManager() {
+        return this.lightmapManager;
+    }
+    /**
+     * Generates a debug node for the world
+     * @returns A debug node for the world
+     */
+    generateDebugNode() {
+        const children = [];
+        children.push(this.gameMode.generateDebugNode());
+        for (const actor of this.actors) {
+            children.push(actor.generateDebugNode());
+        }
+        return {
+            title: this.name,
+            children,
+            data: {
+                uuid: this.uuid,
+                ...this.options
+            }
+        };
+    }
+    /**
+     * Gets the first actor of a specified type
+     * @param type - The type of actor to search for
+     * @returns The first actor of the specified type or null if no such actor exists
+     */
+    getFirstActor(type) {
+        return this.actors.find(actor => actor instanceof type);
+    }
+    /**
+     * Gets the first component of a specified type
+     * @param type - The type of component to search for
+     * @returns The first component of the specified type or null if no such component exists
+     */
+    getComponent(type) {
+        for (const actor of this.actors) {
+            const component = actor.getComponent(type);
+            if (component) {
+                return component;
+            }
+        }
+        return null;
+    }
+    /**
+     * Gets all actors of a specified type
+     * @param type - The type of actor to search for
+     * @returns An array of all actors of the specified type
+     */
+    getActors(type = Actor) {
+        return this.actors.filter(actor => actor instanceof type);
+    }
+    /**
+     * Gets an actor by its UUID
+     * @param uuid - The UUID of the actor to search for
+     * @returns The actor with the specified UUID or null if no such actor exists
+     */
+    getActorByUuid(uuid) {
+        return this.actors.find(actor => actor.uuid === uuid);
+    }
+    /**
+     * Gets all actors that match a predicate
+     * @param predicate - The predicate to match
+     * @returns An array of all actors that match the predicate
+     */
+    getActorsByPredicate(predicate) {
+        return this.actors.filter(predicate);
+    }
+    /**
+     * Gets the first actor with the specified tag
+     * @param tag - The tag to search for
+     * @returns The first actor with the specified tag or null if no such actor exists
+     */
+    getFirstActorByTag(tag) {
+        return this.actors.find(actor => actor.hasActorTag(tag)) ?? null;
+    }
+    /**
+     * Gets all actors with the specified tag
+     * @param tag - The tag to search for
+     * @returns An array of all actors with the specified tag
+     */
+    getActorsByTag(tag) {
+        return this.actors.filter(actor => actor.hasActorTag(tag));
+    }
+    /**
+     * Gets the first actor that has any of the specified tags
+     * @param tags - The tags to search for
+     * @returns The first actor with any of the specified tags or null if no such actor exists
+     */
+    getFirstActorByAnyTag(tags) {
+        return this.actors.find(actor => actor.hasAnyActorTag(tags)) ?? null;
+    }
+    /**
+     * Gets all actors that have any of the specified tags
+     * @param tags - The tags to search for
+     * @returns An array of all actors with any of the specified tags
+     */
+    getActorsByAnyTag(tags) {
+        return this.actors.filter(actor => actor.hasAnyActorTag(tags));
+    }
+    /**
+     * Gets the first actor that has all of the specified tags
+     * @param tags - The tags to search for
+     * @returns The first actor with all of the specified tags or null if no such actor exists
+     */
+    getFirstActorByAllTags(tags) {
+        return this.actors.find(actor => actor.hasAllActorTags(tags)) ?? null;
+    }
+    /**
+     * Gets all actors that have all of the specified tags
+     * @param tags - The tags to search for
+     * @returns An array of all actors with all of the specified tags
+     */
+    getActorsByAllTags(tags) {
+        return this.actors.filter(actor => actor.hasAllActorTags(tags));
+    }
+    /**
+     * Gets the first player pawn in the world
+     * @returns The first player pawn in the world or null if no player pawn exists
+     */
+    getFirstPlayerPawn() {
+        return this.getFirstActor(PlayerController)?.getPawn() ?? null;
+    }
+    /**
+     * Clears the world
+     */
+    clearWorld() {
+        this.removeActors(...this.actors);
+        this.actors = [];
+        this.scene.remove(...this.scene.children);
+        if (this.isEditorWorld) {
+            this.onEditorActorAddToWorld = undefined;
+            this.onEditorActorRemoveFromWorld = undefined;
+        }
+    }
+    /**
+     * Gets the path name of the world
+     * @returns The path name of the world
+     */
+    getPathName() {
+        return this.name;
+    }
+    /**
+     * Adds a box to the world
+     * @param options - The options for the box
+     * @returns The actor that was created
+     */
+    addBox(options) {
+        return this.addBasicGeometry({
+            ...options,
+            geometry: new THREE.BoxGeometry(options.width, options.height, options.depth),
+        });
+    }
+    /**
+     * Adds a sphere to the world
+     * @param options - The options for the sphere
+     * @returns The actor that was created
+     */
+    addSphere(options) {
+        return this.addBasicGeometry({
+            ...options,
+            geometry: new THREE.SphereGeometry(options.radius),
+        });
+    }
+    /**
+     * Adds a capsule to the world
+     * @param options - The options for the capsule
+     * @returns The actor that was created
+     */
+    addCapsule(options) {
+        return this.addBasicGeometry({
+            ...options,
+            geometry: new THREE.CapsuleGeometry(options.radius, options.height),
+        });
+    }
+    /**
+     * Adds a cylinder to the world
+     * @param options - The options for the cylinder
+     * @returns The actor that was created
+     */
+    addCylinder(options) {
+        return this.addBasicGeometry({
+            ...options,
+            geometry: new THREE.CylinderGeometry(options.radius, options.radius, options.height),
+        });
+    }
+    /**
+     * Adds a cone to the world
+     * @param options - The options for the cone
+     * @returns The actor that was created
+     */
+    addCone(options) {
+        return this.addBasicGeometry({
+            ...options,
+            geometry: new THREE.ConeGeometry(options.radius, options.height),
+        });
+    }
+    /**
+     * Adds a basic geometry to the world
+     * @param options - The options for the geometry
+     * @returns The actor that was created
+     */
+    addBasicGeometry(options) {
+        const actor = new Actor({
+            rootComponent: new MeshComponent({
+                position: options.position,
+                rotation: options.rotation,
+                scale: options.scale,
+                geometry: options.geometry,
+                material: new THREE.MeshStandardMaterial({ color: options.color }),
+                physicsOptions: {
+                    enabled: !!options.motionType,
+                    motionType: options.motionType
+                }
+            })
+        });
+        this.addActors(actor);
+        return actor;
+    }
+    /**
+     * Adds an axes helper to the world
+     * @param options - The options for the axes helper
+     * @returns The actor that was created
+     */
+    addAxesHelper(options) {
+        const actor = new Actor({
+            position: options.position,
+            rotation: options.rotation,
+        });
+        actor.rootComponent.add(new THREE.AxesHelper(options.size));
+        this.addActors(actor);
+        return actor;
+    }
+    /**
+     * Returns an exported object representation of the world
+     * @param includeDefaults Whether to include default values
+     * @returns An exported object representation of the world
+     */
+    asExportedObject(includeDefaults = false) {
+        return WorldSerializer.exportObject(this, includeDefaults);
+    }
+    /**
+     * Gets the game time
+     * @returns The game time
+     */
+    getGameTime() {
+        return this.gameTime;
+    }
+    /**
+     * Gets the active camera to render the scene
+     * @returns The active camera
+     */
+    getActiveCamera() {
+        if (this.overrideCamera) {
+            return this.overrideCamera;
+        }
+        return this.playerControllers[0]?.getCamera() ?? null;
+    }
+    /**
+     * Renders the scene
+     * @param renderer - The renderer to use
+     */
+    renderScene(renderer, windowSize) {
+        const camera = this.getActiveCamera();
+        if (!camera) {
+            this.logCameraWarning();
+        }
+        this.renderWindowSize = windowSize;
+        const cameraToUse = camera ?? this.fallbackCamera;
+        if (cameraToUse instanceof THREE.PerspectiveCamera) {
+            cameraToUse.aspect = windowSize.width / windowSize.height;
+            cameraToUse.updateProjectionMatrix();
+        }
+        this.postProcessManager.renderScene(renderer, this.scene, cameraToUse, windowSize);
+    }
+    /**
+     * Logs a warning when no camera is found, throttled to every 10 seconds
+     */
+    logCameraWarning() {
+        const currentTime = Date.now();
+        // Only log warning every 10 seconds (10000ms)
+        if (currentTime - this.lastCameraWarningTime >= 10000) {
+            console.warn('No camera found. Please add a three.js camera to your pawn or set one using "world.setOverrideCamera(camera)".');
+            this.lastCameraWarningTime = currentTime;
+        }
+    }
+    /**
+     * Gets the override camera
+     * @returns The override camera
+     */
+    getOverrideCamera() {
+        return this.overrideCamera;
+    }
+    /**
+     * Sets the override camera
+     * @param camera - The camera to set
+     */
+    setOverrideCamera(camera) {
+        this.overrideCamera = camera;
+    }
+    /**
+     * Gets the skybox component
+     * @returns The skybox component
+     */
+    getSkyboxComponent() {
+        return this.skyboxComponent;
+    }
+    /**
+     * Sets the skybox component
+     * @param component - The skybox component to set
+     */
+    setSkyboxComponent(component) {
+        if (this.skyboxComponent && component && this.skyboxComponent !== component) {
+            ensure(false, 'Skybox component already set, cannot set another');
+            return;
+        }
+        this.skyboxComponent = component;
+    }
+    destroy() {
+        if (this.isPlaying()) {
+            this.endPlay();
+        }
+        this.scene.setWorld(null);
+        // Reset camera warning timer
+        this.lastCameraWarningTime = 0;
+        // Clean up UI manager
+        this.uiManager.destroy();
+        // Clean up input manager
+        this.inputManager.destroy();
+        if (this.physicsEngine) {
+            this.physicsEngine.destroy();
+            this.physicsEngine = null;
+        }
+        this.consoleManager.removeCommandHandler(this);
+        this.consoleManager.destroy();
+        this.postProcessManager.destroy();
+        this.navigationServer?.destroy();
+        // Clean up navigation mesh visualization
+        if (this.navigationMeshVisualization) {
+            this.scene.remove(this.navigationMeshVisualization);
+            this.navigationMeshVisualization = null;
+        }
+        this.hiddenInGameActors.clear();
+        this.actors = [];
+    }
+    //====================================================================================================
+    doBeginPlay() {
+        if (!this.physicsEngineCreated) {
+            throw new Error('Physics engine not created');
+        }
+        this.consoleManager.addCommandHandler(this);
+        // other actors can be spawned in the beginPlay call below and add themselves to this.actors
+        // so we must iterate over a copy
+        // and we're iterating on the actors before calling beginPlay on the subsystems below
+        // to avoid the issue where the subsystems can spawn actors which would get beginPlay called twice
+        for (const actor of [...this.actors]) {
+            actor.beginPlay();
+        }
+        this.inputManager.beginPlay();
+        // Begin play for the timer system
+        this.timerSystem.beginPlay();
+        this.gameMode.beginPlay();
+        this.netWorld.beginPlay();
+    }
+    doEndPlay() {
+        for (const actor of this.actors) {
+            actor.endPlay();
+        }
+        this.netWorld.endPlay();
+        this.inputManager.endPlay();
+        this.gameMode.endPlay();
+        // End play for the timer system
+        this.timerSystem.endPlay();
+        // End play for the global audio manager
+        this.globalAudioManager.endPlay();
+    }
+    describe(options) {
+        const description = {};
+        if (this.editorData && Object.keys(this.editorData).length > 0) {
+            description.info = this.editorData;
+        }
+        const specifiedActors = options?.specifiedActors;
+        return {
+            ...description,
+            actorsNumber: this.actors.length,
+            actors: this.actors.map(actor => actor.describe({
+                includeComponentsDetails: options?.includeComponentsDetails,
+                omitDescription: specifiedActors ? !specifiedActors.includes(actor.uuid) : false
+            })),
+        };
+    }
+    clearWorldCommand() {
+        this.clearWorld();
+        return 'World cleared';
+    }
+    dumpSG(format = 'html') {
+        format = format.toLowerCase();
+        if (format === 'html') {
+            const html = SceneGraphUtils.dumpHtml(this);
+            const blob = new Blob([html], { type: 'text/html' });
+            const url = URL.createObjectURL(blob);
+            window.open(url, '_blank');
+            return 'Scene graph dumped to html';
+        }
+        return 'Invalid format';
+    }
+    exportWorld(includeDefaults) {
+        const worldData = WorldSerializer.exportObject(this, !!includeDefaults);
+        const worldDataString = JSON.stringify(worldData, null, 2);
+        const blob = new Blob([worldDataString], { type: 'application/json' });
+        const url = URL.createObjectURL(blob);
+        window.open(url, '_blank');
+        return true;
+    }
+    pause() {
+        this.isPaused = !this.isPaused;
+        return `World paused: ${this.isPaused}`;
+    }
+    setSlomoCommand(value) {
+        const num = parseFloat(value);
+        if (isNaN(num)) {
+            return 'Invalid number';
+        }
+        this.slomo = num;
+        return `World slomo set to: ${this.slomo}`;
+    }
+    clearCachedResources() {
+        resourceManager.clearCachedResources();
+        return true;
+    }
+    logCachedResources() {
+        resourceManager.logCachedResources();
+        return true;
+    }
+    show(helperType) {
+        const type = helperType.toLowerCase();
+        if (type === 'stats') {
+            this.statsDisplay.toggle();
+            return 'Stats console toggled';
+        }
+        if (type === 'navmesh') {
+            const navigationServer = this.getNavigationServer();
+            if (!navigationServer) {
+                return 'Navigation server not available';
+            }
+            if (this.navigationMeshVisualization) {
+                // Remove existing visualization
+                this.scene.remove(this.navigationMeshVisualization);
+                this.navigationMeshVisualization = null;
+                return 'Navigation mesh visualization hidden';
+            }
+            else {
+                // Create and add visualization
+                const visualization = navigationServer.createDebugVisualization();
+                if (!visualization) {
+                    console.error('[Navigation Server] show navmesh: Failed to create debug visualization');
+                    return 'Failed to create debug visualization';
+                }
+                // Disable raycasting for debug mesh to prevent interference with any gameplay
+                visualization.traverse((child) => {
+                    child.raycast = () => { };
+                });
+                this.scene.add(visualization);
+                this.navigationMeshVisualization = visualization;
+                return 'Navigation mesh visualization shown';
+            }
+        }
+        if (type === 'collision') {
+            const physicsEngine = this.getPhysicsEngine();
+            if (!physicsEngine) {
+                return 'Physics engine not available';
+            }
+            physicsEngine.setDebugRendererEnabled(!physicsEngine.isDebugRendererEnabled());
+            return 'Collision debug visualization ' + (physicsEngine.isDebugRendererEnabled() ? 'enabled' : 'disabled');
+        }
+        const lightComponents = [];
+        for (const actor of this.actors) {
+            lightComponents.push(...actor.getComponents(LightComponent));
+        }
+        if (type === 'lighthelper') {
+            for (const lightComponent of lightComponents) {
+                lightComponent.showHelper(!lightComponent.isHelperVisible());
+            }
+            return `Toggled light helpers for ${lightComponents.length} lights`;
+        }
+        else if (type === 'lightcamerahelper') {
+            for (const lightComponent of lightComponents) {
+                lightComponent.showCameraHelper(!lightComponent.isCameraHelperVisible());
+            }
+            return `Toggled light camera helpers for ${lightComponents.length} lights`;
+        }
+        else {
+            return 'Invalid helper type. Use: lighthelper, lightcamerahelper, navmesh, or collision';
+        }
+    }
+    setActorHiddenInGame(actor, hidden) {
+        if (!this.isEditorWorld) {
+            if (hidden) {
+                this.hiddenInGameActors.add(actor);
+                actor.rootComponent.traverse(obj => obj.layers.disableAll());
+                this.postProcessManager.hiddenObjects.add(actor.rootComponent);
+            }
+            else {
+                this.postProcessManager.hiddenObjects.delete(actor.rootComponent);
+                actor.rootComponent.traverse(obj => obj.layers.enable(0));
+                this.hiddenInGameActors.delete(actor);
+            }
+        }
+    }
+    setSceneComponentHiddenInGame(sceneComponent, hidden) {
+        if (!this.isEditorWorld) {
+            if (hidden) {
+                this.hiddenInGameSceneComponents.add(sceneComponent);
+                sceneComponent.traverse(obj => obj.layers.disableAll());
+                this.postProcessManager.hiddenObjects.add(sceneComponent);
+            }
+            else {
+                this.postProcessManager.hiddenObjects.delete(sceneComponent);
+                sceneComponent.traverse(obj => obj.layers.enable(0));
+                this.hiddenInGameSceneComponents.delete(sceneComponent);
+            }
+        }
+    }
+    setIsEditorWorld(isEditorWorld, onActorAddToWorld, onActorRemoveFromWorld) {
+        this.isEditorWorld = isEditorWorld;
+        if (onActorAddToWorld) {
+            this.onEditorActorAddToWorld = onActorAddToWorld;
+        }
+        if (onActorRemoveFromWorld) {
+            this.onEditorActorRemoveFromWorld = onActorRemoveFromWorld;
+        }
+    }
+};
+_a = ISerializableObjectTag;
+__decorate([
+    ConsoleCommand('clearworld', 'Clear all actors from the world'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", String)
+], World.prototype, "clearWorldCommand", null);
+__decorate([
+    ConsoleCommand('dumpsg', 'Dump scene graph to HTML file (usage: dumpsg [html])'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", String)
+], World.prototype, "dumpSG", null);
+__decorate([
+    ConsoleCommand('exportworld', 'Export world data to JSON file (usage: exportworld [includeDefaults])'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Boolean)
+], World.prototype, "exportWorld", null);
+__decorate([
+    ConsoleCommand('pause', 'Toggle world pause state'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", String)
+], World.prototype, "pause", null);
+__decorate([
+    ConsoleCommand('slomo', 'Set world slow motion multiplier (usage: slomo <value>)'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", String)
+], World.prototype, "setSlomoCommand", null);
+__decorate([
+    ConsoleCommand('clearcache', 'Clear all cached resources'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Boolean)
+], World.prototype, "clearCachedResources", null);
+__decorate([
+    ConsoleCommand('logcache', 'Log all cached resources to console'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Boolean)
+], World.prototype, "logCachedResources", null);
+__decorate([
+    ConsoleCommand('show', 'Show/hide debug visualizations (usage: show <lighthelper | lightcamerahelper | navmesh | collision>)'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], World.prototype, "show", null);
+World = __decorate([
+    EngineClass('World'),
+    __metadata("design:paramtypes", [Object])
+], World);
+export { World };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"World.js","sourceRoot":"","sources":["../../../src/game/World.ts"],"names":[],"mappings":"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"}