loadrunner

function setup() {
  createCanvas(windowWidth, windowHeight);
  pixelDensity(1);
  textFont('sans-serif');
  computeLayout();
  setupControls();
  setupLevelEditorUI();
  startNewGame();
}

function draw() {
  background(2, 3, 10);

  if (!editorVisible) {
    updateInputFromPointers();

    if (gameState === 'playing') {
      updateHoles();
      updatePlayer();
      updateEnemies();
      checkPlayerEnemyCollision();

      if (goldTotal > 0 && goldCollected >= goldTotal) {
        const elapsedFrames = frameCount - levelStartFrame;
        lastLevelTimeSec = floor(elapsedFrames / 60);
        const timeBonus = max(0, (120 - lastLevelTimeSec)) * TIME_BONUS_PER_SECOND;
        score += LEVEL_CLEAR_BONUS + timeBonus;
        gameState = 'won';
        playWinSound();
      }
    }
  }

  drawLevel();
  drawPlayer();
  drawEnemies();
  drawHUD();
  drawControls();
}

function computeLayout() {
  tileSize = floor(min(width / COLS, height / ROWS));
  tileSize = max(tileSize, 18);

  const worldW = tileSize * COLS;
  const worldH = tileSize * ROWS;

  offsetX = (width - worldW) / 2;
  offsetY = (height - worldH) / 2;
}

function setupControls() {
  buttons = [];

  const sBase = min(width, height) * 0.13;
  const s = constrain(sBase, 44, 110);
  const margin = 16;

  const padCX = margin + s * 1.2;
  const padCY = height - margin - s * 1.2;

  btnLeft  = new UIButton(padCX - s, padCY,       s, s, "◀", "left");
  btnRight = new UIButton(padCX + s, padCY,       s, s, "▶", "right");
  btnUp    = new UIButton(padCX,     padCY - s,   s, s, "▲", "up");
  btnDown  = new UIButton(padCX,     padCY + s,   s, s, "▼", "down");

  const digY = height - margin - s;
  const digRightX = width - margin - s;
  const digLeftX  = digRightX - s * 1.35;

  btnDigLeft  = new UIButton(digLeftX,  digY, s, s, "L", "digLeft");
  btnDigRight = new UIButton(digRightX, digY, s, s, "R", "digRight");

  buttons = [btnLeft, btnRight, btnUp, btnDown, btnDigLeft, btnDigRight];
}

function startNewGame() {
  lives = START_LIVES;
  score = 0;
  resetGame();
}

function resetGame() {
  holes = [];
  level = [];
  enemies = [];
  goldTotal = 0;
  goldCollected = 0;
  gameState = 'playing';
  levelStartFrame = frameCount;
  lastLevelTimeSec = 0;

  for (let r = 0; r < ROWS; r++) {
    const rowStr = levelTemplate[r];
    const row = [];
    for (let c = 0; c < COLS; c++) {
      let ch = rowStr.charAt(c);
      if (ch === '_') ch = TILE_EMPTY;

      if (ch === 'S') {
        player = createPlayer(c, r);
        ch = TILE_EMPTY;
      } else if (ch === 'E') {
        enemies.push(createEnemy(c, r));
        ch = TILE_EMPTY;
      } else if (ch === TILE_GOLD) {
        goldTotal++;
      }

      row.push(ch);
    }
    level.push(row);
  }
}

function createPlayer(c, r) {
  return {
    col: c,
    row: r,
    startCol: c,
    startRow: r,
    fromCol: c,
    fromRow: r,
    toCol: c,
    toRow: r,
    progress: 0,
    isMoving: false
  };
}

function createEnemy(c, r) {
  return {
    col: c,
    row: r,
    startCol: c,
    startRow: r,
    fromCol: c,
    fromRow: r,
    toCol: c,
    toRow: r,
    progress: 0,
    isMoving: false,
    trapped: false,
    moveCooldown: 0
  };
}

function tileAt(c, r) {
  if (r < 0 || r >= ROWS || c < 0 || c >= COLS) return TILE_BLOCK;
  return level[r][c];
}

function isOnLadder(c, r) {
  return tileAt(c, r) === TILE_LADDER;
}

function shouldFallFrom(c, r) {
  const below = tileAt(c, r + 1);
  return !(below === TILE_BLOCK || below === TILE_LADDER);
}

function updateInputFromPointers() {
  const kbLeft  = keyIsDown(LEFT_ARROW)  || keyIsDown(65);
  const kbRight = keyIsDown(RIGHT_ARROW) || keyIsDown(68);
  const kbUp    = keyIsDown(UP_ARROW)    || keyIsDown(87);
  const kbDown  = keyIsDown(DOWN_ARROW)  || keyIsDown(83);

  let pointerLeft = false;
  let pointerRight = false;
  let pointerUp = false;
  let pointerDown = false;

  for (const b of buttons) {
    b.wasPressed = b.isPressed;
    b.isPressed = false;
  }

  const points = [];

  if (touches.length > 0) {
    for (const t of touches) {
      points.push({ x: t.x, y: t.y });
    }
  } else if (mouseIsPressed) {
    points.push({ x: mouseX, y: mouseY });
  }

  for (const p of points) {
    for (const b of buttons) {
      if (b.contains(p.x, p.y)) {
        b.isPressed = true;
      }
    }
  }

  for (const b of buttons) {
    if (b.type === 'left'  && b.isPressed) pointerLeft  = true;
    if (b.type === 'right' && b.isPressed) pointerRight = true;
    if (b.type === 'up'    && b.isPressed) pointerUp    = true;
    if (b.type === 'down'  && b.isPressed) pointerDown  = true;

    if (b.type === 'digLeft' && b.isPressed && !b.wasPressed) {
      tryDig('left');
    }
    if (b.type === 'digRight' && b.isPressed && !b.wasPressed) {
      tryDig('right');
    }
  }

  controls.left  = kbLeft  || pointerLeft;
  controls.right = kbRight || pointerRight;
  controls.up    = kbUp    || pointerUp;
  controls.down  = kbDown  || pointerDown;
}

function canMoveHorizontalPlayer(dx) {
  const c = player.col;
  const r = player.row;
  const nc = c + dx;
  if (nc < 0 || nc >= COLS) return false;
  const dest = tileAt(nc, r);
  if (dest === TILE_BLOCK) return false;
  return true;
}

function canMoveVerticalPlayer(dy) {
  const c = player.col;
  const r = player.row;
  const nr = r + dy;
  if (nr < 0 || nr >= ROWS) return false;
  const dest = tileAt(c, nr);
  if (dest === TILE_BLOCK) return false;

  if (dy < 0) {
    return isOnLadder(c, r) || dest === TILE_LADDER;
  } else {
    return isOnLadder(c, r) || dest === TILE_LADDER;
  }
}

function startPlayerMove(toC, toR) {
  player.isMoving = true;
  player.fromCol = player.col;
  player.fromRow = player.row;
  player.toCol = toC;
  player.toRow = toR;
  player.progress = 0;
}

function handlePlayerLanding() {
  const c = player.col;
  const r = player.row;
  const t = tileAt(c, r);

  if (t === TILE_GOLD) {
    goldCollected++;
    level[r][c] = TILE_EMPTY;
    score += SCORE_PER_GOLD;
    playGoldSound();
  }
}

function killPlayer() {
  playDeathSound();
  lives--;

  if (lives <= 0) {
    gameState = 'gameover';
    lastLevelTimeSec = floor((frameCount - levelStartFrame) / 60);
    return;
  }

  player.col = player.startCol;
  player.row = player.startRow;
  player.fromCol = player.col;
  player.fromRow = player.row;
  player.toCol = player.col;
  player.toRow = player.row;
  player.isMoving = false;
  player.progress = 0;
}

function updatePlayer() {
  if (!player) return;

  if (player.isMoving) {
    player.progress += MOVE_SPEED;
    if (player.progress >= 1) {
      player.col = player.toCol;
      player.row = player.toRow;
      player.isMoving = false;
      player.progress = 0;
      handlePlayerLanding();
    }
    return;
  }

  handlePlayerLanding();

  if (!isOnLadder(player.col, player.row) &&
      shouldFallFrom(player.col, player.row)) {
    startPlayerMove(player.col, player.row + 1);
    return;
  }

  let dx = 0;
  let dy = 0;

  if (controls.left && !controls.right)  dx = -1;
  else if (controls.right && !controls.left) dx = 1;

  if (controls.up && !controls.down)    dy = -1;
  else if (controls.down && !controls.up) dy = 1;

  if (dy !== 0 && canMoveVerticalPlayer(dy)) {
    startPlayerMove(player.col, player.row + dy);
  } else if (dx !== 0 && canMoveHorizontalPlayer(dx)) {
    startPlayerMove(player.col + dx, player.row);
  }
}

function tryDig(direction) {
  if (gameState !== 'playing' || !player) return;
  if (player.isMoving) return;

  const c = player.col;
  const r = player.row;
  const dc = direction === 'left' ? -1 : 1;
  const sideC = c + dc;
  const targetR = r + 1;

  if (sideC < 0 || sideC >= COLS || targetR < 0 || targetR >= ROWS) return;

  const sideTile = tileAt(sideC, r);
  const targetTile = tileAt(sideC, targetR);

  if (targetTile === TILE_BLOCK &&
      sideTile !== TILE_BLOCK &&
      sideTile !== TILE_HOLE) {
    level[targetR][sideC] = TILE_HOLE;
    holes.push({ row: targetR, col: sideC, timer: HOLE_DURATION });
    playDigSound();
  }
}

function updateHoles() {
  for (let i = holes.length - 1; i >= 0; i--) {
    const h = holes[i];
    h.timer--;
    if (h.timer <= 0) {
      if (player && player.row === h.row && player.col === h.col) {
        killPlayer();
      }
      for (const e of enemies) {
        if (e.row === h.row && e.col === h.col) {
          respawnEnemy(e);
        }
      }
      level[h.row][h.col] = TILE_BLOCK;
      holes.splice(i, 1);
    }
  }
}

function startEnemyMove(e, toC, toR) {
  e.isMoving = true;
  e.fromCol = e.col;
  e.fromRow = e.row;
  e.toCol = toC;
  e.toRow = toR;
  e.progress = 0;
}

function canEnemyMoveHorizontal(e, dx) {
  const c = e.col;
  const r = e.row;
  const nc = c + dx;
  if (nc < 0 || nc >= COLS) return false;
  const dest = tileAt(nc, r);
  if (dest === TILE_BLOCK || dest === TILE_HOLE) return false;
  return true;
}

function canEnemyMoveVertical(e, dy) {
  const c = e.col;
  const r = e.row;
  const nr = r + dy;
  if (nr < 0 || nr >= ROWS) return false;
  const dest = tileAt(c, nr);
  if (dest === TILE_BLOCK || dest === TILE_HOLE) return false;

  if (dy < 0) {
    return isOnLadder(c, r) || dest === TILE_LADDER;
  } else {
    return isOnLadder(c, r) || dest === TILE_LADDER;
  }
}

function respawnEnemy(e) {
  e.col = e.startCol;
  e.row = e.startRow;
  e.fromCol = e.col;
  e.fromRow = e.row;
  e.toCol = e.col;
  e.toRow = e.row;
  e.isMoving = false;
  e.progress = 0;
  e.trapped = false;
  e.moveCooldown = ENEMY_PAUSE;
}

function updateEnemy(e) {
  if (e.trapped) {
    return;
  }

  if (tileAt(e.col, e.row) === TILE_HOLE) {
    e.trapped = true;
    return;
  }

  if (e.isMoving) {
    e.progress += ENEMY_SPEED;
    if (e.progress >= 1) {
      e.col = e.toCol;
      e.row = e.toRow;
      e.isMoving = false;
      e.progress = 0;
    }
    return;
  }

  if (!isOnLadder(e.col, e.row) &&
      shouldFallFrom(e.col, e.row)) {
    startEnemyMove(e, e.col, e.row + 1);
    return;
  }

  if (e.moveCooldown > 0) {
    e.moveCooldown--;
    return;
  }

  let dx = 0;
  let dy = 0;

  if (isOnLadder(e.col, e.row) && player && player.row !== e.row) {
    if (player.row < e.row && canEnemyMoveVertical(e, -1)) dy = -1;
    else if (player.row > e.row && canEnemyMoveVertical(e, 1)) dy = 1;
  }

  if (dy === 0 && player && player.col !== e.col) {
    if (player.col < e.col && canEnemyMoveHorizontal(e, -1)) dx = -1;
    else if (player.col > e.col && canEnemyMoveHorizontal(e, 1)) dx = 1;
  }

  if (dx === 0 && dy === 0) {
    const options = [];
    if (canEnemyMoveHorizontal(e, -1)) options.push({ dx: -1, dy: 0 });
    if (canEnemyMoveHorizontal(e, 1))  options.push({ dx: 1,  dy: 0 });

    if (isOnLadder(e.col, e.row)) {
      if (canEnemyMoveVertical(e, -1)) options.push({ dx: 0, dy: -1 });
      if (canEnemyMoveVertical(e, 1))  options.push({ dx: 0, dy: 1 });
    }

    if (options.length > 0) {
      const choice = random(options);
      dx = choice.dx;
      dy = choice.dy;
    }
  }

  if (dy !== 0 && canEnemyMoveVertical(e, dy)) {
    startEnemyMove(e, e.col, e.row + dy);
    e.moveCooldown = ENEMY_PAUSE;
  } else if (dx !== 0 && canEnemyMoveHorizontal(e, dx)) {
    startEnemyMove(e, e.col + dx, e.row);
    e.moveCooldown = ENEMY_PAUSE;
  }
}

function updateEnemies() {
  for (const e of enemies) {
    updateEnemy(e);
  }
}

function checkPlayerEnemyCollision() {
  if (!player) return;
  for (const e of enemies) {
    if (!e.trapped && e.col === player.col && e.row === player.row) {
      killPlayer();
      return;
    }
  }
}

function gridToScreen(c, r) {
  return {
    x: offsetX + (c + 0.5) * tileSize,
    y: offsetY + (r + 0.5) * tileSize
  };
}

function getInterpolatedPosition(obj) {
  let c = obj.col;
  let r = obj.row;
  if (obj.isMoving) {
    const t = obj.progress;
    c = lerp(obj.fromCol, obj.toCol, t);
    r = lerp(obj.fromRow, obj.toRow, t);
  }
  return gridToScreen(c, r);
}

function formatTime(sec) {
  const s = max(0, sec | 0);
  const m = Math.floor(s / 60);
  const ss = (s % 60).toString().padStart(2, '0');
  return `${m}:${ss}`;
}

function drawLevel() {
  rectMode(CORNER);
  noStroke();

  fill(4, 6, 26);
  rect(offsetX, offsetY, tileSize * COLS, tileSize * ROWS);

  for (let r = 0; r < ROWS; r++) {
    for (let c = 0; c < COLS; c++) {
      const t = tileAt(c, r);
      const x = offsetX + c * tileSize;
      const y = offsetY + r * tileSize;

      if (t === TILE_BLOCK) {
        drawBrickCell(x, y);
      }
      if (t === TILE_HOLE) {
        drawHoleCell(x, y);
      }
      if (t === TILE_LADDER) {
        drawLadderCell(x, y);
      }
      if (t === TILE_GOLD) {
        drawGoldCell(x, y);
      }
    }
  }
}

function drawBrickCell(x, y) {
  const s = tileSize;
  noStroke();
  fill(18, 10, 12);
  rect(x, y, s, s);

  const margin = s * 0.08;
  const brickH = (s - margin * 3) / 2;

  for (let row = 0; row < 2; row++) {
    const by = y + margin + row * (brickH + margin);
    fill(190, 150, 80);
    stroke(90, 60, 30);
    strokeWeight(max(1, s * 0.03));
    rect(x + margin, by, s - margin * 2, brickH, 4);

    stroke(130, 90, 50);
    const splitX = x + s * 0.45;
    line(splitX, by, splitX, by + brickH);
  }

  noFill();
  stroke(255, 220, 150, 130);
  strokeWeight(max(1, s * 0.02));
  line(x + margin * 1.5, y + margin * 1.2, x + s - margin * 1.5, y + margin * 1.2);
}

function drawHoleCell(x, y) {
  const s = tileSize;
  noStroke();
  fill(5, 2, 4);
  rect(x, y, s, s);
  fill(0, 0, 0, 150);
  ellipse(x + s / 2, y + s * 0.65, s * 0.8, s * 0.4);
}

function drawLadderCell(x, y) {
  const s = tileSize;
  noFill();
  stroke(240, 210, 120);
  strokeWeight(max(1, s * 0.08));
  const pad = s * 0.25;
  line(x + pad, y, x + pad, y + s);
  line(x + s - pad, y, x + s - pad, y + s);

  const rungs = 4;
  for (let i = 1; i < rungs; i++) {
    const ry = y + (s * i) / rungs;
    line(x + pad, ry, x + s - pad, ry);
  }
}

function drawGoldCell(x, y) {
  const s = tileSize;
  const cx = x + s / 2;
  const cy = y + s / 2;
  const pulse = 0.3 + 0.1 * sin(frameCount * 0.2);
  const r = s * (0.3 + pulse * 0.25);

  noStroke();
  fill(255, 215, 100, 70);
  ellipse(cx, cy, r * 2.2, r * 2.2);
  fill(255, 230, 120);
  ellipse(cx, cy, r * 2, r * 2);
  fill(255, 255, 255, 160);
  ellipse(cx - r * 0.2, cy - r * 0.2, r * 0.7, r * 0.7);
}

function drawPlayer() {
  if (!player) return;
  const pos = getInterpolatedPosition(player);

  push();
  translate(pos.x, pos.y);
  const s = tileSize;

  noStroke();
  fill(0, 0, 0, 100);
  ellipse(0, s * 0.45, s * 0.55, s * 0.25);

  rectMode(CENTER);
  fill(70, 180, 255);
  stroke(20, 60, 100);
  strokeWeight(max(1, s * 0.04));
  const bodyW = s * 0.45;
  const bodyH = s * 0.6;
  rect(0, s * 0.05, bodyW, bodyH, 6);

  fill(245, 230, 210);
  stroke(120, 90, 70);
  const headR = s * 0.28;
  ellipse(0, -s * 0.35, headR * 2, headR * 2);

  noStroke();
  fill(250, 240, 170);
  arc(0, -s * 0.38, headR * 2.1, headR * 1.7, PI, TWO_PI);

  stroke(245, 230, 210);
  strokeWeight(max(1, s * 0.06));
  line(-bodyW * 0.7, -s * 0.05, -bodyW * 0.1, -s * 0.15);
  line(bodyW * 0.7,  -s * 0.02,  bodyW * 0.1, -s * 0.12);

  stroke(60, 150, 230);
  strokeWeight(max(1, s * 0.07));
  line(-bodyW * 0.25, s * 0.3, -bodyW * 0.25, s * 0.5);
  line( bodyW * 0.25, s * 0.3,  bodyW * 0.25, s * 0.5);

  pop();
}

function drawEnemies() {
  for (const e of enemies) {
    const pos = getInterpolatedPosition(e);
    push();
    translate(pos.x, pos.y);
    const s = tileSize;

    noStroke();
    fill(0, 0, 0, 110);
    ellipse(0, s * 0.4, s * 0.5, s * 0.24);

    fill(220, 70, 70);
    stroke(120, 20, 20);
    strokeWeight(max(1, s * 0.04));
    const r = s * 0.33;
    ellipse(0, -s * 0.05, r * 2, r * 2.1);

    noStroke();
    fill(255);
    const eyeOffset = s * 0.12;
    ellipse(-eyeOffset, -s * 0.12, s * 0.12, s * 0.12);
    ellipse(eyeOffset,  -s * 0.12, s * 0.12, s * 0.12);
    fill(0);
    ellipse(-eyeOffset, -s * 0.12, s * 0.06, s * 0.06);
    ellipse(eyeOffset,  -s * 0.12, s * 0.06, s * 0.06);

    fill(0);
    rectMode(CENTER);
    rect(0, s * 0.02, s * 0.22, s * 0.09, 4);

    pop();
  }
}

function drawHUD() {
  push();
  textAlign(LEFT, TOP);
  textSize(16);
  fill(255);
  const margin = 10;
  let y = margin;
  const x = margin;

  text(`Gold:  ${goldCollected} / ${goldTotal}`, x, y); y += 18;
  text(`Lives: ${lives}`, x, y); y += 18;
  text(`Score: ${score}`, x, y); y += 18;

  const elapsedSec = (gameState === 'playing')
    ? floor((frameCount - levelStartFrame) / 60)
    : lastLevelTimeSec;
  text(`Time:  ${formatTime(elapsedSec)}`, x, y);

  if (gameState === 'won') {
    textAlign(CENTER, CENTER);
    textSize(28);
    fill(255, 255, 170);
    text("YOU WIN!\nTap anywhere or press R to restart", width / 2, height * 0.2);
  } else if (gameState === 'gameover') {
    textAlign(CENTER, CENTER);
    textSize(28);
    fill(255, 180, 180);
    text("GAME OVER\nTap anywhere or press R to restart", width / 2, height * 0.2);
  }

  const b = getEditButtonRect();
  rectMode(CORNER);
  stroke(90, 130, 230);
  strokeWeight(1.5);
  fill(20, 30, 80, 220);
  rect(b.x, b.y, b.w, b.h, 8);

  noStroke();
  fill(235);
  textAlign(CENTER, CENTER);
  textSize(13);
  text('EDIT', b.x + b.w / 2, b.y + b.h / 2);

  pop();
}

function drawControls() {
  push();
  noStroke();
  fill(0, 0, 0, 90);
  const barH = min(height * 0.24, 200);
  rect(0, height - barH, width, barH);
  pop();

  for (const b of buttons) {
    b.draw();
  }
}

function keyPressed() {
  if (editorVisible) return;

  ensureAudioContext();

  if (key === 'z' || key === 'Z') tryDig('left');
  if (key === 'x' || key === 'X') tryDig('right');

  if (key === 'r' || key === 'R') {
    startNewGame();
  }
}

function mousePressed() {
  if (editorVisible) return;

  ensureAudioContext();

  if (isOverEditButton(mouseX, mouseY)) {
    showEditor();
    return;
  }

  if (gameState === 'won' || gameState === 'gameover') {
    startNewGame();
  }
}

function touchStarted() {
  if (editorVisible) {
    return;
  }

  ensureAudioContext();

  const x = touches.length > 0 ? touches[0].x : mouseX;
  const y = touches.length > 0 ? touches[0].y : mouseY;

  if (isOverEditButton(x, y)) {
    showEditor();
    return false;
  }

  if (gameState === 'won' || gameState === 'gameover') {
    startNewGame();
  }

  return false;
}

function initAudioContext() {
  const AudioCtx = window.AudioContext || window.webkitAudioContext;
  if (!AudioCtx) {
    console.warn('Web Audio API not supported in this browser.');
    return;
  }
  if (!audioCtx) {
    audioCtx = new AudioCtx();
    masterGain = audioCtx.createGain();
    masterGain.gain.value = 0.35;
    masterGain.connect(audioCtx.destination);
  }
}

function ensureAudioContext() {
  if (!audioCtx) {
    initAudioContext();
  }
  if (audioCtx && audioCtx.state === 'suspended') {
    audioCtx.resume();
  }
}

function playTone(freq, startOffset, duration, type = 'square', volume = 1) {
  if (!audioCtx || audioCtx.state !== 'running') return;

  const osc = audioCtx.createOscillator();
  const gain = audioCtx.createGain();

  osc.type = type;
  osc.frequency.value = freq;

  const now = audioCtx.currentTime;
  const startTime = now + (startOffset || 0);
  const attack = 0.01;
  const endTime = startTime + duration;

  gain.gain.setValueAtTime(0, startTime);
  gain.gain.linearRampToValueAtTime(volume, startTime + attack);
  gain.gain.exponentialRampToValueAtTime(0.001, endTime);

  osc.connect(gain);
  gain.connect(masterGain);

  osc.start(startTime);
  osc.stop(endTime + 0.05);
}

function playDigSound() {
  ensureAudioContext();
  if (!audioCtx || audioCtx.state !== 'running') return;
  playTone(900, 0.00, 0.045, 'square', 0.55);
  playTone(650, 0.04, 0.045, 'square', 0.5);
}

function playGoldSound() {
  ensureAudioContext();
  if (!audioCtx || audioCtx.state !== 'running') return;
  playTone(650, 0.00, 0.06, 'triangle', 0.55);
  playTone(950, 0.05, 0.06, 'triangle', 0.55);
  playTone(1300,0.10, 0.10, 'triangle', 0.6);
}

function playDeathSound() {
  ensureAudioContext();
  if (!audioCtx || audioCtx.state !== 'running') return;
  playTone(700, 0.00, 0.18, 'sawtooth', 0.5);
  playTone(450, 0.14, 0.20, 'sawtooth', 0.45);
  playTone(260, 0.28, 0.24, 'square',   0.4);
}

function playWinSound() {
  ensureAudioContext();
  if (!audioCtx || audioCtx.state !== 'running') return;
  playTone(523.25, 0.00, 0.16, 'triangle', 0.45);
  playTone(659.25, 0.08, 0.16, 'triangle', 0.45);
  playTone(783.99, 0.16, 0.20, 'triangle', 0.5);
}

class UIButton {
  constructor(x, y, w, h, label, type) {
    this.x = x;
    this.y = y;
    this.w = w;
    this.h = h;
    this.label = label;
    this.type = type;
    this.isPressed = false;
    this.wasPressed = false;
  }

  contains(px, py) {
    return px >= this.x && px <= this.x + this.w &&
           py >= this.y && py <= this.y + this.h;
  }

  draw() {
    push();
    rectMode(CORNER);
    textAlign(CENTER, CENTER);
    textSize(this.h * 0.5);
    noStroke();

    const bg = this.isPressed ? color(50, 120, 255, 230) : color(20, 60, 160, 210);
    fill(bg);
    rect(this.x, this.y, this.w, this.h, 12);

    fill(255);
    text(this.label, this.x + this.w / 2, this.y + this.h / 2);
    pop();
  }
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
  computeLayout();
  setupControls();
}