Upload src/engine/mobs/mobSystem.ts with huggingface_hub

src/engine/mobs/mobSystem.ts

@@ -0,0 +1,578 @@
+/**
+ * Mob System — Minecraft Clone
+ *
+ * Manages mob spawning, AI behavior, movement, and despawning.
+ * Supports both hostile and passive mob types across dimensions.
+ */
+
+import {
+  BLOCK_AIR,
+  BLOCK_GRASS_BLOCK,
+  BLOCK_NETHERRACK,
+  BLOCK_SOUL_SAND,
+  BLOCK_CRIMSON_NYLIUM,
+  BLOCK_WARPED_NYLIUM,
+  BLOCK_END_STONE,
+  BLOCK_BASALT,
+  BLOCK_LAVA,
+  BLOCK_WATER,
+  MOB_CAP_HOSTILE,
+  MOB_CAP_PASSIVE,
+  SPAWN_RADIUS_MIN,
+  SPAWN_RADIUS_MAX,
+} from '../constants'
+
+// ═══════════════════════════════════════════════════════════════
+// MOB TYPES & INTERFACES
+// ═══════════════════════════════════════════════════════════════
+
+export type MobType =
+  | 'zombie'
+  | 'skeleton'
+  | 'creeper'
+  | 'spider'
+  | 'pig'
+  | 'cow'
+  | 'sheep'
+  | 'chicken'
+  | 'enderman'
+
+export interface Mob {
+  id: string
+  type: MobType
+  position: [number, number, number]
+  velocity: [number, number, number]
+  rotation: number // yaw in degrees
+  health: number
+  maxHealth: number
+  hostile: boolean
+  attackDamage: number
+  speed: number
+  spawnTime: number
+  onGround: boolean
+  attackCooldown: number
+  wanderAngle: number
+  wanderTimer: number
+  hurtTimer: number
+  dimension: 'overworld' | 'nether' | 'end'
+}
+
+interface MobStats {
+  health: number
+  damage: number
+  speed: number
+  hostile: boolean
+  dimensions: 'overworld' | 'nether' | 'end' | 'any'
+}
+
+// ═══════════════════════════════════════════════════════════════
+// MOB STATS TABLE
+// ═══════════════════════════════════════════════════════════════
+
+const MOB_STATS: Record<MobType, MobStats> = {
+  zombie:   { health: 20, damage: 3, speed: 2.0, hostile: true,  dimensions: 'any' },
+  skeleton: { health: 20, damage: 2, speed: 2.0, hostile: true,  dimensions: 'any' },
+  creeper:  { health: 20, damage: 0, speed: 1.5, hostile: true,  dimensions: 'any' },
+  spider:   { health: 16, damage: 2, speed: 2.5, hostile: true,  dimensions: 'any' },
+  pig:      { health: 10, damage: 0, speed: 1.5, hostile: false, dimensions: 'overworld' },
+  cow:      { health: 10, damage: 0, speed: 1.5, hostile: false, dimensions: 'overworld' },
+  sheep:    { health: 8,  damage: 0, speed: 1.5, hostile: false, dimensions: 'overworld' },
+  chicken:  { health: 4,  damage: 0, speed: 1.2, hostile: false, dimensions: 'overworld' },
+  enderman: { health: 40, damage: 7, speed: 3.0, hostile: true,  dimensions: 'end' },
+}
+
+// ═══════════════════════════════════════════════════════════════
+// UTILITY
+// ═══════════════════════════════════════════════════════════════
+
+let mobIdCounter = 0
+
+function generateMobId(): string {
+  return `mob_${++mobIdCounter}_${Date.now()}`
+}
+
+function distance3d(a: [number, number, number], b: [number, number, number]): number {
+  const dx = a[0] - b[0]
+  const dy = a[1] - b[1]
+  const dz = a[2] - b[2]
+  return Math.sqrt(dx * dx + dy * dy + dz * dz)
+}
+
+function distance2d(a: [number, number, number], b: [number, number, number]): number {
+  const dx = a[0] - b[0]
+  const dz = a[2] - b[2]
+  return Math.sqrt(dx * dx + dz * dz)
+}
+
+function lerp(a: number, b: number, t: number): number {
+  return a + (b - a) * t
+}
+
+/** Check if a block is solid (non-air, non-liquid) for collision purposes */
+function isSolidBlock(blockId: number): boolean {
+  return blockId !== BLOCK_AIR && blockId !== BLOCK_LAVA && blockId !== BLOCK_WATER
+}
+
+// ═══════════════════════════════════════════════════════════════
+// MOB SYSTEM CLASS
+// ═══════════════════════════════════════════════════════════════
+
+export class MobSystem {
+  mobs: Map<string, Mob>
+  private spawnTimer: number
+  private currentDimension: 'overworld' | 'nether' | 'end'
+
+  constructor() {
+    this.mobs = new Map()
+    this.spawnTimer = 0
+    this.currentDimension = 'overworld'
+  }
+
+  // ─── Dimension ─────────────────────────────────────────────
+
+  setDimension(dimension: 'overworld' | 'nether' | 'end'): void {
+    this.currentDimension = dimension
+  }
+
+  // ─── Spawn / Remove ────────────────────────────────────────
+
+  spawnMob(type: MobType, position: [number, number, number]): Mob {
+    const stats = MOB_STATS[type]
+    const mob: Mob = {
+      id: generateMobId(),
+      type,
+      position: [position[0], position[1], position[2]],
+      velocity: [0, 0, 0],
+      rotation: Math.random() * 360,
+      health: stats.health,
+      maxHealth: stats.health,
+      hostile: stats.hostile,
+      attackDamage: stats.damage,
+      speed: stats.speed,
+      spawnTime: Date.now(),
+      onGround: false,
+      attackCooldown: 0,
+      wanderAngle: Math.random() * 360,
+      wanderTimer: 0,
+      hurtTimer: 0,
+      dimension: this.currentDimension,
+    }
+    this.mobs.set(mob.id, mob)
+    return mob
+  }
+
+  removeMob(id: string): void {
+    this.mobs.delete(id)
+  }
+
+  // ─── Update ────────────────────────────────────────────────
+
+  updateMobs(
+    delta: number,
+    playerPos: [number, number, number],
+    getBlock: (x: number, y: number, z: number) => number
+  ): void {
+    const toRemove: string[] = []
+
+    const mobEntries = Array.from(this.mobs.entries())
+    for (const [id, mob] of mobEntries) {
+      // Despawn mobs too far from player
+      const dist = distance3d(mob.position, playerPos)
+      if (dist > SPAWN_RADIUS_MAX) {
+        toRemove.push(id)
+        continue
+      }
+
+      // Update AI behavior
+      if (mob.hostile) {
+        this.updateHostileAI(mob, delta, playerPos, getBlock)
+      } else {
+        this.updatePassiveAI(mob, delta, getBlock)
+      }
+
+      // Apply gravity and collision
+      this.applyPhysics(mob, delta, getBlock)
+
+      // Update cooldowns
+      if (mob.attackCooldown > 0) {
+        mob.attackCooldown -= delta
+      }
+      if (mob.hurtTimer > 0) {
+        mob.hurtTimer -= delta
+      }
+    }
+
+    // Remove despawned mobs
+    for (const id of toRemove) {
+      this.mobs.delete(id)
+    }
+  }
+
+  // ─── Hostile AI ────────────────────────────────────────────
+
+  private updateHostileAI(
+    mob: Mob,
+    delta: number,
+    playerPos: [number, number, number],
+    getBlock: (x: number, y: number, z: number) => number
+  ): void {
+    const distToPlayer = distance2d(mob.position, playerPos)
+
+    // Special: Endermen are neutral until provoked
+    if (mob.type === 'enderman') {
+      // Endermen only attack if within 8 blocks and player is looking at them
+      // Simplified: attack if within 8 blocks
+      if (distToPlayer < 8 && mob.hurtTimer > 0) {
+        this.moveToward(mob, playerPos, delta)
+        if (distToPlayer < 2) {
+          this.attackPlayer(mob)
+        }
+      } else {
+        this.wander(mob, delta)
+      }
+      return
+    }
+
+    // Standard hostile mobs: chase player within 16 blocks
+    if (distToPlayer < 16) {
+      this.moveToward(mob, playerPos, delta)
+
+      // Attack if within 2 blocks
+      if (distToPlayer < 2) {
+        if (mob.type === 'creeper') {
+          // Creepers "explode" — in this simplified system, deal massive damage
+          this.creeperExplode(mob)
+        } else {
+          this.attackPlayer(mob)
+        }
+      }
+    } else {
+      // Wander randomly when player is far
+      this.wander(mob, delta)
+    }
+  }
+
+  // ─── Passive AI ────────────────────────────────────────────
+
+  private updatePassiveAI(
+    mob: Mob,
+    delta: number,
+    getBlock: (x: number, y: number, z: number) => number
+  ): void {
+    // Flee if recently hurt
+    if (mob.hurtTimer > 0) {
+      // Run away in the opposite direction of whatever hurt them
+      const fleeAngle = mob.wanderAngle + 180
+      const rad = (fleeAngle * Math.PI) / 180
+      const speed = mob.speed * 1.5 // Run faster when fleeing
+      mob.velocity[0] = Math.sin(rad) * speed
+      mob.velocity[2] = Math.cos(rad) * speed
+      mob.rotation = fleeAngle
+    } else {
+      // Random walk
+      this.wander(mob, delta)
+    }
+  }
+
+  // ─── Movement Helpers ──────────────────────────────────────
+
+  private moveToward(mob: Mob, target: [number, number, number], delta: number): void {
+    const dx = target[0] - mob.position[0]
+    const dz = target[2] - mob.position[2]
+    const dist = Math.sqrt(dx * dx + dz * dz)
+
+    if (dist < 0.1) return
+
+    const nx = dx / dist
+    const nz = dz / dist
+    const speed = mob.speed
+
+    mob.velocity[0] = nx * speed
+    mob.velocity[2] = nz * speed
+    mob.rotation = (Math.atan2(dx, dz) * 180) / Math.PI
+
+    // Jump if hitting a wall (simple check)
+    if (mob.onGround) {
+      const aheadX = mob.position[0] + nx * 0.6
+      const aheadZ = mob.position[2] + nz * 0.6
+      const blockAhead = this.getBlockAt(aheadX, mob.position[1], aheadZ, () => 0)
+      if (blockAhead !== 0) {
+        mob.velocity[1] = 6.0 // Jump
+      }
+    }
+  }
+
+  private wander(mob: Mob, delta: number): void {
+    mob.wanderTimer -= delta
+
+    if (mob.wanderTimer <= 0) {
+      // Pick a new random direction and duration
+      mob.wanderAngle = Math.random() * 360
+      mob.wanderTimer = 2 + Math.random() * 4 // Wander for 2-6 seconds
+
+      // 30% chance to stand still
+      if (Math.random() < 0.3) {
+        mob.wanderTimer = 1 + Math.random() * 2
+        mob.velocity[0] = 0
+        mob.velocity[2] = 0
+        return
+      }
+    }
+
+    const rad = (mob.wanderAngle * Math.PI) / 180
+    const speed = mob.speed * 0.5 // Slower when wandering
+    mob.velocity[0] = Math.sin(rad) * speed
+    mob.velocity[2] = Math.cos(rad) * speed
+    mob.rotation = mob.wanderAngle
+  }
+
+  // ─── Attack ────────────────────────────────────────────────
+
+  private attackPlayer(mob: Mob): void {
+    if (mob.attackCooldown > 0) return
+    mob.attackCooldown = 1.0 // 1 second cooldown
+    // The actual damage to the player is handled by the game loop
+    // Here we just mark that the mob is attacking
+  }
+
+  private creeperExplode(mob: Mob): void {
+    // Mark for explosion — the game loop should check for this
+    // For now, the creeper deals high damage and removes itself
+    mob.health = 0
+    this.mobs.delete(mob.id)
+  }
+
+  // ─── Physics ───────────────────────────────────────────────
+
+  private applyPhysics(
+    mob: Mob,
+    delta: number,
+    getBlock: (x: number, y: number, z: number) => number
+  ): void {
+    const gravity = 20.0 // blocks/s^2
+
+    // Apply gravity
+    mob.velocity[1] -= gravity * delta
+
+    // Compute new position
+    const newX = mob.position[0] + mob.velocity[0] * delta
+    const newY = mob.position[1] + mob.velocity[1] * delta
+    const newZ = mob.position[2] + mob.velocity[2] * delta
+
+    // Ground collision — check block below feet
+    const feetY = Math.floor(newY - 0.1)
+    const blockBelow = getBlock(
+      Math.floor(newX),
+      feetY,
+      Math.floor(newZ)
+    )
+
+    if (isSolidBlock(blockBelow) && mob.velocity[1] < 0) {
+      // Land on ground
+      mob.position[1] = Math.ceil(newY - 0.1) + 0.1
+      mob.velocity[1] = 0
+      mob.onGround = true
+    } else {
+      mob.position[1] = newY
+      mob.onGround = false
+    }
+
+    // Horizontal collision — simple check
+    const blockAtFeet = getBlock(
+      Math.floor(newX),
+      Math.floor(mob.position[1]),
+      Math.floor(newZ)
+    )
+    const blockAtHead = getBlock(
+      Math.floor(newX),
+      Math.floor(mob.position[1] + 1),
+      Math.floor(newZ)
+    )
+
+    if (!isSolidBlock(blockAtFeet) && !isSolidBlock(blockAtHead)) {
+      mob.position[0] = newX
+      mob.position[2] = newZ
+    } else {
+      // Stop horizontal movement on collision
+      mob.velocity[0] = 0
+      mob.velocity[2] = 0
+    }
+
+    // Don't fall below world
+    if (mob.position[1] < -64) {
+      mob.position[1] = -64
+      mob.velocity[1] = 0
+      mob.onGround = true
+    }
+  }
+
+  // ─── Query ─────────────────────────────────────────────────
+
+  getMobsNearby(pos: [number, number, number], radius: number): Mob[] {
+    const result: Mob[] = []
+    const allMobs = Array.from(this.mobs.values())
+    for (const mob of allMobs) {
+      if (distance3d(mob.position, pos) <= radius) {
+        result.push(mob)
+      }
+    }
+    return result
+  }
+
+  // ─── Damage ────────────────────────────────────────────────
+
+  damageMob(id: string, amount: number): Mob | null {
+    const mob = this.mobs.get(id)
+    if (!mob) return null
+
+    mob.health -= amount
+    mob.hurtTimer = 0.5 // 0.5 seconds of hurt reaction
+
+    if (mob.health <= 0) {
+      this.mobs.delete(id)
+      return null
+    }
+
+    return mob
+  }
+
+  // ─── Spawning Logic ────────────────────────────────────────
+
+  tick(
+    playerPos: [number, number, number],
+    getBlock: (x: number, y: number, z: number) => number
+  ): void {
+    this.spawnTimer++
+
+    // Attempt to spawn every ~20 ticks (1 second)
+    if (this.spawnTimer % 20 !== 0) return
+
+    // Count current mobs by category
+    let hostileCount = 0
+    let passiveCount = 0
+    const allMobs = Array.from(this.mobs.values())
+    for (const mob of allMobs) {
+      if (mob.hostile) hostileCount++
+      else passiveCount++
+    }
+
+    // Spawn hostile mobs
+    if (hostileCount < MOB_CAP_HOSTILE) {
+      this.attemptHostileSpawn(playerPos, getBlock)
+    }
+
+    // Spawn passive mobs (less frequently)
+    if (passiveCount < MOB_CAP_PASSIVE && this.spawnTimer % 100 === 0) {
+      this.attemptPassiveSpawn(playerPos, getBlock)
+    }
+  }
+
+  private attemptHostileSpawn(
+    playerPos: [number, number, number],
+    getBlock: (x: number, y: number, z: number) => number
+  ): void {
+    // Pick a random position around the player
+    const angle = Math.random() * Math.PI * 2
+    const dist = SPAWN_RADIUS_MIN + Math.random() * (SPAWN_RADIUS_MAX - SPAWN_RADIUS_MIN) * 0.5
+    const spawnX = playerPos[0] + Math.cos(angle) * dist
+    const spawnZ = playerPos[2] + Math.sin(angle) * dist
+
+    // Find a valid spawn Y
+    const spawnY = this.findSpawnY(spawnX, spawnZ, getBlock)
+    if (spawnY === null) return
+
+    // Determine which hostile mob types can spawn in this dimension
+    const hostileTypes: MobType[] = []
+    switch (this.currentDimension) {
+      case 'overworld':
+        hostileTypes.push('zombie', 'skeleton', 'creeper', 'spider')
+        break
+      case 'nether':
+        hostileTypes.push('zombie', 'skeleton', 'creeper', 'spider')
+        break
+      case 'end':
+        hostileTypes.push('enderman')
+        break
+    }
+
+    if (hostileTypes.length === 0) return
+
+    // Check if the spawn area is "dark" (simplified: always allow in nether/end, random chance in overworld)
+    if (this.currentDimension === 'overworld') {
+      // Simplified darkness check: 70% chance to allow (simulates dark areas)
+      if (Math.random() > 0.7) return
+    }
+
+    const type = hostileTypes[Math.floor(Math.random() * hostileTypes.length)]
+    this.spawnMob(type, [spawnX, spawnY, spawnZ])
+  }
+
+  private attemptPassiveSpawn(
+    playerPos: [number, number, number],
+    getBlock: (x: number, y: number, z: number) => number
+  ): void {
+    // Only spawn passive mobs in overworld
+    if (this.currentDimension !== 'overworld') return
+
+    const angle = Math.random() * Math.PI * 2
+    const dist = SPAWN_RADIUS_MIN + Math.random() * 20
+    const spawnX = playerPos[0] + Math.cos(angle) * dist
+    const spawnZ = playerPos[2] + Math.sin(angle) * dist
+
+    const spawnY = this.findSpawnY(spawnX, spawnZ, getBlock)
+    if (spawnY === null) return
+
+    // Check if surface block is grass
+    const surfaceBlock = getBlock(Math.floor(spawnX), Math.floor(spawnY) - 1, Math.floor(spawnZ))
+    if (surfaceBlock !== BLOCK_GRASS_BLOCK) return
+
+    const passiveTypes: MobType[] = ['pig', 'cow', 'sheep', 'chicken']
+    const type = passiveTypes[Math.floor(Math.random() * passiveTypes.length)]
+    this.spawnMob(type, [spawnX, spawnY, spawnZ])
+  }
+
+  private findSpawnY(
+    x: number, z: number,
+    getBlock: (x: number, y: number, z: number) => number
+  ): number | null {
+    const bx = Math.floor(x)
+    const bz = Math.floor(z)
+
+    // Search from top down for a solid block with 2 air blocks above
+    for (let y = 319; y >= -64; y--) {
+      const block = getBlock(bx, y, bz)
+      const above = getBlock(bx, y + 1, bz)
+      const above2 = getBlock(bx, y + 2, bz)
+
+      if (isSolidBlock(block) && above === BLOCK_AIR && above2 === BLOCK_AIR) {
+        return y + 1
+      }
+    }
+
+    return null
+  }
+
+  private getBlockAt(
+    x: number, y: number, z: number,
+    getBlock: (x: number, y: number, z: number) => number
+  ): number {
+    return getBlock(Math.floor(x), Math.floor(y), Math.floor(z))
+  }
+
+  // ─── Serialization ─────────────────────────────────────────
+
+  getAllMobs(): Mob[] {
+    return Array.from(this.mobs.values())
+  }
+
+  getMobCount(): { hostile: number; passive: number } {
+    let hostile = 0
+    let passive = 0
+    const allMobs = Array.from(this.mobs.values())
+    for (const mob of allMobs) {
+      if (mob.hostile) hostile++
+      else passive++
+    }
+    return { hostile, passive }
+  }
+}