`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.speed = 4 + Math.random() * 2
 +        koi.state.panicTimer = 0.8 + Math.random() * 0.6 // Shorter panic
 +        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
 -        koi.tail.rotation.y = Math.sin(elapsed * 4 + s.flickerPhase) * 0.2
 -        koi.group.position.y = -0.1 + Math.sin(elapsed * 3 + s.flickerPhase) * 0.01
 +        // 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
+       }
        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
 -            s.targetX = otherKoi.state.targetX + (Math.random() - 0.5) * 1.5
 -            s.targetZ = otherKoi.state.targetZ + (Math.random() - 0.5) * 1.5
 +            // 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)
+         }
 -        // Restless koi change direction more often
 -        s.wanderTimer = (1 + Math.random() * 3) / s.restlessness
 +        // Longer wander intervals for more natural movement
 +        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) {
 -        // Calculate target rotation
 -        const targetRot = Math.atan2(dx, dz)
+-
 -        // Smooth rotation - varies by individual
 -        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
 -        const moveSpeed = s.panicMode ? s.speed * 2.5 : s.speed * (0.4 + s.restlessness * 0.4)
 -        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
 -        const wiggleSpeed = s.panicMode ? 25 : 8 + s.restlessness * 8
 -        koi.tail.rotation.y = Math.sin(elapsed * wiggleSpeed + s.flickerPhase) * 0.5
 -      } else {
 -        // Reached target - maybe idle, maybe pick new target
 -        if (Math.random() < 0.3) {
 +      // Always swim forward, turn gradually
 +      const targetRot = Math.atan2(dx, dz)
++
 +      // 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
++
 +      // 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 - 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
 +      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
 -      koi.group.position.y = -0.08 + Math.sin(elapsed * 8 + s.flickerPhase) * 0.015
+-
 -      // 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)
 -        }
 -      }
 +      // Gentle depth variation - natural swimming motion
 +      koi.group.position.y = -0.08 + Math.sin(elapsed * 3 + s.flickerPhase) * 0.01
 -      // 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) {
 -        const scale = (pondRadius * 0.85) / currentDist
 -        koi.group.position.x *= scale
 -        koi.group.position.z *= scale
 -        // Turn back toward center
 -        pickNewTarget(koi, pondRadius * 0.5)
 +      if (currentDist > pondRadius * 0.85) {
 +        // Steer back toward center
 +        s.targetX = (Math.random() - 0.5) * pondRadius * 0.5
 +        s.targetZ = (Math.random() - 0.5) * 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
 -        group.rotation.z = Math.sin(state.timer * 4) * 0.08
 +        // Tilt nose UP ~55 degrees - rotate around Z since model faces +X
 +        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
 -        group.rotation.x = 0.95 + Math.sin(elapsed * 1.5) * 0.05
 +        // Slowly turn toward Doug
          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
+     }