`420b0f7`

make ai less stupid

Authored by

espadonne 9 months ago

SHA: 420b0f7d994fa8a51ad4eb494d46ff049a6914eb
Parents: a64f1ed
Tree: 6798017

1 changed file

Status	File	+	-
M	`sprong.js`	148	84

sprong.jsmodified

  let rightSupport, rightPaddle, rightSpring;
  // Game state
--let gameMode    = 'vs-cpu';  // 'vs-cpu' or 'vs-human'
  let leftScore = 0;
--let aiEnabled   = true;
--let gameState   = 'menu';   // 'menu', 'playing', 'paused'
  let rightScore = 0;
  let gameStarted = false;
++let gameState = 'menu'; // 'menu', 'playing', 'paused'
++let gameMode = 'vs-cpu'; // 'vs-cpu' or 'vs-human'
++let aiEnabled = true;
  // Menu state
  let menuState = {
      aggressionLevel: 0.5, // 0 = defensive, 1 = maximum aggression
      lastHitTime: 0,
--    // Oscillation parameters (tuned for smoother movement)
++    // Oscillation parameters (increased for better windup)
--    windupDistance: 40,   // Slightly increased from 35 with longer spring
++    windupDistance: 120,  // Much bigger - about half canvas height
      swingPower: 1.05,     // Reduced from 1.1 for more control
      timingWindow: 40,     // Slightly longer execution window
  const SUPPORT_MAX_SPEED = 8;      // Higher max speed
  // Touch/mouse control constants
--const MOUSE_SPEED_LIMIT = 4;    // Max speed for mouse movement
  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
  // Spring physics constants (adjusted for better oscillation)
          leftSupport, leftPaddle, leftSpring,
          rightSupport, rightPaddle, rightSpring
      ]);
++
++    console.log("Sprong Phase 5 Complete!");
++    console.log("Particle effects system");
++    console.log("Tuned physics for maximum bounce");
++    console.log("Faster, more responsive paddles");
+ }
  function createSpringPaddleSystem(side) {
+ }
  function handleAITracking(currentTime, ballPos, ballVel, aiSettings) {
--    // Only react if enough time has passed (reaction delay)
++    // Always track ball position for more responsive movement
--    if (currentTime - aiState.lastUpdateTime < aiSettings.reactionTime) return;
--
--    // Check if ball is approaching AI paddle
      let ballApproaching = ballVel.x > 0;
      let ballDistance = width - ballPos.x;
      let ballSpeed = Math.sqrt(ballVel.x * ballVel.x + ballVel.y * ballVel.y);
--    if (ballApproaching && ballDistance < 280) {
++    // 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);
--        aiState.interceptY = ballPos.y + ballVel.y * timeToReach;
++            let predictedBallY = ballPos.y + ballVel.y * timeToReach;
              // Account for wall bounces
--        if (aiState.interceptY < 50) {
++            if (predictedBallY < 50) {
--            aiState.interceptY = 100 - aiState.interceptY;
++                predictedBallY = 100 - predictedBallY;
--        } else if (aiState.interceptY > height - 50) {
++            } else if (predictedBallY > height - 50) {
--            aiState.interceptY = 2 * (height - 50) - aiState.interceptY;
++                predictedBallY = 2 * (height - 50) - predictedBallY;
+             }
              // Add accuracy error
              let error = (random() - 0.5) * 35 * (1 - aiSettings.accuracy);
--        aiState.interceptY += error;
++            predictedBallY += error;
--        // Smart oscillation decision: lower velocity threshold and more distance
++            // Calculate where PADDLE needs to be to hit the ball
--        let shouldWindUp = ballSpeed < 7 &&           // Reduced from 9 - easier to trigger
++            aiState.interceptY = predictedBallY;
--                          ballDistance > 160 &&       // More distance required
++
--                          Math.abs(ballVel.y) < 5 &&  // Stricter vertical movement limit
++            // Calculate where ANCHOR needs to be to position paddle correctly
--                          random() < aiSettings.oscillation * aiState.aggressionLevel;
++            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 intercept)
++                // Determine windup direction (opposite of where paddle needs to be)
--            let currentY = rightSupport.position.y;
++                aiState.windupDirection = aiState.interceptY > paddlePos.y ? -1 : 1;
--            aiState.windupDirection = aiState.interceptY > currentY ? -1 : 1;
              } else {
--            // Simple tracking without oscillation
++                // Use paddle-aware intercept positioning
--            aiState.targetY = aiState.interceptY;
++                aiState.targetY = lerp(aiState.targetY, targetAnchorForIntercept, 0.3);
+             }
              aiState.lastUpdateTime = currentTime;
--    } else {
--        // When ball isn't approaching, do lifelike tracking
--        let trackingY = ballPos.y + aiState.microAdjustment;
--        trackingY = constrain(trackingY, 80, height - 80);
--        aiState.targetY = lerp(aiState.targetY, trackingY, 0.02); // Very gentle tracking
+         }
+     }
++}
++
++// 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;
++}
  function handleAIWindup(currentTime, ballPos, ballVel, aiSettings) {
      let windupTime = currentTime - aiState.windupStartTime;
--    let maxWindupTime = 350 / Math.max(aiState.aggressionLevel, 0.3); // Slower windup, minimum time
++    let maxWindupTime = 500 / Math.max(aiState.aggressionLevel, 0.3); // Longer windup for bigger movement
--    // Calculate windup target (move away from intercept point)
++    // Calculate windup target with much bigger distance
--    let currentY = rightSupport.position.y;
++    let paddlePos = rightPaddle.position;
--    let windupTarget = currentY + aiState.windupDirection * aiState.windupDistance * aiState.aggressionLevel;
++    let windupTarget = paddlePos.y + aiState.windupDirection * aiState.windupDistance * aiState.aggressionLevel;
--    windupTarget = constrain(windupTarget, 70, height - 70); // More margin from edges
++    windupTarget = constrain(windupTarget, 50, height - 50); // Allow closer to edges for big windup
--    aiState.targetY = windupTarget;
++    // 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 - more conservative timing
++    // Check if it's time to swing - allow more time for bigger windups
      let ballDistance = width - ballPos.x;
      let ballSpeed = Math.sqrt(ballVel.x * ballVel.x + ballVel.y * ballVel.y);
      let shouldSwing = windupTime > maxWindupTime ||
--                     ballDistance < 90 ||
++                     ballDistance < 120 ||
--                     ballSpeed > 8; // Lower threshold - abort if ball speeds up
++                     ballSpeed > 6; // Abort if ball speeds up even slightly
      if (shouldSwing) {
          aiState.mode = 'SWINGING';
+ }
  function handleAISwing(currentTime, ballPos, ballVel, aiSettings) {
--    // Aggressive swing toward intercept point
++    // Aggressive swing toward intercept point - but position anchor for paddle placement
--    aiState.targetY = aiState.interceptY;
++    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;
      let swingTime = currentTime - aiState.swingStartTime;
      let maxSwingTime = aiState.timingWindow;
+ }
  function handleAIAnticipation(currentTime, ballPos, ballVel, aiSettings) {
--    // Stay near center with subtle lifelike movements
++    // Stay near center with subtle lifelike movements, but use paddle-aware positioning
--    aiState.targetY = aiState.idleTarget + aiState.breathingOffset + aiState.microAdjustment;
++    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;
      // Switch back to tracking when ball changes direction
      if (ballVel.x > 0) {
      let currentY = rightSupport.position.y;
      let deltaY = aiState.targetY - currentY;
--    if (Math.abs(deltaY) > 2) { // Smaller dead zone for more responsive micro-movements
++    if (Math.abs(deltaY) > 1) { // Very small dead zone for responsive tracking
--        let baseSpeed = 0.06 * aiSettings.speed; // Slightly slower base movement
++        let baseSpeed = 0.08 * aiSettings.speed; // Back to more responsive speed
          // Apply swing power during swing phase
          if (aiState.mode === 'SWINGING') {
              baseSpeed *= aiState.swingPower * (1 + aiState.aggressionLevel * 0.3);
          } else if (aiState.mode === 'WINDING_UP') {
--            baseSpeed *= 0.7; // Slower during windup for more deliberate movement
++            baseSpeed *= 0.6; // Slower during windup for more deliberate movement
+         }
          // Apply aggression multiplier
          // Show AI technique indicators
          if (aiState.mode === 'WINDING_UP') {
              fill(255, 150, 50, 200);
--            text("AI WINDING UP FOR POWER SHOT", 10, 175);
++            text("🔄 AI WINDING UP FOR POWER SHOT", 10, 175);
          } else if (aiState.mode === 'SWINGING') {
              fill(255, 50, 50, 200);
              text("⚡ AI POWER SWING!", 10, 175);
      if (key === 'm' || key === 'M') {
          aiEnabled = !aiEnabled;
          gameMode = aiEnabled ? 'vs-cpu' : 'vs-human';
--        console.log(`Switched to ${gameMode} mode`);
++        console.log("Switched to " + gameMode + " mode");
+     }
      // Change AI difficulty (only during gameplay)
          } else {
              aiState.difficulty = 'easy';
+         }
--        console.log(`AI difficulty: ${aiState.difficulty}`);
++        console.log("AI difficulty: " + aiState.difficulty);
+     }
      // Reset game with spacebar
+     }
      // Return to menu with ESC
--    if (keyCode === 27) { // ESC key
++    if (keyCode === 27) {
          gameState = 'menu';
          gameStarted = false;
          particles = [];
      // Clear particles
      particles = [];
--    console.log(`Started ${gameMode} mode${aiEnabled ? ' - Difficulty: ' + aiState.difficulty : ''}`);
++    console.log("Started " + gameMode + " mode" + (aiEnabled ? " - Difficulty: " + aiState.difficulty : ""));
+ }
  function keyReleased() {