hytopia 0.1.33 → 0.1.34

package/examples/block-entity/index.ts

@@ -0,0 +1,173 @@
+import {
+  startServer,
+  ColliderShape,
+  PlayerEntity,
+  Entity,
+  RigidBodyType,
+  GameServer,
+  SimpleCharacterController,
+} from 'hytopia';
+
+import worldMap from './assets/map.json';
+
+startServer(world => {
+  // Boilerplate
+  world.simulation.enableDebugRendering(true);
+  world.loadMap(worldMap);
+  world.onPlayerJoin = player => {
+    const playerEntity = new PlayerEntity({
+      player,
+      name: 'Player',
+      modelUri: 'models/player.gltf',
+      modelLoopedAnimations: [ 'idle' ],
+      modelScale: 0.5,
+    });
+  
+    playerEntity.spawn(world, { x: 0, y: 10, z: 0 });
+  };
+
+  world.onPlayerLeave = player => {
+    world.entityManager.getAllPlayerEntities(player).forEach(entity => entity.despawn());
+  };
+
+  /**
+   * Spawn a block entity as a moving platform
+   */
+  const blockPlatform = new Entity({
+    blockTextureUri: 'textures/grass', // A texture URI without a file extension will use a folder and look for the textures for each face in the folder (-x.png, +x.png, -y.png, +y.png, -z.png, +z.png)
+    blockHalfExtents: { x: 1, y: 0.5, z: 1 },
+    rigidBodyOptions: {
+      type: RigidBodyType.KINEMATIC_VELOCITY, // Kinematic means platform won't be effected by external physics, including gravity
+      linearVelocity: { x: 0, y: 0, z: 3 }, // A starting velocity that won't change because it's kinematic
+    },
+  });
+
+  // Clamp the z range the platform moves back and forth between
+  blockPlatform.onTick = blockPlatform => { 
+    const position = blockPlatform.getTranslation();
+
+    if (position.z < -9) {
+      blockPlatform.setLinearVelocity({ x: 0, y: 0, z: 3 });
+    }
+
+    if (position.z > 8) {
+      blockPlatform.setLinearVelocity({ x: 0, y: 0, z: -3 });
+    }
+  };
+
+  blockPlatform.spawn(world, { x: 3, y: 3, z: -7 });
+
+  /**
+   * Spawn a 2x2x2 block entity that spins in the air
+   */
+  const spinningBlock = new Entity({
+    blockTextureUri: 'textures/stone_bricks.png',
+    blockHalfExtents: { x: 1, y: 1, z: 1 }, // half extents at the target size / 2.
+    rigidBodyOptions: {
+      type: RigidBodyType.KINEMATIC_VELOCITY,
+      angularVelocity: { x: 1, y: 1, z: 1 },
+    }
+  });
+
+  spinningBlock.spawn(world, { x: 0, y: 10, z: -6 });
+
+  /**
+   * Spawn a block entity that interacts with physics and can be pushed by players
+   */
+  const movableBlock = new Entity({ // Entity is dynamic by default, meaning it will interact with external forces, including gravity
+    blockTextureUri: 'textures/sand.png',
+
+    // A block of 1x1x1 would be half extents of 0.5x0.5x0.5, 
+    // if you do not explicitly create rigidBodyOptions.colliders 
+    // for the block, a collider will be created automatically 
+    // based on the block half extends.
+    blockHalfExtents: { x: 0.5, y: 0.5, z: 0.5 }, 
+  });
+
+  movableBlock.onEntityCollision = (movableBlock, otherEntity, started) => {
+    if (started) {
+      world.chatManager.sendBroadcastMessage('The sand block was pushed!');
+    }
+  }
+
+  movableBlock.spawn(world, { x: -4, y: 10, z: -6 });
+
+  /**
+   * Spawn a very heavy block that interacts with physics, and is much harder to move,
+   * Also, prevent it from rotating.
+   */
+  const heavyBlock = new Entity({
+    blockTextureUri: 'textures/stone_bricks.png',
+    blockHalfExtents: { x: 0.5, y: 0.5, z: 0.5 },
+    rigidBodyOptions: {
+      type: RigidBodyType.DYNAMIC,
+      additionalMass: 10,
+      enabledRotations: { x: false, y: false, z: false },
+    }
+  });
+
+  heavyBlock.spawn(world, { x: -4, y: 10, z: -1 });
+
+  /**
+   * Spawn a bouncing block, because why not?
+   * Also disable rotations so it doesn't spin around like a maniac
+   */
+  const bouncingBlock = new Entity({
+    blockTextureUri: 'textures/ice.png',
+    blockHalfExtents: { x: 0.5, y: 0.5, z: 0.5 },
+    rigidBodyOptions: {
+      type: RigidBodyType.DYNAMIC,
+      enabledRotations: { x: false, y: false, z: false },
+      colliders: [
+        {
+          shape: ColliderShape.BLOCK,
+          halfExtents: { x: 0.5, y: 0.5, z: 0.5 },
+          bounciness: 2
+        }
+      ]
+    }
+  });
+
+  bouncingBlock.spawn(world, { x: 0, y: 10, z: -3 });
+
+  /**
+   * Make a block pet that follows a player around
+   * Because, again why not?
+   */
+  const blockPet = new Entity({
+    blockTextureUri: 'textures/bricks.png',
+    blockHalfExtents: { x: 0.5, y: 0.5, z: 0.5 },
+    // attach a simple character controller so we can pathfind,
+    // the character controller will be created and associated when we spawn the entity
+    createCustomCharacterController: entity => new SimpleCharacterController(entity), 
+  });
+
+  blockPet.spawn(world, { x: 0, y: 10, z: -6 });
+
+  // Simple pathfinding
+  let pathfindAccumulator = 0;
+  blockPet.onTick = (blockPet, tickDeltaMs) => {
+    pathfindAccumulator += tickDeltaMs;
+
+    if (pathfindAccumulator > 3000) { // only pathfind every 3 seconds so we don't do unecessary pathfinding
+      pathfindAccumulator = 0;
+
+      const connectedPlayers = GameServer.instance.playerManager.getConnectedPlayers();
+      if (!connectedPlayers.length) { return; } // if no players, don't pathfind.
+
+      // pick a random player to follow
+      const targetPlayer = connectedPlayers[Math.floor(Math.random() * connectedPlayers.length)];
+
+      // get the player's entity
+      const targetPlayerEntity = world.entityManager.getAllPlayerEntities(targetPlayer)[0];
+
+      if (!targetPlayerEntity) { return; } // if the player doesn't have an entity, don't pathfind.
+
+      // pathfind to the player's entity
+      const blockPetCharacterController = blockPet.characterController as SimpleCharacterController;
+      const targetPosition = targetPlayerEntity.getTranslation();
+      blockPetCharacterController.move(targetPosition, 3);
+      blockPetCharacterController.face(targetPosition, 1);
+    }
+  };
+});

package/examples/block-entity/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "block-entity",
+  "module": "index.ts",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "hytopia": "^0.1.33"
+  }
+}

package/examples/payload-game/index.ts

@@ -19,6 +19,7 @@
 import {
   Audio,
   BlockType,
+  PlayerCameraMode,
   ColliderShape,
   CollisionGroup,
   DefaultCharacterController,
@@ -105,6 +106,12 @@ startServer(world => { // Perform our game setup logic in the startServer init c
       modelScale: 0.5,
     });
 
+    // Setup a first person camera for the player
+    player.camera.setMode(PlayerCameraMode.FIRST_PERSON); // set first person mode
+    player.camera.setOffset({ x: 0, y: 0.4, z: 0 }); // shift camrea up on Y axis so we see from "head" perspective.
+    player.camera.setHiddenModelNodes([ 'head', 'neck' ]); // hide the head node from the model so we don't see it in the camera, this is just hidden for the controlling player.
+    player.camera.setForwardOffset(0.3); // Shift the camera forward so we are looking slightly in front of where the player is looking.
+
     // Spawn the player entity at a random coordinate
     const randomSpawnCoordinate = PLAYER_SPAWN_COORDINATES[Math.floor(Math.random() * PLAYER_SPAWN_COORDINATES.length)];
     playerEntity.spawn(world, randomSpawnCoordinate);

package/package.json

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