@hytopia.com/examples 1.0.3 → 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/package.json

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

package/hygrounds/package.json

@@ -10,8 +10,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "latest",
-    "hytopia": "latest"
+    "@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": "latest",
-    "hytopia": "latest"
+    "@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": "latest",
-    "hytopia": "latest"
+    "@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.3",
+  "version": "1.0.4",
   "description": "",
   "license": "ISC",
   "author": "",

package/pathfinding/package.json

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

package/payload-game/index.ts

@@ -273,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) {
@@ -400,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({
@@ -506,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": "latest",
-    "hytopia": "latest"
+    "@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": "latest",
-    "hytopia": "latest"
+    "@hytopia.com/assets": "^0.3.2",
+    "hytopia": "^0.6.4"
   },
   "trustedDependencies": [
     "mediasoup",

package/wall-dodge-game/package.json

@@ -10,8 +10,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hytopia.com/assets": "latest",
-    "hytopia": "latest"
+    "@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": "latest",
-    "hytopia": "latest"
+    "@hytopia.com/assets": "^0.3.2",
+    "hytopia": "^0.6.4"
   },
   "trustedDependencies": [
     "mediasoup",

package/zombies-fps/package.json

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

package/frontiers-rpg-game/src/entities/npcs/BankerEntity.ts

@@ -1,13 +0,0 @@
-import BaseEntity, { BaseEntityOptions } from '../BaseEntity';
-
-export default class BankerEntity extends BaseEntity {
-  public constructor(options?: BaseEntityOptions) {
-    super({
-      idleAnimations: [ 'idle' ],
-      modelUri: 'models/npcs/banker.gltf',
-      modelScale: 0.75,
-      name: 'Banker',
-      ...options,
-    });
-  }
-}

package/frontiers-rpg-game/src/entities/npcs/MerchantEntity.ts

@@ -1,13 +0,0 @@
-import BaseEntity, { BaseEntityOptions } from '../BaseEntity';
-
-export default class MerchantEntity extends BaseEntity {
-  public constructor(options?: BaseEntityOptions) {
-    super({
-      idleAnimations: [ 'idle' ],
-      modelUri: 'models/npcs/merchant.gltf',
-      modelScale: 0.75,
-      name: 'Merchant',
-      ...options,
-    });
-  }
-}

package/frontiers-rpg-game/src/regions/StalkhavenRegion.ts

@@ -1,77 +0,0 @@
-import { Quaternion } from 'hytopia';
-
-import GameRegion from '../GameRegion';
-import stalkhavenMap from '../../assets/maps/stalkhaven.json';
-
-import AdventurerEntity from '../entities/npcs/AdventurerEntity';
-import BankerEntity from '../entities/npcs/BankerEntity';
-import BlacksmithEntity from '../entities/npcs/BlacksmithEntity';
-import FarmerEntity from '../entities/npcs/FarmerEntity';
-import MerchantEntity from '../entities/npcs/MerchantEntity';
-import CapfolkVillagerEntity from '../entities/npcs/CapfolkVillagerEntity';
-import CapfolkElderEntity from '../entities/npcs/CapfolkElderEntity';
-import CapfolkKnightEntity from '../entities/npcs/CapfolkKnightEntity';
-
-export default class StalkhavenRegion extends GameRegion {
-  public constructor() {
-    super({
-      name: 'Stalkhaven',
-      map: stalkhavenMap,
-      skyboxUri: 'skyboxes/partly-cloudy',
-      spawnPoint: { x: 1, y: 5, z: 40 },
-    });
-  }
-
-  protected override _setup(): void {
-    super._setup();
-
-    (new AdventurerEntity({ facingAngle: 90 })).spawn(this.world, { x: 30, y: 2, z: 22 });
-    (new BankerEntity({ facingAngle: 90 })).spawn(this.world, { x: 12, y: 3, z: 41 });
-    (new BlacksmithEntity({ facingAngle: -120 })).spawn(this.world, { x: -25.5, y: 3, z: -12.5 });
-    (new CapfolkElderEntity({ facingAngle: 180 })).spawn(this.world, { x: -13.5, y: 2, z: -30 });
-    (new FarmerEntity({ facingAngle: -90 })).spawn(this.world, { x: -32, y: 3, z: 1 });
-    (new MerchantEntity({ facingAngle: 90 })).spawn(this.world, { x: 13, y: 3, z: 26.5 });
-
-    (new CapfolkVillagerEntity({ facingAngle: -30 })).spawn(this.world, { x: -1.5, y: 2, z: 45.5 });
-    (new CapfolkVillagerEntity({ facingAngle: 15 })).spawn(this.world, { x: 3, y: 2, z: 45.5 });
-    (new CapfolkKnightEntity({ modelScale: 0.7 })).spawn(this.world, { x: 0.75, y: 2, z: 45 });
-
-
-    const wonderDestinations = [
-      { x: -16.5, y: 1.5, z: -30 },   // church 1
-      { x: -12.5, y: 1.5, z: -27 },   // church 2
-      { x: -14,   y: 1.5, z: -24 },   // church 3  
-      { x: -27,   y: 1.5, z: -22.5 }, // cemetary 1
-      { x: -22,   y: 1.5, z: -12 },   // blacksmith
-      { x: -11, y: 1.5, z: -12.5 },  // town square 1
-      { x: 2, y: 1.5, z: -10.5 },  // town square 2
-      { x: 12.5, y: 1.5, z: 3 },  // town square 3
-      { x: -10, y: 1.5, z: -15 },  // town square 4
-      { x: 10.5, y: 1.5, z: 26.5 },  // merchant
-      { x: 9, y: 1.5, z: 41 },  // banker
-      { x: 22, y: 1.5, z: 41 },  // well 1
-      { x: 30, y: 1.5, z: 42 },  // well 2
-      { x: 28, y: 1.5, z: 36 },  // well 3
-      { x: 32, y: 1.5, z: 40 },  // well 4
-      { x: 28, y: 1.5, z: 25 },  // inn 1
-      { x: 29, y: 1.5, z: 18.5 },  // inn 2
-      { x: 26, y: 1.5, z: 16.5 },  // inn 3
-      { x: 22, y: 1.5, z: 9.5 },  // inn garden
-      { x: 28, y: 1.5, z: -6 },  // market 1
-      { x: 27, y: 1.5, z: -20 },  // market 2
-      { x: 29.5, y: 1.5, z: -29 },  // market 3
-      { x: 28, y: 1.5, z: -32 },  // market 3
-      { x: 16, y: 1.5, z: -25 },  // market 4
-      { x: 17, y: 1.5, z: -15 },  // market 5
-    ];
-
-    for (let i = 0; i < 20; i++) {
-      const spawnPoint = wonderDestinations[Math.floor(Math.random() * wonderDestinations.length)];
-      const villager = new CapfolkVillagerEntity();
-      villager.spawn(this.world, spawnPoint);
-      setTimeout(() => {
-        villager.wander(wonderDestinations, 1 + Math.random() * 3);
-      }, 5000);
-    }
-  }
-}