zeroed-some/sprong / 420b0f7

+const Body = Matter.Body;

+let leftScore = 0;

+let rightScore = 0;

+let gameState = 'menu'; // 'menu', 'playing', 'paused'

+let gameMode = 'vs-cpu'; // 'vs-cpu' or 'vs-human'

+let aiEnabled = true;

+    selectedOption: 0, // 0 = 1 Player, 1 = 2 Player

+    difficultySelected: 1, // 0 = Easy, 1 = Medium, 2 = Hard

+    // Oscillation parameters (increased for better windup)

+    windupDistance: 120,  // Much bigger - about half canvas height

+const SUPPORT_SPEED     = 6.5;    // Bumped up from 4.5

+const SUPPORT_ACCEL     = 1.2;    // Increased acceleration

+const INPUT_SMOOTHING   = 0.25;   // More responsive

+const SUPPORT_MAX_SPEED = 8;      // Higher max speed

+const MOUSE_LAG_FACTOR  = 0.12;   // How much lag in mouse following

+const MOUSE_SPEED_LIMIT = 4;      // Max speed for mouse movement

+const TOUCH_SENSITIVITY = 1.2;    // Touch movement multiplier

+const PADDLE_MASS       = 0.8;    // Back to more stable value

+const SPRING_LENGTH     = 50;     // Increased from 40 for more room

+const SPRING_DAMPING    = 0.6;    // More damping = less erratic

+const SPRING_STIFFNESS  = 0.025;  // Slightly lower for smoother motion

+    

+    console.log("Sprong Phase 5 Complete!");

+    console.log("Particle effects system");

+    console.log("Tuned physics for maximum bounce");

+    console.log("Faster, more responsive paddles");

+    // Always track ball position for more responsive movement

+    // Calculate where the AI paddle currently is (not the anchor)

+    let paddlePos = rightPaddle.position;

+    let anchorPos = rightSupport.position;

+    

+    // Continuous ball tracking with paddle awareness

+    let trackingIntensity = ballApproaching ? 0.08 : 0.03;

+    

+    // Calculate where anchor should be to position PADDLE at target Y

+    let desiredPaddleY = ballPos.y + aiState.microAdjustment;

+    desiredPaddleY = constrain(desiredPaddleY, 80, height - 80);

+    

+    // Estimate anchor position needed to get paddle to desired position

+    // This is tricky because spring physics affects paddle position

+    let anchorOffsetNeeded = calculateAnchorOffset(desiredPaddleY, paddlePos, anchorPos);

+    let targetAnchorY = desiredPaddleY + anchorOffsetNeeded;

+    

+    // Always apply some level of paddle-aware tracking

+    aiState.targetY = lerp(aiState.targetY, targetAnchorY, trackingIntensity);

+    

+    // Only do advanced prediction and windup logic if enough time has passed (reaction delay)

+    if (currentTime - aiState.lastUpdateTime > aiSettings.reactionTime) {

+        if (ballApproaching && ballDistance < 300) {

+            // Calculate intercept point with advanced prediction

+            let timeToReach = ballDistance / Math.abs(ballVel.x);

+            let predictedBallY = ballPos.y + ballVel.y * timeToReach;

+            

+            // Account for wall bounces

+            if (predictedBallY < 50) {

+                predictedBallY = 100 - predictedBallY;

+            } else if (predictedBallY > height - 50) {

+                predictedBallY = 2 * (height - 50) - predictedBallY;

+            }

+            // Add accuracy error

+            let error = (random() - 0.5) * 35 * (1 - aiSettings.accuracy);

+            predictedBallY += error;

+            // Calculate where PADDLE needs to be to hit the ball

+            aiState.interceptY = predictedBallY;

+            

+            // Calculate where ANCHOR needs to be to position paddle correctly

+            let interceptAnchorOffset = calculateAnchorOffset(aiState.interceptY, paddlePos, anchorPos);

+            let targetAnchorForIntercept = aiState.interceptY + interceptAnchorOffset;

+            

+            // VERY selective windup decision: only for very slow balls

+            let shouldWindUp = ballSpeed < 4.5 &&         // Much stricter - very slow balls only

+                              ballDistance > 200 &&       // Lots of distance required  

+                              Math.abs(ballVel.y) < 3 &&  // Very limited vertical movement

+                              Math.abs(ballVel.x) > 1 &&  // Ball must be actually moving toward AI

+                              random() < aiSettings.oscillation * aiState.aggressionLevel * 0.3; // Much lower chance

+            

+            if (shouldWindUp) {

+                // Start winding up for power shot

+                aiState.mode = 'WINDING_UP';

+                aiState.windupStartTime = currentTime;

+                

+                // Determine windup direction (opposite of where paddle needs to be)

+                aiState.windupDirection = aiState.interceptY > paddlePos.y ? -1 : 1;

+                

+            } else {

+                // Use paddle-aware intercept positioning

+                aiState.targetY = lerp(aiState.targetY, targetAnchorForIntercept, 0.3);

+            }

+            

+            aiState.lastUpdateTime = currentTime;

+// Helper function to estimate where anchor should be to position paddle at target Y

+function calculateAnchorOffset(targetPaddleY, currentPaddlePos, currentAnchorPos) {

+    // Calculate current spring vector

+    let springVectorY = currentPaddlePos.y - currentAnchorPos.y;

+    

+    // The paddle tends to lag behind the anchor due to spring physics

+    // We need to account for this offset when positioning

+    

+    // Simple approximation: if spring is compressed/extended, paddle will be offset

+    let currentSpringLength = dist(currentAnchorPos.x, currentAnchorPos.y, 

+                                  currentPaddlePos.x, currentPaddlePos.y);

+    let springCompression = SPRING_LENGTH - currentSpringLength;

+    

+    // Estimate the Y offset the paddle will have relative to anchor

+    // This is a simplified physics approximation

+    let estimatedPaddleOffset = springVectorY * 0.8; // Paddle lags behind anchor

+    

+    // Return the offset needed for anchor positioning

+    return -estimatedPaddleOffset;

+}

+

+    let maxWindupTime = 500 / Math.max(aiState.aggressionLevel, 0.3); // Longer windup for bigger movement

+    // Calculate windup target with much bigger distance

+    let paddlePos = rightPaddle.position;

+    let windupTarget = paddlePos.y + aiState.windupDirection * aiState.windupDistance * aiState.aggressionLevel;

+    windupTarget = constrain(windupTarget, 50, height - 50); // Allow closer to edges for big windup

+    // Convert paddle target to anchor target using paddle awareness

+    let anchorOffsetNeeded = calculateAnchorOffset(windupTarget, paddlePos, rightSupport.position);

+    aiState.targetY = windupTarget + anchorOffsetNeeded;

+    // Check if it's time to swing - allow more time for bigger windups

+                     ballDistance < 120 || 

+                     ballSpeed > 6; // Abort if ball speeds up even slightly

+    // Aggressive swing toward intercept point - but position anchor for paddle placement

+    let paddlePos = rightPaddle.position;

+    

+    // Calculate where anchor should be to get paddle to intercept point

+    let anchorOffsetNeeded = calculateAnchorOffset(aiState.interceptY, paddlePos, rightSupport.position);

+    aiState.targetY = aiState.interceptY + anchorOffsetNeeded;

+    // Stay near center with subtle lifelike movements, but use paddle-aware positioning

+    let baseTarget = aiState.idleTarget + aiState.breathingOffset + aiState.microAdjustment;

+    let ballTrackingTarget = ballPos.y;

+    

+    // Blend idle position with gentle ball tracking

+    let desiredPaddleY = lerp(baseTarget, ballTrackingTarget, 0.15);

+    

+    // Convert paddle target to anchor target

+    let paddlePos = rightPaddle.position;

+    let anchorPos = rightSupport.position;

+    let anchorOffsetNeeded = calculateAnchorOffset(desiredPaddleY, paddlePos, anchorPos);

+    aiState.targetY = desiredPaddleY + anchorOffsetNeeded;

+    if (Math.abs(deltaY) > 1) { // Very small dead zone for responsive tracking

+        let baseSpeed = 0.08 * aiSettings.speed; // Back to more responsive speed

+            baseSpeed *= 0.6; // Slower during windup for more deliberate movement

+            text("🔄 AI WINDING UP FOR POWER SHOT", 10, 175);

+        console.log("Switched to " + gameMode + " mode");

+        console.log("AI difficulty: " + aiState.difficulty);

+    if (keyCode === 27) {

+    console.log("Started " + gameMode + " mode" + (aiEnabled ? " - Difficulty: " + aiState.difficulty : ""));