+    <title>Sprong :: Pong with Physick</title>

+const AI_WINDUP_SPEED       = 0.15;   // Base oscillation speed

+const AI_WINDUP_SMOOTHNESS  = 1.00;   // Smooth transitions

+const AI_WINDUP_RADIUS      = 240;    // Circular motion radius

+const AI_WINDUP_MIN_TIME    = 300;    // Minimum windup duration

+const AI_WINDUP_MAX_TIME    = 1200;   // Maximum windup duration

+const AI_BOP_AT_PEAK_CHANCE = 0.4;    // Chance to bop at windup peak

+const AI_CIRCULAR_MOTION    = 0.9;    // How circular vs linear the motion is

+const AI_MOMENTUM_CARRY     = 0.85;   // How much momentum carries between moves

+const AI_PHASE_SPEED        = 0.1;    // Speed of phase progression (radians per frame)

+

+const AI_IDLE_MOVEMENT  = 0.8;        // How much AI moves when idle

+const AI_NERVOUS_ENERGY = 0.5;        // Random fidgeting energy

+const AI_PREDICTIVE_MOVEMENT = 0.7;   // How much AI moves based on prediction

+const AI_TRACKING_AGGRESSION = 0.15;  // How aggressively AI tracks the ball

+

+        reactionTime: 350,

+        aggression: 0.4,

+        phaseSpeed: 0.06,

+        idleMovement: 0.3,

+        trackingAggression: 0.1

+        reactionTime: 200,

+        aggression: 0.7,

+        phaseSpeed: 0.08,

+        idleMovement: 0.5,

+        trackingAggression: 0.15

+        reactionTime: 100,

+        speed: 1.5,

+        prediction: 0.85,

+        aggression: 1.0,

+        windupRadius: 60,

+        phaseSpeed: 0.12,

+        idleMovement: 0.8,

+        trackingAggression: 0.25

+    let aiSettings = AI_SETTINGS[aiState.difficulty];

+    

+    // More pronounced breathing motion

+    aiState.breathingOffset = Math.sin(currentTime * 0.005) * 5 * aiSettings.idleMovement;

+    // More frequent micro-adjustments

+    if (currentTime - aiState.lastMicroTime > 1000 + Math.random() * 500) {

+        aiState.microAdjustment = (Math.random() - 0.5) * 30 * aiSettings.idleMovement;

+    // Slower decay for more persistent movement

+    aiState.microAdjustment *= 0.95;

+    

+    // Add "nervous energy" - small random movements

+    let nervousEnergy = (Math.random() - 0.5) * AI_NERVOUS_ENERGY * aiSettings.aggression;

+    aiState.microAdjustment += nervousEnergy;

+        let wanderRadius = 40 * aiSettings.idleMovement; // Larger wander radius

+        aiState.idleTarget = centerY + Math.sin(currentTime * 0.003) * wanderRadius;

+        

+        // Add vertical patrol behavior

+        let patrolOffset = Math.sin(currentTime * 0.002) * 30 * aiSettings.idleMovement;

+        aiState.idleTarget += patrolOffset;

+    // More aggressive tracking based on difficulty

+    let trackingIntensity = ballApproaching ? 

+        (0.08 + aiSettings.trackingAggression) : 

+        (0.03 + aiSettings.trackingAggression * 0.5);

+    

+    // Predict where ball will be and move preemptively

+    let futureTime = 0.5; // Look ahead 0.5 seconds

+    let futureBallY = ballPos.y + ballVel.y * futureTime * 60; // 60 fps assumption

+    // Blend current and future position based on difficulty

+    let targetBallY = lerp(ballPos.y, futureBallY, aiSettings.prediction);

+    

+    let desiredPaddleY = targetBallY + aiState.microAdjustment + aiState.breathingOffset;

+    // Add aggressive positioning - AI tries to "cut off" the ball

+    if (ballApproaching && aiSettings.aggression > 0.5) {

+        let aggressiveOffset = (ballVel.y > 0 ? 1 : -1) * 20 * aiSettings.aggression;

+        desiredPaddleY += aggressiveOffset;

+    }

+    

+    // Faster interpolation for more responsive movement

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

+    

+    // Lower threshold for more constant movement

+    if (Math.abs(deltaY) > 0.5) { // Reduced from 1

+        let baseSpeed = 0.15 * aiSettings.speed; // Increased from 0.12

+            baseSpeed *= aiState.swingPower * (1 + aiState.aggressionLevel * 0.5); // Increased multiplier

+                baseSpeed *= (1 + aiState.targetVelocity * 0.15); // Increased from 0.1

+                aiState.targetVelocity *= 0.85; // Slower decay

+            baseSpeed *= (2.0 + windupSpeedMultiplier); // Increased from 1.5

+                baseSpeed *= 1.5; // Increased from 1.3

+            }

+        } else if (aiState.mode === 'TRACKING' || aiState.mode === 'ANTICIPATING') {

+            // Add movement urgency based on ball position

+            let ball = window.ball; // Access global ball

+            if (ball && ball.velocity.x > 0) {

+                let urgency = 1 + (1 - (ball.position.x / window.width)) * aiSettings.aggression;

+                baseSpeed *= urgency;

+        // Apply aggression multiplier with higher impact

+        baseSpeed *= (1 + aiState.aggressionLevel * 0.5); // Increased from 0.3

+        

+        // Allow faster movement for hard AI

+        let maxSpeed = SUPPORT_SPEED * (1.2 + aiSettings.aggression * 0.3);

+        movement = Math.max(-maxSpeed, Math.min(maxSpeed, movement));

+        window.inputBuffer.right = movement / maxSpeed;

+        // Even when close to target, add small movements for liveliness

+        if (aiSettings.idleMovement > 0.5) {

+            let tinyMovement = (Math.random() - 0.5) * aiSettings.idleMovement;

+            const moveSupportEnhanced = window.moveSupportEnhanced;

+            moveSupportEnhanced(rightSupport, tinyMovement, window.height);

+            window.inputBuffer.right = tinyMovement / SUPPORT_SPEED;

+        } else {

+            // Gradually reduce input buffer when AI is not moving

+            window.inputBuffer.right *= 0.9; // Slower decay for more visible movement

+        }

+const BALL_SPEED    = 5;

+const BOP_RANGE             = 500;   // also self explanatory. TWIST it.

+const BOP_DURATION          = 1000; // traversal duration.    SHAKE it.

+const BOP_COOLDOWN          = 0;  // also also self expl.   PULL  it.

+const ANCHOR_RECOIL         = 60;   // How far the anchor moves backward during bop

+const BOP_VELOCITY_BOOST    = 5;    // Initial velocity boost for paddle

+    // BOP_COOLDOWN controls the minimum time between bops

+        currentTime - bopState.left.lastBopTime > BOP_COOLDOWN) {

+        // BOP_COOLDOWN controls the minimum time between bops

+            currentTime - bopState.right.lastBopTime > BOP_COOLDOWN) {

+

+        // ANCHOR_RECOIL now properly controls the recoil distance

+        let anchorRecoilDistance = ANCHOR_RECOIL * 0.3; // Can adjust the 0.3 multiplier

+

+        // Move support and paddle backward together

+        Body.translate(support, { x: -dx * anchorRecoilDistance, y: -dy * anchorRecoilDistance });

+        Body.translate(paddle,  { x: -dx * anchorRecoilDistance, y: -dy * anchorRecoilDistance });

+

+        // Remember where the support started so we can ease it back later

+            x: support.position.x + dx * anchorRecoilDistance,

+        // BOP_VELOCITY_BOOST controls the initial forward velocity

+        let forwardSpeed = BOP_VELOCITY_BOOST;

+

+        // BOP_FORCE controls the sustained forward thrust

+        // Combined with BOP_RANGE for the total force applied

+            x: dx * BOP_FORCE * BOP_RANGE * 0.002,  // Scaled down for Matter.js

+            y: dy * BOP_FORCE * BOP_RANGE * 0.002

+

+    console.log(`${side} player BOP! Duration: ${BOP_DURATION}ms, Cooldown: ${BOP_COOLDOWN}ms`);

+        let progress = elapsed / BOP_DURATION;  // BOP_DURATION controls how long the effect lasts

+            console.log("Left bop ended after", elapsed, "ms");

+                // Smooth return motion with easing

+    // Update right bop (same logic)

+        let progress = elapsed / BOP_DURATION;  // BOP_DURATION controls how long the effect lasts

+            console.log("Right bop ended after", elapsed, "ms");

+    // BOP_RANGE controls the maximum extension allowed

+        // Clamp paddle position to max range

+        

+        // Dampen velocity when hitting the range limit

+        // Add rotational physics

+        inertia: PADDLE_MASS * 200,  // Lower inertia = more rotation

+        frictionAngular: 0.02,       // Slight angular damping

+        damping: SPRING_DAMPING,

+        // Add angular stiffness to create torque from movement

+        angularStiffness: 0.01,  // Allows paddle to rotate based on spring tension

+        render: { visible: false }

+// ============= COLLISION =============

+    // Track collision state to prevent double-triggering

+    let collisionState = {

+        left: { inCollision: false, lastCollisionTime: 0 },

+        right: { inCollision: false, lastCollisionTime: 0 }

+    };

+    

+                let side = isLeftPaddle ? 'left' : 'right';

+                

+                // Prevent multiple collisions in quick succession

+                let currentTime = Date.now();

+                if (currentTime - collisionState[side].lastCollisionTime < 100) {

+                    continue; // Skip if we just had a collision

+                }

+                collisionState[side].lastCollisionTime = currentTime;

+                

+                // Apply bop boost if paddle is currently bopping

+                    // Get actual collision point from Matter.js

+                    let collision = pair.collision;

+                    let contactPoint = collision.supports[0];

+                    // Check if this is a valid collision

+                    let isValidCollision = false;

+                    if (contactPoint) {

+                        isValidCollision = true;

+                    } else {

+                        // Use penetration depth as fallback to avoid false positives

+                        const depth = collision.depth || 0;

+                        isValidCollision = depth > 0.5;

+                    }

+                    if (isValidCollision) {

+                        // During bop, ALWAYS apply boost

+                        let ballVel = ball.velocity;

+                        let paddleVel = paddle.velocity;

+                        

+                        // Calculate the normal collision response first

+                        let normal = collision.normal;

+                        let relativeVelocity = {

+                            x: ballVel.x - paddleVel.x,

+                            y: ballVel.y - paddleVel.y

+                        };

+                        // Calculate the velocity along the collision normal

+                        let velocityAlongNormal = relativeVelocity.x * normal.x + relativeVelocity.y * normal.y;

+                        

+                        // Only apply boost if ball is approaching paddle

+                        if (velocityAlongNormal < 0) {

+                            // Base reflection velocity (enhanced during bop)

+                            let restitution = 1.5; // Higher restitution during bop

+                            let impulse = 2 * velocityAlongNormal * restitution;

+                            

+                            // Apply the impulse

+                            let newVelX = ballVel.x - impulse * normal.x;

+                            let newVelY = ballVel.y - impulse * normal.y;

+                            

+                            // Add paddle velocity influence (more during bop)

+                            let paddleInfluence = 0.6; // Higher influence during bop

+                            newVelX += paddleVel.x * paddleInfluence;

+                            newVelY += paddleVel.y * paddleInfluence;

+                            

+                            // Add bop boost in the direction of the normal

+                            let bopBoostMagnitude = 3; // Extra boost during bop

+                            newVelX += normal.x * bopBoostMagnitude;

+                            newVelY += normal.y * bopBoostMagnitude;

+                            

+                            // Ensure minimum speed after bop

+                            let newSpeed = Math.sqrt(newVelX * newVelX + newVelY * newVelY);

+                            let minSpeed = BALL_SPEED * 1.3; // At least 30% faster than normal

+                            

+                            if (newSpeed < minSpeed) {

+                                let scale = minSpeed / newSpeed;

+                                newVelX *= scale;

+                                newVelY *= scale;

+                            }

+                            

+                            // Apply the new velocity

+                            Body.setVelocity(ball, {

+                                x: newVelX,

+                                y: newVelY

+                            });

+                            

+                            // Move ball slightly away from paddle to prevent sticking

+                            let separation = 2; // pixels

+                            Body.setPosition(ball, {

+                                x: ball.position.x + normal.x * separation,

+                                y: ball.position.y + normal.y * separation

+                            });

+                            

+                            // Create impact particles

+                            for (let j = 0; j < IMPACT_PARTICLES * 2; j++) { // More particles for bop

+                                let angle = Math.atan2(normal.y, normal.x) + (Math.random() - 0.5) * Math.PI;

+                                let speed = Math.random() * 8 + 4;

+                                

+                                particles.push({

+                                    x: contactPoint ? contactPoint.x : ball.position.x,

+                                    y: contactPoint ? contactPoint.y : ball.position.y,

+                                    vx: Math.cos(angle) * speed,

+                                    vy: Math.sin(angle) * speed,

+                                    size: Math.random() * 5 + 3,

+                                    life: PARTICLE_LIFE,

+                                    maxLife: PARTICLE_LIFE,

+                                    color: { r: 255, g: Math.random() * 155 + 100, b: 50 },

+                                    type: 'impact'

+                                });

+                            }

+                            

+                            console.log(`BOP HIT! Clean bounce. New speed: ${newSpeed.toFixed(1)}, Side: ${side}`);

+                        }

+    

+    // Reset collision state on collision end

+    Matter.Events.on(engine, 'collisionEnd', function(event) {

+        let pairs = event.pairs;

+        

+        for (let i = 0; i < pairs.length; i++) {

+            let pair = pairs[i];

+            

+            if ((pair.bodyA === ball && (pair.bodyB === leftPaddle || pair.bodyB === rightPaddle)) ||

+                (pair.bodyB === ball && (pair.bodyA === leftPaddle || pair.bodyA === rightPaddle))) {

+                

+                let paddle = pair.bodyA === ball ? pair.bodyB : pair.bodyA;

+                let isLeftPaddle = paddle === leftPaddle;

+                let side = isLeftPaddle ? 'left' : 'right';

+                

+                collisionState[side].inCollision = false;

+            }

+        }

+    });

+window.ball = null;

+    window.ball = ball;

+        

+        window.ball = ball;  // ADD THIS LINE - Update global reference

+        window.ball = ball;  // ADD THIS LINE - Update global reference

+        window.ball = ball;