hytopia 0.1.98 → 0.2.0

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

@@ -1,27 +1,53 @@
 import {
+  Audio,
+  CollisionGroup,
+  CollisionGroupsBuilder,
   Entity,
   EntityOptions,
+  PlayerEntity,
+  Vector3Like,
+  QuaternionLike,
+  World,
+  PlayerEntityController,
 } from 'hytopia';
 
+import EnemyEntity from './EnemyEntity';
+import type GamePlayerEntity from './GamePlayerEntity';
+
 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.
+  ammo: number;              // The amount of ammo in the clip.
+  damage: number;            // The damage of the gun.
+  fireRate: number;          // Bullets shot per second.
+  hand: GunHand;             // The hand the weapon is held in.
+  iconImageUri: string;      // The image uri of the weapon icon.
+  idleAnimation: string;     // The animation played when the gun is idle.
+  maxAmmo: number;           // The amount of ammo the clip can hold.
+  parent?: GamePlayerEntity; // The parent player entity.
+  range: number;             // The max range bullets travel for raycast hits
+  reloadAudioUri: string;    // The audio played when reloading
+  reloadTimeMs: number;      // Seconds to reload.
+  shootAnimation: string;    // The animation played when the gun is shooting.
+  shootAudioUri: string;     // The audio played when shooting
 }
 
-export default class GunEntity extends Entity {
+export default abstract class GunEntity extends Entity {
   public ammo: number;
   public damage: number;
   public fireRate: number;
   public hand: GunHand;
+  public iconImageUri: string;
+  public idleAnimation: string;
   public maxAmmo: number;
-  public reloadTime: number;
+  public range: number;
+  public reloadTimeMs: number;
+  public shootAnimation: string;
   private _lastFireTime: number = 0;
+  private _muzzleFlashChildEntity: Entity | undefined;
+  private _reloadAudio: Audio;
+  private _reloading: boolean = false;
+  private _shootAudio: Audio;
 
   public constructor(options: GunEntityOptions) {
     super({
@@ -30,12 +56,76 @@ export default class GunEntity extends Entity {
       parentNodeName: options.parent ? GunEntity._getParentNodeName(options.hand) : undefined,
     });
 
-    this.fireRate = options.fireRate;
-    this.damage = options.damage;
     this.ammo = options.ammo;
+    this.damage = options.damage;
+    this.fireRate = options.fireRate;
     this.hand = options.hand;
+    this.iconImageUri = options.iconImageUri;
+    this.idleAnimation = options.idleAnimation;
     this.maxAmmo = options.maxAmmo;
-    this.reloadTime = options.reloadTime;
+    this.range = options.range;
+    this.reloadTimeMs = options.reloadTimeMs;
+    this.shootAnimation = options.shootAnimation;
+
+    // Create reusable audio instances
+    this._reloadAudio = new Audio({
+      attachedToEntity: this,
+      uri: options.reloadAudioUri,  
+    });
+
+    this._shootAudio = new Audio({
+      attachedToEntity: this,
+      uri: options.shootAudioUri,
+      volume: 0.3,
+      referenceDistance: 8,
+    });
+
+    if (options.parent) {
+      this._updateParentAnimations();
+    }
+  }
+
+  public get isEquipped(): boolean { return !!this.parent; }
+
+  public override spawn(world: World, position: Vector3Like, rotation: QuaternionLike) {
+    super.spawn(world, position, rotation);
+    this.createMuzzleFlashChildEntity();
+    this._updatePlayerUIAmmo();
+    this._updatePlayerUIWeapon();
+  }
+
+  public createMuzzleFlashChildEntity() {
+    if (!this.isSpawned || !this.world) {
+      return;
+    }
+
+    this._muzzleFlashChildEntity = new Entity({
+      parent: this,
+      modelUri: 'models/environment/muzzle-flash.gltf',
+      modelScale: 0.5,
+      opacity: 0,
+    });
+
+    // pistol specific atm
+    const { position, rotation } = this.getMuzzleFlashPositionRotation();
+    this._muzzleFlashChildEntity.spawn(this.world, position, rotation);
+  }
+
+  public abstract getMuzzleFlashPositionRotation(): { position: Vector3Like, rotation: QuaternionLike };
+
+  public getShootOriginDirection(): { origin: Vector3Like, direction: Vector3Like } {
+    const parentPlayerEntity = this.parent as GamePlayerEntity;
+
+    const { x, y, z } = parentPlayerEntity.position;
+    const cameraYOffset = parentPlayerEntity.player.camera.offset.y;    
+    const direction = parentPlayerEntity.player.camera.facingDirection;
+    const origin = {
+      x: x + (direction.x * 0.5),
+      y: y + (direction.y * 0.5) + cameraYOffset,
+      z: z + (direction.z * 0.5),
+    };
+
+    return { origin, direction };
   }
 
   // simple convenience helper for handling ammo and fire rate in shoot() overrides.
@@ -47,7 +137,8 @@ export default class GunEntity extends Entity {
     }
 
     if (this.ammo <= 0) {
-      //return false;
+      this.reload();
+      return false;
     }
 
     this.ammo--;
@@ -56,8 +147,129 @@ export default class GunEntity extends Entity {
     return true;
   }
 
+  public reload() {
+    if (!this.parent || !this.parent.world || this._reloading) {
+      return;
+    }
+
+    this.ammo = 0; // set the ammo to 0 to prevent fire while reloading if clip wasn't empty.
+    this._reloading = true;
+    this._reloadAudio.play(this.parent.world, true);
+    this._updatePlayerUIReload();
+
+    setTimeout(() => {
+      if (!this.isEquipped) {
+        return;
+      }
+
+      this.ammo = this.maxAmmo;
+      this._reloading = false;
+      this._updatePlayerUIAmmo();
+    }, this.reloadTimeMs);
+  }
+
   // override to create specific gun shoot logic
-  public shoot() {}
+  public shoot() {
+    if (!this.parent || !this.parent.world) {
+      return;
+    }
+
+    const parentPlayerEntity = this.parent as GamePlayerEntity;
+    
+    // Deal damage and raycast
+    const { origin, direction } = this.getShootOriginDirection();
+    this.shootRaycast(origin, direction, this.range);
+
+    // Play shoot animation
+    parentPlayerEntity.startModelOneshotAnimations([ this.shootAnimation ]);
+
+    // Show Muzzle Flash
+    if (this._muzzleFlashChildEntity) {
+      this._muzzleFlashChildEntity.setOpacity(1);
+      setTimeout(() => {
+        if (this.isSpawned && this._muzzleFlashChildEntity?.isSpawned) {
+          this._muzzleFlashChildEntity.setOpacity(0);
+        }
+      }, 35);
+    }
+    
+    // Update player ammo
+    this._updatePlayerUIAmmo();
+    
+    // Play shoot audio
+    this._shootAudio.play(this.parent.world, true);
+  }
+
+  public shootRaycast(origin: Vector3Like, direction: Vector3Like, length: number) {
+    if (!this.parent || !this.parent.world) {
+      return;
+    }
+
+    const parentPlayerEntity = this.parent as GamePlayerEntity;
+   
+    const raycastHit = this.parent.world.simulation.raycast(origin, direction, length, {
+      filterGroups: CollisionGroupsBuilder.buildRawCollisionGroups({ // filter group is the group the raycast belongs to.
+        belongsTo: [ CollisionGroup.ALL ],
+        collidesWith: [ CollisionGroup.BLOCK, CollisionGroup.ENTITY ],
+      }),
+    });
+
+    const hitEntity = raycastHit?.hitEntity;
+
+    if (hitEntity && hitEntity instanceof EnemyEntity) {
+      hitEntity.takeDamage(this.damage, parentPlayerEntity);
+    }
+  }
+
+  private _updateParentAnimations() {
+    if (!this.parent || !this.parent.world) {
+      return;
+    }
+
+    const playerEntityController = this.parent.controller as PlayerEntityController;
+
+    playerEntityController.idleLoopedAnimations = [ this.idleAnimation, 'idle_lower' ];
+    playerEntityController.walkLoopedAnimations = [ this.idleAnimation, 'walk_lower' ];
+    playerEntityController.runLoopedAnimations = [ this.idleAnimation, 'run_lower' ];
+  }
+
+  private _updatePlayerUIAmmo() {
+    if (!this.parent || !this.parent.world) {
+      return;
+    }
+
+    const parentPlayerEntity = this.parent as PlayerEntity;
+
+    parentPlayerEntity.player.ui.sendData({
+      type: 'ammo',
+      ammo: this.ammo,
+      maxAmmo: this.maxAmmo,
+    });
+  }
+
+  private _updatePlayerUIReload() {
+    if (!this.parent || !this.parent.world) {
+      return;
+    }
+
+    const parentPlayerEntity = this.parent as PlayerEntity;
+
+    parentPlayerEntity.player.ui.sendData({ type: 'reload' });
+  }
+
+  private _updatePlayerUIWeapon() {
+    if (!this.parent || !this.parent.world) {
+      return;
+    }
+
+    const parentPlayerEntity = this.parent as PlayerEntity;
+
+    parentPlayerEntity.player.ui.sendData({
+      type: 'weapon',
+      name: this.name,
+      iconImageUri: this.iconImageUri,
+    });
+  }
 
   // convenience helper for getting the node name of the hand the gun is held in.
   private static _getParentNodeName(hand: GunHand): string {

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

@@ -0,0 +1,9 @@
+import {
+  Entity,
+} from 'hytopia';
+
+import GamePlayerEntity from './GamePlayerEntity';
+
+export default abstract class InteractableEntity extends Entity {
+  public abstract interact(interactingPlayer: GamePlayerEntity): void;
+}

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

@@ -1,19 +1,24 @@
 import {
   ColliderOptions,
   ColliderShape,
+  CollisionGroup,
   Entity,
-  RigidBodyType,
   QuaternionLike,
+  RigidBodyType,
+  SceneUI,
   Vector3Like,
   World,
 } from 'hytopia';
 
+import GameManager from './GameManager';
+import GamePlayerEntity from './GamePlayerEntity';
+import InteractableEntity from './InteractableEntity';
+
 const WALL_COLLIDER_OPTIONS: ColliderOptions = {
   shape: ColliderShape.BLOCK,
-  halfExtents: {
-    x: 0.5,
-    y: 5,
-    z: 0.5,
+  collisionGroups: {
+    belongsTo: [ CollisionGroup.BLOCK ],
+    collidesWith: [ CollisionGroup.PLAYER ],
   },
 };
 
@@ -21,33 +26,66 @@ export interface PurchaseBarrierEntityOptions {
   name: string;
   removalPrice: number;
   width: number;
+  unlockIds: string[];
 }
 
-export default class PurchaseBarrierEntity extends Entity {
+export default class PurchaseBarrierEntity extends InteractableEntity {
   public removalPrice: number;
+  private _unlockIds: string[];
   private _width: number;
-
   public constructor(options: PurchaseBarrierEntityOptions) {
     super({
       name: options.name,
       modelUri: 'models/environment/barbedfence.gltf',
       rigidBodyOptions: {
         type: RigidBodyType.FIXED,
-        colliders: [ WALL_COLLIDER_OPTIONS ],
       },
     });
 
     this.removalPrice = options.removalPrice;
+    this._unlockIds = options.unlockIds;
     this._width = options.width;
   }
 
   public get width(): number {
     return this._width;
   }
+  
+  public override interact(interactingPlayer: GamePlayerEntity) {
+    if (!this.isSpawned || !this.world) {
+      return;
+    }
+
+    if (!interactingPlayer.spendMoney(this.removalPrice)) {
+      this.world.chatManager.sendPlayerMessage(interactingPlayer.player, `You don't have enough money to unlock this barrier!`, 'FF0000');
+      return;
+    }
+
+    this.world.chatManager.sendBroadcastMessage(`The ${this.name} barrier has been unlocked!`, '00FF00');
+
+    // Add unlocked ids to game state, so zombies can spawn in the new areas
+    this._unlockIds.forEach(id => {
+      GameManager.instance.addUnlockedId(id);
+    });
+
+    this.despawn();
+  }
 
   public override spawn(world: World, position: Vector3Like, rotation?: QuaternionLike): void {
+    // Add the barrier collider based on spawn position and width before spawning the barrier.
+    this.createAndAddChildCollider({
+      ...WALL_COLLIDER_OPTIONS,
+      halfExtents: {
+        x: rotation?.w === 1 ? (this._width * 0.5) : 0.5,
+        y: 5,
+        z: rotation?.w === 1 ? 0.5 : (this._width * 0.5),
+      },
+      relativeRotation: rotation,
+    });
+    
     super.spawn(world, position, rotation);    
 
+    // Add children barriers for visual barrier width
     if (this._width > 1) {
       const offset = Math.floor((this._width - 1) / 2);
       for (let i = -offset; i <= offset; i++) {
@@ -56,19 +94,34 @@ export default class PurchaseBarrierEntity extends Entity {
         const barrier = new Entity({
           name: `${this.name} (${Math.abs(i)})`,
           modelUri: 'models/environment/barbedfence.gltf',
-          rigidBodyOptions: {
-            type: RigidBodyType.FIXED,
-            colliders: [ WALL_COLLIDER_OPTIONS ],
-          },
+          parent: this,
         });
 
+        // Because of the anchor point of the barbedfence model
+        // being in the lower corner and not centered, we need
+        // to offset the child barriers by half the height to
+        // center them, this is just a unique for to this model.
+        const halfHeight = this.height / 2;
+
         barrier.spawn(world, {
-          x: position.x + (rotation?.w === 1 ? i : 0),
-          y: position.y,
-          z: position.z + (rotation?.w === 1 ? 0 : i),
-        }, rotation);
+          x: i - halfHeight,
+          y: -halfHeight,
+          z: -halfHeight,
+        });
       }
-    };
+    }
+
+    // Spawn Scene UI that shows barrier removal price
+    (new SceneUI({
+      attachedToEntity: this,
+      offset: { x: 0, y: 1, z: 0 },
+      templateId: 'purchase-label',
+      viewDistance: 4,
+      state: {
+        name: this.name,
+        cost: this.removalPrice,
+      },
+    })).load(world);
   }
 }
 

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

@@ -0,0 +1,173 @@
+import {
+  Audio,
+  Collider,
+  RigidBodyType,
+  QuaternionLike,
+  Vector3Like,
+  World,
+  SceneUI,
+} from 'hytopia';
+
+import GamePlayerEntity from './GamePlayerEntity';
+import InteractableEntity from './InteractableEntity';
+
+import AK47Entity from './guns/AK47Entity';
+import AR15Entity from './guns/AR15Entity';
+import AutoPistolEntity from './guns/AutoPistolEntity';
+import AutoShotgunEntity from './guns/AutoShotgunEntity';
+import PistolEntity from './guns/PistolEntity';
+import ShotgunEntity from './guns/ShotgunEntity';
+import type { GunEntityOptions } from './GunEntity';
+import type GunEntity from './GunEntity';
+
+const POSSIBLE_WEAPONS = [
+  {
+    id: 'ak47',
+    name: 'AK-47',
+    iconUri: 'icons/ak-47.png',
+  },
+  {
+    id: 'ar15',
+    name: 'AR-15',
+    iconUri: 'icons/ar-15.png',
+  },
+  {
+    id: 'auto-pistol',
+    name: 'Auto Pistol',
+    iconUri: 'icons/auto-pistol.png',
+  },
+  {
+    id: 'auto-shotgun',
+    name: 'Auto Shotgun',
+    iconUri: 'icons/auto-shotgun.png',
+  },
+  {
+    id: 'pistol',
+    name: 'Pistol',
+    iconUri: 'icons/pistol.png',
+  },
+  {
+    id: 'shotgun',
+    name: 'Shotgun',
+    iconUri: 'icons/shotgun.png',
+  },
+]
+
+export interface WeaponCrateEntityOptions {
+  name: string,
+  price: number,
+  rollableWeaponIds: string[],
+};
+
+export default class WeaponCrateEntity extends InteractableEntity {
+  public purchasePrice: number;
+  private _purchaseSceneUI: SceneUI;
+  private _rouletteAudio: Audio;
+  private _rouletteSceneUI: SceneUI;
+  private _rollableWeaponIds: string[];
+  private _rolledWeaponId: string | undefined;
+
+  public constructor(options: WeaponCrateEntityOptions) {
+    const colliderOptions = Collider.optionsFromModelUri('models/environment/weaponbox.gltf');
+
+    if (colliderOptions.halfExtents) { // make it taller for better interact area
+      colliderOptions.halfExtents.y = 3;
+    }
+
+    super({
+      name: options.name,
+      modelUri: 'models/environment/weaponbox.gltf',
+      rigidBodyOptions: {
+        type: RigidBodyType.FIXED,
+        colliders: [ colliderOptions ]
+      },
+      tintColor: { r: 255, g: 255, b: 255 },
+    });
+
+    this.purchasePrice = options.price;
+    this._rollableWeaponIds = options.rollableWeaponIds;
+
+    this._purchaseSceneUI = new SceneUI({
+      attachedToEntity: this,
+      offset: { x: 0, y: 1, z: 0 },
+      templateId: 'purchase-label',
+      viewDistance: 4,
+      state: {
+        name: this.name,
+        cost: this.purchasePrice,
+      },
+    });
+
+    this._rouletteAudio = new Audio({
+      attachedToEntity: this,
+      uri: 'audio/sfx/roulette.mp3',
+      volume: 0.3,
+      referenceDistance: 4,
+    });
+
+    this._rouletteSceneUI = new SceneUI({
+      attachedToEntity: this,
+      offset: { x: 0, y: 1, z: 0 },
+      templateId: 'weapon-roulette',
+      viewDistance: 4,
+    });
+  }
+
+  public override interact(interactingPlayer: GamePlayerEntity) {
+    if (!this.isSpawned || !this.world) {
+      return;
+    }
+
+    // If interacting and a weapon is rolled, equip it.
+    if (this._rolledWeaponId) {
+      this._rouletteSceneUI.unload();
+      this._purchaseSceneUI.load(this.world);
+
+      const GunClass = this._weaponIdToGunClass(this._rolledWeaponId);
+      if (GunClass) {
+        interactingPlayer.equipGun(new GunClass({ parent: interactingPlayer }));
+      }
+      
+      this._rolledWeaponId = undefined;
+      return;
+    }
+
+    // If interacting and no weapon is rolled, spend $ to roll a weapon.
+    if (!interactingPlayer.spendMoney(this.purchasePrice)) {
+      this.world.chatManager.sendPlayerMessage(interactingPlayer.player, `You don't have enough money to purchase this weapon crate!`, 'FF0000');
+      return;
+    }
+
+    // Unload purchase scene UI
+    this._purchaseSceneUI.unload();
+
+    // Roll a weapon and show roll UI
+    this._rolledWeaponId = this._rollableWeaponIds[Math.floor(Math.random() * this._rollableWeaponIds.length)];
+    this._rouletteSceneUI.setState({
+      selectedWeaponId: this._rolledWeaponId,
+      possibleWeapons: POSSIBLE_WEAPONS,
+    });
+    this._rouletteSceneUI.load(this.world);
+
+    this._rouletteAudio.play(this.world, true);
+  }
+
+  public override spawn(world: World, position: Vector3Like, rotation?: QuaternionLike): void {
+    super.spawn(world, position, rotation);
+
+    // Spawn Scene UI that shows purchase price
+    this._purchaseSceneUI.load(world);
+  }
+
+  private _weaponIdToGunClass(weaponId: string): (new (options: Partial<GunEntityOptions>) => GunEntity) | undefined {
+    switch (weaponId) {
+      case 'ak47': return AK47Entity;
+      case 'ar15': return AR15Entity;
+      case 'auto-pistol': return AutoPistolEntity;
+      case 'auto-shotgun': return AutoShotgunEntity;
+      case 'pistol': return PistolEntity;
+      case 'shotgun': return ShotgunEntity;
+      default: return undefined;
+    }   
+  }
+}

package/examples/zombies-fps/classes/enemies/RipperEntity.ts

@@ -0,0 +1,67 @@
+import { GameServer, PathfindingEntityController } from 'hytopia';
+import type { GamePlayerEntity, QuaternionLike, Vector3Like, World } from 'hytopia';
+
+import EnemyEntity from '../EnemyEntity';
+import type { EnemyEntityOptions } from '../EnemyEntity';
+
+export default class RipperEntity extends EnemyEntity {
+  public constructor(options: Partial<EnemyEntityOptions> = {}) {
+    const speed = options.speed ?? 2;
+    const animation = speed > 6 ? 'animation.ripper_zombie.sprint' : 'animation.ripper_zombie.walk';
+
+    super({
+      damage: options.damage ?? 6,
+      damageAudioUri: options.damageAudioUri ?? 'audio/sfx/entity/zombie/zombie-hurt.mp3',
+      health: options.health ?? 300,
+      idleAudioUri: options.idleAudioUri ?? 'audio/sfx/ripper-idle.mp3',
+      idleAudioVolume: 1,
+      idleAudioReferenceDistance: 8,
+      jumpHeight: options.jumpHeight ?? 2,
+      preferJumping: true,
+      reward: options.reward ?? 300,
+      speed,
+      controller: new PathfindingEntityController(),
+      modelUri: 'models/npcs/ripper-boss.gltf',
+      modelLoopedAnimations: [ animation ],
+      modelScale: 0.5,
+      rigidBodyOptions: {
+        enabledRotations: { x: false, y: true, z: false },
+        ccdEnabled: true,
+      },
+    });
+  }
+
+  public override spawn(world: World, position: Vector3Like, rotation?: QuaternionLike) {
+    super.spawn(world, position, rotation);
+
+    this._updateBossUI({
+      type: 'boss',
+      name: 'BOSS: RIPPER',
+      health: this.health,
+      maxHealth: this.maxHealth,
+      show: true,
+    });
+  }
+
+  public override takeDamage(damage: number, fromPlayer: GamePlayerEntity) {
+    // Do the UI check first, because otherwise
+    // takeDamage can trigger a despawn if health < 0
+    this._updateBossUI({
+      type: 'boss',
+      show: this.health - damage > 0,
+      healthPercent: ((this.health - damage) / this.maxHealth) * 100,
+    });
+
+    super.takeDamage(damage, fromPlayer);
+  }
+
+  private _updateBossUI(data = {}) {
+    if (!this.world) {
+      return;
+    }
+
+    GameServer.instance.playerManager.getConnectedPlayersByWorld(this.world).forEach(player => {
+      player.ui.sendData(data);
+    });
+  }
+}

package/examples/zombies-fps/classes/enemies/ZombieEntity.ts

@@ -0,0 +1,30 @@
+import { PathfindingEntityController } from 'hytopia';
+
+import EnemyEntity from '../EnemyEntity';
+import type { EnemyEntityOptions } from '../EnemyEntity';
+
+export default class ZombieEntity extends EnemyEntity {
+  public constructor(options: Partial<EnemyEntityOptions> = {}) {
+    const speed = options.speed ?? 1 + Math.random() * 4;    
+    const animation = speed > 5 ? 'run' : speed > 3 ? 'walk' : 'crawling';
+
+    super({
+      damage: options.damage ?? 2,
+      damageAudioUri: options.damageAudioUri ?? 'audio/sfx/entity/zombie/zombie-hurt.mp3',
+      health: options.health ?? 7,
+      idleAudioUri: options.idleAudioUri ?? 'audio/sfx/zombie-idle.mp3',
+      jumpHeight: options.jumpHeight ?? 2,
+      reward: options.reward ?? 20,
+      speed: options.speed ?? speed,
+
+      controller: new PathfindingEntityController(),
+      modelUri: 'models/npcs/zombie.gltf',
+      modelLoopedAnimations: [ animation ],
+      modelScale: 0.5 + Math.random() * 0.2,
+      rigidBodyOptions: {
+        enabledRotations: { x: false, y: true, z: false },
+        ccdEnabled: true,
+      },
+    });
+  }
+}