`978c402`

fix donny. fix koi

Authored by

espadonne 4 months ago

SHA: 978c4025e8feaba78e514bbf8e0ff9ac8031d03b
Parents: b9b831c
Tree: 440957f

2 changed files

Status	File	+	-
M	`src/renderers/three/koi.js`	52	60
M	`src/renderers/three/narwhal.js`	14	9

src/renderers/three/koi.jsmodified

          koi.group.position.z - z
+       )
--      if (dist < 2) {
++      if (dist < 1.5) {
          koi.state.panicMode = true
--        koi.state.panicTimer = 1.5 + Math.random() * 1
++        koi.state.panicTimer = 0.8 + Math.random() * 0.6 // Shorter panic
--        koi.state.speed = 4 + Math.random() * 2
++        koi.state.speed = koi.state.baseSpeed * 2 // Just double speed, not crazy fast
--        // Flee away from the bread
++        // Flee away from the bread - but keep it smooth
          const fleeAngle = Math.atan2(
            koi.group.position.z - z,
            koi.group.position.x - x
+         )
--        const fleeDist = pondRadius * 0.6 + Math.random() * pondRadius * 0.2
++        const fleeDist = pondRadius * 0.5 + Math.random() * pondRadius * 0.3
          koi.state.targetX = Math.cos(fleeAngle) * fleeDist
          koi.state.targetZ = Math.sin(fleeAngle) * fleeDist
            s.isIdle = false
            pickNewTarget(koi, pondRadius)
+         }
--        // Gentle drifting while idle
++        // Gentle drifting while idle - still wiggle tail slowly
--        koi.tail.rotation.y = Math.sin(elapsed * 4 + s.flickerPhase) * 0.2
++        koi.tail.rotation.y = Math.sin(elapsed * 3 + s.flickerPhase) * 0.15
--        koi.group.position.y = -0.1 + Math.sin(elapsed * 3 + s.flickerPhase) * 0.01
++        koi.group.position.y = -0.1 + Math.sin(elapsed * 2 + s.flickerPhase) * 0.008
          continue
+       }
        s.wanderTimer -= delta
        if (s.wanderTimer <= 0 && !s.panicMode) {
          // Random chance to go idle
--        if (Math.random() < 0.15) {
++        if (Math.random() < 0.2) {
            s.isIdle = true
--          s.idleTimer = 1 + Math.random() * 3
++          s.idleTimer = 2 + Math.random() * 4
            s.wanderTimer = 0.5
            continue
+         }
--        // Sometimes follow another koi (if sociable)
++        // 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're going, with some offset
++            // Head toward where they are, with some offset
--            s.targetX = otherKoi.state.targetX + (Math.random() - 0.5) * 1.5
++            s.targetX = otherKoi.group.position.x + (Math.random() - 0.5) * 2
--            s.targetZ = otherKoi.state.targetZ + (Math.random() - 0.5) * 1.5
++            s.targetZ = otherKoi.group.position.z + (Math.random() - 0.5) * 2
+           }
          } else {
            pickNewTarget(koi, pondRadius)
+         }
--        // Restless koi change direction more often
++        // Longer wander intervals for more natural movement
--        s.wanderTimer = (1 + Math.random() * 3) / s.restlessness
++        s.wanderTimer = 2 + Math.random() * 4
+       }
--      // Move toward target
++      // Move toward target - smooth, natural swimming
        const dx = s.targetX - koi.group.position.x
        const dz = s.targetZ - koi.group.position.z
        const dist = Math.hypot(dx, dz)
--      if (dist > 0.15) {
++      // Always swim forward, turn gradually
--        // Calculate target rotation
        const targetRot = Math.atan2(dx, dz)
--        // Smooth rotation - varies by individual
++      // 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
--        koi.group.rotation.y += rotDiff * s.turnSpeed * delta
--        // Move forward - speed varies
++      // Slower turn rate for natural movement
--        const moveSpeed = s.panicMode ? s.speed * 2.5 : s.speed * (0.4 + s.restlessness * 0.4)
++      const turnRate = s.panicMode ? 2.5 : 1.2
++      koi.group.rotation.y += rotDiff * turnRate * delta
++
++      // Always moving forward (fish don't stop mid-water)
++      const moveSpeed = s.panicMode ? s.speed * 1.8 : s.speed * 0.5
        const moveX = Math.sin(koi.group.rotation.y) * moveSpeed * delta
        const moveZ = Math.cos(koi.group.rotation.y) * moveSpeed * delta
        koi.group.position.x += moveX
        koi.group.position.z += moveZ
--        // Tail wiggle - faster when moving fast
++      // Tail wiggle - proportional to speed
--        const wiggleSpeed = s.panicMode ? 25 : 8 + s.restlessness * 8
++      const wiggleSpeed = s.panicMode ? 15 : 8
--        koi.tail.rotation.y = Math.sin(elapsed * wiggleSpeed + s.flickerPhase) * 0.5
++      const wiggleAmount = s.panicMode ? 0.4 : 0.3
--      } else {
++      koi.tail.rotation.y = Math.sin(elapsed * wiggleSpeed + s.flickerPhase) * wiggleAmount
--        // Reached target - maybe idle, maybe pick new target
++
--        if (Math.random() < 0.3) {
++      // Reached close to target - pick new one
++      if (dist < 0.3) {
++        if (Math.random() < 0.25) {
            s.isIdle = true
--          s.idleTimer = 0.5 + Math.random() * 2
++          s.idleTimer = 1 + Math.random() * 3
          } else {
            pickNewTarget(koi, pondRadius)
+         }
+       }
--      // Flicker/shimmer effect - slight Y oscillation
++      // Gentle depth variation - natural swimming motion
--      koi.group.position.y = -0.08 + Math.sin(elapsed * 8 + s.flickerPhase) * 0.015
++      koi.group.position.y = -0.08 + Math.sin(elapsed * 3 + s.flickerPhase) * 0.01
--
--      // Erratic depth changes when panicked
--      if (s.panicMode) {
--        koi.group.position.y += Math.sin(elapsed * 20 + s.flickerPhase) * 0.03
--        // Random direction jitters
--        if (Math.random() < delta * 5) {
--          koi.group.rotation.y += (Math.random() - 0.5) * 0.8
--          pickNewTarget(koi, pondRadius)
--        }
--      }
--      // Keep in pond bounds
++      // Keep in pond bounds - smooth turnaround
        const currentDist = Math.hypot(koi.group.position.x, koi.group.position.z)
--      if (currentDist > pondRadius * 0.9) {
++      if (currentDist > pondRadius * 0.85) {
--        const scale = (pondRadius * 0.85) / currentDist
++        // Steer back toward center
--        koi.group.position.x *= scale
++        s.targetX = (Math.random() - 0.5) * pondRadius * 0.5
--        koi.group.position.z *= scale
++        s.targetZ = (Math.random() - 0.5) * pondRadius * 0.5
--        // Turn back toward center
--        pickNewTarget(koi, pondRadius * 0.5)
+       }
+     }
+   }

src/renderers/three/narwhal.jsmodified

          const easeOut = 1 - Math.pow(1 - emergeProgress, 3)
          group.position.y = -2 + easeOut * 2.5 // Rise higher out of water
--        // Tilt nose UP ~55 degrees (0.96 radians)
--        group.rotation.x = 0.95 * easeOut
--
          // Slowly turn toward Doug - lugubrious, not laser tracking
          group.rotation.y = lerpAngle(group.rotation.y, angleToDoug, delta * 0.5)
--        // Gentle rocking as emerging
++        // Tilt nose UP ~55 degrees - rotate around Z since model faces +X
--        group.rotation.z = Math.sin(state.timer * 4) * 0.08
++        group.rotation.z = 0.95 * easeOut
++
++        // Gentle side-to-side rocking
++        group.rotation.x = Math.sin(state.timer * 4) * 0.06
          if (emergeProgress >= 1) {
            state.mode = 'surfaced'
        case 'surfaced':
          // Bob gently, positioned higher
          group.position.y = 0.5 + Math.sin(elapsed * 2) * 0.06
--        group.rotation.z = Math.sin(elapsed * 1.5) * 0.04
--        // Keep steep tilt ~55 degrees - nose up, tail in water
++        // Slowly turn toward Doug
--        group.rotation.x = 0.95 + Math.sin(elapsed * 1.5) * 0.05
          group.rotation.y = lerpAngle(group.rotation.y, angleToDoug, delta * 0.3)
++        // Keep steep tilt ~55 degrees - nose up, tail in water
++        group.rotation.z = 0.95 + Math.sin(elapsed * 1.5) * 0.04
++
++        // Gentle side-to-side rocking
++        group.rotation.x = Math.sin(elapsed * 1.5) * 0.03
++
          // Gentle flipper animation
          leftFlipper.rotation.z = 2.2 + Math.sin(elapsed * 3) * 0.15
          rightFlipper.rotation.z = 2.2 + Math.sin(elapsed * 3 + 0.5) * 0.15
          group.position.y = 0.5 - easeIn * 2.7
          // Tilt nose down as diving back under
--        group.rotation.x = 0.95 - easeIn * 1.2
++        group.rotation.z = 0.95 - easeIn * 1.2
          // Add bubbles/ripples as submerging
          if (Math.random() < delta * 4) {
            group.visible = false
            group.position.y = -3
            group.rotation.x = 0
++          group.rotation.z = 0
+         }
          break
+     }