Update src/components/WorldTreeVisualizer.tsx

src/components/WorldTreeVisualizer.tsx

@@ -1493,6 +1493,14 @@ export const WorldTreeVisualizer: React.FC<WorldTreeVisualizerProps> = ({ audioE
       // Calculate distance and sphere radius early for use in forces
       const dist = Math.sqrt(x*x + y*y + z*z)
       const sphereRadius = params.sphereRadius
+      
+      // Define containment zones for use throughout particle update
+      const coreZone = sphereRadius * 0.4      // Core zone - natural movement
+      const innerZone = sphereRadius * 0.65    // Inner zone - gentle forces
+      const boundaryZone = sphereRadius * 0.8  // Warning zone - medium forces  
+      const dangerZone = sphereRadius * 0.92   // Danger zone - strong forces
+      const emergencyZone = sphereRadius * 0.98 // Emergency zone - very strong forces
+      const hardBoundary = sphereRadius * 1.02 // Hard boundary - immediate reset
 
       // Apply noise-based turbulence with distance-based scaling
       const ns = params.noiseScale * adaptiveLevel // Scale noise with performance
@@ -1513,10 +1521,10 @@ export const WorldTreeVisualizer: React.FC<WorldTreeVisualizerProps> = ({ audioE
       // STABILITY: Scale turbulence by performance, distance, and containment zones
       const performanceScale = Math.min(1.0, 60 * clampedDeltaTime) // Scale down for low FPS
       
-      // Reduce turbulence based on distance from center to prevent escaping
-      const distanceScale = Math.max(0.1, 1 - (dist / sphereRadius) * 0.8) // Reduce turbulence near boundaries
+      // Scale turbulence to maintain audio reactivity while preventing boundary escape
+      const distanceScale = Math.max(0.3, 1 - (dist / sphereRadius) * 0.6) // Less aggressive reduction
       
-      const turbulenceScale = params.turbulenceStrength * performanceScale * distanceScale * 0.7 // Reduced overall turbulence
+      const turbulenceScale = params.turbulenceStrength * performanceScale * distanceScale * 0.9 // Preserve more turbulence
       
       vx += noiseX * turbulenceScale
       vy += noiseY * turbulenceScale
@@ -1536,13 +1544,9 @@ export const WorldTreeVisualizer: React.FC<WorldTreeVisualizerProps> = ({ audioE
           const dz = z / dist
 
           // Modified beat force to prevent dispersion with stronger containment awareness
-          const baseBeatForce = be * params.beatStrength * 0.5 // Reduced base beat force
+          const baseBeatForce = be * params.beatStrength * 0.8 // Increased to preserve audio reactivity
           
-          // Define beat force zones based on containment zones
-          const coreZone = sphereRadius * 0.4
-          const innerZone = sphereRadius * 0.65
-          const boundaryZone = sphereRadius * 0.8
-          const dangerZone = sphereRadius * 0.92
+          // Use containment zones already defined above
           
           if (dist < coreZone) {
             // Normal outward beat force in core zone only
@@ -1589,13 +1593,10 @@ export const WorldTreeVisualizer: React.FC<WorldTreeVisualizerProps> = ({ audioE
         const dy = y / dist
         const dz = z / dist
 
-        // Greatly reduce wave force intensity and make it containment-zone aware
-        const baseWaveIntensity = 0.0002 // Further reduced
+        // Balance wave force intensity to preserve audio reactivity while maintaining containment
+        const baseWaveIntensity = 0.0006 // Increased to preserve audio reactivity
         
-        // Apply different wave behavior based on containment zones
-        const coreZone = sphereRadius * 0.4
-        const innerZone = sphereRadius * 0.65
-        const boundaryZone = sphereRadius * 0.8
+        // Use containment zones already defined above for wave behavior
         
         let waveIntensity = baseWaveIntensity
         let waveDirection = 1 // 1 = outward, -1 = inward, 0 = tangential
@@ -1642,21 +1643,18 @@ export const WorldTreeVisualizer: React.FC<WorldTreeVisualizerProps> = ({ audioE
         // Create geometric patterns based on frequency
         const geometricPattern = getCymatePattern(x, y, z, freq, currentTime * 0.001)
         
-        // Scale cymatic intensity based on distance from center to prevent boundary escape
-        const coreZone = sphereRadius * 0.4
-        const boundaryZone = sphereRadius * 0.8
-        
+        // Scale cymatic intensity to balance audio reactivity with containment
         let cymateScale = 1.0
         if (dist > boundaryZone) {
-          // Greatly reduce cymatic forces near boundaries
-          cymateScale = 0.1
+          // Moderate reduction near boundaries while preserving some reactivity
+          cymateScale = 0.4
         } else if (dist > coreZone) {
-          // Gradually reduce cymatic forces outside core
-          cymateScale = 1.0 - ((dist - coreZone) / (boundaryZone - coreZone)) * 0.7
+          // Gentle reduction outside core
+          cymateScale = 1.0 - ((dist - coreZone) / (boundaryZone - coreZone)) * 0.4
         }
         
-        // Further reduce base intensity for more stability
-        const organicIntensity = 0.0008 * cymateScale * (0.8 + 0.2 * Math.sin(currentTime * 0.0005))
+        // Maintain stronger cymatic intensity for audio reactivity
+        const organicIntensity = 0.0012 * cymateScale * (0.8 + 0.2 * Math.sin(currentTime * 0.0005))
         vx += geometricPattern.x * organicIntensity
         vy += geometricPattern.y * organicIntensity  
         vz += geometricPattern.z * organicIntensity
@@ -1700,19 +1698,25 @@ export const WorldTreeVisualizer: React.FC<WorldTreeVisualizerProps> = ({ audioE
           avgVy /= neighborCount
           avgVz /= neighborCount
           
-          // Apply simplified collective behavior
-          const flockInfluence = entronautParams.coupling * 0.2
-          vx += (avgVx - vx) * flockInfluence
-          vy += (avgVy - vy) * flockInfluence
-          vz += (avgVz - vz) * flockInfluence
+          // Reduce flocking influence to prevent convergence and preserve individuality
+          const flockInfluence = entronautParams.coupling * 0.08 // Reduced from 0.2
+          
+          // Add some randomness to promote emergence rather than convergence
+          const emergenceRandomness = (Math.random() - 0.5) * 0.001
+          
+          vx += (avgVx - vx) * flockInfluence + emergenceRandomness
+          vy += (avgVy - vy) * flockInfluence + emergenceRandomness
+          vz += (avgVz - vz) * flockInfluence + emergenceRandomness
         }
       }
       
-      // Simplified metabolic pulsing for all particles
+      // Light metabolic pulsing to add organic variation without dampening
       if (entronautEnabled && adaptiveCoupling) {
-        const metabolicPulse = entronautParams.diffusion * 0.5
-        vx += metabolicPulse * Math.cos(i * 0.01)
-        vy += metabolicPulse * Math.sin(i * 0.01)
+        const metabolicPulse = entronautParams.diffusion * 0.3 // Reduced from 0.5
+        const timeVariation = currentTime * 0.0001 // Add time-based variation
+        vx += metabolicPulse * Math.cos(i * 0.01 + timeVariation)
+        vy += metabolicPulse * Math.sin(i * 0.01 + timeVariation)
+        vz += metabolicPulse * Math.sin(i * 0.007 + timeVariation) * 0.5 // Add Z variation
       }
       
       // STABILITY: Velocity clamping to prevent runaway particles
@@ -1724,34 +1728,24 @@ export const WorldTreeVisualizer: React.FC<WorldTreeVisualizerProps> = ({ audioE
         vz *= scale
       }
 
-      // Apply adaptive drag/damping with living characteristics and additional stability damping
+      // Apply adaptive drag/damping with preservation of audio reactivity
       let dampingFactor = entronautParams.damping
       
-      // Apply extra damping based on distance from center for stability
-      if (dist > sphereRadius * 0.8) {
-        dampingFactor *= 0.8 // Extra damping near boundaries
-      } else if (dist > sphereRadius * 0.6) {
-        dampingFactor *= 0.9 // Medium extra damping
+      // Only apply extra damping in extreme zones to preserve energy
+      if (dist > emergencyZone) {
+        dampingFactor *= 0.9 // Light extra damping only near hard boundary
       }
       
-      // Apply global velocity decay to prevent long-term accumulation
-      const velocityDecay = config?.visualization?.physics?.velocityDecay || 0.995
-      dampingFactor = Math.min(dampingFactor, velocityDecay)
+      // Use less aggressive velocity decay to maintain particle liveliness
+      const velocityDecay = config?.visualization?.physics?.velocityDecay || 0.998 // Increased from 0.995
+      dampingFactor = Math.max(dampingFactor, velocityDecay) // Use max to preserve energy
       
       vx *= dampingFactor
       vy *= dampingFactor
       vz *= dampingFactor
 
       // ENHANCED MULTI-LAYER CONTAINMENT SYSTEM
-      // (dist and sphereRadius already calculated above)
-      
-      // Define containment zones with much tighter control
-      const coreZone = sphereRadius * 0.4      // Core zone - natural movement
-      const innerZone = sphereRadius * 0.65    // Inner zone - gentle forces
-      const boundaryZone = sphereRadius * 0.8  // Warning zone - medium forces  
-      const dangerZone = sphereRadius * 0.92   // Danger zone - strong forces
-      const emergencyZone = sphereRadius * 0.98 // Emergency zone - very strong forces
-      const hardBoundary = sphereRadius * 1.02 // Hard boundary - immediate reset
+      // (dist, sphereRadius, and containment zones already calculated above)
       
       // HARD BOUNDARY - Immediate containment for escaped particles
       if (dist > hardBoundary) {
@@ -1840,28 +1834,26 @@ export const WorldTreeVisualizer: React.FC<WorldTreeVisualizerProps> = ({ audioE
         vz -= dz * innerForce
       }
       
-      // MAGNETIC CENTER ATTRACTION - Always pull towards center
-      if (dist > coreZone && dist > 0) {
+      // GENTLE CENTER BIAS - Only for particles very far from center
+      if (dist > sphereRadius * 0.9 && dist > 0) {
         const dx = x / dist
         const dy = y / dist
         const dz = z / dist
         
-        // Gentle magnetic pull towards center (scales with distance)
-        const magneticStrength = Math.min(0.002, (dist - coreZone) / sphereRadius * 0.005)
-        vx -= dx * magneticStrength
-        vy -= dy * magneticStrength
-        vz -= dz * magneticStrength
+        // Very gentle pull only when approaching boundaries
+        const centerBias = (dist - sphereRadius * 0.9) / (sphereRadius * 0.1) * 0.0008
+        vx -= dx * centerBias
+        vy -= dy * centerBias
+        vz -= dz * centerBias
       }
       
-      // VELOCITY CLAMPING - Multiple levels based on zone
-      let maxVel = config?.visualization?.physics?.maxVelocity || 0.018
+      // VELOCITY CLAMPING - Less restrictive to preserve audio reactivity
+      let maxVel = config?.visualization?.physics?.maxVelocity || 0.025 // Increased base velocity
       
-      if (dist > dangerZone) {
-        maxVel *= 0.3 // Severely limit velocity in danger zones
-      } else if (dist > boundaryZone) {
-        maxVel *= 0.6 // Moderately limit velocity in boundary zone
-      } else if (dist > innerZone) {
-        maxVel *= 0.8 // Slightly limit velocity in inner zone
+      if (dist > emergencyZone) {
+        maxVel *= 0.6 // Moderate limit only in emergency zone
+      } else if (dist > dangerZone) {
+        maxVel *= 0.8 // Light limit in danger zone
       }
       
       const velMag = Math.sqrt(vx*vx + vy*vy + vz*vz)