hytopia 0.3.6 → 0.3.7

package/examples/hygrounds/classes/GunEntity.ts

@@ -0,0 +1,263 @@
+import {
+  Audio,
+  Entity,
+  Vector3Like,
+  Quaternion,
+  QuaternionLike,
+  World,
+} from 'hytopia';
+
+import GamePlayerEntity from './GamePlayerEntity';
+import ItemEntity from './ItemEntity';
+import TerrainDamageManager from './TerrainDamageManager';
+import type { ItemEntityOptions } from './ItemEntity';
+
+export type GunHand = 'left' | 'right' | 'both';
+
+export interface GunEntityOptions extends ItemEntityOptions {
+  ammo: number;              // The amount of ammo in the clip.
+  damage: number;            // The damage of the gun.
+  fireRate: number;          // Bullets shot per second.
+  maxAmmo: number;           // The amount of ammo the clip can hold.
+  totalAmmo: number;         // The amount of ammo remaining for this gun.
+  range: number;             // The max range bullets travel for raycast hits
+  reloadAudioUri: string;    // The audio played when reloading
+  reloadTimeMs: number;      // Seconds to reload.
+  shootAudioUri: string;     // The audio played when shooting
+  scopeZoom?: number;         // The zoom level when scoped in.
+}
+
+export default abstract class GunEntity extends ItemEntity {
+  protected readonly damage: number;
+  protected readonly fireRate: number;
+  protected readonly maxAmmo: number;
+  protected readonly range: number;
+  protected readonly reloadTimeMs: number;
+  protected readonly scopeZoom: number = 1;
+
+  protected ammo: number;
+  protected totalAmmo: number;
+  private _lastFireTime: number = 0;
+  private _muzzleFlashChildEntity: Entity | undefined;
+  private _reloadAudio: Audio;
+  private _reloading: boolean = false;
+  private _shootAudio: Audio;
+
+  public constructor(options: GunEntityOptions) {
+    if (!options.modelUri) {
+      throw new Error('GunEntity requires modelUri');
+    }
+
+    super(options);
+
+    this.ammo = options.ammo;
+    this.damage = options.damage;
+    this.fireRate = options.fireRate;
+    this.maxAmmo = options.maxAmmo;
+    this.totalAmmo = options.totalAmmo;
+    this.range = options.range;
+    this.reloadTimeMs = options.reloadTimeMs;
+    this.scopeZoom = options.scopeZoom ?? 1;
+
+    this._reloadAudio = new Audio({
+      attachedToEntity: this,
+      uri: options.reloadAudioUri,  
+    });
+
+    this._shootAudio = new Audio({
+      attachedToEntity: this,
+      uri: options.shootAudioUri,
+      volume: 0.3,
+      referenceDistance: 8,
+    });
+  }
+
+  public override equip(): void {
+    if (!this.world) return;
+    
+    super.equip();
+    
+    this.setPosition({ x: 0, y: 0, z: -0.2 });
+    this.setRotation(Quaternion.fromEuler(-90, 0, 0));
+    this._reloadAudio.play(this.world, true);
+
+  }
+
+  public override unequip(): void {
+    super.unequip();
+
+    // reset any scope zoom
+    const player = this.parent as GamePlayerEntity;
+    this.zoomScope(true);
+  }
+
+  public override spawn(world: World, position: Vector3Like, rotation?: QuaternionLike): void {
+    super.spawn(world, position, rotation);
+
+    this._createMuzzleFlash();
+  }
+
+  public override getQuantity(): number {
+    return this.totalAmmo;
+  }
+
+  public reload(): void {
+    if (!this.parent?.world || this._reloading || !this.totalAmmo) return;
+    this._startReload();
+    this._reloadAudio.play(this.parent.world, true);
+
+    setTimeout(() => this._finishReload(), this.reloadTimeMs);
+  }
+
+  public abstract getMuzzleFlashPositionRotation(): { position: Vector3Like, rotation: QuaternionLike };
+
+  public shoot(): void {
+    if (!this.parent?.world) return;
+
+    const player = this.parent as GamePlayerEntity;
+    const { origin, direction } = this.getShootOriginDirection();
+    
+    this._performShootEffects(player);
+    this.shootRaycast(origin, direction, this.range);
+    this._updateUI(player);
+  }
+
+  public zoomScope(reset: boolean = false): void {
+    if (!this.parent?.world || this.scopeZoom === 1) return;
+
+    const player = this.parent as GamePlayerEntity;
+    const zoom = player.player.camera.zoom === 1 && !reset ? this.scopeZoom : 1;
+
+    player.player.camera.setZoom(zoom);
+    player.player.ui.sendData({
+      type: 'scope-zoom',
+      zoom,
+    });
+  }
+
+  protected getShootOriginDirection(): { origin: Vector3Like, direction: Vector3Like } {
+    const player = this.parent as GamePlayerEntity;
+    const { x, y, z } = player.position;
+    const cameraYOffset = player.player.camera.offset.y;    
+    const direction = player.player.camera.facingDirection;
+    
+    return {
+      origin: {
+        x: x + (direction.x * 0.5),
+        y: y + (direction.y * 0.5) + cameraYOffset,
+        z: z + (direction.z * 0.5),
+      },
+      direction
+    };
+  }
+
+  protected processShoot(): boolean {
+    if (this.totalAmmo <= 0 || this._reloading) return false;
+
+    const now = performance.now();
+    if (this._lastFireTime && now - this._lastFireTime < 1000 / this.fireRate) return false;
+
+    if (this.ammo <= 0) {
+      this.reload();
+      return false;
+    }
+
+    this.ammo--;
+    this.totalAmmo--;
+    this._lastFireTime = now;
+
+    return true;
+  }
+
+  protected shootRaycast(origin: Vector3Like, direction: Vector3Like, length: number): void {
+    if (!this.parent?.world) return;
+   
+    const { world } = this.parent;
+    const raycastHit = this.parent.world.simulation.raycast(origin, direction, length, {
+      filterExcludeRigidBody: this.parent.rawRigidBody,
+    });
+
+    if (raycastHit?.hitBlock) {
+      TerrainDamageManager.instance.damageBlock(world, raycastHit.hitBlock, this.damage);
+    }
+
+    if (raycastHit?.hitEntity) {
+      this._handleHitEntity(raycastHit.hitEntity, direction);
+    }
+  }
+
+  private _createMuzzleFlash(): void {
+    if (!this.isSpawned || !this.world) return;
+
+    this._muzzleFlashChildEntity = new Entity({
+      parent: this,
+      modelUri: 'models/environment/muzzle-flash.gltf',
+      modelScale: 0.5,
+      opacity: 0,
+    });
+
+    const { position, rotation } = this.getMuzzleFlashPositionRotation();
+    this._muzzleFlashChildEntity.spawn(this.world, position, rotation);
+  }
+
+  private _startReload(): void {
+    this.ammo = 0;
+    this._reloading = true;
+    this.updateAmmoIndicatorUI(true);
+  }
+
+  private _finishReload(): void {
+    this._reloading = false;
+
+    // prevent reloads if they swapped active item mid reload.
+    if (!this.parent || !(this.parent as GamePlayerEntity).isItemActiveInInventory(this)) return;
+
+    this.ammo = Math.min(this.maxAmmo, this.totalAmmo);
+    this.updateAmmoIndicatorUI();
+  }
+
+  private _performShootEffects(player: GamePlayerEntity): void {
+    player.startModelOneshotAnimations([ this.mlAnimation ]);
+    this._showMuzzleFlash();
+    this._shootAudio.play(this.parent!.world!, true);
+  }
+
+  private _showMuzzleFlash(): void {
+    if (!this._muzzleFlashChildEntity) return;
+
+    this._muzzleFlashChildEntity.setOpacity(1);
+    setTimeout(() => {
+      if (this.isSpawned && this._muzzleFlashChildEntity?.isSpawned) {
+        this._muzzleFlashChildEntity.setOpacity(0);
+      }
+    }, 35);
+  }
+
+  private _updateUI(player: GamePlayerEntity): void {
+    player.updateItemInventoryQuantity(this);
+    this.updateAmmoIndicatorUI();
+  }
+
+  protected _handleHitEntity(hitEntity: Entity, hitDirection: Vector3Like): void {
+    if (!(hitEntity instanceof GamePlayerEntity) || hitEntity.isDead) return;
+
+    const attacker = this.parent as GamePlayerEntity;
+
+    attacker.dealtDamage(this.damage);
+    hitEntity.takeDamage(this.damage, hitDirection, attacker);
+  }
+
+  public updateAmmoIndicatorUI(reloading: boolean = false): void {
+    const player = this.parent as GamePlayerEntity;
+
+    player.player.ui.sendData(reloading ? {
+      type: 'ammo-indicator',
+      reloading: true,
+    } : {
+      type: 'ammo-indicator',
+      ammo: this.ammo,
+      totalAmmo: this.totalAmmo,
+      show: true,
+    });
+  }
+}

package/examples/hygrounds/classes/ItemEntity.ts

@@ -0,0 +1,225 @@
+import {
+  Audio,
+  Collider,
+  CollisionGroup,
+  Entity,
+  EntityOptions,
+  PlayerEntityController,
+  QuaternionLike,
+  SceneUI,
+  Vector3Like,
+  World,
+} from 'hytopia';
+
+import GamePlayerEntity from './GamePlayerEntity';
+import { ITEM_DESPAWN_TIME_MS } from '../gameConfig';
+
+const INVENTORIED_POSITION = { x: 0, y: -300, z: 0 };
+
+export type HeldHand = 'left' | 'right' | 'both';
+
+export interface ItemEntityOptions extends EntityOptions {
+  heldHand: HeldHand;    // The hand the item is held in.
+  iconImageUri: string;  // The image uri of the weapon icon.
+  idleAnimation: string; // The animation played when the player holding it is idle.
+  mlAnimation: string;   // The animation played when the player holding it clicks the left mouse button.
+  quantity?: number;
+  consumable?: boolean;
+  consumeAudioUri?: string;
+  consumeTimeMs?: number;
+}
+
+export default class ItemEntity extends Entity {
+  public readonly consumable: boolean;
+  public quantity: number;
+  public readonly heldHand: HeldHand;
+  public readonly iconImageUri: string;
+  protected readonly consumeAudioUri: string | undefined;
+  protected readonly consumeTimeMs: number;
+  protected readonly idleAnimation: string;
+  protected readonly mlAnimation: string;
+  private _despawnTimer: NodeJS.Timeout | undefined;
+  private readonly _labelSceneUI: SceneUI;
+
+  public constructor(options: ItemEntityOptions) {
+    if (!options.modelUri && !options.blockHalfExtents) {
+      throw new Error('ItemEntity requires either modelUri or blockHalfExtents');
+    }
+
+    const colliderOptions = options.modelUri
+      ? Collider.optionsFromModelUri(options.modelUri)
+      : Collider.optionsFromBlockHalfExtents(options.blockHalfExtents!);
+
+
+    super({
+      ...options,
+      parentNodeName: ItemEntity._getHandAnchorNode(options.heldHand),
+      rigidBodyOptions: ItemEntity._createRigidBodyOptions(colliderOptions, options.modelScale ?? 1),
+    });
+
+    this.consumable = options.consumable ?? false;
+    this.consumeAudioUri = options.consumeAudioUri;
+    this.consumeTimeMs = options.consumeTimeMs ?? 0;
+    this.quantity = options.quantity ?? -1;
+    this.heldHand = options.heldHand;
+    this.iconImageUri = options.iconImageUri;
+    this.idleAnimation = options.idleAnimation;
+    this.mlAnimation = options.mlAnimation;
+
+    this._labelSceneUI = this._createLabelUI();
+      
+    if (options.parent) {
+      this.setParentAnimations();
+    }
+  }
+
+  public consume(): void {
+    if (!this.consumable || !this.consumeAudioUri || this.quantity <= 0 || !this.parent || !this.world) return;
+
+    if (!(this.parent instanceof GamePlayerEntity)) {
+      return;
+    }
+
+    this.parent.player.input.ml = false;
+
+    this.quantity--;
+
+    this.parent.updateItemInventoryQuantity(this);
+    
+    if (!this.quantity) {
+      this.parent.dropActiveInventoryItem();
+      setTimeout(() => {
+        this.despawn();
+      }, 0);
+    }
+
+    (new Audio({
+      attachedToEntity: this.parent,
+      uri: this.consumeAudioUri,
+      volume: 0.5,
+      referenceDistance: 5,
+    })).play(this.world);
+
+  }
+
+  public drop(fromPosition: Vector3Like, direction: Vector3Like): void {
+    if (!this.world) return;
+
+    this.startDespawnTimer();
+
+    this.setParent(undefined, undefined, fromPosition);
+
+    // Apply impulse in next tick to avoid physics issues
+    setTimeout(() => {
+      this.applyImpulse({
+        x: direction.x * this.mass * 7,
+        y: direction.y * this.mass * 15,
+        z: direction.z * this.mass * 7,
+      });
+    }, 0);
+
+    this._updateVisualEffects();
+  }
+
+  public equip() {
+    this.setPosition({ x: 0, y: 0, z: 0 });
+    this.setParentAnimations();
+  }
+
+  public unequip() {
+    this.setPosition(INVENTORIED_POSITION);
+
+    if (this.parent instanceof GamePlayerEntity) {
+      this.parent.resetAnimations();
+    }
+  }
+  
+  public getQuantity(): number {
+    return this.quantity;
+  }
+
+  public pickup(player: GamePlayerEntity): void {
+    if (!player.world) return;
+
+    this.stopDespawnTimer();
+
+    this.setParent(player, ItemEntity._getHandAnchorNode(this.heldHand), INVENTORIED_POSITION);
+    this._updateVisualEffects();
+    
+    player.addItemToInventory(this);
+  }
+
+  public setParentAnimations(): void {
+    if (!this.parent || !this.parent.world || !(this.parent instanceof GamePlayerEntity)) return;
+
+    const controller = this.parent.controller as PlayerEntityController;
+    controller.idleLoopedAnimations = [ this.idleAnimation, 'idle_lower' ];
+    controller.walkLoopedAnimations = [ this.idleAnimation, 'walk_lower' ];
+    controller.runLoopedAnimations = [ this.idleAnimation, 'run_lower' ];
+  }
+
+  public override spawn(world: World, position: Vector3Like, rotation?: QuaternionLike): void {
+    super.spawn(world, position, rotation);
+    this._updateVisualEffects(); 
+  }
+
+  public startDespawnTimer(): void {
+    if (this._despawnTimer) return;
+
+    this._despawnTimer = setTimeout(() => {
+      this.despawn();
+    }, ITEM_DESPAWN_TIME_MS);
+  }
+
+  public stopDespawnTimer(): void {
+    if (!this._despawnTimer) return;
+
+    clearTimeout(this._despawnTimer);
+    this._despawnTimer = undefined;
+  }
+
+  private _createLabelUI(): SceneUI {
+    return new SceneUI({
+      attachedToEntity: this,
+      templateId: 'item-label',
+      state: { name: this.name, quantity: this.getQuantity() },
+      viewDistance: 8,
+      offset: { x: 0, y: 1, z: 0 },
+    });
+  }
+
+  private _updateVisualEffects(): void {
+    if (!this.world) return;
+
+    if (!this.parent) {
+      this._labelSceneUI.setState({ quantity: this.getQuantity() });
+      this._labelSceneUI.load(this.world);
+    } else {
+      this._labelSceneUI.unload();
+    }
+  }
+
+  private static _getHandAnchorNode(heldHand: HeldHand): string {
+    return heldHand === 'left' ? 'hand_left_anchor' : 'hand_right_anchor';
+  }
+
+  private static _createRigidBodyOptions(colliderOptions: any, modelScale: number) {
+    return {
+      enabledRotations: { x: false, y: true, z: false },
+      colliders: [{
+        ...colliderOptions,
+        collisionGroups: {
+          belongsTo: [ CollisionGroup.ENTITY ],
+          collidesWith: [ CollisionGroup.BLOCK ],
+        },
+        halfExtents: colliderOptions.halfExtents ? {
+          x: colliderOptions.halfExtents.x * modelScale,
+          y: colliderOptions.halfExtents.y * modelScale * 1.5,
+          z: colliderOptions.halfExtents.z * modelScale,
+        } : undefined,
+        halfHeight: colliderOptions.halfHeight ? colliderOptions.halfHeight * modelScale * 1.5 : undefined,
+        radius: colliderOptions.radius ? colliderOptions.radius * modelScale * 1.5 : undefined,
+      }]
+    };
+  }
+}

package/examples/hygrounds/classes/ItemFactory.ts

@@ -0,0 +1,49 @@
+
+export default class ItemFactory {
+  public static async createItem(itemId: string) {
+    let itemModule
+
+    // We do imports here to avoid circular dependencies
+    // We should really just refactor import patterns,
+    // but this is a quick fix for now.
+    switch(itemId) {
+      case 'ak47':
+        itemModule = await import('./weapons/AK47Entity');
+        break;
+      case 'auto-shotgun':
+        itemModule = await import('./weapons/AutoShotgunEntity');
+        break;
+      case 'bolt-action-sniper':
+        itemModule = await import('./weapons/BoltActionSniperEntity');
+        break;
+      case 'light-machine-gun':
+        itemModule = await import('./weapons/LightMachineGunEntity');
+        break;
+      case 'medpack':
+        itemModule = await import('./items/MedPackEntity');
+        break;
+      case 'mining-drill':
+        itemModule = await import('./weapons/MiningDrillEntity');
+        break;
+      case 'pistol':
+        itemModule = await import('./weapons/PistolEntity');
+        break;
+      case 'rocket-launcher':
+        itemModule = await import('./weapons/RocketLauncherEntity');
+        break;
+      case 'shotgun':
+        itemModule = await import('./weapons/ShotgunEntity');
+        break;
+      case 'shield-potion':
+        itemModule = await import('./items/ShieldPotionEntity');
+        break;
+      default:
+        throw new Error(`Unknown chest item id: ${itemId}`);
+    }
+
+    const itemClass = itemModule.default;
+    const item = new itemClass();
+
+    return item;
+  }
+}

package/examples/hygrounds/classes/MeleeWeaponEntity.ts

@@ -0,0 +1,138 @@
+import {
+  Audio,
+  Entity,
+  Quaternion,
+  RaycastHit,
+  Vector3Like,
+} from 'hytopia';
+
+import GamePlayerEntity from './GamePlayerEntity';
+import ItemEntity from './ItemEntity';
+import TerrainDamageManager from './TerrainDamageManager';
+import type { ItemEntityOptions } from './ItemEntity';
+
+export interface MeleeWeaponEntityOptions extends ItemEntityOptions {
+  damage: number;           // The damage dealt by the weapon
+  attackRate: number;       // Attacks per second
+  range: number;            // The range of the melee attack
+  attackAudioUri: string;   // The audio played when attacking
+  hitAudioUri: string;      // The audio played when hitting an entity or block
+  minesMaterials: boolean;     // Whether the weapon mines materials when it hits a block
+}
+
+export default abstract class MeleeWeaponEntity extends ItemEntity {
+  protected readonly damage: number;
+  protected readonly attackRate: number;
+  protected readonly range: number;
+  protected readonly minesMaterials: boolean;
+
+  private _lastAttackTime: number = 0;
+  private _attackAudio: Audio;
+  private _hitAudio: Audio;
+
+  public constructor(options: MeleeWeaponEntityOptions) {
+    super(options);
+
+    this.damage = options.damage;
+    this.attackRate = options.attackRate;
+    this.range = options.range;
+    this.minesMaterials = options.minesMaterials;
+
+    this._attackAudio = new Audio({
+      attachedToEntity: this,
+      uri: options.attackAudioUri,
+      volume: 0.3,
+      referenceDistance: 3,
+    });
+
+    this._hitAudio = new Audio({
+      attachedToEntity: this,
+      uri: options.hitAudioUri,
+      volume: 0.3,
+      referenceDistance: 3,
+    });
+  }
+
+  public override equip(): void {
+    if (!this.world) return;
+    
+    super.equip();
+    
+    this.setRotation(Quaternion.fromEuler(-90, 0, 0));
+  }
+
+  public attack(): void {
+    if (!this.parent?.world) return;
+
+    const player = this.parent as GamePlayerEntity;
+    const { origin, direction } = this.getAttackOriginDirection();
+    
+    this._performAttackEffects(player);
+    this.attackRaycast(origin, direction, this.range);
+  }
+
+  protected getAttackOriginDirection(): { origin: Vector3Like, direction: Vector3Like } {
+    const player = this.parent as GamePlayerEntity;
+    const { x, y, z } = player.position;
+    const cameraYOffset = player.player.camera.offset.y;    
+    const direction = player.player.camera.facingDirection;
+
+    return {
+      origin: { x, y: y + cameraYOffset, z },
+      direction
+    };
+  }
+
+  protected processAttack(): boolean {
+    const now = performance.now();
+    if (this._lastAttackTime && now - this._lastAttackTime < 1000 / this.attackRate) return false;
+
+    this._lastAttackTime = now;
+    return true;
+  }
+
+  protected attackRaycast(origin: Vector3Like, direction: Vector3Like, length: number): RaycastHit | null | undefined {
+    if (!this.parent?.world) return;
+   
+    const { world } = this.parent;
+    const raycastHit = world.simulation.raycast(origin, direction, length, {
+      filterExcludeRigidBody: this.parent.rawRigidBody,
+    });
+
+    if (raycastHit?.hitBlock) {
+      const brokeBlock = TerrainDamageManager.instance.damageBlock(world, raycastHit.hitBlock, this.damage);
+
+      if (this.minesMaterials && brokeBlock) {
+        const player = this.parent as GamePlayerEntity;
+        const blockId = raycastHit.hitBlock.blockType.id;
+        const materialCount = TerrainDamageManager.getBreakMaterialCount(blockId);
+
+        player.addMaterial(materialCount);
+      }
+    }
+
+    if (raycastHit?.hitEntity) {
+      this._handleHitEntity(raycastHit.hitEntity, direction);
+    }
+
+    if (raycastHit?.hitBlock || raycastHit?.hitEntity) {
+      this._hitAudio.play(world, true);
+    }
+
+    return raycastHit;
+  }
+
+  private _performAttackEffects(player: GamePlayerEntity): void {
+    player.startModelOneshotAnimations([ this.mlAnimation ]);
+    this._attackAudio.play(this.parent!.world!, true);
+  }
+
+  protected _handleHitEntity(hitEntity: Entity, hitDirection: Vector3Like): void {
+    if (!(hitEntity instanceof GamePlayerEntity) || hitEntity.isDead) return;
+    
+    const attacker = this.parent as GamePlayerEntity;
+
+    attacker.dealtDamage(this.damage);
+    hitEntity.takeDamage(this.damage, hitDirection, attacker);
+  }
+}