reverse platform

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

function resetGame() {
  platforms = [];
  spikes = [];
  waypoints = [];

  const groundH = 24;
  const groundY = height - groundH / 2;

  // --- Main ground segments ---
  const groundW = width * 0.36;

  // Left ground
  platforms.push(new Platform(width * 0.18, groundY, groundW, groundH, false));
  // Right ground
  platforms.push(new Platform(width * 0.82, groundY, groundW, groundH, false));

  // --- Movable platforms (you control these) ---

  // Movable bridge across the center gap (ground level)
  platforms.push(new Platform(width * 0.5, groundY, width * 0.18, 20, true));

  const movableW = width * 0.16;
  const movableH = 18;

  // Extra movable platform above the left side of the gap
  platforms.push(new Platform(width * 0.35, groundY - 120, movableW, movableH, true));

  // Extra movable platform higher in the middle
  platforms.push(new Platform(width * 0.65, groundY - 160, movableW * 0.9, movableH, true));

  // Extra movable platform over the right side
  platforms.push(new Platform(width * 0.78, groundY - 70, movableW * 0.7, movableH, true));

  // --- Static platforms for alternate routes / decoration ---

  const smallW = width * 0.14;
  const smallH = 18;

  // Above left ground
  platforms.push(new Platform(width * 0.22, groundY - 80, smallW, smallH, false));

  // High middle platform
  platforms.push(new Platform(width * 0.48, groundY - 210, smallW * 0.9, smallH, false));

  // Very high right‑middle platform
  platforms.push(new Platform(width * 0.72, groundY - 230, smallW * 0.8, smallH, false));

  // Floating platform near the goal side
  platforms.push(new Platform(width * 0.9, groundY - 140, smallW * 0.7, smallH, false));

  // Select the first movable platform (in case we add more later)
  selectedPlatformIndex = platforms.findIndex(p => p.movable);
  if (selectedPlatformIndex === -1) selectedPlatformIndex = 0;

  // Goal zone on the right side (tall so the AI can touch it from ground or platforms)
  goal = {
    x: width * 0.9,
    y: groundY - 120,
    w: 70,
    h: 140
  };

  // AI starts on left ground, walking to the right
  ai = new AIPlayer(width * 0.1, groundY - 40);

  // --- Built‑in spikes: a deadly pit in the center gap ---
  // (You can still add more spikes with the mouse.)

  const spikeW = 26;
  const spikeH = 26;

  const pitY = height - 30;
  for (let x = width * 0.38; x <= width * 0.62; x += 34) {
    spikes.push({ x, y: pitY, w: spikeW, h: spikeH });
  }

  // --- Scripted obby path (waypoints) the AI will try to follow ---
  // Indices in platforms[] noted above.

  const leftGround = platforms[0];
  const rightGround = platforms[1];

  // 0: Jump from left ground up to the static platform above it (index 6)
  waypoints.push({ x: platforms[6].x, y: platforms[6].y });

  // 1: Run off that platform and drop back down to left ground near the gap
  waypoints.push({
    x: leftGround.x + leftGround.w * 0.35,
    y: leftGround.y
  });

  // 2: Cross the center on the movable bridge (index 2)
  waypoints.push({ x: platforms[2].x, y: platforms[2].y });

  // 3: Reach mid-right section of the right ground
  waypoints.push({
    x: rightGround.x - rightGround.w * 0.35,
    y: rightGround.y
  });

  // 4: Jump up to the movable platform over the right side (index 5)
  waypoints.push({ x: platforms[5].x, y: platforms[5].y });

  // 5: Jump again to the floating platform near the goal (index 9)
  waypoints.push({ x: platforms[9].x, y: platforms[9].y });

  // After waypoint 5, the AI just heads for the goal rectangle.
}

function draw() {
  background(20, 24, 40);

  handlePlatformControl();

  // Update AI logic & physics
  ai.update(platforms, spikes, goal);

  // Draw goal
  drawGoal();

  // Draw platforms
  for (let i = 0; i < platforms.length; i++) {
    platforms[i].display(i === selectedPlatformIndex);
  }

  // Draw spikes
  drawSpikes();

  // Draw AI
  ai.display();

  // HUD / instructions
  drawHUD();
}

function handlePlatformControl() {
  const p = platforms[selectedPlatformIndex];
  if (!p || !p.movable) return;

  const speed = 5;

  // Arrow keys or WASD for moving the selected platform
  if (keyIsDown(LEFT_ARROW) || keyIsDown(65)) { // A
    p.x -= speed;
  }
  if (keyIsDown(RIGHT_ARROW) || keyIsDown(68)) { // D
    p.x += speed;
  }
  if (keyIsDown(UP_ARROW) || keyIsDown(87)) { // W
    p.y -= speed;
  }
  if (keyIsDown(DOWN_ARROW) || keyIsDown(83)) { // S
    p.y += speed;
  }

  // Constrain inside the canvas
  p.x = constrain(p.x, p.w / 2, width - p.w / 2);
  p.y = constrain(p.y, 80, height - 40);
}

function keyPressed() {
  // Switch which platform is selected (cycles through all movable ones)
  if (key === 'q' || key === 'Q') {
    selectedPlatformIndex--;
    if (selectedPlatformIndex < 0) {
      selectedPlatformIndex = platforms.length - 1;
    }
  } else if (key === 'e' || key === 'E') {
    selectedPlatformIndex++;
    if (selectedPlatformIndex >= platforms.length) {
      selectedPlatformIndex = 0;
    }
  }

  // Reset
  if (key === 'r' || key === 'R') {
    resetGame();
  }
}

function mousePressed() {
  // Spawn a spike obstacle where you click
  // (avoid very top so you don't cover the HUD)
  if (mouseY > 60) {
    spikes.push({
      x: mouseX,
      y: mouseY,
      w: 26,
      h: 26
    });
  }
}

function drawGoal() {
  push();
  rectMode(CENTER);
  noStroke();
  fill(80, 220, 140, 160);
  rect(goal.x, goal.y, goal.w, goal.h, 8);
  pop();
}

function drawSpikes() {
  noStroke();
  for (let s of spikes) {
    push();
    translate(s.x, s.y);
    fill(220, 80, 80);
    beginShape();
    vertex(-s.w / 2, s.h / 2);
    vertex(0, -s.h / 2);
    vertex(s.w / 2, s.h / 2);
    endShape(CLOSE);
    pop();
  }
}

function drawHUD() {
  push();
  fill(240);
  noStroke();
  textSize(14);
  textAlign(LEFT, TOP);
  text(
    "Reverse Platformer\n" +
    "You control the level; the yellow hero is AI.\n" +
    "AI now follows a full obby route (if you don't interfere).\n\n" +
    "Controls:\n" +
    "  Q / E       : switch movable platform\n" +
    "  Arrows/WASD : move selected platform\n" +
    "  Mouse click : spawn spike obstacle\n" +
    "  R           : reset\n\n" +
    "Goal: Help or sabotage the AI as it runs the course.",
    16,
    16
  );

  // Status
  let status = "";
  if (!ai.alive) status = "AI status: DEAD";
  else if (ai.reachedGoal) status = "AI status: REACHED GOAL!";
  else status = "AI status: RUNNING";

  text(status, 16, 220);
  pop();
}

function rectsOverlap(a, b) {
  const halfW = a.w / 2 + b.w / 2;
  const halfH = a.h / 2 + b.h / 2;
  return (
    Math.abs(a.x - b.x) < halfW &&
    Math.abs(a.y - b.y) < halfH
  );
}

class Platform {
  constructor(x, y, w, h, movable) {
    this.x = x;
    this.y = y;
    this.w = w;
    this.h = h;
    this.movable = movable;
  }

  display(isSelected) {
    rectMode(CENTER);
    stroke(230);
    strokeWeight(2);
    if (this.movable) {
      if (isSelected) {
        fill(80, 180, 255);
      } else {
        fill(70, 130, 220);
      }
    } else {
      fill(60, 70, 90);
    }
    rect(this.x, this.y, this.w, this.h, 4);
  }
}

class AIPlayer {
  constructor(x, y) {
    this.x = x;
    this.y = y;
    this.prevX = x;
    this.prevY = y;
    this.vx = 0;
    this.vy = 0;
    this.w = 26;
    this.h = 40;
    this.onGround = false;
    this.alive = true;
    this.reachedGoal = false;
    this.wpIndex = 0;
  }

  update(platforms, spikes, goal) {
    if (!this.alive || this.reachedGoal) return;

    this.prevX = this.x;
    this.prevY = this.y;

    this.think(platforms, goal);
    this.vy += GRAVITY;

    this.x += this.vx;
    this.resolveCollisions(platforms, "x");

    this.y += this.vy;
    this.onGround = false;
    this.resolveCollisions(platforms, "y");

    for (let s of spikes) {
      if (rectsOverlap(this, s)) {
        this.alive = false;
      }
    }

    if (this.y - this.h / 2 > height + 200) {
      this.alive = false;
    }

    if (rectsOverlap(this, goal)) {
      this.reachedGoal = true;
    }

    if (this.alive && !this.reachedGoal) {
      this.updateWaypointProgress();
    }
  }

  think(platforms, goal) {
    const hasWaypoint = this.wpIndex < waypoints.length;
    const target = hasWaypoint ? waypoints[this.wpIndex] : goal;

    const dir = 1;
    this.vx = dir * AI_SPEED;

    if (!hasWaypoint && this.x > goal.x - goal.w) {
      this.vx *= 0.7;
    }

    if (!this.onGround) return;

    const dx = target.x - this.x;
    const dyUp = this.y - target.y;
    const goingDown = target.y > this.y + 25;

    const ascendVerticalThreshold = 12;
    const ascendHorizontalRange = 45;

    if (!goingDown && dyUp > ascendVerticalThreshold && Math.abs(dx) < ascendHorizontalRange) {
      this.jump();
      return;
    }

    if (!goingDown) {
      const aheadDist = this.w * 0.7;
      const footX = this.x + dir * aheadDist;
      const footY = this.y + this.h / 2 + 2;

      let groundAhead = false;
      for (let p of platforms) {
        const withinX = footX > p.x - p.w / 2 && footX < p.x + p.w / 2;
        const platformTop = p.y - p.h / 2;
        if (
          withinX &&
          footY <= platformTop + 4 &&
          footY + 24 >= platformTop
        ) {
          groundAhead = true;
          break;
        }
      }

      if (!groundAhead) {
        this.jump();
        return;
      }
    }

    if (!goingDown) {
      const sensorX = this.x + dir * (this.w / 2 + 2);
      const sensorTop = this.y - this.h / 4;
      const sensorBottom = this.y + this.h / 4;
      let wallAhead = false;

      for (let p of platforms) {
        const withinY =
          sensorBottom > p.y - p.h / 2 && sensorTop < p.y + p.h / 2;
        const withinX =
          sensorX > p.x - p.w / 2 && sensorX < p.x + p.w / 2;
        if (withinX && withinY && p.y >= this.y) {
          wallAhead = true;
          break;
        }
      }

      if (wallAhead) {
        this.jump();
      }
    }
  }

  updateWaypointProgress() {
    if (this.wpIndex >= waypoints.length) return;

    const target = waypoints[this.wpIndex];
    const dx = Math.abs(this.x - target.x);
    const dy = Math.abs(this.y - target.y);

    const reachX = 45;
    const reachY = 45;

    if (dx < reachX && dy < reachY && this.onGround) {
      this.wpIndex++;
    }
  }

  jump() {
    if (this.onGround) {
      this.vy = -AI_JUMP;
      this.onGround = false;
    }
  }

  resolveCollisions(platforms, axis) {
    for (let p of platforms) {
      if (!rectsOverlap(this, p)) continue;

      if (axis === "y") {
        if (
          this.vy > 0 &&
          this.prevY + this.h / 2 <= p.y - p.h / 2
        ) {
          this.y = p.y - p.h / 2 - this.h / 2;
          this.vy = 0;
          this.onGround = true;
        }
        else if (
          this.vy < 0 &&
          this.prevY - this.h / 2 >= p.y + p.h / 2
        ) {
          this.y = p.y + p.h / 2 + this.h / 2;
          this.vy = 0;
        }
      } else if (axis === "x") {
        if (
          this.vx > 0 &&
          this.prevX + this.w / 2 <= p.x - p.w / 2
        ) {
          this.x = p.x - p.w / 2 - this.w / 2;
          this.vx = 0;
        }
        else if (
          this.vx < 0 &&
          this.prevX - this.w / 2 >= p.x + p.w / 2
        ) {
          this.x = p.x + p.w / 2 + this.w / 2;
          this.vx = 0;
        }
      }
    }
  }

  display() {
    push();
    rectMode(CENTER);
    noStroke();
    if (!this.alive) {
      fill(200, 60, 60);
    } else if (this.reachedGoal) {
      fill(80, 230, 120);
    } else {
      fill(250, 220, 120);
    }
    rect(this.x, this.y, this.w, this.h, 4);

    stroke(20);
    strokeWeight(2);
    point(this.x - 4, this.y - 4);
    point(this.x + 4, this.y - 4);
    line(this.x - 4, this.y + 4, this.x + 4, this.y + 4);
    pop();
  }
}