`fc5951a`

reapproach koi

Authored by

espadonne 4 months ago

SHA: fc5951abccc22b2693093ab052f9bb604748a507
Parents: 3d099f7
Tree: 5304778

2 changed files

Status	File	+	-
M	`src/renderers/three/koi.js`	93	167
M	`src/renderers/three/narwhal.js`	8	6

src/renderers/three/koi.jsmodified

--// Koi fish - rapid flickering swimmers that react to bread
++// Koi fish - natural swimmers that react to bread
  import * as THREE from 'three'
  export function createKoiSchool(scene, gradientMap, pondRadius) {
    const koiColors = [
      { body: 0xff6b35, spots: 0xffffff },  // Orange with white
      { body: 0xffffff, spots: 0xff4444 },  // White with red
--    { body: 0xffaa00, spots: 0x000000 },  // Gold with black
++    { body: 0xffaa00, spots: 0x222222 },  // Gold with black
      { body: 0xff3333, spots: 0xffffff },  // Red with white
      { body: 0xffd700, spots: 0xff6600 },  // Golden
+   ]
    for (let i = 0; i < koiCount; i++) {
      const koi = createKoi(gradientMap, koiColors[i % koiColors.length])
--    // Random starting position
++    // Random starting position and direction
      const angle = Math.random() * Math.PI * 2
--    const dist = Math.random() * pondRadius * 0.7 + pondRadius * 0.1
++    const dist = Math.random() * pondRadius * 0.6 + pondRadius * 0.1
++
      koi.group.position.set(
        Math.cos(angle) * dist,
--      -0.08, // Just below water surface
++      -0.08,
        Math.sin(angle) * dist
+     )
++
++    // Face a random direction to start
      koi.group.rotation.y = Math.random() * Math.PI * 2
      koi.state = {
--      targetX: koi.group.position.x,
++      speed: 0.3 + Math.random() * 0.3,
--      targetZ: koi.group.position.z,
++      turnRate: 0,  // Current turning rate
--      baseSpeed: 0.8 + Math.random() * 1.2,
++      targetTurnRate: 0,
--      speed: 0.8 + Math.random() * 1.2,
++      turnTimer: Math.random() * 3,
--      turnSpeed: 2 + Math.random() * 3,
--      flickerPhase: Math.random() * Math.PI * 2,
        panicTimer: 0,
--      panicMode: false,
++      flickerPhase: Math.random() * Math.PI * 2
--      wanderTimer: Math.random() * 3,
--      // Independent personality
--      restlessness: 0.3 + Math.random() * 0.7, // How often they change direction
--      curiosity: Math.random(), // Likelihood to investigate bread vs flee
--      sociability: Math.random() * 0.5, // How much they follow others
--      idleTimer: 0,
--      isIdle: false,
--      idleDuration: 0
+     }
      group.add(koi.group)
        gradientMap: gradientMap
      })
--    // Body - elongated oval
++    // Body - elongated oval, facing +Z
--    const bodyGeom = new THREE.SphereGeometry(0.12, 6, 4)
++    const bodyGeom = new THREE.SphereGeometry(0.1, 6, 4)
--    bodyGeom.scale(2, 0.6, 0.8)
++    bodyGeom.scale(0.7, 0.5, 1.8) // Long along Z
      const body = new THREE.Mesh(bodyGeom, bodyMaterial)
      koiGroup.add(body)
--    // Head
++    // Head - at +Z end
--    const headGeom = new THREE.SphereGeometry(0.08, 5, 4)
++    const headGeom = new THREE.SphereGeometry(0.07, 5, 4)
--    headGeom.scale(1.2, 0.8, 1)
++    headGeom.scale(0.9, 0.7, 1)
      const head = new THREE.Mesh(headGeom, bodyMaterial)
--    head.position.set(0.2, 0, 0)
++    head.position.set(0, 0.01, 0.18)
      koiGroup.add(head)
--    // Tail fin
++    // Tail fin - at -Z end
--    const tailGeom = new THREE.ConeGeometry(0.08, 0.18, 4)
++    const tailGeom = new THREE.ConeGeometry(0.06, 0.15, 4)
++    tailGeom.rotateX(Math.PI / 2) // Point along Z
      const tail = new THREE.Mesh(tailGeom, bodyMaterial)
--    tail.position.set(-0.28, 0, 0)
++    tail.position.set(0, 0, -0.22)
--    tail.rotation.z = Math.PI / 2
      koiGroup.add(tail)
--    // Spots (2-3 random spots)
++    // Spots on top
      const spotCount = 2 + Math.floor(Math.random() * 2)
      for (let i = 0; i < spotCount; i++) {
--      const spotGeom = new THREE.SphereGeometry(0.04 + Math.random() * 0.03, 4, 3)
++      const spotGeom = new THREE.SphereGeometry(0.03 + Math.random() * 0.02, 4, 3)
        const spot = new THREE.Mesh(spotGeom, spotMaterial)
        spot.position.set(
--        (Math.random() - 0.5) * 0.2,
++        (Math.random() - 0.5) * 0.06,
 .04,
--        (Math.random() - 0.5) * 0.08
++        (Math.random() - 0.5) * 0.12
+       )
--      spot.scale.y = 0.5
++      spot.scale.y = 0.4
        koiGroup.add(spot)
+     }
      // Dorsal fin
--    const dorsalGeom = new THREE.ConeGeometry(0.03, 0.08, 3)
++    const dorsalGeom = new THREE.ConeGeometry(0.02, 0.06, 3)
      const dorsal = new THREE.Mesh(dorsalGeom, bodyMaterial)
--    dorsal.position.set(-0.05, 0.06, 0)
++    dorsal.position.set(0, 0.055, -0.03)
--    dorsal.rotation.z = -0.3
      koiGroup.add(dorsal)
--    // Scale down the whole koi
++    // Scale the whole koi
--    koiGroup.scale.setScalar(0.8)
++    koiGroup.scale.setScalar(0.9)
--    return { group: koiGroup, body, tail }
++    return { group: koiGroup, tail }
--  }
--
--  function pickNewTarget(koi, pondRadius, avoidX, avoidZ) {
--    let attempts = 0
--    let x, z
--
--    do {
--      const angle = Math.random() * Math.PI * 2
--      const dist = Math.random() * pondRadius * 0.7 + pondRadius * 0.1
--      x = Math.cos(angle) * dist
--      z = Math.sin(angle) * dist
--      attempts++
--    } while (
--      avoidX !== undefined &&
--      Math.hypot(x - avoidX, z - avoidZ) < 1.5 &&
--      attempts < 10
--    )
--
--    koi.state.targetX = x
--    koi.state.targetZ = z
+   }
    function triggerPanic(x, z) {
+       )
        if (dist < 1.5) {
--        koi.state.panicMode = true
++        koi.state.panicTimer = 1 + Math.random() * 0.5
--        koi.state.panicTimer = 0.8 + Math.random() * 0.6 // Shorter panic
++
--        koi.state.speed = koi.state.baseSpeed * 2 // Just double speed, not crazy fast
++        // Turn away from the disturbance
--
++        const awayAngle = Math.atan2(
--        // Flee away from the bread - but keep it smooth
++          koi.group.position.x - x,
--        const fleeAngle = Math.atan2(
++          koi.group.position.z - z
--          koi.group.position.z - z,
--          koi.group.position.x - x
+         )
--        const fleeDist = pondRadius * 0.5 + Math.random() * pondRadius * 0.3
++        // Set a strong turn toward the away direction
--        koi.state.targetX = Math.cos(fleeAngle) * fleeDist
++        let turnNeeded = awayAngle - koi.group.rotation.y
--        koi.state.targetZ = Math.sin(fleeAngle) * fleeDist
++        while (turnNeeded > Math.PI) turnNeeded -= Math.PI * 2
--
++        while (turnNeeded < -Math.PI) turnNeeded += Math.PI * 2
--        // Clamp to pond
++        koi.state.targetTurnRate = Math.sign(turnNeeded) * 3
--        const targetDist = Math.hypot(koi.state.targetX, koi.state.targetZ)
--        if (targetDist > pondRadius * 0.85) {
--          koi.state.targetX *= (pondRadius * 0.85) / targetDist
--          koi.state.targetZ *= (pondRadius * 0.85) / targetDist
--        }
+       }
+     }
+   }
    function update(delta, elapsed) {
      for (const koi of kois) {
        const s = koi.state
++      const pos = koi.group.position
--      // Update panic timer
++      // Update panic
--      if (s.panicMode) {
++      const isPanicked = s.panicTimer > 0
++      if (isPanicked) {
          s.panicTimer -= delta
--        if (s.panicTimer <= 0) {
--          s.panicMode = false
--          s.speed = s.baseSpeed
--        }
+       }
--      // Idle behavior - sometimes koi just stop and chill
++      // Decide turning behavior
--      if (s.isIdle) {
++      s.turnTimer -= delta
--        s.idleTimer -= delta
++      if (s.turnTimer <= 0 && !isPanicked) {
--        if (s.idleTimer <= 0) {
++        // Occasionally change turn rate for natural wandering
--          s.isIdle = false
++        s.targetTurnRate = (Math.random() - 0.5) * 1.5
--          pickNewTarget(koi, pondRadius)
++        s.turnTimer = 1 + Math.random() * 3
--        }
--        // Gentle drifting while idle - still wiggle tail slowly
--        koi.tail.rotation.y = Math.sin(elapsed * 3 + s.flickerPhase) * 0.15
--        koi.group.position.y = -0.1 + Math.sin(elapsed * 2 + s.flickerPhase) * 0.008
--        continue
+       }
--      // Wander behavior - each koi has its own rhythm
++      // Check if heading toward pond edge
--      s.wanderTimer -= delta
++      const distFromCenter = Math.hypot(pos.x, pos.z)
--      if (s.wanderTimer <= 0 && !s.panicMode) {
++      if (distFromCenter > pondRadius * 0.75) {
--        // Random chance to go idle
++        // Calculate angle to center
--        if (Math.random() < 0.2) {
++        const toCenter = Math.atan2(-pos.x, -pos.z)
--          s.isIdle = true
++        let turnNeeded = toCenter - koi.group.rotation.y
--          s.idleTimer = 2 + Math.random() * 4
++        while (turnNeeded > Math.PI) turnNeeded -= Math.PI * 2
--          s.wanderTimer = 0.5
++        while (turnNeeded < -Math.PI) turnNeeded += Math.PI * 2
--          continue
++
--        }
++        // Steer back toward center
--
++        s.targetTurnRate = Math.sign(turnNeeded) * 1.5
--        // Sometimes follow another koi loosely (if sociable)
--        if (Math.random() < s.sociability && kois.length > 1) {
--          const otherKoi = kois[Math.floor(Math.random() * kois.length)]
--          if (otherKoi !== koi) {
--            // Head toward where they are, with some offset
--            s.targetX = otherKoi.group.position.x + (Math.random() - 0.5) * 2
--            s.targetZ = otherKoi.group.position.z + (Math.random() - 0.5) * 2
--          }
--        } else {
--          pickNewTarget(koi, pondRadius)
--        }
--
--        // Longer wander intervals for more natural movement
--        s.wanderTimer = 2 + Math.random() * 4
+       }
--      // Move toward target - smooth, natural swimming
++      // Smooth turn rate changes
--      const dx = s.targetX - koi.group.position.x
++      s.turnRate += (s.targetTurnRate - s.turnRate) * delta * 2
--      const dz = s.targetZ - koi.group.position.z
--      const dist = Math.hypot(dx, dz)
--
--      // Calculate target rotation - koi model faces +X, so use atan2(dz, dx)
--      const targetRot = Math.atan2(dz, dx)
--
--      // Very smooth rotation - fish don't turn sharply
--      let rotDiff = targetRot - koi.group.rotation.y
--      while (rotDiff > Math.PI) rotDiff -= Math.PI * 2
--      while (rotDiff < -Math.PI) rotDiff += Math.PI * 2
--
--      // Slower turn rate for natural movement
--      const turnRate = s.panicMode ? 2.5 : 1.2
--      koi.group.rotation.y += rotDiff * turnRate * delta
--
--      // Move in the direction koi is facing (model faces +X, so use cos/sin)
--      const moveSpeed = s.panicMode ? s.speed * 1.8 : s.speed * 0.5
--      const moveX = Math.cos(koi.group.rotation.y) * moveSpeed * delta
--      const moveZ = Math.sin(koi.group.rotation.y) * moveSpeed * delta
--      koi.group.position.x += moveX
--      koi.group.position.z += moveZ
--
--      // Tail wiggle - proportional to speed
--      const wiggleSpeed = s.panicMode ? 15 : 8
--      const wiggleAmount = s.panicMode ? 0.4 : 0.3
--      koi.tail.rotation.y = Math.sin(elapsed * wiggleSpeed + s.flickerPhase) * wiggleAmount
--      // Reached close to target - pick new one
++      // Apply rotation
--      if (dist < 0.3) {
++      koi.group.rotation.y += s.turnRate * delta
--        if (Math.random() < 0.25) {
--          s.isIdle = true
--          s.idleTimer = 1 + Math.random() * 3
--        } else {
--          pickNewTarget(koi, pondRadius)
--        }
--      }
--      // Gentle depth variation - natural swimming motion
++      // Move forward (in the direction the fish is facing, which is +Z in local space)
--      koi.group.position.y = -0.08 + Math.sin(elapsed * 3 + s.flickerPhase) * 0.01
++      const speed = isPanicked ? s.speed * 2.5 : s.speed
--      // Keep in pond bounds - smooth turnaround
++      // Get forward direction from rotation
--      const currentDist = Math.hypot(koi.group.position.x, koi.group.position.z)
++      const forwardX = Math.sin(koi.group.rotation.y)
--      if (currentDist > pondRadius * 0.85) {
++      const forwardZ = Math.cos(koi.group.rotation.y)
--        // Steer back toward center
++
--        s.targetX = (Math.random() - 0.5) * pondRadius * 0.5
++      pos.x += forwardX * speed * delta
--        s.targetZ = (Math.random() - 0.5) * pondRadius * 0.5
++      pos.z += forwardZ * speed * delta
++
++      // Tail wiggle - faster when moving fast
++      const wiggleSpeed = isPanicked ? 18 : 10
++      const wiggleAmount = isPanicked ? 0.4 : 0.25
++      koi.tail.rotation.y = Math.sin(elapsed * wiggleSpeed + s.flickerPhase) * wiggleAmount
++
++      // Gentle vertical bob
++      pos.y = -0.08 + Math.sin(elapsed * 2.5 + s.flickerPhase) * 0.008
++
++      // Hard clamp to pond bounds
++      const currentDist = Math.hypot(pos.x, pos.z)
++      if (currentDist > pondRadius * 0.88) {
++        const scale = (pondRadius * 0.85) / currentDist
++        pos.x *= scale
++        pos.z *= scale
+       }
+     }
+   }

src/renderers/three/narwhal.jsmodified

    head.position.set(1.0, 0.25, 0)
    group.add(head)
--  // The magnificent tusk!
++  // The magnificent tusk! - positioned so base touches front of head
--  const tuskGeom = new THREE.ConeGeometry(0.06, 1.8, 6)
++  const tuskGeom = new THREE.ConeGeometry(0.05, 1.4, 6)
++  // Shift geometry so base is at origin, tip extends in +Y
++  tuskGeom.translate(0, 0.7, 0)
    const tusk = new THREE.Mesh(tuskGeom, tuskMaterial)
--  tusk.position.set(1.6, 0.35, 0)
++  // Position at front of head
--  tusk.rotation.z = -Math.PI / 2 + 0.15 // Pointing forward, slightly up
++  tusk.position.set(1.35, 0.4, 0)
--  // Add spiral ridges (simplified with rotation)
++  // Rotate to point forward and slightly up
--  tusk.rotation.y = 0.3
++  tusk.rotation.z = -Math.PI / 2 + 0.2
    group.add(tusk)
    // Eyes