@directivegames/genesys.js 3.1.24

package/dist/games/examples/plugin-demo/plugins/simple-cube.js

@@ -0,0 +1,44 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+class SimpleCube extends ENGINE.Actor {
+    constructor(options) {
+        super({
+            ...options,
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(1, 1, 1),
+                material: new THREE.MeshStandardMaterial({ color: 'yellow' }),
+            }),
+        });
+        this.rootComponent.castShadow = true;
+    }
+}
+export default class SimpleCubePlugin {
+    constructor() {
+        // keep track of the actors created by the plugin
+        Object.defineProperty(this, "pluginActors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    async init(world, previousState) {
+        this.pluginActors.push(new SimpleCube({
+            position: new THREE.Vector3(0, 2, -3),
+        }));
+        world.addActors(...this.pluginActors);
+        return true;
+    }
+    async dispose() {
+        // destroy the actors created by the plugin
+        this.pluginActors.forEach((actor) => {
+            actor.destroy();
+        });
+        this.pluginActors = [];
+        return Promise.resolve();
+    }
+    saveState() {
+        return {};
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltcGxlLWN1YmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9nYW1lcy9leGFtcGxlcy9wbHVnaW4tZGVtby9wbHVnaW5zL3NpbXBsZS1jdWJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxNQUFNLE1BQU0sWUFBWSxDQUFDO0FBQ3JDLE9BQU8sS0FBSyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBRy9CLE1BQU0sVUFBVyxTQUFRLE1BQU0sQ0FBQyxLQUFLO0lBQ25DLFlBQVksT0FBNEI7UUFDdEMsS0FBSyxDQUFDO1lBQ0osR0FBRyxPQUFPO1lBQ1YsYUFBYSxFQUFFLElBQUksTUFBTSxDQUFDLGFBQWEsQ0FBQztnQkFDdEMsUUFBUSxFQUFFLElBQUksS0FBSyxDQUFDLFdBQVcsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQztnQkFDeEMsUUFBUSxFQUFFLElBQUksS0FBSyxDQUFDLG9CQUFvQixDQUFDLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxDQUFDO2FBQzlELENBQUM7U0FDSCxDQUFDLENBQUM7UUFDSCxJQUFJLENBQUMsYUFBYSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUM7SUFDdkMsQ0FBQztDQUNGO0FBRUQsTUFBTSxDQUFDLE9BQU8sT0FBTyxnQkFBZ0I7SUFBckM7UUFDRSxpREFBaUQ7UUFDekM7Ozs7bUJBQStCLEVBQUU7V0FBQztJQXdCNUMsQ0FBQztJQXRCUSxLQUFLLENBQUMsSUFBSSxDQUFDLEtBQW1CLEVBQUUsYUFBbUI7UUFDeEQsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQ3BCLElBQUksVUFBVSxDQUFDO1lBQ2IsUUFBUSxFQUFFLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO1NBQ3RDLENBQUMsQ0FDSCxDQUFDO1FBQ0YsS0FBSyxDQUFDLFNBQVMsQ0FBQyxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUN0QyxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFTSxLQUFLLENBQUMsT0FBTztRQUNsQiwyQ0FBMkM7UUFDM0MsSUFBSSxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRTtZQUNsQyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDbEIsQ0FBQyxDQUFDLENBQUM7UUFDSCxJQUFJLENBQUMsWUFBWSxHQUFHLEVBQUUsQ0FBQztRQUN2QixPQUFPLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRU0sU0FBUztRQUNkLE9BQU8sRUFBRSxDQUFDO0lBQ1osQ0FBQztDQUNGIn0=

package/dist/games/examples/plugin-demo/plugins/tic-tac-toe.d.ts

@@ -0,0 +1,8 @@
+import * as ENGINE from 'genesys.js';
+export default class TicTacToePlugin implements ENGINE.IPlugin {
+    private pluginActors;
+    private static readonly BOARD_POSITION;
+    init(world: ENGINE.World, previousState?: any): Promise<boolean>;
+    dispose(): Promise<void>;
+    saveState(): any;
+}

package/dist/games/examples/plugin-demo/plugins/tic-tac-toe.js

@@ -0,0 +1,526 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+var GamePiece;
+(function (GamePiece) {
+    GamePiece[GamePiece["Empty"] = 0] = "Empty";
+    GamePiece[GamePiece["X"] = 1] = "X";
+    GamePiece[GamePiece["O"] = 2] = "O";
+})(GamePiece || (GamePiece = {}));
+class RestartButton extends ENGINE.Actor {
+    constructor(options) {
+        super({
+            ...options,
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(1, 0.3, 0.3),
+                material: new THREE.MeshStandardMaterial({
+                    color: 'green',
+                    emissive: new THREE.Color(0.1, 0.3, 0.1)
+                }),
+                physicsOptions: {
+                    motionType: ENGINE.PhysicsMotionType.Static,
+                    generateCollisionEvents: true,
+                }
+            }),
+        });
+        Object.defineProperty(this, "vrInteractable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "onRestart", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.onRestart = options.onRestart;
+        this.rootComponent.castShadow = true;
+        this.rootComponent.receiveShadow = true;
+        // Add VR interaction support
+        this.vrInteractable = new ENGINE.VRInteractableComponent({
+            vrInteractionRange: 10,
+            vrInteractionButton: ENGINE.XRButton.Trigger,
+        });
+        this.addComponent(this.vrInteractable);
+    }
+    getVRInteractable() {
+        return this.vrInteractable;
+    }
+    restart() {
+        this.onRestart();
+    }
+}
+class GameTile extends ENGINE.Actor {
+    constructor(options) {
+        const geometry = new THREE.BoxGeometry(0.9, 0.1, 0.9);
+        const material = new THREE.MeshStandardMaterial({
+            color: new THREE.Color(0.8, 0.8, 0.9),
+            roughness: 0.3,
+            metalness: 0.1
+        });
+        super({
+            ...options,
+            rootComponent: new ENGINE.MeshComponent({
+                geometry,
+                material,
+                physicsOptions: {
+                    motionType: ENGINE.PhysicsMotionType.Static,
+                    generateCollisionEvents: true,
+                }
+            }),
+        });
+        Object.defineProperty(this, "tileIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "piece", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: GamePiece.Empty
+        });
+        Object.defineProperty(this, "pieceActor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "isHovered", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "originalMaterial", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "hoverMaterial", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vrInteractable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tileIndex = options.tileIndex;
+        this.originalMaterial = material;
+        this.hoverMaterial = new THREE.MeshStandardMaterial({
+            color: new THREE.Color(0.9, 0.9, 1.0),
+            roughness: 0.3,
+            metalness: 0.1
+        });
+        // Add VR interaction support
+        this.vrInteractable = new ENGINE.VRInteractableComponent({
+            vrInteractionRange: 10,
+            vrInteractionButton: ENGINE.XRButton.Trigger,
+        });
+        this.addComponent(this.vrInteractable);
+        this.rootComponent.castShadow = true;
+        this.rootComponent.receiveShadow = true;
+    }
+    getTileIndex() {
+        return this.tileIndex;
+    }
+    getVRInteractable() {
+        return this.vrInteractable;
+    }
+    getPiece() {
+        return this.piece;
+    }
+    canPlacePiece() {
+        return this.piece === GamePiece.Empty;
+    }
+    placePiece(piece) {
+        if (!this.canPlacePiece())
+            return false;
+        this.piece = piece;
+        this.createPieceActor(piece);
+        return true;
+    }
+    clearPiece() {
+        this.piece = GamePiece.Empty;
+        if (this.pieceActor) {
+            this.pieceActor.destroy();
+            this.pieceActor = null;
+        }
+    }
+    setHovered(hovered) {
+        if (this.isHovered === hovered)
+            return;
+        this.isHovered = hovered;
+        const meshComponent = this.rootComponent;
+        meshComponent.setMaterial(hovered ? this.hoverMaterial : this.originalMaterial);
+    }
+    createPieceActor(piece) {
+        const world = this.getWorld();
+        if (!world)
+            return;
+        // Position piece on the other side of the tile
+        const position = this.getWorldPosition().clone();
+        position.z += 0.15; // Move to the back side of the tile
+        if (piece === GamePiece.X) {
+            // Create X using two intersecting boxes
+            this.pieceActor = new ENGINE.Actor({
+                position,
+                rootComponent: new ENGINE.MeshComponent({
+                    geometry: new THREE.BoxGeometry(0.1, 0.1, 0.1), // Dummy geometry
+                    material: new THREE.MeshStandardMaterial({ color: 'red', transparent: true, opacity: 0 }),
+                }),
+            });
+            const bar1 = new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(0.6, 0.1, 0.1),
+                material: new THREE.MeshStandardMaterial({ color: 'red' }),
+                rotation: new THREE.Euler(0, 0, Math.PI / 4),
+            });
+            const bar2 = new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(0.6, 0.1, 0.1),
+                material: new THREE.MeshStandardMaterial({ color: 'red' }),
+                rotation: new THREE.Euler(0, 0, -Math.PI / 4),
+            });
+            this.pieceActor.rootComponent.add(bar1, bar2);
+        }
+        else if (piece === GamePiece.O) {
+            // Create O using a torus - no rotation so it appears as a circle on the vertical board
+            this.pieceActor = new ENGINE.Actor({
+                position,
+                rootComponent: new ENGINE.MeshComponent({
+                    geometry: new THREE.TorusGeometry(0.25, 0.05, 8, 16),
+                    material: new THREE.MeshStandardMaterial({ color: 'blue' }),
+                }),
+            });
+        }
+        if (this.pieceActor) {
+            this.pieceActor.rootComponent.castShadow = true;
+            world.addActors(this.pieceActor);
+        }
+    }
+    doEndPlay() {
+        if (this.pieceActor) {
+            this.pieceActor.destroy();
+            this.pieceActor = null;
+        }
+        super.doEndPlay();
+    }
+}
+class TicTacToeBoard extends ENGINE.Actor {
+    constructor(options) {
+        super({
+            ...options,
+            rootComponent: new ENGINE.MeshComponent({
+                geometry: new THREE.BoxGeometry(0.1, 0.1, 0.1),
+                material: new THREE.MeshStandardMaterial({
+                    transparent: true,
+                    opacity: 0
+                }),
+            })
+        });
+        Object.defineProperty(this, "tiles", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "currentPlayer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: GamePiece.X
+        });
+        Object.defineProperty(this, "gameWon", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "gameWinner", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: GamePiece.Empty
+        });
+        Object.defineProperty(this, "restartButton", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    doBeginPlay() {
+        super.doBeginPlay();
+        this.createBoard();
+        this.setupInputHandling();
+    }
+    createBoard() {
+        const world = this.getWorld();
+        if (!world)
+            return;
+        // Create 3x3 grid of tiles
+        for (let row = 0; row < 3; row++) {
+            for (let col = 0; col < 3; col++) {
+                const tileIndex = row * 3 + col;
+                const localPosition = new THREE.Vector3((col - 1) * 1.1, (row - 1) * 1.1, 0);
+                const tile = new GameTile({
+                    position: localPosition, // Local position relative to board
+                    rotation: new THREE.Euler(Math.PI / 2, 0, 0),
+                    tileIndex,
+                });
+                this.tiles.push(tile);
+                world.addActors(tile);
+                // Directly attach to this board's root component
+                this.rootComponent.add(tile.rootComponent);
+            }
+        }
+    }
+    setupInputHandling() {
+        const world = this.getWorld();
+        if (!world)
+            return;
+        const inputManager = world.inputManager;
+        // Set up VR interaction for each tile
+        this.tiles.forEach((tile) => {
+            const vrInteractable = tile.getVRInteractable();
+            vrInteractable.onInteract.add((hand) => {
+                if (!this.gameWon) {
+                    this.handleTileClick(tile);
+                }
+                return true;
+            });
+        });
+        // Set up restart button VR interaction (will be created when needed)
+        this.setupRestartButtonInteraction();
+        // Create an input handler for mouse/keyboard interaction
+        const gameInputHandler = {
+            handleKeyDown: () => false,
+            handleKeyUp: () => false,
+            handleMouseDown: (button, e) => {
+                if (button !== ENGINE.MouseButton.Left)
+                    return false;
+                this.handleMouseInteraction(e);
+                return false; // Allow other handlers to process
+            },
+            handleMouseUp: () => false,
+            handleMouseMove: (e) => {
+                if (this.gameWon)
+                    return false;
+                this.handleMouseHover(e);
+                return false; // Allow other handlers to process
+            },
+            handleMouseClick: () => false,
+            setInputManager: () => { },
+        };
+        inputManager.addInputHandler(gameInputHandler);
+    }
+    handleMouseInteraction(e) {
+        const world = this.getWorld();
+        if (!world)
+            return;
+        const raycaster = new THREE.Raycaster();
+        const camera = world.getActiveCamera();
+        if (!camera)
+            return;
+        // Convert mouse coordinates to normalized device coordinates
+        const rect = e.target.getBoundingClientRect();
+        const mouse = new THREE.Vector2(((e.clientX - rect.left) / rect.width) * 2 - 1, -((e.clientY - rect.top) / rect.height) * 2 + 1);
+        raycaster.setFromCamera(mouse, camera);
+        // Check for restart button first
+        if (this.restartButton) {
+            const buttonMesh = this.restartButton.rootComponent.getMesh();
+            const buttonIntersects = raycaster.intersectObject(buttonMesh);
+            if (buttonIntersects.length > 0) {
+                this.restartButton.restart();
+                return;
+            }
+        }
+        // Check for tile intersection
+        if (!this.gameWon) {
+            for (const tile of this.tiles) {
+                const meshComponent = tile.rootComponent;
+                const mesh = meshComponent.getMesh();
+                const intersects = raycaster.intersectObject(mesh);
+                if (intersects.length > 0) {
+                    this.handleTileClick(tile);
+                    break;
+                }
+            }
+        }
+    }
+    handleMouseHover(e) {
+        const world = this.getWorld();
+        if (!world)
+            return;
+        const raycaster = new THREE.Raycaster();
+        const camera = world.getActiveCamera();
+        if (!camera)
+            return;
+        const rect = e.target.getBoundingClientRect();
+        const mouse = new THREE.Vector2(((e.clientX - rect.left) / rect.width) * 2 - 1, -((e.clientY - rect.top) / rect.height) * 2 + 1);
+        raycaster.setFromCamera(mouse, camera);
+        // Reset all hover states
+        this.tiles.forEach(tile => tile.setHovered(false));
+        // Check for tile intersection
+        for (const tile of this.tiles) {
+            if (!tile.canPlacePiece())
+                continue;
+            const meshComponent = tile.rootComponent;
+            const mesh = meshComponent.getMesh();
+            const intersects = raycaster.intersectObject(mesh);
+            if (intersects.length > 0) {
+                tile.setHovered(true);
+                break;
+            }
+        }
+    }
+    handleTileClick(tile) {
+        if (!tile.canPlacePiece() || this.gameWon)
+            return;
+        // Place the piece
+        if (tile.placePiece(this.currentPlayer)) {
+            // Check for win
+            if (this.checkWin()) {
+                this.gameWon = true;
+                this.gameWinner = this.currentPlayer;
+                console.log(`Player ${this.currentPlayer === GamePiece.X ? 'X' : 'O'} wins!`);
+                this.showRestartButton();
+            }
+            else if (this.checkDraw()) {
+                this.gameWon = true;
+                console.log('It\'s a draw!');
+                this.showRestartButton();
+            }
+            else {
+                // Switch players
+                this.currentPlayer = this.currentPlayer === GamePiece.X ? GamePiece.O : GamePiece.X;
+            }
+        }
+    }
+    checkWin() {
+        const board = this.tiles.map(tile => tile.getPiece());
+        // Check rows
+        for (let row = 0; row < 3; row++) {
+            if (board[row * 3] !== GamePiece.Empty &&
+                board[row * 3] === board[row * 3 + 1] &&
+                board[row * 3] === board[row * 3 + 2]) {
+                return true;
+            }
+        }
+        // Check columns
+        for (let col = 0; col < 3; col++) {
+            if (board[col] !== GamePiece.Empty &&
+                board[col] === board[col + 3] &&
+                board[col] === board[col + 6]) {
+                return true;
+            }
+        }
+        // Check diagonals
+        if (board[0] !== GamePiece.Empty &&
+            board[0] === board[4] &&
+            board[0] === board[8]) {
+            return true;
+        }
+        if (board[2] !== GamePiece.Empty &&
+            board[2] === board[4] &&
+            board[2] === board[6]) {
+            return true;
+        }
+        return false;
+    }
+    checkDraw() {
+        return this.tiles.every(tile => !tile.canPlacePiece());
+    }
+    showRestartButton() {
+        if (this.restartButton)
+            return; // Already showing
+        const world = this.getWorld();
+        if (!world)
+            return;
+        // Position button above the board
+        const buttonPosition = this.getWorldPosition().clone();
+        buttonPosition.y += 2;
+        this.restartButton = new RestartButton({
+            position: buttonPosition,
+            onRestart: () => this.restartGame()
+        });
+        world.addActors(this.restartButton);
+        this.rootComponent.add(this.restartButton.rootComponent);
+        // Set up VR interaction for restart button
+        const vrInteractable = this.restartButton.getVRInteractable();
+        vrInteractable.onInteract.add((hand) => {
+            this.restartButton?.restart();
+            return true;
+        });
+    }
+    setupRestartButtonInteraction() {
+        // This will be called when the restart button is created
+    }
+    restartGame() {
+        // Reset game state
+        this.gameWon = false;
+        this.gameWinner = GamePiece.Empty;
+        this.currentPlayer = GamePiece.X;
+        // Clear all tiles
+        this.tiles.forEach(tile => {
+            tile.clearPiece();
+        });
+        // Hide restart button
+        if (this.restartButton) {
+            this.restartButton.destroy();
+            this.restartButton = null;
+        }
+        console.log('Game restarted!');
+    }
+    doEndPlay() {
+        this.tiles.forEach(tile => tile.destroy());
+        this.tiles = [];
+        if (this.restartButton) {
+            this.restartButton.destroy();
+            this.restartButton = null;
+        }
+        super.doEndPlay();
+    }
+}
+class TicTacToePlugin {
+    constructor() {
+        Object.defineProperty(this, "pluginActors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    async init(world, previousState) {
+        this.pluginActors.push(new TicTacToeBoard({
+            position: TicTacToePlugin.BOARD_POSITION,
+        }));
+        world.addActors(...this.pluginActors);
+        return true;
+    }
+    async dispose() {
+        this.pluginActors.forEach((actor) => {
+            actor.destroy();
+        });
+        this.pluginActors = [];
+        return Promise.resolve();
+    }
+    saveState() {
+        return {};
+    }
+}
+// Configuration for the board
+Object.defineProperty(TicTacToePlugin, "BOARD_POSITION", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new THREE.Vector3(0, 2, -3)
+});
+export default TicTacToePlugin;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tic-tac-toe.js","sourceRoot":"","sources":["../../../../../games/examples/plugin-demo/plugins/tic-tac-toe.ts"],"names":[],"mappings":"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"}

package/dist/games/examples/plugin-demo/plugins/wobbling-sphere.d.ts

@@ -0,0 +1,7 @@
+import * as ENGINE from 'genesys.js';
+export default class WobblingSpherePlugin implements ENGINE.IPlugin {
+    private pluginActors;
+    init(world: ENGINE.World, previousState?: any): Promise<boolean>;
+    dispose(): Promise<void>;
+    saveState(): any;
+}