@hytopia.com/examples 1.0.2 → 1.0.4

package/frontiers-rpg-game/src/systems/Spawner.ts

@@ -0,0 +1,242 @@
+import {
+  Entity,
+  EntityEvent,
+  ErrorHandler,
+  Quaternion,
+  Vector3Like,
+  World,
+} from 'hytopia';
+
+import BaseEntity from '../entities/BaseEntity';
+import BaseItem from '../items/BaseItem';
+import type { ItemClass } from '../items/BaseItem';
+import type { WanderOptions } from '../entities/BaseEntity';
+
+export type BoundingBox = {
+  min: Vector3Like;
+  max: Vector3Like;
+};
+
+export type SpawnRegion = BoundingBox & {
+  weight?: number;
+};
+
+export type EntitySpawnable = {
+  entityConstructor: new () => BaseEntity;
+  weight: number;
+  wanders?: boolean;
+  wanderOptions?: WanderOptions;
+};
+
+export type ItemSpawnable = {
+  itemClass: ItemClass;
+  minQuantity?: number;
+  maxQuantity?: number;
+  weight: number;
+};
+
+export type Spawnable = EntitySpawnable | ItemSpawnable;
+
+export type SpawnerOptions = {
+  exclusionZones?: BoundingBox[];
+  groundCheckDistance?: number;
+  maxSpawns: number;
+  spawnables: Spawnable[];
+  spawnRegions: SpawnRegion[];
+  spawnIntervalMs: number;
+  world: World;
+};
+
+export default class Spawner {
+  private _exclusionZones: BoundingBox[];
+  private _groundCheckDistance: number;
+  private _maxSpawns: number;
+  private _spawnables: Spawnable[];
+  private _spawnedEntities: Set<Entity> = new Set();
+  private _spawnInterval: NodeJS.Timeout | undefined;
+  private _spawnIntervalMs: number;
+  private _spawnRegions: SpawnRegion[];
+  private _totalSpawnableWeight: number;
+  private _totalRegionWeight: number;
+  private _world: World;
+
+  public constructor(options: SpawnerOptions) {
+    if (options.spawnables.length === 0) {
+      throw new Error('Spawner: spawnables cannot be empty');
+    }
+
+    if (options.spawnRegions.length === 0) {
+      throw new Error('Spawner: spawnRegions cannot be empty');
+    }
+
+    this._groundCheckDistance = options.groundCheckDistance ?? 4;
+    this._maxSpawns = Math.max(1, options.maxSpawns);
+    this._spawnables = options.spawnables;
+    this._spawnRegions = options.spawnRegions;
+    this._exclusionZones = options.exclusionZones ?? [];
+    this._spawnIntervalMs = Math.max(100, options.spawnIntervalMs);
+    this._world = options.world;
+
+    this._totalSpawnableWeight = this._spawnables.reduce((sum, spawnable) => sum + Math.max(0, spawnable.weight), 0);
+    this._totalRegionWeight = this._spawnRegions.reduce((sum, region) => sum + Math.max(1, region.weight ?? 1), 0);
+  }
+
+  public get exclusionZones(): BoundingBox[] { return this._exclusionZones; }
+  public get isStarted(): boolean { return this._spawnInterval !== undefined; }
+  public get maxSpawns(): number { return this._maxSpawns; }
+  public get spawnables(): Spawnable[] { return this._spawnables; }
+  public get spawnedCount(): number { return this._spawnedEntities.size; }
+  public get spawnIntervalMs(): number { return this._spawnIntervalMs; }
+  public get spawnRegions(): SpawnRegion[] { return this._spawnRegions; }
+  public get world(): World { return this._world; }
+
+  public start(spawnAllImmediately: boolean = false): void {
+    if (this._spawnInterval) return;
+
+    if (spawnAllImmediately) {
+      let attempts = 0;
+      while (this._spawnedEntities.size < this._maxSpawns) {
+        this._spawnEntity();
+
+        if (attempts > 500) { // Prevent infinite loop
+          ErrorHandler.warning('Spawner: Failed to spawn all entities after 500 attempts');
+          break;
+        }
+      }
+    }
+
+    this._spawnInterval = setInterval(() => {
+      if (this._spawnedEntities.size < this._maxSpawns) {
+        this._spawnEntity();
+      }
+    }, this._spawnIntervalMs);
+  }
+
+  public stop(): void {
+    if (this._spawnInterval) {
+      clearInterval(this._spawnInterval);
+      this._spawnInterval = undefined;
+    }
+  }
+
+  private _spawnEntity(): void {
+    const spawnable = this._pickRandomSpawnable();
+    if (!spawnable) return;
+
+    const spawnPoint = this._findValidSpawnPoint();
+    if (!spawnPoint) return;
+
+    const rotation = Quaternion.fromEuler(0, Math.random() * 360, 0);
+
+    if ('entityConstructor' in spawnable) {
+      // Handle BaseEntity spawning
+      const instance = new spawnable.entityConstructor();
+      
+      instance.on(EntityEvent.DESPAWN, ({ entity }: { entity: Entity }) => {
+        this._spawnedEntities.delete(entity);
+      });
+
+      instance.spawn(this._world, spawnPoint, rotation);
+
+      // Apply wandering behavior if configured
+      if (spawnable.wanders && spawnable.wanderOptions) {
+        instance.wander(instance.moveSpeed, spawnable.wanderOptions);
+      }
+
+      this._spawnedEntities.add(instance);
+    } else {
+      // Handle BaseItem spawning
+      const minQty = spawnable.minQuantity ?? 1;
+      const maxQty = spawnable.maxQuantity ?? 1;
+      const quantity = Math.floor(Math.random() * (maxQty - minQty + 1)) + minQty;
+      
+      const instance = spawnable.itemClass.create({ quantity });
+      instance.spawnEntityAsDrop(this._world, spawnPoint, rotation);
+      
+      // Track the created entity (BaseItem handles its own despawn cleanup)
+      const spawnedEntity = instance.entity;
+
+      if (spawnedEntity) {
+        spawnedEntity.on(EntityEvent.DESPAWN, ({ entity }: { entity: Entity }) => {
+          this._spawnedEntities.delete(entity);
+        });
+        
+        this._spawnedEntities.add(spawnedEntity);
+      }
+    }
+  }
+
+  private _findValidSpawnPoint(): Vector3Like | null {
+    for (let attempt = 0; attempt < 15; attempt++) {
+      const region = this._pickRandomSpawnRegion();
+      if (!region) continue;
+
+      const point = {
+        x: Math.random() * (region.max.x - region.min.x) + region.min.x,
+        y: Math.random() * (region.max.y - region.min.y) + region.min.y,
+        z: Math.random() * (region.max.z - region.min.z) + region.min.z,
+      };
+
+      // Ignore exclusion zones
+      if (this._isInExclusionZone(point)) continue;
+
+      // Ignore spawn points that would spawn in a block
+      if (this._world.chunkLattice.hasBlock(point)) continue;
+
+      // Check for ground
+      let hasGround = false;
+      for (let i = 1; i <= this._groundCheckDistance; i++) {
+        if (this._world.chunkLattice.hasBlock({ x: point.x, y: point.y - i, z: point.z })) {
+          hasGround = true;
+          break;
+        }
+      }
+
+      if (!hasGround) continue;
+
+      return point;
+    }
+
+    return null;
+  }
+
+  private _isInExclusionZone(point: Vector3Like): boolean {
+    return this._exclusionZones.some(zone =>
+      point.x >= zone.min.x && point.x <= zone.max.x &&
+      point.y >= zone.min.y && point.y <= zone.max.y &&
+      point.z >= zone.min.z && point.z <= zone.max.z
+    );
+  }
+
+  private _pickRandomSpawnRegion(): SpawnRegion | null {
+    if (this._totalRegionWeight <= 0) return this._spawnRegions[0] ?? null;
+
+    const random = Math.random() * this._totalRegionWeight;
+    let cumulativeWeight = 0;
+
+    for (const region of this._spawnRegions) {
+      cumulativeWeight += Math.max(1, region.weight ?? 1);
+      if (random < cumulativeWeight) {
+        return region;
+      }
+    }
+
+    return this._spawnRegions[0] ?? null;
+  }
+
+  private _pickRandomSpawnable(): Spawnable | null {
+    if (this._totalSpawnableWeight <= 0) return this._spawnables[0] ?? null;
+
+    const random = Math.random() * this._totalSpawnableWeight;
+    let cumulativeWeight = 0;
+
+    for (const spawnable of this._spawnables) {
+      cumulativeWeight += Math.max(0, spawnable.weight);
+      if (random < cumulativeWeight) {
+        return spawnable;
+      }
+    }
+
+    return this._spawnables[0] ?? null;
+  }
+}

package/frontiers-rpg-game/src/systems/Storage.ts

@@ -0,0 +1,20 @@
+import { Player } from 'hytopia';
+import BaseItem from '../items/BaseItem';
+import ItemInventory from './ItemInventory';
+import type GamePlayer from '../GamePlayer';
+
+const STORAGE_SIZE = 70;
+const STORAGE_GRID_WIDTH = 7;
+
+export default class Storage extends ItemInventory {
+  private _owner: GamePlayer;
+  
+  public constructor(owner: GamePlayer) {
+    super(STORAGE_SIZE, STORAGE_GRID_WIDTH, 'storage');
+    this._owner = owner;
+  }
+
+  protected override onSlotChanged(position: number, item: BaseItem | null): void {
+    this.syncUIUpdate(this._owner.player, position, item);
+  }
+}

package/frontiers-rpg-game/src/systems/Wearables.ts

@@ -0,0 +1,62 @@
+import BaseWearableItem from '../items/BaseWearableItem';
+import BaseItem from '../items/BaseItem';
+import ItemInventory from './ItemInventory';
+import type GamePlayer from '../GamePlayer';
+import type { WearableSlot } from '../items/BaseWearableItem';
+import type { SerializedItemInventoryData } from './ItemInventory';
+
+export type SerializedWearablesData = SerializedItemInventoryData;
+
+export default class Wearables extends ItemInventory {
+  private static readonly SLOT_POSITIONS: Record<WearableSlot, number> = {
+    helmet: 0,
+    armor: 1,
+    gloves: 2,
+    leggings: 3,
+    boots: 4,
+    accessory: 5,
+  };
+
+  private _owner: GamePlayer;
+
+  public constructor(owner: GamePlayer) {
+    super(6, 6, 'wearables'); // 6 slots, single row
+    this._owner = owner;
+  }
+
+  public getWearableItem(slot: WearableSlot): BaseWearableItem | null {
+    const position = this._getPositionForSlot(slot);
+    const item = this.getItemAt(position);
+    return item && BaseWearableItem.isWearableItem(item) ? item : null;
+  }
+
+  public getReducedDamage(damage: number): number {
+    for (const item of this.items as MapIterator<BaseWearableItem>) {
+      if (item.damageReduction) {
+        damage -= item.damageReduction;
+      }
+
+      if (item.damageReductionPercent) {
+        damage -= damage * item.damageReductionPercent;
+      }
+    }
+
+    return Math.max(1, damage);
+  }
+
+  public override addItem(item: BaseItem): boolean {
+    if (!BaseWearableItem.isWearableItem(item)) return false;
+    
+    const targetPosition = this._getPositionForSlot(item.slot);
+    return super.addItem(item, targetPosition);
+  }
+
+  protected override onSlotChanged(position: number, item: BaseItem | null): void {
+    this.syncUIUpdate(this._owner.player, position, item);
+  }
+
+  private _getPositionForSlot(slot: WearableSlot): number {
+    return Wearables.SLOT_POSITIONS[slot];
+  }
+}
+

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

@@ -15,6 +15,7 @@ import {
   World,
   CollisionGroup,
   PlayerEntity,
+  DefaultPlayerEntityController,
 } from 'hytopia';
 
 import GAME_WALL_SHAPES from './wall-shapes';
@@ -93,7 +94,7 @@ function onPlayerJoin(world: World, player: Player) {
   const playerEntity = new DefaultPlayerEntity({
     player,
     name: 'Player',
-    modelUri: 'models/players/soldier-player.gltf',
+    modelUri: 'models/players/player.gltf',
   });
 
   playerEntity.spawn(world, GAME_CONFIG.POSITIONS.PLAYER_SPAWN);
@@ -113,6 +114,8 @@ function onPlayerJoin(world: World, player: Player) {
       killPlayer(playerEntity);
     }
   });
+
+  (playerEntity.controller as DefaultPlayerEntityController).canSwim = () => false;
 }
 
 function onPlayerLeave(world: World, player: Player) {

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

@@ -10,8 +10,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.21",
-    "hytopia": "^0.5.20"
+    "@hytopia.com/assets": "^0.3.2",
+    "hytopia": "^0.6.4"
   },
   "trustedDependencies": [
     "mediasoup",

package/hygrounds/classes/GamePlayerEntity.ts

@@ -84,6 +84,7 @@ export default class GamePlayerEntity extends DefaultPlayerEntity {
       player,
       name: 'Player',
       modelUri: 'models/players/soldier-player.gltf',
+      modelScale: 0.5,
     });
     
     this._setupPlayerController();
@@ -370,6 +371,7 @@ export default class GamePlayerEntity extends DefaultPlayerEntity {
   }
 
   private _setupPlayerController(): void {
+    this.playerController.applyDirectionalMovementRotations = false;
     this.playerController.autoCancelMouseLeftClick = false;
 
     this.resetAnimations();

package/hygrounds/package.json

@@ -10,8 +10,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.21",
-    "hytopia": "^0.5.20"
+    "@hytopia.com/assets": "^0.3.2",
+    "hytopia": "^0.6.4"
   },
   "trustedDependencies": [
     "mediasoup",

package/lighting/package.json

@@ -10,8 +10,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.21",
-    "hytopia": "^0.5.20"
+    "@hytopia.com/assets": "^0.3.2",
+    "hytopia": "^0.6.4"
   },
   "trustedDependencies": [
     "mediasoup",

package/mobile-controls/package.json

@@ -9,8 +9,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.21",
-    "hytopia": "^0.5.20"
+    "@hytopia.com/assets": "^0.3.2",
+    "hytopia": "^0.6.4"
   },
   "trustedDependencies": [
     "mediasoup",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hytopia.com/examples",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "",
   "license": "ISC",
   "author": "",

package/pathfinding/index.ts

@@ -19,7 +19,6 @@ startServer(world => {
     controller: new PathfindingEntityController(),
     name: 'Zombie',
     modelUri: 'models/npcs/zombie.gltf',
-    modelLoopedAnimations: [ 'walk' ],
     modelScale: 0.5,
     rigidBodyOptions: {
       enabledRotations: { x: false, y: true, z: false },
@@ -27,6 +26,10 @@ startServer(world => {
     },
   });
 
+  const pathfindingController = zombie.controller as PathfindingEntityController;
+  pathfindingController.idleLoopedAnimations = [ 'walk' ];
+  pathfindingController.moveLoopedAnimations = [ 'run' ];
+
   // 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.
 

package/pathfinding/package.json

@@ -10,8 +10,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.21",
-    "hytopia": "^0.5.20"
+    "@hytopia.com/assets": "^0.3.2",
+    "hytopia": "^0.6.4"
   },
   "trustedDependencies": [
     "mediasoup",

package/payload-game/index.ts

@@ -109,6 +109,7 @@ startServer(world => { // Perform our game setup logic in the startServer init c
       player,
       name: 'Player',
       modelUri: 'models/soldier-player.gltf',
+      modelScale: 0.5,
     });
 
     
@@ -126,6 +127,7 @@ startServer(world => { // Perform our game setup logic in the startServer init c
 
     // Override default model animations
     const playerController = playerEntity.controller as DefaultPlayerEntityController;
+    playerController.applyDirectionalMovementRotations = false;
     playerController.idleLoopedAnimations = [ 'idle_lower', 'idle_gun_right' ];
     playerController.interactOneshotAnimations = [];
     playerController.walkLoopedAnimations = ['walk_lower', 'idle_gun_right' ];
@@ -271,9 +273,9 @@ function spawnBullet(world: World, coordinate: Vector3Like, direction: Vector3Li
     const knockback = 14 * mass;
 
     otherEntity.applyImpulse({
-      x: -bulletDirection.x * knockback,
+      x: bulletDirection.x * knockback,
       y: 0,
-      z: -bulletDirection.z * knockback,
+      z: bulletDirection.z * knockback,
     });
 
     if (enemyHealth[otherEntity.id!] <= 0) {
@@ -398,9 +400,9 @@ function spawnSpider(world: World, coordinate: Vector3Like) {
       const knockback = 4 * randomScaleMultiplier;
 
       otherEntity.applyImpulse({
-        x: -spiderDirection.x * knockback,
+        x: spiderDirection.x * knockback,
         y: 4,
-        z: -spiderDirection.z * knockback,
+        z: spiderDirection.z * knockback,
       });
 
       (new Audio({
@@ -504,8 +506,8 @@ function onTickWithPlayerInput(payload: EventPayloads[BaseEntityControllerEvent.
 
     // Adjust horizontal components based on pitch
     const cosP = Math.cos(cameraOrientation.pitch);
-    direction.x = -direction.x * cosP;
-    direction.z = -direction.z * cosP;
+    direction.x = direction.x * cosP;
+    direction.z = direction.z * cosP;
 
     // Normalize the direction vector to unit length
     direction.normalize();

package/payload-game/package.json

@@ -10,8 +10,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.21",
-    "hytopia": "^0.5.20"
+    "@hytopia.com/assets": "^0.3.2",
+    "hytopia": "^0.6.4"
   },
   "trustedDependencies": [
     "mediasoup",

package/player-persistence/package.json

@@ -10,8 +10,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.21",
-    "hytopia": "^0.5.20"
+    "@hytopia.com/assets": "^0.3.2",
+    "hytopia": "^0.6.4"
   },
   "trustedDependencies": [
     "mediasoup",

package/wall-dodge-game/index.ts

@@ -15,6 +15,7 @@ import {
   SimpleEntityController,
   World,
   Collider,
+  DefaultPlayerEntityController,
 } from 'hytopia';
 
 import worldMap from './assets/map.json';
@@ -276,6 +277,7 @@ function onPlayerJoin(world: World, player: Player) {
 
   // Spawn with a random X coordinate to spread players out a bit.
   playerEntity.spawn(world, getRandomSpawnCoordinate());
+  (playerEntity.controller as DefaultPlayerEntityController).canSwim = () => false;
 }
 
 /**

package/wall-dodge-game/package.json

@@ -10,8 +10,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.21",
-    "hytopia": "^0.5.20"
+    "@hytopia.com/assets": "^0.3.2",
+    "hytopia": "^0.6.4"
   },
   "trustedDependencies": [
     "mediasoup",

package/world-switching/package.json

@@ -10,8 +10,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.21",
-    "hytopia": "^0.5.20"
+    "@hytopia.com/assets": "^0.3.2",
+    "hytopia": "^0.6.4"
   },
   "trustedDependencies": [
     "mediasoup",

package/zombies-fps/classes/GamePlayerEntity.ts

@@ -53,10 +53,12 @@ export default class GamePlayerEntity extends DefaultPlayerEntity {
       player,
       name: 'Player',
       modelUri: 'models/players/soldier-player.gltf',
+      modelScale: 0.5,
     });
     
     // Prevent mouse left click from being cancelled, required
     // for auto-fire and semi-auto fire mechanics, etc.
+    this.playerController.applyDirectionalMovementRotations = false;
     this.playerController.autoCancelMouseLeftClick = false;
     
     // Setup player animations

package/zombies-fps/package.json

@@ -10,8 +10,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "^0.2.21",
-    "hytopia": "^0.5.20"
+    "@hytopia.com/assets": "^0.3.2",
+    "hytopia": "^0.6.4"
   },
   "trustedDependencies": [
     "mediasoup",