dino

function setup() {
  createCanvas(windowWidth, windowHeight);

  ground = new Ground();
  dino = new Dino();

  textSize(24);
  textAlign(RIGHT, TOP);

  initializeObstacles(); // Initialize the fixed course
}

function draw() {
  background(220); // Light gray background

  // Check if dino was dead from the previous frame, and reset if so
  if (dino.isDead) {
    resetGame();
    return; // Exit draw() early after reset to prevent further updates in the same frame
  }

  // Game loop runs continuously
  // 1. Process the outcome of the action chosen in the *previous* frame
  // This allows us to check if the dino survived for at least one frame after the action
  if (currentAction !== null) {
    console.log("Processing action:", currentAction.type, "Targeted Obs Count:", currentAction.obstaclesToEvaluate ? currentAction.obstaclesToEvaluate.length : 0);
    if (checkCollision()) {
      // Failure: The action chosen in the previous frame led to a collision
      // Set dino to dead state for visual feedback this frame
      dino.isDead = true;
      // The winningList is NOT updated in case of failure
      currentAction = null; // Clear pending action
      console.log("  Action FAILED: Collision. Resetting next frame.");
      // Do NOT resetGame() immediately, let it render red dino this frame
    } else {
      // Success: No collision occurred. Record outcomes.
      let outcomeRecorded = false; // Flag to check if at least one outcome was recorded

      if (currentAction.type === 'jump' && currentAction.obstaclesToEvaluate !== null) {
        // Iterate through the snapshot of obstacles that were targeted by this jump
        for (let evalObstacle of currentAction.obstaclesToEvaluate) {
          const targetObstacle = obstacles.find(o => o.id === evalObstacle.id);

          // Check if the obstacle was successfully cleared
          // (either still in array and its left edge passed dino's right edge, OR removed from array)
          if ((targetObstacle && (targetObstacle.x < dino.x + dino.w)) || !targetObstacle) { // THIS IS THE NEW CHANGE
            winningList.push({ type: 'positive_jump', obstacleCourseIndex: evalObstacle.obstacleCourseIndex });
            console.log("  WinningList updated. Added POSITIVE JUMP for obstacle:", evalObstacle.obstacleCourseIndex);
            outcomeRecorded = true;
          }
        }
      }

      // If no positive jumps were recorded by this action (e.g., was 'duck', 'none', or a jump that missed)
      if (!outcomeRecorded) {
        winningList.push('neutral'); // Add 'neutral' outcomes to the winningList
        console.log("  WinningList updated. Added NEUTRAL outcome.");
      }
    }
    currentAction = null; // Clear the current action for the next decision cycle
  }

  // 2. Update and show game elements
  noStroke(); // Ensure ground has no stroke
  ground.update();
  ground.show();

  noStroke(); // Ensure dino has no stroke
  dino.update();
  dino.show(); // Show dino (will be red if just collided)

  // 3. Update and show obstacles
  for (let i = obstacles.length - 1; i >= 0; i--) {
    obstacles[i].update();
    obstacles[i].show();

    // Remove off-screen obstacles
    if (obstacles[i].offscreen()) {
      obstacles.splice(i, 1);
    }
  }

  // 4. Dino's action decision logic (now uses decideDinoAction)
  currentAction = decideDinoAction();

  // 5. Increase score and game speed
  score++;
  gameSpeed += 0.001; // Gradually increase game speed


  // Display score
  fill(0);
  noStroke(); // Ensure score text has no stroke
  text('Score: ' + score, width - 20, 20);
  text('High Score: ' + highScore, width - 20, 50);

  // Display Winning List - showing counts for positive jumps and neutral actions
  textAlign(LEFT, TOP);
  text('Winning List (Positive/Neutral):', 20, 20); // Updated title
  const positiveCount = winningList.filter(a => typeof a === 'object' && a.type === 'positive_jump').length;
  const neutralCount = winningList.filter(a => a === 'neutral').length;
  text(`- Positive Jumps: ${positiveCount}`, 20, 50);
  text(`- Neutral Actions: ${neutralCount}`, 20, 80);
  textAlign(RIGHT, TOP); // Reset alignment for score display
}

function decideDinoAction() {
  if (!dino.isGrounded()) {
    return { type: 'none', obstaclesToEvaluate: null }; // Cannot act if not grounded
  }

  let chosenAction = null;
  let obstaclesToEvaluate = null; // Stores snapshot for evaluation

  // 1. Find the closest obstacle currently in front of the dino
  let closestObstacle = null;
  let minDistance = Infinity;
  for (let obstacle of obstacles) {
    if (obstacle.x > dino.x + dino.w) {
      const distance = obstacle.x - (dino.x + dino.w);
      if (distance < minDistance) {
        minDistance = distance;
        closestObstacle = obstacle;
      }
    }
  }

  console.log("decideDinoAction: Closest obstacle found:", closestObstacle ? closestObstacle.obstacleCourseIndex : "None");

  // 2. Prioritize Learned Positive Jumps
  if (closestObstacle) {
    // Check if a positive jump for this specific obstacleCourseIndex is in winningList
    const learnedJump = winningList.find(a => typeof a === 'object' && a.type === 'positive_jump' && a.obstacleCourseIndex === closestObstacle.obstacleCourseIndex);

    if (learnedJump) {
      dino.jump();
      chosenAction = 'jump';
      // When a learned jump is triggered, we still need to capture obstacles for evaluation
      // Capture all obstacles in front of the dino's right edge
      obstaclesToEvaluate = obstacles.filter(o => o.x > dino.x + dino.w).map(o => ({ id: o.id, obstacleCourseIndex: o.obstacleCourseIndex }));
      console.log("  Learned POSITIVE JUMP triggered for obstacle:", closestObstacle.obstacleCourseIndex, ". Evaluating", obstaclesToEvaluate.length, "obstacles.");
    }
  }

  // 3. If no learned jump was triggered, then take a new random action, respecting the interval.
  if (chosenAction === null && (frameCount - lastRandomActionFrame > randomActionInterval || obstacles.length === 0)) {
    lastRandomActionFrame = frameCount; // Reset interval for random actions

    const actions = ['jump', 'duck', 'none'];
    const weights = [0.3, 0.2, 0.5];
    let choice = random(1);
    let cumulativeWeight = 0;

    for (let i = 0; i < actions.length; i++) {
      cumulativeWeight += weights[i];
      if (choice < cumulativeWeight) {
        chosenAction = actions[i];
        console.log("  Random action chosen:", chosenAction);
        if (chosenAction === 'jump') {
          dino.jump();
          // Capture all obstacles in front for evaluation
          // Capture all obstacles in front of the dino's right edge
          obstaclesToEvaluate = obstacles.filter(o => o.x > dino.x + dino.w).map(o => ({ id: o.id, obstacleCourseIndex: o.obstacleCourseIndex }));
        } else if (chosenAction === 'duck') {
          dino.duck();
          // For duck, we don't need obstaclesToEvaluate for positive jump logic, but keep it consistent
          obstaclesToEvaluate = obstacles.filter(o => o.x > dino.x + dino.w).map(o => ({ id: o.id, obstacleCourseIndex: o.obstacleCourseIndex }));
        }
        break; // Exit loop once action is chosen
      }
    }
  }

  // 4. If still no action (e.g., repetition failed and random interval not met), default to 'none'
  if (chosenAction === null) {
    chosenAction = 'none';
    console.log("  Defaulting to 'none' action.");
  }

  return { type: chosenAction, obstaclesToEvaluate: obstaclesToEvaluate };
}

function initializeObstacles() {
  for (let i = 0; i < fixedObstacleCourse.length; i++) { // Loop with index i
    const obsDef = fixedObstacleCourse[i];
    if (obsDef.type === 'cactus') {
      obstacles.push(new Cactus(width + obsDef.xOffset, i)); // Pass index as obstacleCourseIndex
    } else if (obsDef.type === 'bird') {
      obstacles.push(new Bird(width + obsDef.xOffset, i)); // Pass index as obstacleCourseIndex
    }
  }
}

function resetGame() {
  gameOver = false; // Ensure this is false for the next game loop
  highScore = max(highScore, score);
  score = 0;
  gameSpeed = 5;
  obstacles = []; // Clear current obstacles
  obstacleIdCounter = 0; // Reset obstacle IDs for the new course
  initializeObstacles(); // Re-initialize the fixed course
  dino.reset(); // Reset dino's position and state, including isDead flag
  currentAction = null; // Clear any pending action
  lastRandomActionFrame = 0; // Reset random action timer
  // The winningList is NOT cleared, as per user request ("over time the winning list will grow and grow")
}

class Dino {
  constructor() {
    this.w = 50; // Dino width
    this.h = 60; // Dino height (standing)
    this.duckH = 30; // Dino height (ducking)
    this.x = 50;
    this.y = height - ground.y - this.h; // Initial position on the ground
    this.velocity = 0;
    this.gravity = 0.8; // Gravity strength
    this.isJumping = false;
    this.isDucking = false;
    this.initialY = this.y; // Store initial Y for reset and ground check
    this.isDead = false; // New flag for collision feedback
  }

  jump() {
    if (!this.isJumping && !this.isDucking) {
      this.velocity = -20; // Upward velocity for jump - Increased for higher jumps
      this.isJumping = true;
    }
  }

  duck() {
    if (!this.isJumping && !this.isDucking) {
      this.isDucking = true;
      this.y += (this.h - this.duckH); // Move dino down to duck
    }
  }

  update() {
    // Apply gravity
    this.velocity += this.gravity;
    this.y += this.velocity;

    // Prevent dino from going below the ground
    if (this.y >= this.initialY) {
      this.y = this.initialY;
      this.velocity = 0;
      this.isJumping = false;
      // If dino was ducking and hit the ground, stand up
      if (this.isDucking) {
        this.y -= (this.h - this.duckH); // Move dino up to stand
        this.isDucking = false;
      }
    }
  }

  show() {
    if (this.isDead) {
      fill(255, 0, 0); // Red when dead
    } else {
      fill(50); // Dark gray dino
    }
    if (this.isDucking) {
      rect(this.x, this.y, this.w, this.duckH);
    } else {
      rect(this.x, this.y, this.w, this.h);
    }
  }

  isGrounded() {
    return this.y === this.initialY && !this.isJumping;
  }

  // Reset dino's state
  reset() {
    this.y = height - ground.y - this.h;
    this.initialY = this.y;
    this.velocity = 0;
    this.isJumping = false;
    this.isDucking = false;
    this.isDead = false; // Reset dead state
  }
}

class Ground {
  constructor() {
    this.x1 = 0;
    this.x2 = width;
    this.y = 80; // Height from the bottom of the canvas
    this.h = 10;
  }

  update() {
    this.x1 -= gameSpeed;
    this.x2 -= gameSpeed;

    if (this.x1 < -width) {
      this.x1 = width;
    }
    if (this.x2 < -width) {
      this.x2 = width;
    }
  }

  show() {
    fill(100); // Gray ground
    rect(this.x1, height - this.y, width, this.h);
    rect(this.x2, height - this.y, width, this.h);
  }

  reset() {
    this.x1 = 0;
    this.x2 = width;
  }
}

class Obstacle {
  constructor(x, y, w, h, obstacleCourseIndex) { // obstacleCourseIndex parameter added
    this.x = x; // Use provided x, not just width
    this.y = y;
    this.w = w;
    this.h = h;
    this.id = obstacleIdCounter++; // Assign a unique ID to each obstacle in the current session
    this.obstacleCourseIndex = obstacleCourseIndex; // Store the index from the fixed course
  }

  update() {
    this.x -= gameSpeed;
  }

  show() {
    stroke(0); // Add a black stroke (outline)
    strokeWeight(1); // Set stroke weight to 1 pixel
    fill(0); // Make obstacles black for better contrast
    rect(this.x, this.y, this.w, this.h);
  }

  offscreen() {
    return this.x < -this.w;
  }
}

class Cactus extends Obstacle {
  constructor(x, obstacleCourseIndex) { // obstacleCourseIndex passed from initializeObstacles
    const cactusWidth = random(20, 50);
    const cactusHeight = random(40, 80);
    super(x, height - ground.y - cactusHeight, cactusWidth, cactusHeight, obstacleCourseIndex); // Pass obstacleCourseIndex to parent
    this.type = 'cactus';
  }
}

class Bird extends Obstacle {
  constructor(x, obstacleCourseIndex) { // obstacleCourseIndex passed from initializeObstacles
    const birdWidth = random(30, 60);
    const birdHeight = 30; // Birds have a fixed height for simplicity
    // Birds can fly at different heights
    const birdY = random(height - ground.y - dino.h - 100, height - ground.y - dino.h - 30);
    super(x, birdY, birdWidth, birdHeight, obstacleCourseIndex); // Pass obstacleCourseIndex to parent
    this.type = 'bird';
  }
}

function checkCollision() {
  let dinoHitbox;
  if (dino.isDucking) {
    dinoHitbox = {
      x: dino.x,
      y: dino.y,
      w: dino.w,
      h: dino.duckH
    };
  } else {
    dinoHitbox = {
      x: dino.x,
      y: dino.y,
      w: dino.w,
      h: dino.h
    };
  }

  for (let obstacle of obstacles) {
    let obstacleHitbox = {
      x: obstacle.x,
      y: obstacle.y,
      w: obstacle.w,
      h: obstacle.h
    };

    // Simple AABB (Axis-Aligned Bounding Box) collision detection
    if (dinoHitbox.x < obstacleHitbox.x + obstacleHitbox.w &&
      dinoHitbox.x + dinoHitbox.w > obstacleHitbox.x &&
      dinoHitbox.y < obstacleHitbox.y + obstacleHitbox.h &&
      dinoHitbox.y + dinoHitbox.h > obstacleHitbox.y) {
      return true; // Collision detected
    }
  }
  return false; // No collision
}

function keyPressed() {
  if (key === ' ' || keyCode === UP_ARROW) {
    resetGame();
  }
}

function touchStarted() {
  resetGame();
  return false; // Prevent default touch action
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
  ground.reset(); // Adjust ground based on new width
  dino.reset(); // Adjust dino based on new height
  // Re-initialize obstacles on resize to reposition them correctly
  obstacles = [];
  obstacleIdCounter = 0;
  initializeObstacles();
}