@directivegames/genesys.js 3.1.24

package/dist/games/deprecated/shadow-demo.js

@@ -0,0 +1,402 @@
+import * as dat from 'dat.gui';
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+const GROUND_SIZE = 1000;
+const GRID_SIZE = 20;
+const SPACING = 50;
+const STICK_HEIGHT = 100;
+const STICK_RADIUS = 3;
+const SHOW_LIGHT_HELPER = true;
+const SHOW_CAMERA_HELPER = true;
+const SHADOW_CAMERA_SIZE = 50;
+const FOLLOW_CAMERA = true;
+const LIGHT_RADIUS = 500; // Distance from center
+const LIGHT_HEIGHT = 300; // Height above ground
+/**
+ * Demo showcasing dynamic shadow effects with interactive lights
+ * Features moving lights, rotating objects, and shadow quality controls
+ */
+export class ShadowDemo extends ENGINE.BaseGameLoop {
+    constructor(container) {
+        super(container, {
+            ...ENGINE.BaseGameLoop.DEFAULT_OPTIONS,
+            backgroundColor: 0x1a1a2e
+        });
+        Object.defineProperty(this, "gui", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "directionalLight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pointLight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "spotLight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "dirLightActor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "autoRotateLight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "accumulatedRotationTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.gui = new dat.GUI({ autoPlace: false });
+        container.appendChild(this.gui.domElement);
+        // Style the GUI
+        this.gui.domElement.style.position = 'absolute';
+        this.gui.domElement.style.top = '10px';
+        this.gui.domElement.style.right = '10px';
+        this.gui.domElement.style.zIndex = '1000';
+        // Add keyboard event listener for space bar
+        document.addEventListener('keydown', (event) => {
+            if (event.code === 'Space') {
+                event.preventDefault();
+                this.autoRotateLight = !this.autoRotateLight;
+            }
+        });
+    }
+    getWorldConfiguration() {
+        return {
+            ...super.getWorldConfiguration(),
+            navigationOptions: {
+                engine: ENGINE.NavigationEngine.RecastNavigation,
+                debug: false,
+                options: ENGINE.RecastNavigationServer.DEFAULT_OPTIONS,
+                generateOnStartUp: false
+            },
+        };
+    }
+    async preStart() {
+        this.setupPlayer();
+        this.setupLighting();
+        this.createShadowEnvironment();
+        this.setupGUI();
+    }
+    tick(tickTime) {
+        super.tick(tickTime);
+        // Move directional light in a circle around the scene if auto-rotation is enabled
+        if (this.autoRotateLight) {
+            // Accumulate rotation time only when auto-rotation is active
+            this.accumulatedRotationTime += tickTime.deltaTimeMS / 1000;
+            const rotationSpeed = (Math.PI * 2) / 30; // radians per second - complete rotation every 30 seconds
+            const angle = this.accumulatedRotationTime * rotationSpeed;
+            // Move the light position in a circle
+            const lightX = Math.sin(angle) * LIGHT_RADIUS;
+            const lightZ = Math.cos(angle) * LIGHT_RADIUS;
+            // Update the light actor position
+            this.dirLightActor.rootComponent.position.set(lightX, LIGHT_HEIGHT, lightZ);
+            // Keep target fixed at center so light always points toward the scene center
+            this.directionalLight.setTarget(new THREE.Vector3(0, 0, 0));
+        }
+        else if (FOLLOW_CAMERA) {
+            const camera = this.world.getActiveCamera();
+            if (camera) {
+                this.directionalLight.moveTargetTo(camera.getWorldPosition());
+            }
+        }
+    }
+    setupPlayer() {
+        const { pawn } = ENGINE.GameBuilder.createDefaultPawn(this.world);
+        pawn.rootComponent.setWorldPosition(ENGINE.MathHelpers.makeVector({ forward: -20, right: 0, up: 100 }));
+        // hack to make the player move faster
+        pawn.getComponent(ENGINE.CharacterMovementComponent).options.maxSpeed = 100;
+    }
+    setupLighting() {
+        // Ambient light for minimal base lighting
+        const ambientActor = new ENGINE.Actor();
+        const ambientLight = new ENGINE.AmbientLightComponent({
+            color: 0x202040,
+            intensity: 0.15
+        });
+        ambientActor.rootComponent.add(ambientLight);
+        this.world.addActors(ambientActor);
+        // Main directional light (sun)
+        this.dirLightActor = new ENGINE.Actor();
+        this.directionalLight = new ENGINE.DirectionalLightComponent({
+            color: 0xfff8e1,
+            intensity: 1.5,
+        });
+        this.directionalLight.showHelper(SHOW_LIGHT_HELPER);
+        this.directionalLight.showCameraHelper(SHOW_CAMERA_HELPER);
+        this.dirLightActor.rootComponent.position.set(10, 15, 5);
+        this.directionalLight.setTarget(new THREE.Vector3(0, 0, 0));
+        this.directionalLight.castShadow = true;
+        // High-quality shadows for directional light - cover the large stick grid
+        this.directionalLight.configureShadowCamera({
+            left: -SHADOW_CAMERA_SIZE, right: SHADOW_CAMERA_SIZE, top: SHADOW_CAMERA_SIZE, bottom: -SHADOW_CAMERA_SIZE
+        });
+        this.directionalLight.configureShadow({
+            mapSize: 2048, bias: 0, normalBias: 0.02, far: 2000
+        });
+        this.dirLightActor.rootComponent.add(this.directionalLight);
+        this.world.addActors(this.dirLightActor);
+        // Point light with red color
+        const pointLightActor = new ENGINE.Actor();
+        this.pointLight = new ENGINE.PointLightComponent({
+            color: 0xff4444,
+            intensity: 5.0,
+            distance: 200,
+            decay: 0.01
+        });
+        this.pointLight.showHelper(SHOW_LIGHT_HELPER);
+        this.pointLight.showCameraHelper(SHOW_CAMERA_HELPER);
+        this.pointLight.castShadow = true;
+        // Configure shadows for point light
+        this.pointLight.configureShadow({
+            mapSize: 1024,
+            bias: -0.0008,
+            normalBias: 0.02,
+            near: 1,
+            far: 80
+        });
+        pointLightActor.rootComponent.position.set(-15, 25, -15);
+        pointLightActor.rootComponent.add(this.pointLight);
+        this.world.addActors(pointLightActor);
+        // Disable point light by default
+        this.pointLight.visible = false;
+        // Spot light with blue color
+        const spotLightActor = new ENGINE.Actor();
+        this.spotLight = new ENGINE.SpotLightComponent({
+            color: 0x4444ff,
+            intensity: 50.0, // Increased intensity significantly
+            distance: 150,
+            angle: Math.PI / 3, // Even wider angle
+            penumbra: 0.1,
+            decay: 0.01
+        });
+        this.spotLight.showHelper(SHOW_LIGHT_HELPER);
+        this.spotLight.showCameraHelper(SHOW_CAMERA_HELPER);
+        this.spotLight.castShadow = true;
+        // Configure shadows for spot light
+        this.spotLight.configureShadow({
+            mapSize: 1024,
+            bias: -0.0008,
+            normalBias: 0.02,
+            near: 1,
+            far: 150
+        });
+        spotLightActor.rootComponent.position.set(10, 40, 10);
+        spotLightActor.rootComponent.add(this.spotLight);
+        this.world.addActors(spotLightActor);
+        // Set target after adding to world - point down to the ground
+        this.spotLight.setTarget(new THREE.Vector3(15, 0, 15));
+        // Disable spot light by default
+        this.spotLight.visible = false;
+    }
+    createShadowEnvironment() {
+        // Ground plane with shadow receiving
+        const groundActor = new ENGINE.Actor();
+        const groundMesh = new ENGINE.MeshComponent({
+            geometry: new THREE.PlaneGeometry(GROUND_SIZE, GROUND_SIZE),
+            material: new THREE.MeshStandardMaterial({
+                color: 0x666666,
+                transparent: true,
+                opacity: 0.9,
+                roughness: 0.5,
+                metalness: 0.0
+            })
+        });
+        groundMesh.rotation.x = -Math.PI / 2;
+        groundMesh.receiveShadow = true;
+        groundActor.rootComponent.add(groundMesh);
+        this.world.addActors(groundActor);
+        // Create grid of sticks
+        this.createStickGrid();
+        // Add GLB model at center
+        this.createCenterModel();
+    }
+    async createCenterModel() {
+        const modelActor = new ENGINE.Actor();
+        const modelComponent = new ENGINE.GLTFMeshComponent({
+            modelUrl: '@engine/assets/character/mannequinG.glb',
+            scale: new THREE.Vector3(1, 1, 1)
+        });
+        modelComponent.castShadow = true;
+        modelComponent.receiveShadow = true;
+        modelActor.rootComponent.position.set(0, 0, 0);
+        modelActor.rootComponent.add(modelComponent);
+        this.world.addActors(modelActor);
+    }
+    createStickGrid() {
+        // Create a large grid of vertical sticks
+        // Calculate grid bounds
+        const halfGrid = (GRID_SIZE - 1) * SPACING / 2;
+        for (let x = 0; x < GRID_SIZE; x++) {
+            for (let z = 0; z < GRID_SIZE; z++) {
+                const stickActor = new ENGINE.Actor();
+                const stickMesh = new ENGINE.MeshComponent({
+                    geometry: new THREE.CylinderGeometry(STICK_RADIUS, STICK_RADIUS, STICK_HEIGHT, 8),
+                    material: new THREE.MeshStandardMaterial({
+                        color: 0x8B4513, // Brown color for wooden sticks
+                        roughness: 0.5,
+                        metalness: 0.0
+                    })
+                });
+                // Position stick in grid
+                const xPos = (x * SPACING) - halfGrid;
+                const zPos = (z * SPACING) - halfGrid;
+                stickMesh.position.set(xPos, STICK_HEIGHT / 2, zPos);
+                // Enable shadows
+                stickMesh.castShadow = true;
+                stickMesh.receiveShadow = true;
+                stickActor.rootComponent.add(stickMesh);
+                this.world.addActors(stickActor);
+            }
+        }
+    }
+    setupGUI() {
+        // Lighting controls
+        const lightingFolder = this.gui.addFolder('Lighting');
+        lightingFolder.open();
+        // Directional light controls
+        const dirFolder = lightingFolder.addFolder('Directional Light');
+        const dirControls = {
+            enabled: this.directionalLight.visible,
+            intensity: this.directionalLight.getIntensity(),
+            color: `#${this.directionalLight.getColor().getHexString()}`,
+            castShadows: this.directionalLight.castShadow
+        };
+        dirFolder.add(dirControls, 'enabled').onChange((value) => {
+            this.directionalLight.visible = value;
+        });
+        dirFolder.add(dirControls, 'intensity', 0, 3).onChange((value) => {
+            this.directionalLight.setIntensity(value);
+        });
+        dirFolder.addColor(dirControls, 'color').onChange((value) => {
+            this.directionalLight.setColor(value);
+        });
+        dirFolder.add(dirControls, 'castShadows').onChange((value) => {
+            this.directionalLight.castShadow = value;
+        });
+        // Shadow quality controls under directional light
+        const shadowFolder = dirFolder.addFolder('Shadow Quality');
+        const shadowControls = {
+            shadowMapSize: this.directionalLight.getLight().shadow.mapSize.width.toString(),
+            shadowType: 'PCF Soft', // This is a renderer setting, keep as default
+            shadowBias: this.directionalLight.getLight().shadow.bias,
+            cameraSize: Math.abs(this.directionalLight.getLight().shadow.camera.right),
+            cameraFar: this.directionalLight.getLight().shadow.camera.far
+        };
+        const shadowSizes = ['256', '512', '1024', '2048', '4096'];
+        const shadowTypes = ['Basic', 'PCF', 'PCF Soft', 'VSM'];
+        shadowFolder.add(shadowControls, 'shadowMapSize', shadowSizes).onChange((value) => {
+            this.directionalLight.configureShadow({ mapSize: parseInt(value) });
+        });
+        shadowFolder.add(shadowControls, 'shadowType', shadowTypes).onChange((value) => {
+            if (value === 'Basic') {
+                this.renderer.renderer.shadowMap.type = THREE.BasicShadowMap;
+            }
+            else if (value === 'PCF') {
+                this.renderer.renderer.shadowMap.type = THREE.PCFShadowMap;
+            }
+            else if (value === 'PCF Soft') {
+                this.renderer.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+            }
+            else if (value === 'VSM') {
+                this.renderer.renderer.shadowMap.type = THREE.VSMShadowMap;
+            }
+        });
+        shadowFolder.add(shadowControls, 'shadowBias', -0.01, 0.01, 0.0001).onChange((value) => {
+            // Update shadow bias for directional light
+            this.directionalLight.configureShadow({ bias: value });
+        });
+        shadowFolder.add(shadowControls, 'cameraSize', 10, 200).onChange((value) => {
+            // Update shadow camera size for directional light
+            this.directionalLight.configureShadowCamera({
+                left: -value, right: value, top: value, bottom: -value
+            });
+        });
+        shadowFolder.add(shadowControls, 'cameraFar', 50, 2000).onChange((value) => {
+            // Update shadow camera far distance
+            this.directionalLight.configureShadow({ far: value });
+        });
+        // Point light controls
+        const pointFolder = lightingFolder.addFolder('Point Light (Red)');
+        const pointControls = {
+            enabled: this.pointLight.visible,
+            intensity: this.pointLight.getIntensity(),
+            color: `#${this.pointLight.getColor().getHexString()}`,
+            distance: this.pointLight.getDistance(),
+            castShadows: this.pointLight.castShadow
+        };
+        pointFolder.add(pointControls, 'enabled').onChange((value) => {
+            this.pointLight.visible = value;
+        });
+        pointFolder.add(pointControls, 'intensity', 0, 3).onChange((value) => {
+            this.pointLight.setIntensity(value);
+        });
+        pointFolder.addColor(pointControls, 'color').onChange((value) => {
+            this.pointLight.setColor(value);
+        });
+        pointFolder.add(pointControls, 'distance', 10, 150).onChange((value) => {
+            this.pointLight.setDistance(value);
+        });
+        pointFolder.add(pointControls, 'castShadows').onChange((value) => {
+            this.pointLight.castShadow = value;
+        });
+        // Spot light controls
+        const spotFolder = lightingFolder.addFolder('Spot Light (Blue)');
+        const spotControls = {
+            enabled: this.spotLight.visible,
+            intensity: this.spotLight.getIntensity(),
+            color: `#${this.spotLight.getColor().getHexString()}`,
+            distance: this.spotLight.getDistance(),
+            angle: (this.spotLight.getAngle() * 180) / Math.PI, // Convert to degrees for UI
+            penumbra: this.spotLight.getPenumbra(),
+            castShadows: this.spotLight.castShadow
+        };
+        spotFolder.add(spotControls, 'enabled').onChange((value) => {
+            this.spotLight.visible = value;
+        });
+        spotFolder.add(spotControls, 'intensity', 0, 4).onChange((value) => {
+            this.spotLight.setIntensity(value);
+        });
+        spotFolder.addColor(spotControls, 'color').onChange((value) => {
+            this.spotLight.setColor(value);
+        });
+        spotFolder.add(spotControls, 'distance', 20, 200).onChange((value) => {
+            this.spotLight.setDistance(value);
+        });
+        spotFolder.add(spotControls, 'angle', 5, 90).onChange((value) => {
+            this.spotLight.setAngle((value * Math.PI) / 180); // Convert to radians
+        });
+        spotFolder.add(spotControls, 'penumbra', 0, 1).onChange((value) => {
+            this.spotLight.setPenumbra(value);
+        });
+        spotFolder.add(spotControls, 'castShadows').onChange((value) => {
+            this.spotLight.castShadow = value;
+        });
+    }
+    destroy() {
+        if (this.gui) {
+            this.container.removeChild(this.gui.domElement);
+            this.gui.destroy();
+        }
+        super.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shadow-demo.js","sourceRoot":"","sources":["../../../games/deprecated/shadow-demo.ts"],"names":[],"mappings":"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"}

package/dist/games/deprecated/shooting-demo.d.ts

@@ -0,0 +1,19 @@
+import * as ENGINE from 'genesys.js';
+export declare class ShootingDemo extends ENGINE.BaseGameLoop {
+    private uiContainer;
+    private statsContainer;
+    private pawn;
+    private controller;
+    constructor(container: HTMLElement);
+    protected preStart(): Promise<void>;
+    private createUI;
+    private updateStats;
+    protected tick(tickTime: ENGINE.TickTime): void;
+    destroy(): void;
+    private createPlayer;
+    private getStatsComponent;
+    private createEnvironment;
+    private createEnemies;
+    private createBehaviorTreeJSON;
+    private createNpc;
+}