@skewedaspect/sage 0.6.1 → 0.7.0

package/dist/classes/gameEngine.d.ts

@@ -4,6 +4,7 @@ import { SceneEngine } from "../engines/scene.d.ts";
 import { BindingManager } from "../managers/binding.d.ts";
 import { GameManager } from "../managers/game.d.ts";
 import { GameEntityManager } from "../managers/entity.d.ts";
+import { LevelManager } from "../managers/level.d.ts";
 import { UserInputManager } from "../managers/input.d.ts";
 import { GameEventBus } from "./eventBus.d.ts";
 import { LoggingUtility } from "../utils/logger.d.ts";
@@ -25,6 +26,7 @@ interface Managers {
     gameManager: GameManager;
     entityManager: GameEntityManager;
     inputManager: UserInputManager;
+    levelManager: LevelManager;
 }
 /**
  * Class representing the SkewedAspect Game Engine.

package/dist/classes/level.d.ts

@@ -0,0 +1,60 @@
+import { Scene } from '@babylonjs/core';
+import { LoggerInterface } from "../interfaces/logger.d.ts";
+import { SceneEngine } from "../engines/scene.d.ts";
+import { GameEventBus } from "./eventBus.d.ts";
+export interface LevelProgressEvent {
+    type: 'level:progress' | 'level:complete' | 'level:error';
+    levelName: string;
+    progress?: number;
+    message?: string;
+    error?: any;
+}
+/**
+ * Abstract base class for game levels.
+ * Levels are responsible for creating and configuring their own scenes.
+ */
+export declare abstract class Level {
+    protected _name: string;
+    protected _sceneEngine?: SceneEngine;
+    protected _eventBus?: GameEventBus;
+    protected _scene: Scene | null;
+    protected _log: LoggerInterface;
+    constructor(name: string);
+    /**
+     * The name of this level
+     */
+    get name(): string;
+    /**
+     * The current scene for this level (null if not loaded)
+     */
+    get scene(): Scene | null;
+    /**
+     * Whether this level has been loaded
+     */
+    get isLoaded(): boolean;
+    /**
+     * Emit a progress event during loading
+     */
+    protected _emitProgress(progress: number, message: string): void;
+    /**
+     * Load and create the scene for this level.
+     * Progress events will be emitted during loading.
+     *
+     * @param eventBus - The game event bus for publishing events
+     * @param sceneEngine - The scene engine used to create the scene
+     *
+     * @returns Promise that resolves to the loaded scene
+     */
+    loadScene(eventBus: GameEventBus, sceneEngine: SceneEngine): Promise<Scene>;
+    /**
+     * Abstract method for building the scene content.
+     * Concrete levels must implement this to create their specific content.
+     *
+     * @returns Promise that resolves to the created scene
+     */
+    protected abstract buildScene(): Promise<Scene>;
+    /**
+     * Dispose of this level's resources
+     */
+    dispose(): void;
+}

package/dist/engines/scene.d.ts

@@ -1,13 +1,166 @@
-import { AbstractEngine, HavokPlugin, Scene } from '@babylonjs/core';
+import { AbstractEngine, AbstractMesh, AssetContainer, DirectionalLight, FreeCamera, HavokPlugin, HemisphericLight, Light, Mesh, PhysicsAggregate, PhysicsShapeType, PointLight, Scene, Sound, SpotLight, Vector3 } from '@babylonjs/core';
 import { GameCanvas } from "../interfaces/game.d.ts";
 import { LoggingUtility } from "../utils/logger.d.ts";
 export declare class SceneEngine {
+    private _canvas;
     private _engine;
     private _physics;
     private _log;
-    constructor(engine: AbstractEngine, physics: HavokPlugin, logger?: LoggingUtility);
-    private _buildDemoScene;
-    loadScene(canvas: GameCanvas): Promise<Scene>;
+    constructor(canvas: GameCanvas, engine: AbstractEngine, physics: HavokPlugin, logger?: LoggingUtility);
+    /**
+     * Creates a new scene with physics enabled
+     * @returns A new Scene instance with physics enabled
+     */
+    createScene(): Scene;
+    enablePhysics(scene: Scene, gravityVector?: Vector3): void;
+    /**
+     * Creates a free camera at the specified position
+     * @param name - The name for the camera
+     * @param position - The position of the camera
+     * @param scene - The scene to add the camera to
+     * @param canvas - The canvas to attach the camera controls to
+     * @returns A new FreeCamera instance
+     */
+    createFreeCamera(name: string, position: Vector3, scene: Scene, canvas?: GameCanvas): FreeCamera;
+    /**
+     * Creates a hemispheric light (ambient lighting)
+     * @param name - The name for the light
+     * @param direction - The direction of the light
+     * @param scene - The scene to add the light to
+     * @param intensity - The intensity of the light (default: 0.7)
+     * @returns A new HemisphericLight instance
+     */
+    createHemisphericLight(name: string, direction: Vector3, scene: Scene, intensity?: number): HemisphericLight;
+    /**
+     * Creates a directional light (sun-like lighting)
+     * @param name - The name for the light
+     * @param direction - The direction of the light
+     * @param scene - The scene to add the light to
+     * @param intensity - The intensity of the light (default: 1.0)
+     * @returns A new DirectionalLight instance
+     */
+    createDirectionalLight(name: string, direction: Vector3, scene: Scene, intensity?: number): DirectionalLight;
+    /**
+     * Creates a point light (bulb-like lighting)
+     * @param name - The name for the light
+     * @param position - The position of the light
+     * @param scene - The scene to add the light to
+     * @param intensity - The intensity of the light (default: 1.0)
+     * @returns A new PointLight instance
+     */
+    createPointLight(name: string, position: Vector3, scene: Scene, intensity?: number): PointLight;
+    /**
+     * Creates a spot light (flashlight-like lighting)
+     * @param name - The name for the light
+     * @param position - The position of the light
+     * @param direction - The direction of the light
+     * @param angle - The angle of the light cone
+     * @param exponent - The exponent of the light falloff
+     * @param scene - The scene to add the light to
+     * @param intensity - The intensity of the light (default: 1.0)
+     * @returns A new SpotLight instance
+     */
+    createSpotLight(name: string, position: Vector3, direction: Vector3, angle: number, exponent: number, scene: Scene, intensity?: number): SpotLight;
+    /**
+     * Creates a sphere mesh
+     * @param name - The name for the mesh
+     * @param options - Options for creating the sphere
+     * @param scene - The scene to add the mesh to
+     * @returns A new sphere Mesh instance
+     */
+    createSphere(name: string, options: {
+        diameter?: number;
+        segments?: number;
+    } | undefined, scene: Scene): Mesh;
+    /**
+     * Creates a box mesh
+     * @param name - The name for the mesh
+     * @param options - Options for creating the box
+     * @param scene - The scene to add the mesh to
+     * @returns A new box Mesh instance
+     */
+    createBox(name: string, options: {
+        size?: number;
+        width?: number;
+        height?: number;
+        depth?: number;
+    } | undefined, scene: Scene): Mesh;
+    /**
+     * Creates a ground mesh
+     * @param name - The name for the mesh
+     * @param options - Options for creating the ground
+     * @param scene - The scene to add the mesh to
+     * @returns A new ground Mesh instance
+     */
+    createGround(name: string, options: {
+        width?: number;
+        height?: number;
+        subdivisions?: number;
+    } | undefined, scene: Scene): Mesh;
+    /**
+     * Creates a cylinder mesh
+     * @param name - The name for the mesh
+     * @param options - Options for creating the cylinder
+     * @param scene - The scene to add the mesh to
+     * @returns A new cylinder Mesh instance
+     */
+    createCylinder(name: string, options: {
+        height?: number;
+        diameterTop?: number;
+        diameterBottom?: number;
+    } | undefined, scene: Scene): Mesh;
+    /**
+     * Adds physics to a mesh
+     * @param mesh - The mesh to add physics to
+     * @param shapeType - The physics shape type
+     * @param physicsProps - The physics properties (mass, restitution, etc.)
+     * @param scene - The scene the mesh belongs to
+     * @returns A new PhysicsAggregate instance
+     */
+    addPhysics(mesh: Mesh, shapeType: PhysicsShapeType, physicsProps: {
+        mass?: number;
+        restitution?: number;
+        friction?: number;
+    } | undefined, scene: Scene): PhysicsAggregate;
+    /**
+     * Creates and loads a sound
+     * @param name - The name for the sound
+     * @param url - The URL or file path of the sound
+     * @param scene - The scene to add the sound to
+     * @param options - Additional sound options
+     * @returns A new Sound instance
+     */
+    createSound(name: string, url: string, scene: Scene, options?: {
+        loop?: boolean;
+        autoplay?: boolean;
+        volume?: number;
+        playbackRate?: number;
+    }): Sound;
+    /**
+     * Loads a 3D model/asset from a file
+     * @param rootUrl - The root URL where the file is located
+     * @param sceneFilename - The filename of the scene file
+     * @param scene - The scene to load the model into
+     * @returns Promise that resolves with the loaded AssetContainer
+     */
+    loadModel(rootUrl: string, sceneFilename: string, scene: Scene): Promise<AssetContainer>;
+    /**
+     * Imports meshes from a file
+     * @param meshNames - Array of mesh names to import (empty array imports all)
+     * @param rootUrl - The root URL where the file is located
+     * @param sceneFilename - The filename of the scene file
+     * @param scene - The scene to import the meshes into
+     * @returns Promise that resolves with the import result
+     */
+    importMeshes(meshNames: string[], rootUrl: string, sceneFilename: string, scene: Scene): Promise<{
+        meshes: AbstractMesh[];
+        particleSystems: any[];
+        skeletons: any[];
+        animationGroups: any[];
+        transformNodes: any[];
+        geometries: any[];
+        lights: Light[];
+    }>;
     /**
      * Tears down the scene engine and cleans up any resources
      */

package/dist/managers/game.d.ts

@@ -1,22 +1,21 @@
-import { AbstractEngine } from '@babylonjs/core';
-import { GameCanvas } from "../interfaces/game.d.ts";
+import { AbstractEngine, Scene } from '@babylonjs/core';
 import { GameEntityManager } from "./entity.d.ts";
+import { LevelManager } from "./level.d.ts";
 import { UserInputManager } from "./input.d.ts";
-import { SceneEngine } from "../engines/scene.d.ts";
 import { LoggingUtility } from "../utils/logger.d.ts";
 export declare class GameManager {
     private _engine;
     private _entityManager;
     private _inputManager;
-    private _sceneEngine;
-    private _currentScene;
+    private _levelManager;
     private _log;
     private _boundResizeHandler;
     started: boolean;
-    constructor(engine: AbstractEngine, sceneEngine: SceneEngine, entityManager: GameEntityManager, inputManager: UserInputManager, logger?: LoggingUtility);
+    constructor(engine: AbstractEngine, entityManager: GameEntityManager, inputManager: UserInputManager, levelManager: LevelManager, logger?: LoggingUtility);
+    get currentScene(): Scene | null;
     private _renderLoop;
     private _resizeHandler;
-    start(canvas: GameCanvas): Promise<void>;
+    start(): Promise<void>;
     stop(): Promise<void>;
     /**
      * Tears down any resources held by the GameManager

package/dist/managers/level.d.ts

@@ -1,58 +1,54 @@
-import { Engine, Scene } from '@babylonjs/core';
-import { GameEntityManager } from "./entity.d.ts";
-export interface LevelLoadOptions {
-    rootUrl: string;
-    filename: string;
-    useAssetContainer?: boolean;
-    showLoadingUI?: boolean;
-    onProgress?: (percent: number) => void;
-    onSuccess?: (scene: Scene) => void;
-    onError?: (message: string, exception?: any) => void;
-}
-/**
+import { Level } from "../classes/level.d.ts";
+import { GameEventBus } from "../classes/eventBus.d.ts";
+import { SceneEngine } from "../engines/scene.d.ts";
+import { LoggingUtility } from "../utils/logger.d.ts";
 /**
- * Manages level loading and streaming using BabylonJS SceneLoader and AssetContainer.
- * Also includes tagging for auto-detection (e.g. "Door", "Trigger", "Enemy"),
- * and automatically spawns entities via an entity manager if an 'entityType' is found.
- *
- * Additionally, this version checks for audio metadata (e.g. sound files) and automatically
- * creates BabylonJS Sound objects when found.
+ * Manages game levels, tracking loaded levels and the current active scene.
+ * Provides centralized access to level functionality and scene management.
  */
 export declare class LevelManager {
-    private engine;
-    private currentScene;
-    private activeContainer;
-    private entityManager;
-    constructor(engine: Engine, entityManager: GameEntityManager);
+    private _eventBus;
+    private _sceneEngine;
+    private _log;
+    /** Map of registered levels by name */
+    private _registeredLevels;
+    /** The currently active level */
+    private _currentLevel;
+    constructor(eventBus: GameEventBus, sceneEngine: SceneEngine, logger?: LoggingUtility);
     /**
-     * Loads a level, either as a full scene or into a container.
-     * @param options - Specifies rootUrl, filename, and optional callbacks.
+     * Handles level events from the event bus
      */
-    loadLevel(options: LevelLoadOptions): Promise<void>;
+    private _handleLevelEvent;
     /**
-     * Disposes the current scene and container (if any), freeing up memory.
+     * Registers a level class that can be instantiated later
+     * @param name - The name to register the level under
+     * @param level - The level class instance
      */
-    disposeCurrentScene(): void;
+    registerLevel(name: string, level: Level): void;
     /**
-     * Tears down the level manager and cleans up any resources
+     * Loads and activates a level by name
+     * @param levelName - The name of the level to load
+     * @returns Promise that resolves when the level is loaded
      */
-    $teardown(): Promise<void>;
+    loadLevel(levelName: string): Promise<void>;
+    /**
+     * Gets the currently active level
+     */
+    get currentLevel(): Level | null;
     /**
-     * Returns the current active scene, if one is loaded.
+     * Gets a loaded level by name
      */
-    getScene(): Scene | null;
+    getLevel(name: string): Level | null;
     /**
-     * Internal helper: Reports loading progress as a percentage.
-     * @param evt ISceneLoaderProgressEvent data
-     * @param callback optional progress callback
+     * Unloads a level and disposes its resources
      */
-    private reportProgress;
+    unloadLevel(name: string): void;
     /**
-     * Automatically tag loaded meshes and create entities based on metadata.
-     * Also, if audio metadata is present, create spatial sounds.
-     *
-     * @param meshes An array of loaded AbstractMesh objects.
-     * @param scene The scene into which these meshes have been loaded.
+     * Unloads the current level and disposes its resources
      */
-    private autoTagAndEntityHook;
+    unloadCurrentLevel(): void;
+    /**
+     * Tears down the level manager and cleans up any resources
+     */
+    $teardown(): Promise<void>;
 }

package/dist/sage.d.ts

@@ -20,5 +20,6 @@ export * from "./interfaces/logger.d.ts";
 export { GameEventBus, SkewedAspectGameEngine };
 export * from "./classes/eventBus.d.ts";
 export * from "./classes/entity.d.ts";
+export * from "./classes/level.d.ts";
 export * from "./utils/logger.d.ts";
 export * from "./utils/version.d.ts";