hytopia 0.1.71 → 0.1.72

package/examples/hole-in-wall-game/index.ts

@@ -0,0 +1,506 @@
+import {
+  Audio,
+  BlockType,
+  Collider,
+  ColliderShape,
+  Entity,
+  GameServer,
+  RigidBodyType,
+  startServer,
+  Player,
+  PlayerEntity,
+  SceneUI,
+  World,
+} from 'hytopia';
+
+import worldMap from './assets/map.json';
+
+enum GameWallDirection {
+  NORTH = 'NORTH',
+  SOUTH = 'SOUTH',
+  WEST = 'WEST',
+  EAST = 'EAST',
+}
+
+const GAME_LEVEL_DURATION_SECONDS = 10;
+const GAME_START_POSITION = { x: 1, y: 25, z: 1 };
+const GAME_START_DELAY_SECONDS = 3;
+const GAME_WALL_DESPAWN_DISTANCE = 18;
+const GAME_WALL_SPAWN_POSITIONS = {
+  [GameWallDirection.NORTH]: { x: 1, y: 20, z: -10 }, // North (x width)
+  [GameWallDirection.SOUTH]: { x: 1, y: 20, z: 12 }, // South (x width)
+  [GameWallDirection.WEST]: { x: -10, y: 20, z: 1 }, // West (z width)
+  [GameWallDirection.EAST]: { x: 12, y: 20, z: 1 }, // East (z width)
+}
+const GAME_WALL_VELOCITY_DIRECTIONS = {
+  [GameWallDirection.NORTH]: { x: 0, y: 0, z: 1 },
+  [GameWallDirection.SOUTH]: { x: 0, y: 0, z: -1 },
+  [GameWallDirection.WEST]: { x: 1, y: 0, z: 0 },
+  [GameWallDirection.EAST]: { x: -1, y: 0, z: 0 },
+}
+const GAME_WALL_SHAPES = [
+  // lol shape
+  [
+    [0, 1, 0, 1, 1, 1, 0, 1],
+    [0, 1, 0, 1, 0, 1, 0, 1],
+    [0, 1, 0, 1, 1, 1, 0, 1],
+  ],
+  // stairs
+  [
+    [0, 0, 0, 0, 0, 0, 0, 1],
+    [0, 0, 0, 0, 0, 1, 1, 1],
+    [0, 0, 0, 1, 1, 1, 1, 1],
+    [0, 1, 1, 1, 1, 1, 1, 1],
+    [1, 1, 1, 1, 1, 1, 1, 1],
+  ],
+  // horizontal bar
+  [
+    [1, 1, 1, 1, 1, 1, 1, 1],
+    [1, 1, 1, 1, 1, 1, 1, 1],
+  ],
+  // vertical bars
+  [
+    [1, 0, 1, 0, 1, 0, 1, 0],
+    [1, 0, 1, 0, 1, 0, 1, 0],
+    [1, 0, 1, 0, 1, 0, 1, 0],
+    [1, 0, 1, 0, 1, 0, 1, 0],
+  ],
+  // lattice
+  [
+    [1, 0, 1, 0, 1, 0, 1, 0],
+    [0, 1, 0, 1, 0, 1, 0, 1],
+    [1, 0, 1, 0, 1, 0, 1, 0],
+    [0, 1, 0, 1, 0, 1, 0, 1],
+    [1, 0, 1, 0, 1, 0, 1, 0],
+    [0, 0, 0, 1, 0, 1, 0, 0],
+    [1, 0, 1, 0, 1, 0, 1, 0],
+  ],
+  // platforming hole
+  [
+    [1, 1, 1, 0, 0, 1, 1, 1],
+    [1, 1, 1, 0, 0, 1, 1, 1],
+    [1, 1, 1, 2, 2, 1, 1, 1],
+    [1, 1, 2, 1, 1, 2, 1, 1],
+    [1, 2, 1, 1, 1, 1, 2, 1],
+    [2, 1, 1, 1, 1, 1, 1, 2],
+  ],
+  // 3d stairs
+  [
+    [1, 1, 1, 1, 1, 1, 1, 1],
+    [2, 1, 2, 1, 1, 2, 1, 2],
+    [2, 3, 2, 3, 3, 2, 3, 2],
+    [3, 3, 3, 3, 3, 3, 3, 3],
+  ],
+  // 3d lattice
+  [
+    [0, 2, 0, 2, 0, 2, 0, 2],
+    [1, 0, 1, 0, 1, 0, 1, 0],
+    [0, 2, 0, 2, 0, 2, 0, 2], 
+    [1, 0, 2, 0, 2, 0, 1, 0],
+    [1, 0, 1, 0, 1, 0, 1, 0],
+    [0, 2, 0, 2, 0, 2, 0, 2],
+    [1, 0, 3, 0, 3, 0, 1, 0],
+  ],
+  // full wall
+  [
+    [1, 1, 1, 1, 1, 1, 1, 1],
+    [1, 1, 1, 1, 1, 1, 1, 1],
+    [1, 1, 1, 1, 1, 1, 1, 1],
+    [1, 1, 1, 1, 1, 1, 1, 1],
+  ],
+  // zig zag challenge
+  [
+    [1, 1, 1, 0, 0, 0, 0, 0],
+    [0, 0, 1, 1, 1, 0, 0, 0],
+    [0, 0, 0, 0, 1, 1, 1, 0],
+    [0, 0, 0, 0, 0, 0, 1, 1],
+  ],
+  // triple jump
+  [
+    [0, 0, 1, 0, 0, 1, 0, 0],
+    [0, 0, 1, 0, 0, 1, 0, 0],
+    [1, 1, 1, 0, 0, 1, 1, 1],
+  ],
+  // layered tunnel
+  [
+    [1, 1, 1, 1, 1, 1, 1, 1],
+    [1, 0, 0, 2, 2, 0, 0, 1],
+    [1, 0, 0, 3, 3, 0, 0, 1],
+    [1, 1, 1, 1, 1, 1, 1, 1],
+  ],
+  // diagonal dash
+  [
+    [1, 1, 0, 0, 0, 0, 0, 0],
+    [0, 1, 1, 0, 0, 0, 0, 0],
+    [0, 0, 1, 1, 0, 0, 0, 0],
+    [0, 0, 0, 1, 1, 0, 0, 0],
+    [0, 0, 0, 0, 1, 1, 0, 0],
+  ],
+  // wave rider
+  [
+    [1, 0, 0, 0, 0, 0, 0, 1],
+    [1, 1, 0, 0, 0, 0, 1, 1],
+    [0, 1, 1, 0, 0, 1, 1, 0],
+    [0, 0, 1, 1, 1, 1, 0, 0],
+  ],
+  // forward momentum
+  [
+    [1, 1, 2, 2, 3, 3, 3, 3],
+    [1, 1, 2, 2, 3, 3, 3, 3],
+    [1, 1, 2, 2, 3, 3, 3, 3],
+  ],
+  // spiral staircase
+  [
+    [1, 1, 1, 1, 2, 2, 3, 3],
+    [3, 3, 1, 1, 1, 2, 2, 2],
+    [2, 3, 3, 1, 1, 1, 1, 2],
+    [2, 2, 2, 3, 3, 1, 1, 1],
+  ],
+  // hopscotch
+  [
+    [0, 1, 0, 1, 0, 1, 0, 1],
+    [0, 2, 0, 2, 0, 2, 0, 2],
+    [1, 0, 1, 0, 1, 0, 1, 0],
+    [2, 0, 2, 0, 2, 0, 2, 0],
+  ],
+  // snake path
+  [
+    [1, 1, 1, 1, 0, 0, 0, 0],
+    [0, 0, 0, 1, 0, 0, 0, 0],
+    [0, 0, 0, 2, 0, 0, 0, 0],
+    [0, 0, 0, 3, 3, 3, 3, 3],
+  ],
+  // diamond gate
+  [
+    [1, 1, 1, 0, 0, 1, 1, 1],
+    [1, 1, 0, 0, 0, 0, 1, 1],
+    [1, 0, 2, 0, 0, 2, 0, 1],
+    [0, 0, 0, 3, 3, 0, 0, 0],
+    [1, 0, 2, 0, 0, 2, 0, 1],
+    [1, 1, 0, 0, 0, 0, 1, 1],
+    [1, 1, 1, 0, 0, 1, 1, 1],
+  ],
+];
+
+const JOIN_NPC_SPAWN_POSITION = { x: 1, y: 35, z: -7 };
+const PLAYER_SPAWN_POSITION = { x: 1, y: 35, z: 2 };
+const QUEUED_PLAYER_ENTITIES = new Set<PlayerEntity>();
+const GAME_PLAYER_ENTITIES = new Set<PlayerEntity>();
+
+let gameLevel = 1;
+let gameState: 'awaitingPlayers' | 'starting' | 'inProgress' = 'awaitingPlayers';
+let gameCountdownStartTime: number | null = null;
+let gameInterval: NodeJS.Timer;
+let gameStartTime: number | null = null;
+let gameUiState: object = {};
+
+let gameActiveAudio = new Audio({
+  uri: 'audio/music.mp3',
+  loop: true,
+  volume: 0.2,
+});
+
+let gameInactiveAudio = new Audio({
+  uri: 'audio/music/overworld.mp3',
+  loop: true,
+  volume: 0.2,
+});
+
+startServer(world => {
+  world.loadMap(worldMap);
+  world.onPlayerJoin = player => onPlayerJoin(world, player);
+  world.onPlayerLeave = player => onPlayerLeave(world, player);
+
+  spawnJoinNpc(world);
+
+  gameInactiveAudio.play(world);
+});
+
+function onPlayerJoin(world: World, player: Player) {
+  player.ui.load('ui/index.html');
+  player.ui.sendData(gameUiState);
+
+  const playerEntity = new PlayerEntity({
+    player,
+    name: 'Player',
+    modelUri: 'models/player.gltf',
+    modelLoopedAnimations: [ 'idle' ],
+    modelScale: 0.5,
+  });
+
+  playerEntity.spawn(world, PLAYER_SPAWN_POSITION);
+  
+  playerEntity.onTick = () => {
+    if (playerEntity.position.y < 5) {
+      killPlayer(playerEntity);
+    }
+  }
+
+}
+
+function onPlayerLeave(world: World, player: Player) {
+  world.entityManager.getAllPlayerEntities(player).forEach(entity => {
+    // remove from game state
+    removePlayerFromQueue(entity);
+    killPlayer(entity);
+
+    // despawn player entity
+    entity.despawn();
+  });
+}
+
+function spawnJoinNpc(world: World) {
+  const joinNpc = new Entity({
+    name: 'Join NPC',
+    modelUri: 'models/mindflayer.gltf',
+    modelLoopedAnimations: [ 'idle' ],
+    modelScale: 0.4,
+    rigidBodyOptions: {
+      rotation: { x: 0, y: 1, z: 0, w: 0 },
+      enabledPositions: { x: false, y: true, z: false },
+      enabledRotations: { x: false, y: true, z: false },
+      colliders: [
+        Collider.optionsFromModelUri('models/mindflayer.gltf', 0.4),
+        {
+          shape: ColliderShape.CYLINDER,
+          radius: 2,
+          halfHeight: 2,
+          isSensor: true,
+          onCollision: (other: BlockType | Entity, started: boolean) => {
+            if (other instanceof PlayerEntity && started) {
+              addPlayerEntityToQueue(world, other);
+            }
+          }
+        }
+      ],
+    },
+  }); 
+
+  joinNpc.spawn(world, JOIN_NPC_SPAWN_POSITION);
+
+  const sceneUi = new SceneUI({
+    templateId: 'join-npc-ui',
+    attachedToEntity: joinNpc,
+    offset: { x: 0, y: 2.5, z: 0 },
+  });
+
+  sceneUi.load(world);
+}
+
+function addPlayerEntityToQueue(world: World, playerEntity: PlayerEntity) {
+  if (QUEUED_PLAYER_ENTITIES.has(playerEntity)) return;
+  QUEUED_PLAYER_ENTITIES.add(playerEntity);
+  world.chatManager.sendPlayerMessage(playerEntity.player, 'You have joined the next game queue!', '00FF00');
+  uiUpdate({ queueCount: QUEUED_PLAYER_ENTITIES.size });
+
+  if (gameState === 'awaitingPlayers' && QUEUED_PLAYER_ENTITIES.size > 1) {
+    queueGame(world);
+  }
+
+  const queuedSceneUi = new SceneUI({
+    templateId: 'player-queued',
+    attachedToEntity: playerEntity,
+    offset: { x: 0, y: 1, z: 0 },
+  });
+
+  queuedSceneUi.load(world);
+}
+
+function queueGame(world: World) {
+  gameState = 'starting';
+  gameCountdownStartTime = Date.now();
+
+  uiUpdate({
+    gameState,
+    gameCountdownStartTime,
+    countdown: GAME_START_DELAY_SECONDS,
+  });
+
+  setTimeout(() => {
+    QUEUED_PLAYER_ENTITIES.forEach(playerEntity => {
+      playerEntity.setPosition(GAME_START_POSITION);
+      GAME_PLAYER_ENTITIES.add(playerEntity);
+
+      world.sceneUIManager.getAllEntityAttachedSceneUIs(playerEntity).forEach(sceneUi => {
+        sceneUi.unload(); // unload the queued ui
+      });
+    });
+
+    QUEUED_PLAYER_ENTITIES.clear();
+    uiUpdate({ queueCount: 0 });
+    startGame(world);
+  }, GAME_START_DELAY_SECONDS * 1000);
+}
+
+function startGame(world: World) {
+  gameState = 'inProgress';
+  gameStartTime = Date.now();
+
+  gameInactiveAudio.pause();
+  gameActiveAudio.play(world, true);
+
+  const gameLoop = () => {
+    if (!gameStartTime) return clearTimeout(gameInterval);
+
+    const elapsedTime = Date.now() - gameStartTime;
+    const level = Math.floor(elapsedTime / (GAME_LEVEL_DURATION_SECONDS * 1000)) + 1;
+
+    // Calculate difficulty parameters based on level
+    const speedModifier = 1 + (level * 0.15); // 15% faster per level
+    const spawnInterval = Math.max(2000, 10000 - (level * 1000)); // Decrease from 10s by 1s per level, min 2s
+    
+    // Generate wall from random direction
+    const directions = Object.values(GameWallDirection);
+    const randomDirection = directions[Math.floor(Math.random() * directions.length)];
+
+    generateWall(world, randomDirection, speedModifier);
+
+    // Dynamically adjust interval
+    clearTimeout(gameInterval);
+    gameInterval = setTimeout(gameLoop, spawnInterval);
+
+    // Update level
+    if (level > gameLevel) {
+      gameLevel = level;
+      uiUpdate({ gameLevel });
+    }
+  }
+
+  gameLoop(); // invoke to start
+
+  // Update UI
+  uiUpdate({
+    gameState: 'inProgress',
+    gameStartTime,
+    playersRemaining: Array.from(GAME_PLAYER_ENTITIES).map(playerEntity => playerEntity.player.username),
+  });
+}
+
+function endGame() {
+  clearTimeout(gameInterval);
+  gameState = 'awaitingPlayers';
+  gameLevel = 1;
+
+  const winner = Array.from(GAME_PLAYER_ENTITIES)[0];
+  if (winner) {
+    winner.setPosition(PLAYER_SPAWN_POSITION);
+    winner.world!.chatManager.sendBroadcastMessage(`${winner.player.username} wins!`, '00FF00');
+  }
+
+  GAME_PLAYER_ENTITIES.clear();
+
+  gameActiveAudio.pause();
+  gameInactiveAudio.play(gameInactiveAudio.world!, true);
+  
+  uiUpdate({ gameState: 'awaitingPlayers', gameLevel: 1 });
+}
+
+function killPlayer(playerEntity: PlayerEntity) {
+  if (!GAME_PLAYER_ENTITIES.has(playerEntity)) return;
+
+  // return to spawn position
+  playerEntity.setPosition(PLAYER_SPAWN_POSITION);
+
+  // remove from game player list
+  GAME_PLAYER_ENTITIES.delete(playerEntity);
+
+  if (GAME_PLAYER_ENTITIES.size < 1) {
+    endGame();
+  }
+
+  // update remaining players for the ui
+  uiUpdate({
+    playersRemaining: Array.from(GAME_PLAYER_ENTITIES).map(playerEntity => playerEntity.player.username),
+  });
+}
+
+function removePlayerFromQueue(playerEntity: PlayerEntity) {
+  if (!QUEUED_PLAYER_ENTITIES.has(playerEntity)) return;
+
+  // remove from queue
+  QUEUED_PLAYER_ENTITIES.delete(playerEntity);
+
+  // update ui
+  uiUpdate({ queueCount: QUEUED_PLAYER_ENTITIES.size });
+}
+
+function generateWall(world: World, direction: GameWallDirection, speedModifier: number = 1) {
+  const selectedShape = GAME_WALL_SHAPES[Math.floor(Math.random() * GAME_WALL_SHAPES.length)];
+  const isNorthSouth = direction === GameWallDirection.NORTH || direction === GameWallDirection.SOUTH;
+
+  // Iterate through the shape array to create wall segments
+  for (let y = 0; y < selectedShape.length; y++) {
+    for (let x = 0; x < selectedShape[y].length; x++) {
+      if (selectedShape[y][x] === 1 || selectedShape[y][x] === 2 || selectedShape[y][x] === 3) {
+        // Calculate position offset from center
+        const xOffset = (x - selectedShape[y].length / 2) * 1 + 0.5; // 1 block width
+        const yOffset = (selectedShape.length - y - 1) * 1 + 0.5; // 1 block height
+
+        const wallSegment = new Entity({
+          blockTextureUri: selectedShape[y][x] === 2 ? 'textures/dirt.png' : 
+                          selectedShape[y][x] === 3 ? 'textures/sand.png' : 
+                          'textures/oak_leaves.png',
+          blockHalfExtents: {
+            x: isNorthSouth ? 0.5 : 0.5,
+            y: 0.5,
+            z: isNorthSouth ? 0.5 : 0.5
+          },
+          rigidBodyOptions: {
+            type: RigidBodyType.KINEMATIC_VELOCITY,
+          }
+        });
+
+        const spawnPosition = { ...GAME_WALL_SPAWN_POSITIONS[direction] };
+        
+        // Adjust position based on direction
+        if (isNorthSouth) {
+          spawnPosition.x += xOffset;
+          spawnPosition.y += yOffset;
+          if (selectedShape[y][x] === 2) {
+            spawnPosition.z += direction === GameWallDirection.NORTH ? 1 : -1;
+          } else if (selectedShape[y][x] === 3) {
+            spawnPosition.z += direction === GameWallDirection.NORTH ? 2 : -2;
+          }
+        } else {
+          spawnPosition.z += xOffset;
+          spawnPosition.y += yOffset;
+          if (selectedShape[y][x] === 2) {
+            spawnPosition.x += direction === GameWallDirection.WEST ? 1 : -1;
+          } else if (selectedShape[y][x] === 3) {
+            spawnPosition.x += direction === GameWallDirection.WEST ? 2 : -2;
+          }
+        }
+
+        wallSegment.spawn(world, spawnPosition);
+        
+        // Set velocity based on direction
+        wallSegment.setLinearVelocity({
+          x: GAME_WALL_VELOCITY_DIRECTIONS[direction].x * speedModifier,
+          y: GAME_WALL_VELOCITY_DIRECTIONS[direction].y * speedModifier,
+          z: GAME_WALL_VELOCITY_DIRECTIONS[direction].z * speedModifier,
+        });
+
+        wallSegment.onTick = () => {
+          if (!wallSegment.isSpawned) return;
+          const position = wallSegment.position;
+
+          if (Math.abs(position.x - spawnPosition.x) > GAME_WALL_DESPAWN_DISTANCE || Math.abs(position.z - spawnPosition.z) > GAME_WALL_DESPAWN_DISTANCE) {
+            wallSegment.setLinearVelocity({ x: 0, y: -32, z: 0 }); // drop it out of the world to trigger decollision
+            
+            setTimeout(() => {
+              wallSegment.despawn();
+            }, 1000);
+          }
+        }
+      }
+    }
+  }
+}
+
+function uiUpdate(data: object) {
+  gameUiState = { ...gameUiState, ...data };
+
+  GameServer.instance.playerManager.getConnectedPlayers().forEach(player => {
+    player.ui.sendData(data);
+  });
+}

package/examples/hole-in-wall-game/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "hole-in-wall-game",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@hytopia.com/assets": "^0.1.6",
+    "hytopia": "latest"
+  }
+}

package/examples/wall-dodge-game/README.md

@@ -0,0 +1,6 @@
+# wall-dodge-game
+
+A game where players compete to survive the longest while dodging walls.
+
+Includes a number of features such as leaderboards, countdown systems,
+and more.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hytopia",
-  "version": "0.1.71",
+  "version": "0.1.72",
   "description": "The HYTOPIA SDK makes it easy for developers to create massively multiplayer games using JavaScript or TypeScript.",
   "main": "server.js",
   "bin": {

package/server.api.json

@@ -25438,6 +25438,55 @@
               "isAbstract": false,
               "name": "setCcdEnabled"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "server!RigidBody#setCollisionGroupsForSensorColliders:member(1)",
+              "docComment": "/**\n * Sets the collision groups for sensor colliders of the rigid body.\n *\n * @param collisionGroups - The collision groups for sensor colliders of the rigid body.\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "setCollisionGroupsForSensorColliders(collisionGroups: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "CollisionGroups",
+                  "canonicalReference": "server!CollisionGroups:type"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "void"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "releaseTag": "Public",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "collisionGroups",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                }
+              ],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "setCollisionGroupsForSensorColliders"
+            },
             {
               "kind": "Method",
               "canonicalReference": "server!RigidBody#setCollisionGroupsForSolidColliders:member(1)",

package/server.d.ts

@@ -3136,6 +3136,11 @@ export declare class RigidBody {
      * @param collisionGroups - The collision groups for solid colliders of the rigid body.
      */
     setCollisionGroupsForSolidColliders(collisionGroups: CollisionGroups): void;
+    /**
+     * Sets the collision groups for sensor colliders of the rigid body.
+     * @param collisionGroups - The collision groups for sensor colliders of the rigid body.
+     */
+    setCollisionGroupsForSensorColliders(collisionGroups: CollisionGroups): void;
     /**
      * Sets the type of the rigid body.
      * @param type - The type of the rigid body.