`09335cd`

tweaks to ai, collision

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 9 months ago

SHA: 09335cd0db0576b2e51c544829e3f5ef91d7f192
Parents: ea02d88
Tree: 578de96

3 changed files

Status	File	+	-
M	`js/ai.js`	100	41
M	`js/game-systems.js`	147	40
M	`js/sprong.js`	0	1

js/ai.jsmodified

  // ============= AI TECHNIQUE CONSTANTS =============
  const AI_WINDUP_SPEED       = 0.15;   // Base oscillation speed
--const AI_WINDUP_SMOOTHNESS = 0.92;   // Smooth transitions
++const AI_WINDUP_SMOOTHNESS  = 1.00;   // Smooth transitions
--const AI_WINDUP_RADIUS = 40;         // Circular motion radius
++const AI_WINDUP_RADIUS      = 240;    // Circular motion radius
  const AI_WINDUP_MIN_TIME    = 300;    // Minimum windup duration
--const AI_WINDUP_MAX_TIME = 600;      // Maximum 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.7;      // How circular vs linear the motion is
++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.08;         // Speed of phase progression (radians per frame)
++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
++
  // ============= AI SETTINGS =============
  const AI_SETTINGS = {
          aggression: 0.2,
          oscillation: 0.3,
          bopChance: 0.25,
--        // New windup parameters
          windupSpeed: 0.1,
          windupRadius: 30,
          comboBopChance: 0.1,
          circularMotion: 0.4,
--        phaseSpeed: 0.06
++        phaseSpeed: 0.06,
++        idleMovement: 0.3,
++        trackingAggression: 0.1
      },
      medium: {
          reactionTime: 250,
          aggression: 0.5,
          oscillation: 0.7,
          bopChance: 0.55,
--        // New windup parameters
          windupSpeed: 0.15,
          windupRadius: 40,
          comboBopChance: 0.3,
          circularMotion: 0.6,
--        phaseSpeed: 0.08
++        phaseSpeed: 0.08,
++        idleMovement: 0.5,
++        trackingAggression: 0.15
      },
      hard: {
          reactionTime: 150,
          accuracy: 0.95,
--        speed: 1.2,
++        speed: 1.3,  // Increased from 1.2
--        prediction: 0.8,
++        prediction: 0.85, // Increased from 0.8
--        aggression: 0.8,
++        aggression: 0.9,  // Increased from 0.8
          oscillation: 1.0,
          bopChance: 0.85,
--        // New windup parameters
          windupSpeed: 0.2,
--        windupRadius: 50,
++        windupRadius: 60,  // Increased from 50
          comboBopChance: 0.5,
          circularMotion: 0.8,
--        phaseSpeed: 0.1
++        phaseSpeed: 0.12,  // Increased from 0.1
++        idleMovement: 0.8,
++        trackingAggression: 0.25
+     }
  };
  // ============= AI BEHAVIORS =============
  function updateAILifelikeBehavior(currentTime, height) {
--    aiState.breathingOffset = Math.sin(currentTime * 0.003) * 3;
++    let aiSettings = AI_SETTINGS[aiState.difficulty];
++
++    // More pronounced breathing motion
++    aiState.breathingOffset = Math.sin(currentTime * 0.005) * 5 * aiSettings.idleMovement;
--    if (currentTime - aiState.lastMicroTime > 2000 + Math.random() * 1000) {
++    // More frequent micro-adjustments
--        aiState.microAdjustment = (Math.random() - 0.5) * 15;
++    if (currentTime - aiState.lastMicroTime > 1000 + Math.random() * 500) {
++        aiState.microAdjustment = (Math.random() - 0.5) * 30 * aiSettings.idleMovement;
          aiState.lastMicroTime = currentTime;
+     }
--    aiState.microAdjustment *= 0.98;
++    // 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;
      if (aiState.mode === 'ANTICIPATING' || aiState.mode === 'RECOVERING') {
          let centerY = height / 2;
--        let wanderRadius = 25;
++        let wanderRadius = 40 * aiSettings.idleMovement; // Larger wander radius
--        aiState.idleTarget = centerY + Math.sin(currentTime * 0.002) * wanderRadius;
++        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;
+     }
+ }
      let paddlePos = rightPaddle.position;
      let anchorPos = rightSupport.position;
--    let trackingIntensity = ballApproaching ? 0.08 : 0.03;
++    // 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 = ballPos.y + aiState.microAdjustment;
++    let desiredPaddleY = targetBallY + aiState.microAdjustment + aiState.breathingOffset;
      desiredPaddleY = Math.max(80, Math.min(height - 80, desiredPaddleY));
++    // 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;
++    }
++
      let anchorOffsetNeeded = calculateAnchorOffset(desiredPaddleY, paddlePos, anchorPos);
      let targetAnchorY = desiredPaddleY + anchorOffsetNeeded;
--    aiState.targetY = lerp(aiState.targetY, targetAnchorY, trackingIntensity);
++    // Faster interpolation for more responsive movement
++    aiState.targetY = lerp(aiState.targetY, targetAnchorY, trackingIntensity * 1.5);
++
      // AI Bop decision logic
      if (ballApproaching && !aiState.consideringBop && !bopState.right.active) {
      let currentY = rightSupport.position.y;
      let deltaY = aiState.targetY - currentY;
--    if (Math.abs(deltaY) > 1) {
++    // Lower threshold for more constant movement
--        let baseSpeed = 0.12 * aiSettings.speed;
++    if (Math.abs(deltaY) > 0.5) { // Reduced from 1
++        let baseSpeed = 0.15 * aiSettings.speed; // Increased from 0.12
          // Apply swing power during swing phase
          if (aiState.mode === 'SWINGING') {
--            baseSpeed *= aiState.swingPower * (1 + aiState.aggressionLevel * 0.3);
++            baseSpeed *= aiState.swingPower * (1 + aiState.aggressionLevel * 0.5); // Increased multiplier
              // Add momentum from windup if available
              if (aiState.targetVelocity > 0) {
--                baseSpeed *= (1 + aiState.targetVelocity * 0.1);
++                baseSpeed *= (1 + aiState.targetVelocity * 0.15); // Increased from 0.1
--                aiState.targetVelocity *= 0.9; // Decay momentum
++                aiState.targetVelocity *= 0.85; // Slower decay
+             }
          } else if (aiState.mode === 'WINDING_UP') {
              // Enhanced windup speed based on phase and settings
              let windupSpeedMultiplier = aiSettings.windupSpeed / AI_WINDUP_SPEED;
--            baseSpeed *= (1.5 + windupSpeedMultiplier);
++            baseSpeed *= (2.0 + windupSpeedMultiplier); // Increased from 1.5
              // Add extra speed at peak velocity points
              if (aiState.peakReached) {
--                baseSpeed *= 1.3;
++                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
++        // Apply aggression multiplier with higher impact
--        baseSpeed *= (1 + aiState.aggressionLevel * 0.3);
++        baseSpeed *= (1 + aiState.aggressionLevel * 0.5); // Increased from 0.3
          let movement = deltaY * baseSpeed;
--        movement = Math.max(-SUPPORT_SPEED * 1.1, Math.min(SUPPORT_SPEED * 1.1, movement));
++
++        // Allow faster movement for hard AI
++        let maxSpeed = SUPPORT_SPEED * (1.2 + aiSettings.aggression * 0.3);
++        movement = Math.max(-maxSpeed, Math.min(maxSpeed, movement));
          // Import moveSupportEnhanced from game-systems
          const moveSupportEnhanced = window.moveSupportEnhanced;
          moveSupportEnhanced(rightSupport, movement, window.height);
          // Update input buffer for visual effects
--        window.inputBuffer.right = movement / (SUPPORT_SPEED * 1.1);
++        window.inputBuffer.right = movement / maxSpeed;
++    } else {
++        // 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.95;
++            window.inputBuffer.right *= 0.9; // Slower decay for more visible movement
++        }
+     }
+ }

js/game-systems.jsmodified

  const CANVAS_HEIGHT = 400;
  // Game constants
--const BALL_SPEED    = 6;
++const BALL_SPEED    = 5;
  const BALL_RADIUS   = 12;
  const PADDLE_WIDTH  = 20;
  const PADDLE_HEIGHT = 80;
  const SPRING_PARTICLE_RATE  = 0.3;
  // Bop system constants
--const BOP_FORCE             = 1.0;  // self explanatory.      BOP   it.
++const BOP_FORCE             = 0.5;  // self explanatory.      BOP   it.
--const BOP_RANGE             = 500;  // also self explanatory. TWIST it.
++const BOP_RANGE             = 40;   // also self explanatory. TWIST it.
--const BOP_DURATION          = 300;  // traversal duration.    SHAKE it.
++const BOP_DURATION          = 900;  // traversal duration.    SHAKE it.
  const BOP_COOLDOWN          = 500;  // also also self expl.   PULL  it.
  const ANCHOR_RECOIL         = 40;   // How far the anchor moves backward during bop
--const BOP_VELOCITY_BOOST    = 12;   // Initial velocity boost for paddle
++const BOP_VELOCITY_BOOST    = 6;    // Initial velocity boost for paddle
  // ============= BOP SYSTEM =============
  let bopState = {
  function activateBop(side, currentTime, paddle, support, engine, particles) {
      const Body = Matter.Body;
--    const Engine = Matter.Engine;
      bopState[side].active = true;
      bopState[side].startTime = currentTime;
          dx /= magnitude;
          dy /= magnitude;
--        // Calculate anchor recoil distance
++        // Calculate anchor recoil distance (reduced for gentler motion)
--        let anchorRecoilDistance = ANCHOR_RECOIL * 0.4;
++        let anchorRecoilDistance = ANCHOR_RECOIL * 0.3; // Reduced from 0.4
          // Move the support BACKWARD (recoil effect)
          let newSupportX = support.position.x - dx * anchorRecoilDistance;
              y: support.position.y + dy * anchorRecoilDistance
          };
--        // Set paddle velocity directly for immediate forward thrust
++        // Set paddle velocity directly for immediate forward thrust (gentler)
--        let forwardSpeed = (BOP_RANGE / SPRING_LENGTH) * BOP_VELOCITY_BOOST;
++        let forwardSpeed = BOP_VELOCITY_BOOST * 0.8; // Reduced intensity
          Body.setVelocity(paddle, {
              x: paddle.velocity.x + dx * forwardSpeed,
              y: paddle.velocity.y + dy * forwardSpeed
          });
--        // Apply a strong forward force for continued acceleration
++        // Apply a forward force for continued acceleration (gentler)
          Body.applyForce(paddle, paddle.position, {
--            x: dx * bopState[side].power * BOP_RANGE * 0.1,
++            x: dx * bopState[side].power * BOP_RANGE * 0.05, // Reduced from 0.1
--            y: dy * bopState[side].power * BOP_RANGE * 0.1
++            y: dy * bopState[side].power * BOP_RANGE * 0.05
          });
          // Create particle burst for visual feedback
                  type: 'impact'
              });
+         }
--
--        // Force collision detection update
--        Engine.update(engine, 0);
+     }
      console.log(side + " player BOP!");
          frictionAir: side === 'left' ? 0.005 : 0.008,
          isSensor: false,
          slop: 0.01,
++        // Add rotational physics
++        inertia: PADDLE_MASS * 200,  // Lower inertia = more rotation
++        frictionAngular: 0.02,       // Slight angular damping
          render: {
              fillStyle: side === 'left' ? '#00ff88' : '#ff6464'
+         }
          bodyB: paddle,
          length: SPRING_LENGTH,
          stiffness: SPRING_STIFFNESS,
--        damping: SPRING_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 }
      });
      return { support, paddle, spring };
      return ball;
+ }
++// ============= COLLISION =============
  // ============= COLLISION =============
  function setupCollisionHandlers(engine, ball, leftPaddle, rightPaddle, particles) {
      const Body = Matter.Body;
++    // Track collision state to prevent double-triggering
++    let collisionState = {
++        left: { inCollision: false, lastCollisionTime: 0 },
++        right: { inCollision: false, lastCollisionTime: 0 }
++    };
++
      Matter.Events.on(engine, 'collisionStart', function(event) {
          let pairs = event.pairs;
                  let paddle = pair.bodyA === ball ? pair.bodyB : pair.bodyA;
                  let isLeftPaddle = paddle === leftPaddle;
++                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
                  if ((isLeftPaddle && bopState.left.active) || (!isLeftPaddle && bopState.right.active)) {
++                    // 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 {
++                        // Fallback distance check
++                        let dx = ball.position.x - paddle.position.x;
++                        let dy = ball.position.y - paddle.position.y;
++                        let distance = Math.sqrt(dx * dx + dy * dy);
++                        let collisionThreshold = BALL_RADIUS + Math.max(PADDLE_WIDTH, PADDLE_HEIGHT)/2 + 10;
++                        isValidCollision = distance < collisionThreshold;
++                    }
++
++                    if (isValidCollision) {
++                        // During bop, ALWAYS apply boost
                          let ballVel = ball.velocity;
                          let paddleVel = paddle.velocity;
--                    let boostX = paddleVel.x * 0.5;
++                        // Calculate the normal collision response first
--                    let boostY = paddleVel.y * 0.5;
++                        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: ballVel.x * 1.3 + boostX,
++                                x: newVelX,
--                        y: ballVel.y * 1.3 + boostY
++                                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; j++) {
++                            for (let j = 0; j < IMPACT_PARTICLES * 2; j++) { // More particles for bop
--                        let angle = Math.random() * Math.PI * 2;
++                                let angle = Math.atan2(normal.y, normal.x) + (Math.random() - 0.5) * Math.PI;
--                        let speed = Math.random() * 6 + 2;
++                                let speed = Math.random() * 8 + 4;
                                  particles.push({
--                            x: ball.position.x,
++                                    x: contactPoint ? contactPoint.x : ball.position.x,
--                            y: ball.position.y,
++                                    y: contactPoint ? contactPoint.y : ball.position.y,
--                            vx: Math.cos(angle) * speed - ballVel.x * 0.2,
++                                    vx: Math.cos(angle) * speed,
--                            vy: Math.sin(angle) * speed - ballVel.y * 0.2,
++                                    vy: Math.sin(angle) * speed,
--                            size: Math.random() * 4 + 2,
++                                    size: Math.random() * 5 + 3,
                                      life: PARTICLE_LIFE,
                                      maxLife: PARTICLE_LIFE,
--                            color: { r: 255, g: Math.random() * 155 + 100, b: Math.random() * 50 + 100 },
++                                    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;
+             }
+         }
      });

js/sprong.jsmodified


         // Enhanced collision detection during bops
         if (bopState.left.active || bopState.right.active) {
             Engine.update(engine, 8);

         }
         
         // Draw everything

`@@ -104,7 +104,6 @@` function draw() {
104	// Enhanced collision detection during bops	104	// Enhanced collision detection during bops
105	if (bopState.left.active \|\| bopState.right.active) {	105	if (bopState.left.active \|\| bopState.right.active) {
106	Engine.update(engine, 8);	106	Engine.update(engine, 8);
107	- Engine.update(engine, 8);
108	}	107	}
109		108
110	// Draw everything	109	// Draw everything