testing rotation

Status	File	+	-
A	`.DS_Store`	bin
M	`js/ai.js`	0	5
M	`js/game-systems.js`	116	2
M	`js/rendering.js`	19	12
M	`js/sprong.js`	2	0

.DS_Storeadded

Binary file changed.

js/ai.jsmodified

`@@ -560,8 +560,3 @@` function executeAIMovement(aiSettings, rightSupport) {
560	}	560	}
561	}	561	}
562	}	562	}
563	-
564	-// Utility function - should match p5.js lerp
565	-function lerp(start, stop, amt) {
566	- return amt * (stop - start) + start;
567	-}

js/game-systems.jsmodified

  // game-systems.js - Core game mechanics and physics
--// TODO redocument
  // ============= CONSTANTS =============
  // Canvas settings
  const ANCHOR_RECOIL         = 60;   // How far the anchor moves backward during bop
  const BOP_VELOCITY_BOOST    = 5;    // Initial velocity boost for paddle
++// Rotation control constants
++const ROTATION_SPEED        = 0.05;  // Base rotation speed (radians per frame)
++const ROTATION_SMOOTHING    = 0.15;  // Input smoothing for rotation (0-1)
++const ROTATION_DAMPING      = 0.92;  // Angular velocity damping (0-1)
++const ROTATION_MAX_SPEED    = 0.2;   // Maximum angular velocity (radians per frame)
++const ROTATION_RESISTANCE   = 3.0;   // How much harder it is to rotate against momentum
++const ROTATION_MOMENTUM     = 0.85;  // How much angular momentum is preserved (0-1)
++const ROTATION_RETURN_FORCE = 0.02;  // Force returning paddle to neutral position
++const ROTATION_MAX_ANGLE    = Math.PI / 4; // Maximum rotation angle (45 degrees)
++const ROTATION_WITH_MOMENTUM_BOOST = 1.5;  // Speed multiplier when rotating with momentum
++const ROTATION_AGAINST_MOMENTUM_LAG = 0.05; // Lag multiplier when rotating against momentum
++
  // ============= BOP SYSTEM =============
  let bopState = {
      left: {
+     }
  };
++// ============= ROTATION SYSTEM =============
++let rotationState = {
++    left: {
++        targetAngle: 0,           // Target angle based on input
++        currentAngle: 0,          // Current visual angle
++        angularVelocity: 0,       // Current angular velocity
++        angularMomentum: 0,       // Angular momentum
++        inputBuffer: 0,           // Smoothed rotation input (-1 to 1)
++        lastDirection: 0          // Last input direction for momentum checks
++    },
++    right: {
++        targetAngle: 0,
++        currentAngle: 0,
++        angularVelocity: 0,
++        angularMomentum: 0,
++        inputBuffer: 0,
++        lastDirection: 0
++    }
++};
++
  function handleBopInput(keys, aiEnabled, currentTime, leftPaddle, rightPaddle, leftSupport, rightSupport, engine, particles) {
      // Left player bop - use Left Shift for both modes
      let leftBopPressed = keys['Shift'] && !keys['Control'];
      return ball;
+ }
--// ============= COLLISION =============
  // ============= COLLISION =============
  function setupCollisionHandlers(engine, ball, leftPaddle, rightPaddle, particles) {
      const Body = Matter.Body;
+         }
      });
+ }
++
++// ============= ROTATION SYSTEM =============
++function handleRotationInput() {
++    // Left paddle rotation (A/D keys)
++    let leftRotationInput = 0;
++    if (keys['a'] || keys['A']) leftRotationInput -= 1;
++    if (keys['d'] || keys['D']) leftRotationInput += 1;
++
++    // Right paddle rotation (Left/Right arrows, only if AI disabled)
++    let rightRotationInput = 0;
++    if (!aiEnabled) {
++        if (keys['ArrowLeft']) rightRotationInput -= 1;
++        if (keys['ArrowRight']) rightRotationInput += 1;
++    }
++
++    // Update rotation states
++    updateRotationPhysics('left', leftRotationInput, leftPaddle);
++    if (!aiEnabled) {
++        updateRotationPhysics('right', rightRotationInput, rightPaddle);
++    }
++}
++
++function updateRotationPhysics(side, input, paddle) {
++    const Body = Matter.Body;
++    let state = rotationState[side];
++
++    // Smooth the input
++    state.inputBuffer = lerp(state.inputBuffer, input, ROTATION_SMOOTHING);
++
++    // Calculate resistance based on momentum
++    let rotatingWithMomentum = (state.inputBuffer * state.angularVelocity) > 0;
++    let effectiveInput = state.inputBuffer;
++
++    if (rotatingWithMomentum && Math.abs(state.inputBuffer) > 0.1) {
++        // Easier to rotate with momentum
++        effectiveInput *= ROTATION_WITH_MOMENTUM_BOOST;
++    } else if (!rotatingWithMomentum && Math.abs(state.inputBuffer) > 0.1) {
++        // Harder to rotate against momentum
++        effectiveInput *= ROTATION_AGAINST_MOMENTUM_LAG;
++    }
++
++    // Apply torque based on input
++    let torque = effectiveInput * ROTATION_SPEED;
++
++    // Update angular velocity with torque
++    state.angularVelocity += torque;
++
++    // Apply damping
++    state.angularVelocity *= ROTATION_DAMPING;
++
++    // Limit maximum angular velocity
++    state.angularVelocity = Math.max(-ROTATION_MAX_SPEED,
++                                    Math.min(ROTATION_MAX_SPEED, state.angularVelocity));
++
++    // Apply return-to-center force when no input
++    if (Math.abs(state.inputBuffer) < 0.1) {
++        let returnForce = -state.currentAngle * ROTATION_RETURN_FORCE;
++        state.angularVelocity += returnForce;
++    }
++
++    // Update current angle
++    state.currentAngle += state.angularVelocity;
++
++    // Limit maximum rotation angle
++    state.currentAngle = Math.max(-ROTATION_MAX_ANGLE,
++                                 Math.min(ROTATION_MAX_ANGLE, state.currentAngle));
++
++    // Apply rotation to the paddle body
++    Body.setAngle(paddle, state.currentAngle);
++
++    // Update angular momentum for next frame
++    state.angularMomentum = state.angularMomentum * ROTATION_MOMENTUM +
++                           state.angularVelocity * (1 - ROTATION_MOMENTUM);
++
++    // Track last direction for momentum calculations
++    if (Math.abs(input) > 0.1) {
++        state.lastDirection = Math.sign(input);
++    }
++}
++
++// ============= HELPER FUNCTIONS =============
++function lerp(start, stop, amt) {
++    return amt * (stop - start) + start;
++}

js/rendering.jsmodified

      text(`R Spring: ${Math.round(rightSpringLength)}px (${((SPRING_LENGTH/rightSpringLength - 1) * 100).toFixed(0)}%)`, 10, 95);
      text(`Input: L=${inputBuffer.left.toFixed(2)} R=${inputBuffer.right.toFixed(2)}`, 10, 110);
++    // Rotation info
++    if (window.rotationState) {
++        text(`L Rot: ${(window.rotationState.left.currentAngle * 180 / Math.PI).toFixed(1)}° (vel: ${window.rotationState.left.angularVelocity.toFixed(3)})`, 10, 125);
++        text(`R Rot: ${(window.rotationState.right.currentAngle * 180 / Math.PI).toFixed(1)}° (vel: ${window.rotationState.right.angularVelocity.toFixed(3)})`, 10, 140);
++    }
++
      // AI debug info
      if (aiEnabled) {
--        text(`AI State: ${aiState.mode} | Aggression: ${aiState.aggressionLevel.toFixed(2)}`, 10, 125);
++        text(`AI State: ${aiState.mode} | Aggression: ${aiState.aggressionLevel.toFixed(2)}`, 10, 155);
--        text(`Target: ${Math.round(aiState.targetY)} | Intercept: ${Math.round(aiState.interceptY)}`, 10, 140);
++        text(`Target: ${Math.round(aiState.targetY)} | Intercept: ${Math.round(aiState.interceptY)}`, 10, 170);
--        text(`Ball: (${Math.round(ball.position.x)}, ${Math.round(ball.position.y)}) Vel: (${ball.velocity.x.toFixed(1)}, ${ball.velocity.y.toFixed(1)})`, 10, 155);
++        text(`Ball: (${Math.round(ball.position.x)}, ${Math.round(ball.position.y)}) Vel: (${ball.velocity.x.toFixed(1)}, ${ball.velocity.y.toFixed(1)})`, 10, 185);
          // AI technique indicators
          if (aiState.mode === 'WINDING_UP') {
              fill(255, 150, 50, 200);
--            text(`AI WINDING UP | Phase: ${(aiState.windupPhase % (Math.PI * 2)).toFixed(2)} | Velocity: ${aiState.currentVelocity.toFixed(1)}`, 10, 175);
++            text(`AI WINDING UP | Phase: ${(aiState.windupPhase % (Math.PI * 2)).toFixed(2)} | Velocity: ${aiState.currentVelocity.toFixed(1)}`, 10, 205);
              if (aiState.comboBop) {
                  fill(255, 50, 255, 200);
--                text("⚡ COMBO PLANNED!", 10, 190);
++                text("⚡ COMBO PLANNED!", 10, 220);
+             }
          } else if (aiState.mode === 'SWINGING') {
              fill(255, 50, 50, 200);
--            text("AI POWER SWING!", 10, 175);
++            text("AI POWER SWING!", 10, 205);
          } else if (aiState.consideringBop) {
              fill(255, 255, 100, 200);
--            text("AI PREPARING BOP!", 10, 175);
++            text("AI PREPARING BOP!", 10, 205);
+         }
          if (bopState.right.active) {
              fill(255, 255, 0, 255);
--            text("AI BOPPING!", 10, 190);
++            text("AI BOPPING!", 10, 220);
+         }
+     }
+ }
      textSize(14);
      if (aiEnabled) {
--        text("Player vs CPU | Left paddle: W/S or Mouse/Touch", width/2, height/2 + 125);
++        text("Player vs CPU | Move: W/S or Mouse/Touch | Rotate: A/D | Bop: Left Shift", width/2, height/2 + 125);
          text(`AI Difficulty: ${aiDifficulty.toUpperCase()}`, width/2, height/2 + 145);
      } else {
--        text("2 Player Mode | P1: W/S | P2: ↑/↓ | Mouse/Touch: Drag paddles", width/2, height/2 + 125);
++        text("2 Player Mode | P1: W/S + A/D + L.Shift | P2: ↑/↓ + ←/→ + Enter", width/2, height/2 + 125);
++        text("Mouse/Touch: Drag paddles", width/2, height/2 + 145);
+     }
      textSize(12);
      textSize(12);
      fill(255, 100);
      if (menuState.selectedOption === 0) {
--        text("Controls: W/S keys + LEFT SHIFT (bop) or Mouse/Touch", width/2, height - 30);
++        text("Controls: W/S (move) + A/D (rotate) + LEFT SHIFT (bop) or Mouse/Touch", width/2, height - 30);
      } else {
--        text("Controls: P1 (W/S + L.Shift) | P2 (↑/↓ + Enter) | Mouse/Touch", width/2, height - 30);
++        text("P1: W/S + A/D + L.Shift | P2: ↑/↓ + ←/→ + Enter | Mouse/Touch", width/2, height - 30);
+     }
+ }

js/sprong.jsmodified

  window.inputBuffer = inputBuffer;
  window.moveSupportEnhanced = moveSupportEnhanced;
  window.ball = null;
++window.rotationState = rotationState;
  function setup() {
      let canvas = createCanvas(CANVAS_WIDTH, CANVAS_HEIGHT);
  function handleEnhancedInput() {
      handleKeyboardInput();
      handleMouseTouchInput();
++    handleRotationInput();  // Add rotation handling
      handleBopInput(keys, aiEnabled, millis(), leftPaddle, rightPaddle,
                     leftSupport, rightSupport, engine, particles);

zeroed-some/sprong / `5b429e8`

5 changed files