hytopia 0.1.96 → 0.1.98

package/examples/pathfinding/index.ts

@@ -0,0 +1,113 @@
+import {
+  startServer,
+  Entity,
+  PathfindingEntityController,
+  PlayerEntity,
+  Quaternion,
+  RigidBodyType,
+  ColliderShape,
+} from 'hytopia';
+
+import worldMap from './assets/map.json';
+
+startServer(world => {
+  world.loadMap(worldMap);
+
+  // Spawn our zombie that will pathfind around the map
+  const zombie = new Entity({
+    controller: new PathfindingEntityController(),
+    name: 'Zombie',
+    modelUri: 'models/npcs/zombie.gltf',
+    modelLoopedAnimations: [ 'walk' ],
+    modelScale: 0.5,
+    rigidBodyOptions: {
+      enabledRotations: { x: false, y: true, z: false },
+      ccdEnabled: true,
+    },
+  });
+
+  // Spawn somewhere in front of the player
+  zombie.spawn(world, { x: 4, y: 3, z: -6 }, Quaternion.fromEuler(0, 180, 0)); // rotate 180 degrees around Y, facing the player spawn point.
+
+  // Enter /pathfind to make the zombie pathfind to the player
+  let pathfindMarkers: Entity[] = [];
+  world.chatManager.registerCommand('/pathfind', (player, args) => {
+    // Get the entity of the palyer that entered the command
+    const playerEntities = world.entityManager.getPlayerEntitiesByPlayer(player);
+    const playerEntity = playerEntities[0];
+    const playerPosition = playerEntity.position;
+
+    // Remove all existing pathfind markers, which we use in the example just to visualize the path taken.
+    pathfindMarkers.forEach(marker => marker.despawn());
+    pathfindMarkers = [];
+    
+    // Pathfind the zombie to the player
+    const pathfindingController = zombie.controller as PathfindingEntityController;
+
+    // .pathfind() is synchronous and returns immediately soon as a path is found or not, but before the entity has reached the target.
+    const succeeded = pathfindingController.pathfind(playerPosition, 3, { // all possible options for example
+      debug: true, // Setting true will console log pathfinding result info
+      maxFall: 10, // The maximum fall distance (in blocks) the entity can fall when considering a path.
+      maxJump: 1,  // The maximum height (in blocks) the entity will jump when considering a path, the controller will apply the jumps automatically while pathfinding.
+      maxOpenSetIterations: 100, // A performance optimization value. A lower value will make pathfinding faster but may fail for longer paths, a higher value can make pathfinding take longer but will work better for longer paths.
+      verticalPenalty: -1, // A behavior control. The more negative the value, the more the entity will prefer taking a route that requires jumping and falling, even going out of its way to do so. A more positive value will prefer avoiding jumps and falls unless absolutely necessary.
+      pathfindAbortCallback: () => { // Invoked when maxOpenSetIterations is reached and pathfinding aborts.
+        console.log('Pathfinding aborted');
+      },
+      pathfindCompleteCallback: () => { // Invoked when the entity associated with the PathfindingEntityController finishes pathfinding and is now at the target coordinate.
+        console.log('Pathfinding complete');
+      },
+      waypointMoveCompleteCallback: () => { // Invoked when the entity associated with the PathfindingEntityController finishes moving to a calculate waypoint of its current path.
+        console.log('Waypoint reached');
+      },
+      waypointMoveSkippedCallback: () => { // Invoked when the entity associated with the PathfindingEntityController skips a waypoint because it exceeded the waypointTimeoutMs.
+        console.log('Waypoint skipped');
+      },
+      waypointTimeoutMs: 2000, // The timeout in milliseconds for a waypoint to be considered reached. Defaults to 2000ms divided by the speed of the entity.
+    });
+
+    // .pathfind() will return true if the algorithm found a path and began traversing it.
+    console.log(`Path found successfully?: ${succeeded}`);
+
+    // Spawn visual markers for the path
+    pathfindingController.waypoints.forEach(waypoint => {
+      const pathfindMarker = new Entity({
+        modelUri: 'models/items/cookie.gltf',
+        rigidBodyOptions: {
+          type: RigidBodyType.FIXED,
+          colliders: [
+            {
+              shape: ColliderShape.BLOCK,
+              halfExtents: { x: 0.5, y: 0.5, z: 0.5 },
+              isSensor: true,
+            },
+          ],
+        },
+      });
+  
+      pathfindMarker.spawn(world, { x: waypoint.x, y: waypoint.y + 0.25, z: waypoint.z });
+      
+      pathfindMarkers.push(pathfindMarker);
+    });
+  });
+
+  // Spawn a player entity when a player joins the game.
+  world.onPlayerJoin = player => {
+    const playerEntity = new PlayerEntity({
+      player,
+      name: 'Player',
+      modelUri: 'models/players/player.gltf',
+      modelLoopedAnimations: [ 'idle' ],
+      modelScale: 0.5,
+    });
+
+    world.chatManager.sendPlayerMessage(player, 'To make the zombie pathfind to you, enter: /pathfind', '00FF00');
+
+    playerEntity.spawn(world, { x: 4, y: 3, z: 1 });
+  };
+
+  // Despawn all player entities when a player leaves the game.
+  world.onPlayerLeave = player => {
+    world.entityManager.getPlayerEntitiesByPlayer(player).forEach(entity => entity.despawn());
+  };
+});

package/examples/pathfinding/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "pathfinding",
+  "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": "latest",
+    "hytopia": "latest"
+  }
+}

package/examples/payload-game/package.json

@@ -10,7 +10,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.5",
-    "hytopia": "^0.1.86"
+    "@hytopia.com/assets": "latest",
+    "hytopia": "latest"
+
   }
 }

package/examples/wall-dodge-game/package-lock.json

@@ -0,0 +1,30 @@
+{
+  "name": "payload-game",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "payload-game",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "@hytopia.com/assets": "latest",
+        "hytopia": "latest"
+      }
+    },
+    "node_modules/@hytopia.com/assets": {
+      "version": "0.1.7",
+      "resolved": "https://registry.npmjs.org/@hytopia.com/assets/-/assets-0.1.7.tgz",
+      "integrity": "sha512-gC113cIIVKp97cDX3u9n3ats8qS1kuaKPStQXOf1wNxuRs36yBvHM8NJWArfzzk8SG3ilfSZtc7qMYHod2ngcg=="
+    },
+    "node_modules/hytopia": {
+      "version": "0.1.81",
+      "resolved": "https://registry.npmjs.org/hytopia/-/hytopia-0.1.81.tgz",
+      "integrity": "sha512-F7oKIt/3iPwWdrbgycyZ/t7+SrgOOmS4CvmDFiQYDsk+6cILIadBkq/H4M/YpxL3iqqvZVHFDv13tybM+zolZw==",
+      "bin": {
+        "hytopia": "bin/scripts.js"
+      }
+    }
+  }
+}

package/examples/wall-dodge-game/package.json

@@ -10,7 +10,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.5",
-    "hytopia": "^0.1.86"
+    "@hytopia.com/assets": "latest",
+    "hytopia": "latest"
   }
 }

package/examples/zombies-fps/assets/maps/terrain.json

@@ -126,12 +126,6 @@
       "textureUri": "blocks/iron-ore.png",
       "isCustom": false
     },
-    {
-      "id": 22,
-      "name": "lava",
-      "textureUri": "blocks/lava.png",
-      "isCustom": false
-    },
     {
       "id": 23,
       "name": "log",
@@ -246,12 +240,6 @@
       "textureUri": "blocks/voidsoil.png",
       "isCustom": false
     },
-    {
-      "id": 42,
-      "name": "water-flow",
-      "textureUri": "blocks/water-flow.png",
-      "isCustom": false
-    },
     {
       "id": 43,
       "name": "water-still",

package/examples/zombies-fps/assets/ui/index.html

@@ -0,0 +1,35 @@
+<style>
+    .crosshair {
+        position: fixed;
+        top: 50%;
+        left: 50%;
+        transform: translate(-50%, -50%);
+        width: 20px;
+        height: 20px;
+        pointer-events: none;
+        opacity: 0.7;
+    }
+
+    .crosshair::before,
+    .crosshair::after {
+        content: '';
+        position: absolute;
+        background-color: rgba(255, 255, 255, 0.8);
+    }
+
+    .crosshair::before {
+        width: 2px;
+        height: 100%;
+        left: 50%;
+        transform: translateX(-50%);
+    }
+
+    .crosshair::after {
+        width: 100%;
+        height: 2px;
+        top: 50%;
+        transform: translateY(-50%);
+    }
+</style>
+
+<div class="crosshair"></div>

package/examples/zombies-fps/classes/GamePlayerEntity.ts

@@ -1,54 +1,87 @@
 import { 
+  CollisionGroup,
   Player,
+  PlayerCameraOrientation,
   PlayerEntity,
   PlayerCameraMode,
+  PlayerInput,
   Vector3Like,
   QuaternionLike,
   World,
   Quaternion,
+  PlayerEntityController,
 } from 'hytopia';
 
-import WeaponEntity from './WeaponEntity';
+import PistolEntity from './guns/PistolEntity';
+import type GunEntity from './guns/GunEntity';
 
 const BASE_HEALTH = 100;
+const BASE_MONEY = 10;
 
 export default class GamePlayerEntity extends PlayerEntity {
   public health: number;
   public maxHealth: number;
+  public money: number;
+  private _gun: GunEntity | null = null;
+
+  // Player entities always assign a PlayerController to the entity, so we can safely create a convenience getter
+  public get playerController(): PlayerEntityController {
+    return this.controller as PlayerEntityController;
+  }
 
   public constructor(player: Player) {
     super({
       player,
       name: 'Player',
       modelUri: 'models/players/soldier-player.gltf',
-      modelLoopedAnimations: [ 'idle_gun_right', 'shoot_gun_right' ],
       modelScale: 0.5,
     });
+    
+
+    // Prevent mouse left click from being cancelled, required
+    // for auto-fire and semi-auto fire mechanics, etc.
+    this.playerController.autoCancelMouseLeftClick = false;
+    
+    // Setup player animations
+    this.playerController.idleLoopedAnimations = [ 'idle_gun_right', 'idle_lower' ];
+    this.playerController.interactOneshotAnimations = [];
+    this.playerController.walkLoopedAnimations = [ 'idle_gun_right', 'walk_lower' ];
+    this.playerController.runLoopedAnimations = [ 'idle_gun_right', 'run_lower' ];
+    this.playerController.onTickWithPlayerInput = this._onTickWithPlayerInput;
+    
+    // Setup UI
+    this.player.ui.load('ui/index.html');
 
-    // this.player.camera.setMode(PlayerCameraMode.FIRST_PERSON);
-    // this.player.camera.setModelHiddenNodes([ 'head' ]);
-    // this.player.camera.setOffset({ x: 0, y: 0.4, z: 0 });
-    // this.player.camera.setForwardOffset(0.4);
+    // Setup first person camera
+    this.player.camera.setMode(PlayerCameraMode.FIRST_PERSON);
+    this.player.camera.setModelHiddenNodes([ 'head', 'neck' ]);
+    this.player.camera.setOffset({ x: 0, y: 0.5, z: 0 });
+    this.player.camera.setForwardOffset(0.2);
   
+    // Set base stats
     this.health = BASE_HEALTH;
     this.maxHealth = BASE_HEALTH;
+    this.money = BASE_MONEY;
   }
 
   public override spawn(world: World, position: Vector3Like, rotation?: QuaternionLike): void {
     super.spawn(world, position, rotation);
 
-    const weapon = new WeaponEntity({
-      name: 'Pistol',
-      modelUri: 'models/items/pistol.glb',
-      modelScale: 1.3,
-      damage: 10,
-      ammo: 10,
-      maxAmmo: 10,
-      parent: this,
-      parentNodeName: 'hand_right_anchor',
+    // Prevent players from colliding, setup appropriate collision groups for invisible walls, etc.
+    this.setCollisionGroupsForSolidColliders({
+      belongsTo: [ CollisionGroup.PLAYER ],
+      collidesWith: [ CollisionGroup.BLOCK, CollisionGroup.ENTITY, CollisionGroup.ENTITY_SENSOR ],
     });
 
-    weapon.spawn(world, { x: 0, y: 0, z: 0 }, Quaternion.fromEuler(-90, 0, 0));
+    // Give player a pistol.
+    this._gun = new PistolEntity({ parent: this });
+    this._gun.spawn(world, { x: 0, y: 0, z: -0.2 }, Quaternion.fromEuler(-90, 0, 0));
+  }
+
+  private _onTickWithPlayerInput = (entity: PlayerEntity, input: PlayerInput, cameraOrientation: PlayerCameraOrientation, deltaTimeMs: number) => {
+    if (input.ml && this._gun) {
+      this._gun.shoot();
+    }
   }
 }
 

package/examples/zombies-fps/classes/GunEntity.ts

@@ -0,0 +1,66 @@
+import {
+  Entity,
+  EntityOptions,
+} from 'hytopia';
+
+export type GunHand = 'left' | 'right' | 'both';
+
+export interface GunEntityOptions extends EntityOptions {
+  ammo: number;       // The amount of ammo in the clip.
+  damage: number;     // The damage of the gun.
+  fireRate: number;   // Bullets shot per second.
+  reloadTime: number; // Seconds to reload.
+  hand: GunHand;      // The hand the weapon is held in.
+  maxAmmo: number;    // The amount of ammo the clip can hold.
+}
+
+export default class GunEntity extends Entity {
+  public ammo: number;
+  public damage: number;
+  public fireRate: number;
+  public hand: GunHand;
+  public maxAmmo: number;
+  public reloadTime: number;
+  private _lastFireTime: number = 0;
+
+  public constructor(options: GunEntityOptions) {
+    super({
+      ...options,
+      parent: options.parent,
+      parentNodeName: options.parent ? GunEntity._getParentNodeName(options.hand) : undefined,
+    });
+
+    this.fireRate = options.fireRate;
+    this.damage = options.damage;
+    this.ammo = options.ammo;
+    this.hand = options.hand;
+    this.maxAmmo = options.maxAmmo;
+    this.reloadTime = options.reloadTime;
+  }
+
+  // simple convenience helper for handling ammo and fire rate in shoot() overrides.
+  public processShoot(): boolean {
+    const now = performance.now();
+
+    if (this._lastFireTime && now - this._lastFireTime < 1000 / this.fireRate) {
+      return false;
+    }
+
+    if (this.ammo <= 0) {
+      //return false;
+    }
+
+    this.ammo--;
+    this._lastFireTime = now;
+
+    return true;
+  }
+
+  // override to create specific gun shoot logic
+  public shoot() {}
+
+  // convenience helper for getting the node name of the hand the gun is held in.
+  private static _getParentNodeName(hand: GunHand): string {
+    return hand === 'left' ? 'hand_left_anchor' : 'hand_right_anchor';
+  }
+}

package/examples/zombies-fps/classes/guns/PistolEntity.ts

@@ -0,0 +1,49 @@
+import {
+  Audio,
+  PlayerEntity,
+} from 'hytopia';
+
+import GunEntity from '../GunEntity';
+import type { GunEntityOptions } from '../GunEntity';
+
+export default class PistolEntity extends GunEntity {
+  public constructor(options: Partial<GunEntityOptions>) {
+    super({
+      ammo: options.ammo ?? 10,
+      damage: options.damage ?? 3,
+      fireRate: options.fireRate ?? 5,
+      hand: options.hand ?? 'right',
+      maxAmmo: options.maxAmmo ?? 10,
+      modelUri: 'models/items/pistol.glb',
+      modelScale: 1.3,
+      parent: options.parent,
+      reloadTime: options.reloadTime ?? 1,
+    });
+  }
+
+  public override shoot() {
+    if (!this.parent || !this.processShoot()) {
+      return;
+    }
+
+    const parentPlayerEntity = this.parent as PlayerEntity;
+
+    if (!parentPlayerEntity.world) {
+      return;
+    }
+
+    // cancel the input, pistols require click to shoot
+    parentPlayerEntity.player.input.ml = false;
+
+    // play shoot animation
+    parentPlayerEntity.startModelOneshotAnimations([ 'shoot_gun_right' ]);
+
+    (new Audio({
+      position: parentPlayerEntity.position,
+      referenceDistance: 20,
+      uri: 'audio/sfx/pistol-shoot-1.mp3',
+      volume: 1,
+    })).play(parentPlayerEntity.world, true);
+  }
+}
+

package/examples/zombies-fps/index.ts

@@ -1,4 +1,4 @@
-import { startServer, Collider, ColliderShape } from 'hytopia';
+import { startServer, Collider, ColliderShape, CollisionGroup } from 'hytopia';
 import GamePlayerEntity from './classes/GamePlayerEntity';
 import PurchaseBarrierEntity from './classes/PurchaseBarrierEntity';
 import { INVISIBLE_WALLS, PURCHASE_BARRIERS } from './gameConfig';
@@ -19,6 +19,10 @@ startServer(world => {
       shape: ColliderShape.BLOCK,
       halfExtents: wall.halfExtents,
       relativePosition: wall.position, // since this is not attached to a rigid body, relative position is realtive to the world global coordinate space.
+      collisionGroups: {
+        belongsTo: [ CollisionGroup.BLOCK ],
+        collidesWith: [ CollisionGroup.PLAYER ],
+      },
     });
 
     wallCollider.addToSimulation(world.simulation);

package/examples/zombies-fps/package.json

@@ -10,7 +10,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.5",
-    "hytopia": "^0.1.93"
+    "@hytopia.com/assets": "latest",
+    "hytopia": "latest"
   }
 }

package/package.json

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