hytopia 0.3.6 → 0.3.8

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

@@ -0,0 +1,195 @@
+import { Audio, CollisionGroup, Entity, Quaternion, Vector3Like, QuaternionLike, RigidBodyType, EntityEvent, Vector3, Collider } 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,
+        colliders: [
+          {
+            ...Collider.optionsFromModelUri('models/items/rocket-missile.glb', 0.75),
+            collisionGroups: {
+              belongsTo: [ CollisionGroup.ENTITY ],
+              collidesWith: [ CollisionGroup.BLOCK ],
+            }
+          },
+        ],
+        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);
+  }
+}

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

@@ -0,0 +1,84 @@
+import { Quaternion, Vector3Like, QuaternionLike } from 'hytopia';
+import GunEntity from '../GunEntity';
+import type { GunEntityOptions } from '../GunEntity';
+import type GamePlayerEntity from '../GamePlayerEntity';
+
+const DEFAULT_SHOTGUN_OPTIONS: GunEntityOptions = {
+  ammo: 4,
+  damage: 13,
+  fireRate: 0.8,
+  heldHand: 'both',
+  iconImageUri: 'icons/shotgun.png',
+  idleAnimation: 'idle_gun_both',
+  mlAnimation: 'shoot_gun_both',
+  name: 'Shotgun',
+  maxAmmo: 4,
+  totalAmmo: 24,
+  modelUri: 'models/items/shotgun.glb',
+  modelScale: 1.2,
+  range: 8,
+  reloadAudioUri: 'audio/sfx/shotgun-reload.mp3',
+  reloadTimeMs: 3000,
+  shootAudioUri: 'audio/sfx/shotgun-shoot.mp3',
+};
+
+export default class ShotgunEntity extends GunEntity {
+  public constructor(options: Partial<GunEntityOptions> = {}) {
+    super({ ...DEFAULT_SHOTGUN_OPTIONS, ...options });
+  }
+
+  public override shoot(): void {
+    if (!this.parent || !this.processShoot()) return;
+
+    super.shoot();
+    
+    // Cancel input since shotgun 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: -1.5 },
+      rotation: Quaternion.fromEuler(0, 90, 0),
+    };
+  }
+
+  public override shootRaycast(origin: Vector3Like, direction: Vector3Like, length: number) {
+    // Create spread pattern for 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/SubmachineGunEntity.ts

@@ -0,0 +1,43 @@
+import { Quaternion, Vector3Like, QuaternionLike } from 'hytopia';
+import GunEntity from '../GunEntity';
+import type { GunEntityOptions } from '../GunEntity';
+
+const DEFAULT_SUBMACHINE_GUN_OPTIONS: GunEntityOptions = {
+  ammo: 60,
+  damage: 6,
+  fireRate: 12,
+  heldHand: 'right',
+  iconImageUri: 'icons/submachine-gun.png',
+  idleAnimation: 'idle_gun_right',
+  mlAnimation: 'shoot_gun_right',
+  name: 'Submachine Gun',
+  maxAmmo: 60,
+  totalAmmo: 240,
+  scopeZoom: 1.35,
+  modelUri: 'models/items/submachine-gun.glb',
+  modelScale: 1.3,
+  range: 35,
+  reloadAudioUri: 'audio/sfx/rifle-reload.mp3',
+  reloadTimeMs: 1500,
+  shootAudioUri: 'audio/sfx/pistol-shoot.mp3',
+};
+
+export default class SubmachineGunEntity extends GunEntity {
+  public constructor(options: Partial<GunEntityOptions> = {}) {
+    super({ ...DEFAULT_SUBMACHINE_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: -0.95 },
+      rotation: Quaternion.fromEuler(0, 90, 0),
+    };
+  }
+}
+