hytopia 0.3.6 → 0.3.7

package/examples/hygrounds/classes/TerrainDamageManager.ts

@@ -0,0 +1,56 @@
+import { Block, Vector3Like, World } from 'hytopia';
+import {
+  BEDROCK_BLOCK_ID,
+  BLOCK_ID_BREAK_DAMAGE,
+  BLOCK_ID_MATERIALS,
+ } from '../gameConfig';
+
+interface BlockDamage {
+  blockId: number;
+  totalDamage: number;
+}
+
+export default class TerrainDamageManager {
+  public static instance: TerrainDamageManager = new TerrainDamageManager();
+
+  private _blockDamages: Map<string, BlockDamage> = new Map();
+
+  private constructor() {}
+
+  public static getBreakMaterialCount(blockId: number): number {
+    return BLOCK_ID_MATERIALS[blockId] ?? BLOCK_ID_MATERIALS.default; 
+  }
+
+  public damageBlock(world: World, block: Block, damage: number): boolean {
+    const coordinateKey = this._coordinateToKey(block.globalCoordinate);
+    let blockDamage = this._blockDamages.get(coordinateKey);
+
+    if (!blockDamage) {
+      const blockId = block.blockType.id;
+
+      if (block.blockType.isLiquid || blockId === BEDROCK_BLOCK_ID) {
+        return false;
+      }
+
+      blockDamage = { blockId, totalDamage: 0 };
+      this._blockDamages.set(coordinateKey, blockDamage);
+    }
+
+    blockDamage.totalDamage += damage;
+
+    const requiredBreakDamage = BLOCK_ID_BREAK_DAMAGE[blockDamage.blockId] ?? BLOCK_ID_BREAK_DAMAGE.default;
+
+    if (blockDamage.totalDamage >= requiredBreakDamage) {
+      world.chunkLattice.setBlock(block.globalCoordinate, 0);
+      this._blockDamages.delete(coordinateKey);
+      
+      return true;
+    }
+
+    return false;
+  }
+
+  private _coordinateToKey(coordinate: Vector3Like): string {
+    return `${coordinate.x},${coordinate.y},${coordinate.z}`;
+  }
+}

package/examples/hygrounds/classes/items/MedPackEntity.ts

@@ -0,0 +1,43 @@
+import { Quaternion } from 'hytopia';
+import ItemEntity from "../ItemEntity";
+import GamePlayerEntity from '../GamePlayerEntity';
+import type { ItemEntityOptions } from "../ItemEntity";
+
+const ADD_HEALTH_AMOUNT = 50;
+
+const DEFAULT_MEDPACK_OPTIONS: ItemEntityOptions = {
+  heldHand: 'right',
+  iconImageUri: 'icons/medpack.png',
+  idleAnimation: 'idle_gun_right',
+  mlAnimation: 'shoot_gun_right',
+  modelUri: 'models/items/medpack.glb',
+  modelScale: 0.4,
+  name: 'Med Pack',
+  consumable: true,
+  consumeAudioUri: 'audio/sfx/medpack-consume.mp3',
+  consumeTimeMs: 1000,
+  quantity: 1,
+}
+
+export default class MedPackEntity extends ItemEntity {
+  public constructor(options: Partial<ItemEntityOptions> = {}) {
+    super({ ...DEFAULT_MEDPACK_OPTIONS, ...options });
+  }
+
+  public override consume(): void {
+    if (!(this.parent instanceof GamePlayerEntity) || this.parent.health >= this.parent.maxHealth) {
+      return;
+    }
+
+    this.parent.updateHealth(ADD_HEALTH_AMOUNT);
+
+    super.consume(); 
+  }
+
+  public override equip(): void {
+    super.equip();
+
+    this.setPosition({ x: 0, y: 0.15, z: 0.3 });
+    this.setRotation(Quaternion.fromEuler(-90, 0, 270));
+  }
+}

package/examples/hygrounds/classes/items/ShieldPotionEntity.ts

@@ -0,0 +1,43 @@
+import { Quaternion } from 'hytopia';
+import ItemEntity from "../ItemEntity";
+import GamePlayerEntity from '../GamePlayerEntity';
+import type { ItemEntityOptions } from "../ItemEntity";
+
+const ADD_SHIELD_AMOUNT = 25;
+
+const DEFAULT_SHIELD_POTION_OPTIONS: ItemEntityOptions = {
+  heldHand: 'right',
+  iconImageUri: 'icons/shield-potion.png',
+  idleAnimation: 'idle_gun_right',
+  mlAnimation: 'shoot_gun_right',
+  modelUri: 'models/items/shield-potion.glb',
+  modelScale: 0.4,
+  name: 'Shield Potion',
+  consumable: true,
+  consumeAudioUri: 'audio/sfx/shield-potion-consume.mp3',
+  consumeTimeMs: 1000,
+  quantity: 1,
+}
+
+export default class ShieldPotionEntity extends ItemEntity {
+  public constructor(options: Partial<ItemEntityOptions> = {}) {
+    super({ ...DEFAULT_SHIELD_POTION_OPTIONS, ...options });
+  }
+
+  public override consume(): void {
+    if (!(this.parent instanceof GamePlayerEntity) || this.parent.shield >= this.parent.maxShield) {
+      return;
+    }
+
+    this.parent.updateShield(ADD_SHIELD_AMOUNT);
+
+    super.consume(); 
+  }
+
+  public override equip(): void {
+    super.equip();
+
+    this.setPosition({ x: 0, y: 0.15, z: -0.2 });
+    this.setRotation(Quaternion.fromEuler(-90, 0, 0));
+  }
+}

package/examples/hygrounds/classes/weapons/AK47Entity.ts

@@ -0,0 +1,43 @@
+import { Quaternion, Vector3Like, QuaternionLike } from 'hytopia';
+import GunEntity from '../GunEntity';
+import type { GunEntityOptions } from '../GunEntity';
+
+const DEFAULT_AK47_OPTIONS: GunEntityOptions = {
+  ammo: 25,
+  damage: 22,
+  fireRate: 5,
+  heldHand: 'both',
+  iconImageUri: 'icons/ak-47.png',
+  idleAnimation: 'idle_gun_both',
+  mlAnimation: 'shoot_gun_both',
+  name: 'AK-47',
+  maxAmmo: 25,
+  totalAmmo: 150,
+  scopeZoom: 2,
+  modelUri: 'models/items/ak-47.glb',
+  modelScale: 1.3,
+  range: 70,
+  reloadAudioUri: 'audio/sfx/rifle-reload.mp3',
+  reloadTimeMs: 2200,
+  shootAudioUri: 'audio/sfx/rifle-shoot.mp3',
+};
+
+export default class AK47Entity extends GunEntity {
+  public constructor(options: Partial<GunEntityOptions> = {}) {
+    super({ ...DEFAULT_AK47_OPTIONS, ...options });
+  }
+
+  public override shoot(): void {
+    if (!this.parent || !this.processShoot()) return;
+
+    super.shoot();
+  }
+
+  public override getMuzzleFlashPositionRotation(): { position: Vector3Like, rotation: QuaternionLike } {
+    return {
+      position: { x: 0, y: 0.01, z: -1.25 },
+      rotation: Quaternion.fromEuler(0, 90, 0),
+    };
+  }
+}
+

package/examples/hygrounds/classes/weapons/AutoShotgunEntity.ts

@@ -0,0 +1,80 @@
+import { Quaternion, Vector3Like, QuaternionLike } from 'hytopia';
+import GunEntity from '../GunEntity';
+import type { GunEntityOptions } from '../GunEntity';
+
+const DEFAULT_AUTO_SHOTGUN_OPTIONS: GunEntityOptions = {
+  ammo: 6,
+  damage: 10,         // Per pellet (7 pellets = 70 max damage)
+  fireRate: 1.5,
+  heldHand: 'both',
+  iconImageUri: 'icons/auto-shotgun.png',
+  idleAnimation: 'idle_gun_both',
+  mlAnimation: 'shoot_gun_both',
+  name: 'Auto Shotgun',
+  maxAmmo: 6,
+  totalAmmo: 30,
+  modelUri: 'models/items/auto-shotgun.glb',
+  modelScale: 1.2,
+  range: 8,
+  reloadAudioUri: 'audio/sfx/shotgun-reload.mp3',
+  reloadTimeMs: 3500,
+  shootAudioUri: 'audio/sfx/shotgun-shoot.mp3',
+};
+
+export default class AutoShotgunEntity extends GunEntity {
+  public constructor(options: Partial<GunEntityOptions> = {}) {
+    super({ ...DEFAULT_AUTO_SHOTGUN_OPTIONS, ...options });
+  }
+
+  public override shoot(): void {
+    if (!this.parent || !this.processShoot()) return;
+
+    super.shoot();
+  }
+
+  public override getMuzzleFlashPositionRotation(): { position: Vector3Like, rotation: QuaternionLike } {
+    return {
+      position: { x: 0.015, y: 0, z: -1 },
+      rotation: Quaternion.fromEuler(0, 90, 0),
+    };
+  }
+
+  public override shootRaycast(origin: Vector3Like, direction: Vector3Like, length: number) {
+    // Create spread pattern for auto-shotgun pellets using angles relative to direction
+    const spreadAngles = [
+      { x: 0, y: 0 },      // Center
+      { x: 0.05, y: 0.05 },  // Upper right
+      { x: -0.05, y: 0.05 }, // Upper left
+      { x: 0.07, y: 0 },   // Right
+      { x: -0.07, y: 0 },  // Left
+      { x: 0.05, y: -0.05 }, // Lower right
+      { x: -0.05, y: -0.05 } // Lower left
+    ];
+
+    // Fire each pellet with spread applied to original direction
+    for (const angle of spreadAngles) {
+      // Calculate spread direction relative to original direction
+      const spreadDirection = {
+        x: direction.x + (direction.z * angle.x), // Add horizontal spread
+        y: direction.y + angle.y,                 // Add vertical spread
+        z: direction.z - (direction.x * angle.x)  // Maintain direction magnitude
+      };
+
+      // Normalize the spread direction to maintain consistent range
+      const magnitude = Math.sqrt(
+        spreadDirection.x * spreadDirection.x + 
+        spreadDirection.y * spreadDirection.y + 
+        spreadDirection.z * spreadDirection.z
+      );
+
+      const normalizedDirection = {
+        x: spreadDirection.x / magnitude,
+        y: spreadDirection.y / magnitude,
+        z: spreadDirection.z / magnitude
+      };
+
+      super.shootRaycast(origin, normalizedDirection, length);
+    }
+  }
+}
+

package/examples/hygrounds/classes/weapons/BoltActionSniperEntity.ts

@@ -0,0 +1,46 @@
+import { Quaternion, Vector3Like, QuaternionLike } from 'hytopia';
+import GunEntity from '../GunEntity';
+import type { GunEntityOptions } from '../GunEntity';
+
+const DEFAULT_BOLT_ACTION_SNIPER_OPTIONS: GunEntityOptions = {
+  ammo: 1,
+  damage: 75,
+  fireRate: 0.5,
+  heldHand: 'both',
+  iconImageUri: 'icons/bolt-action-sniper.png',
+  idleAnimation: 'idle_gun_both',
+  mlAnimation: 'shoot_gun_both',
+  name: 'Bolt Action Sniper',
+  maxAmmo: 1,
+  totalAmmo: 12,
+  scopeZoom: 5,
+  modelUri: 'models/items/bolt-action-sniper.glb',
+  modelScale: 1.3,
+  range: 100,
+  reloadAudioUri: 'audio/sfx/sniper-reload.mp3',
+  reloadTimeMs: 2200,
+  shootAudioUri: 'audio/sfx/sniper-shoot.mp3',
+};
+
+export default class BoltActionSniperEntity extends GunEntity {
+  public constructor(options: Partial<GunEntityOptions> = {}) {
+    super({ ...DEFAULT_BOLT_ACTION_SNIPER_OPTIONS, ...options });
+  }
+
+  public override shoot(): void {
+    if (!this.parent || !this.processShoot()) return;
+
+    super.shoot();
+
+    // It's bolt action, auto reload it 300ms after a shot.
+    setTimeout(() => { this.reload() }, 300);
+  }
+
+  public override getMuzzleFlashPositionRotation(): { position: Vector3Like, rotation: QuaternionLike } {
+    return { // TODO: FIX MUZZLE FLASH POSITION
+      position: { x: 0, y: 0.01, z: -1.25 },
+      rotation: Quaternion.fromEuler(0, 90, 0),
+    };
+  }
+}
+

package/examples/hygrounds/classes/weapons/LightMachineGunEntity.ts

@@ -0,0 +1,43 @@
+import { Quaternion, Vector3Like, QuaternionLike } from 'hytopia';
+import GunEntity from '../GunEntity';
+import type { GunEntityOptions } from '../GunEntity';
+
+const DEFAULT_LIGHT_MACHINE_GUN_OPTIONS: GunEntityOptions = {
+  ammo: 50,
+  damage: 15,
+  fireRate: 10,
+  heldHand: 'both',
+  iconImageUri: 'icons/light-machine-gun.png',
+  idleAnimation: 'idle_gun_both',
+  mlAnimation: 'shoot_gun_both',
+  name: 'Light Machine Gun',
+  maxAmmo: 50,
+  totalAmmo: 300,
+  scopeZoom: 1.5,
+  modelUri: 'models/items/light-machine-gun.glb',
+  modelScale: 1.3,
+  range: 50,
+  reloadAudioUri: 'audio/sfx/machine-gun-reload.mp3',
+  reloadTimeMs: 4200,
+  shootAudioUri: 'audio/sfx/machine-gun-shoot.mp3',
+};
+
+export default class LightMachineGunEntity extends GunEntity {
+  public constructor(options: Partial<GunEntityOptions> = {}) {
+    super({ ...DEFAULT_LIGHT_MACHINE_GUN_OPTIONS, ...options });
+  }
+
+  public override shoot(): void {
+    if (!this.parent || !this.processShoot()) return;
+
+    super.shoot();
+  }
+
+  public override getMuzzleFlashPositionRotation(): { position: Vector3Like, rotation: QuaternionLike } {
+    return {
+      position: { x: 0, y: 0.05, z: -1.7 },
+      rotation: Quaternion.fromEuler(0, 90, 0),
+    };
+  }
+}
+

package/examples/hygrounds/classes/weapons/MiningDrillEntity.ts

@@ -0,0 +1,38 @@
+import { Quaternion } from 'hytopia';
+import MeleeWeaponEntity from '../MeleeWeaponEntity';
+import type { MeleeWeaponEntityOptions } from '../MeleeWeaponEntity';
+
+const DEFAULT_MINING_DRILL_OPTIONS: MeleeWeaponEntityOptions = {
+  damage: 40,
+  attackRate: 5, 
+  heldHand: 'right',
+  iconImageUri: 'icons/mining-drill.png',
+  idleAnimation: 'idle_gun_right',
+  mlAnimation: 'shoot_gun_right', 
+  name: 'Mining Drill',
+  modelUri: 'models/items/mining-drill.glb',
+  modelScale: 0.05,
+  range: 1.5,
+  minesMaterials: true,
+  attackAudioUri: 'audio/sfx/mining-drill-drilling.mp3',
+  hitAudioUri: 'audio/sfx/dig/dig-stone.mp3',
+};
+
+export default class MiningDrillEntity extends MeleeWeaponEntity {
+  public constructor(options: Partial<MeleeWeaponEntityOptions> = {}) {
+    super({ ...DEFAULT_MINING_DRILL_OPTIONS, ...options, tag: 'mining-drill' });
+  }
+
+  public override attack(): void {
+    if (!this.parent || !this.processAttack()) return;
+
+    super.attack();
+  }
+
+  public override equip(): void {
+    super.equip();
+
+    this.setPosition({ x: -0.3, y: 0.5, z: -0.1 });
+    this.setRotation(Quaternion.fromEuler(180, 0, -90));
+  }
+}

package/examples/hygrounds/classes/weapons/PickaxeEntity.ts

@@ -0,0 +1,38 @@
+import { Quaternion } from 'hytopia';
+import MeleeWeaponEntity from '../MeleeWeaponEntity';
+import type { MeleeWeaponEntityOptions } from '../MeleeWeaponEntity';
+
+const DEFAULT_PICKAXE_OPTIONS: MeleeWeaponEntityOptions = {
+  damage: 10,         // 10 hits to kill unshielded
+  attackRate: 4.5,    // Slower attack rate to prevent spam
+  heldHand: 'right',
+  iconImageUri: 'icons/pickaxe.png',
+  idleAnimation: 'idle_gun_right',
+  mlAnimation: 'simple_interact', 
+  name: 'Pickaxe',
+  modelUri: 'models/items/pickaxe.gltf',
+  modelScale: 1.25,
+  range: 2,
+  minesMaterials: true,
+  attackAudioUri: 'audio/sfx/player/player-swing-woosh.mp3',
+  hitAudioUri: 'audio/sfx/dig/dig-stone.mp3',
+};
+
+export default class PickaxeEntity extends MeleeWeaponEntity {
+  public constructor(options: Partial<MeleeWeaponEntityOptions> = {}) {
+    super({ ...DEFAULT_PICKAXE_OPTIONS, ...options, tag: 'pickaxe' });
+  }
+
+  public override attack(): void {
+    if (!this.parent || !this.processAttack()) return;
+
+    super.attack();
+  }
+
+  public override equip(): void {
+    super.equip();
+
+    this.setPosition({ x: 0, y: 0.2, z: 0 });
+    this.setRotation(Quaternion.fromEuler(-90, 0, 90));
+  }
+}

package/examples/hygrounds/classes/weapons/PistolEntity.ts

@@ -0,0 +1,46 @@
+import { Quaternion, Vector3Like, QuaternionLike } from 'hytopia';
+import GunEntity from '../GunEntity';
+import type { GunEntityOptions } from '../GunEntity';
+import type GamePlayerEntity from '../GamePlayerEntity';
+
+const DEFAULT_PISTOL_OPTIONS: GunEntityOptions = {
+  ammo: 15,
+  damage: 18,
+  fireRate: 6,
+  heldHand: 'right',
+  iconImageUri: 'icons/pistol.png',
+  idleAnimation: 'idle_gun_right',
+  mlAnimation: 'shoot_gun_right',
+  name: 'Pistol',
+  maxAmmo: 15,
+  totalAmmo: 75,
+  modelUri: 'models/items/pistol.glb',
+  modelScale: 1.3,
+  range: 30,
+  reloadAudioUri: 'audio/sfx/pistol-reload.mp3',
+  reloadTimeMs: 1500,
+  shootAudioUri: 'audio/sfx/pistol-shoot.mp3',
+};
+
+export default class PistolEntity extends GunEntity {
+  public constructor(options: Partial<GunEntityOptions> = {}) {
+    super({ ...DEFAULT_PISTOL_OPTIONS, ...options });
+  }
+
+  public override shoot(): void {
+    if (!this.parent || !this.processShoot()) return;
+
+    super.shoot();
+    
+    // Cancel input since pistol requires click-to-shoot
+    (this.parent as GamePlayerEntity).player.input.ml = false;
+  }
+
+  public override getMuzzleFlashPositionRotation(): { position: Vector3Like, rotation: QuaternionLike } {
+    return {
+      position: { x: 0.03, y: 0.1, z: -0.5 },
+      rotation: Quaternion.fromEuler(0, 90, 0),
+    };
+  }
+}
+

package/examples/hygrounds/classes/weapons/RocketLauncherEntity.ts

@@ -0,0 +1,186 @@
+import { Audio, Entity, Quaternion, Vector3Like, QuaternionLike, RigidBodyType, EntityEvent, Vector3 } from 'hytopia';
+import GunEntity from '../GunEntity';
+import { BEDROCK_BLOCK_ID } from '../../gameConfig';
+import type { GunEntityOptions } from '../GunEntity';
+import type GamePlayerEntity from '../GamePlayerEntity';
+
+const ROCKET_DESTRUCTION_RADIUS = 4;
+
+const DEFAULT_ROCKET_LAUNCHER_OPTIONS: GunEntityOptions = {
+  ammo: 1,
+  damage: 80,
+  fireRate: 0.8,
+  heldHand: 'right',
+  iconImageUri: 'icons/rocket-launcher.png',
+  idleAnimation: 'idle_gun_right',
+  mlAnimation: 'shoot_gun_right',
+  name: 'Rocket Launcher',
+  maxAmmo: 1,
+  totalAmmo: 5,
+  modelUri: 'models/items/rocket-launcher.glb',
+  modelScale: 1.3,
+  range: 8,
+  reloadAudioUri: 'audio/sfx/rocket-launcher-reload.mp3',
+  reloadTimeMs: 2500,
+  shootAudioUri: 'audio/sfx/rocket-launcher-shoot.mp3',
+};
+
+export default class RocketLauncherEntity extends GunEntity {
+  public constructor(options: Partial<GunEntityOptions> = {}) {
+    super({ ...DEFAULT_ROCKET_LAUNCHER_OPTIONS, ...options });
+  }
+
+  public override shoot(): void {
+    if (!this.parent || !this.processShoot()) return;
+
+    super.shoot();
+    
+    // Cancel input since rocket launcher requires click-to-shoot
+    (this.parent as GamePlayerEntity).player.input.ml = false;
+  }
+
+  public override getMuzzleFlashPositionRotation(): { position: Vector3Like, rotation: QuaternionLike } {
+    return {
+      position: { x: 0.03, y: 0.6, z: -1.5 },
+      rotation: Quaternion.fromEuler(0, 90, 0),
+    };
+  }
+
+  public override equip(): void {
+    super.equip();
+
+    this.setPosition({ x: 0, y: 0.3, z: 0.4 });
+  }
+
+  public override shootRaycast(origin: Vector3Like, direction: Vector3Like, length: number) {
+    // Instead of a raycast, we'll spawn a projectile that on collision with a block or entity explodes
+    // and deals damage and blows up blocks
+    if (!this.parent?.world) {
+      return;
+    }
+
+    const rocketMissileEntity = new Entity({
+      modelUri: 'models/items/rocket-missile.glb',
+      modelScale: 0.75,
+      rigidBodyOptions: {
+        type: RigidBodyType.KINEMATIC_VELOCITY,
+        linearVelocity: { 
+          x: direction.x * 30,
+          y: direction.y * 30,
+          z: direction.z * 30,
+        },
+      }
+    });
+
+    // Create a despawn timer if it doesn't hit
+    setTimeout(() => {
+      if (rocketMissileEntity.isSpawned) {
+        rocketMissileEntity.despawn();
+      }
+    }, 3000);
+
+    // Convert direction vector to quaternion that faces in the direction vector
+    const directionQuat = Quaternion.fromEuler(
+      Math.atan2(-direction.y, Math.sqrt(direction.x * direction.x + direction.z * direction.z)) * 180 / Math.PI,
+      Math.atan2(direction.x, direction.z) * 180 / Math.PI,
+      0
+    );
+
+    rocketMissileEntity.on(EntityEvent.BLOCK_COLLISION, ({ blockType, colliderHandleA, colliderHandleB }) => {
+      if (!this.parent?.world || !rocketMissileEntity.isSpawned || blockType.isLiquid) {
+        return;
+      }
+
+      const { world } = this.parent;
+      const contactManifold = world.simulation.getContactManifolds(colliderHandleA, colliderHandleB)[0];
+
+      if (!contactManifold) {
+        return;
+      }
+
+      const contactPoint = contactManifold.contactPoints[0];
+      const contactCoordinate = {
+        x: Math.floor(contactPoint.x),
+        y: Math.floor(contactPoint.y), 
+        z: Math.floor(contactPoint.z)
+      };
+
+      // Deal damage to nearby players
+      this.parent.world.entityManager.getAllPlayerEntities().forEach(playerEntity => {
+        const playerPos = Vector3.fromVector3Like(playerEntity.position);
+        const contactPos = Vector3.fromVector3Like(contactPoint);
+        const distance = playerPos.distance(contactPos);
+
+        if (distance <= ROCKET_DESTRUCTION_RADIUS) {
+          (playerEntity as GamePlayerEntity).takeDamage(this.damage, direction, this.parent as GamePlayerEntity);
+        }
+      });
+      
+      // Break blocks
+      for (let dx = -ROCKET_DESTRUCTION_RADIUS; dx <= ROCKET_DESTRUCTION_RADIUS; dx++) {
+        for (let dy = -ROCKET_DESTRUCTION_RADIUS; dy <= ROCKET_DESTRUCTION_RADIUS; dy++) {
+          for (let dz = -ROCKET_DESTRUCTION_RADIUS; dz <= ROCKET_DESTRUCTION_RADIUS; dz++) {
+            // Calculate distance from center of explosion
+            const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+            
+            // Only destroy blocks within the spherical radius
+            if (distance > ROCKET_DESTRUCTION_RADIUS) {
+              continue;
+            }
+
+            const coordinate = {
+              x: contactCoordinate.x + dx,
+              y: contactCoordinate.y + dy,
+              z: contactCoordinate.z + dz
+            }
+
+            // do not destroy bedrock!
+            if (world.chunkLattice.getBlockId(coordinate) !== BEDROCK_BLOCK_ID) {
+              world.chunkLattice.setBlock(coordinate, 0);
+            }
+          }
+        }
+      }
+
+      // Explosion Visual
+      const explosionEntity = new Entity({
+        modelUri: 'models/environment/explosion.glb',
+        modelScale: 0.2,
+        rigidBodyOptions: { type: RigidBodyType.KINEMATIC_POSITION },
+      });
+
+      const explosionDirectionQuat = Quaternion.fromEuler(
+        Math.atan2(-direction.y, Math.sqrt(direction.x * direction.x + direction.z * direction.z)) * 180 / Math.PI + 90,
+        Math.atan2(direction.x, direction.z) * 180 / Math.PI + 180, // Add 180 degrees to invert direction
+        0
+      );
+
+      explosionEntity.spawn(world, contactPoint, explosionDirectionQuat);
+      explosionEntity.setCollisionGroupsForSolidColliders({ 
+        belongsTo: [],
+        collidesWith: [],
+      })
+
+      const explosionEffectInterval = setInterval(() => {
+        if (explosionEntity.opacity <= 0) {
+          explosionEntity.despawn();
+          clearInterval(explosionEffectInterval);
+          return;
+        }
+
+        explosionEntity.setOpacity(explosionEntity.opacity - 0.1);
+      }, 100);
+
+      // Explosion Audio
+      (new Audio({
+        uri: 'audio/sfx/rocket-launcher-explosion.mp3',
+        referenceDistance: 20,
+        volume: 0.4,
+      })).play(world);
+
+      rocketMissileEntity.despawn();
+    });
+    
+    rocketMissileEntity.spawn(this.parent.world, origin, directionQuat);
+  }
+}