// Change seed. The same number draws the same sheet.
// Paste generate.js, balance.js, and draw.js below this file.


const settings = {
  seed: 135,
  ratio: 1.35,
  cols: 10,
  rows: 12,
  cellW: 36,
  mergeProbability: 0.25,
  bend: 4,
  repetition: 1.5,
  horizontalWeight: 1.4,
  divisions: 6,
  lineWidth: 2,
  accentProbability: 0.08,
  tension: 0.45,
};


let modules = [];


function setup() {
  const cellH = settings.cellW * settings.ratio;
  createCanvas(settings.cols * settings.cellW, settings.rows * cellH);
  randomSeed(settings.seed);
  noiseSeed(settings.seed);
  modules = generate();
  noLoop();
}


function draw() {
  background(255);
  for (let i = 0; i < modules.length; i++) drawModule(modules[i]);
}

// Walks the grid from the top left.
// A cell may merge 2×1, 1×2, or 2×2. If stability falls under the floor, the merge returns.


const MERGE = [
  [2, 1],
  [1, 2],
  [2, 2],
];
const BASE = [19, 11, 27, 20, 23];


function generate() {
  const list = [];
  const occupied = [];
  for (let r = 0; r < settings.rows; r++) {
    occupied[r] = [];
    for (let c = 0; c < settings.cols; c++) occupied[r][c] = false;
  }


  for (let r = 0; r < settings.rows; r++) {
    for (let c = 0; c < settings.cols; c++) {
      if (occupied[r][c]) continue;


      let spanC = 1;
      let spanR = 1;
      if (random() < settings.mergeProbability * tensionOf()) {
        const valid = [];
        for (let i = 0; i < MERGE.length; i++) {
          if (canMerge(occupied, c, r, MERGE[i][0], MERGE[i][1])) valid.push(MERGE[i]);
        }
        if (valid.length > 0) {
          const choice = random(valid);
          spanC = choice[0];
          spanR = choice[1];
        }
      }


      for (let dy = 0; dy < spanR; dy++) {
        for (let dx = 0; dx < spanC; dx++) occupied[r + dy][c + dx] = true;
      }


      const tile = {
        c: c,
        r: r,
        spanC: spanC,
        spanR: spanR,
        type: chooseElement(list, c, r),
        accent: random() < settings.accentProbability,
        id: random(100000),
        connector: random() < 0.4 || meetsMergedVertical(list, c, r),
      };
      list.push(tile);


      if (!accepted(list) && (spanC > 1 || spanR > 1)) {
        for (let dy = 0; dy < spanR; dy++) {
          for (let dx = 0; dx < spanC; dx++) {
            if (dx === 0 && dy === 0) continue;
            occupied[r + dy][c + dx] = false;
          }
        }
        tile.spanC = 1;
        tile.spanR = 1;
      }
      if (!accepted(list)) tile.type = relieveElement(list, tile);
    }
  }
  return list;
}


function canMerge(occupied, c, r, w, h) {
  if (c + w > settings.cols || r + h > settings.rows) return false;
  for (let dy = 0; dy < h; dy++) {
    for (let dx = 0; dx < w; dx++) {
      if (occupied[r + dy][c + dx]) return false;
    }
  }
  return true;
}


function chooseElement(list, c, r) {
  const weights = BASE.slice();
  weights[2] *= settings.horizontalWeight;
  for (let i = 0; i < list.length; i++) {
    const neighbor = list[i];
    const touchesLeft =
      neighbor.c + neighbor.spanC === c && r >= neighbor.r && r < neighbor.r + neighbor.spanR;
    const touchesTop =
      neighbor.r + neighbor.spanR === r && c >= neighbor.c && c < neighbor.c + neighbor.spanC;
    if (touchesLeft || touchesTop) weights[neighbor.type] *= settings.repetition;
  }
  const adjusted = relationWeights(weights, list, c, r);
  return weightedRandom(adjusted);
}


function weightedRandom(weights) {
  let total = 0;
  for (let i = 0; i < weights.length; i++) total += weights[i];
  let v = random(total);
  for (let i = 0; i < weights.length; i++) {
    v -= weights[i];
    if (v < 0) return i;
  }
  return weights.length - 1;
}

// S = 0.34B + 0.28R + 0.24C − 0.22D
// The floor drops as tension rises. Below the floor, the last change is taken back.


function tensionOf() {
  if (settings.tension < 0) return 0;
  if (settings.tension > 1) return 1;
  return settings.tension;
}


function stabilityFloor() {
  return 0.62 - 0.34 * tensionOf();
}


function accepted(list) {
  return sanjoBalance(list).stability >= stabilityFloor();
}


function sanjoBalance(list) {
  const balance = lightnessBalance(list);
  const rhythm = neighborRhythm(list);
  const connectivity = lineConnectivity(list);
  const disorder = structuralDisorder(list);
  return {
    stability: 0.34 * balance + 0.28 * rhythm + 0.24 * connectivity - 0.22 * disorder,
  };
}


function relationWeights(weights, list, c, r) {
  const next = weights.slice();
  const tension = tensionOf();
  for (let i = 0; i < list.length; i++) {
    const neighbor = list[i];
    if (!touches(neighbor, c, r)) continue;
    const area = neighbor.spanC * neighbor.spanR;
    if (neighbor.type === 0 && area >= 2) next[4] *= 1 + 1.6 * tension;
    if (neighbor.type === 3 && area >= 2) next[3] *= 1 + tension;
  }
  const sides = sideLightness(list);
  if (sides.leftArea > 0 && sides.rightArea > 0) {
    const onLeft = c + 0.5 < settings.cols / 2;
    const here = onLeft ? sides.left : sides.right;
    const other = onLeft ? sides.right : sides.left;
    const gap = here - other;
    const boost = 1 + min(1.2, abs(gap) * 4) * tension;
    if (gap > 0.03) next[0] *= boost;
    if (gap < -0.03) next[1] *= boost;
  }
  return next;
}


function meetsMergedVertical(list, c, r) {
  for (let i = 0; i < list.length; i++) {
    const neighbor = list[i];
    if (
      neighbor.type === 3 &&
      neighbor.spanC * neighbor.spanR >= 2 &&
      touches(neighbor, c, r)
    ) return true;
  }
  return false;
}


function relieveElement(list, tile) {
  const sides = sideLightness(list);
  if (sides.leftArea === 0 || sides.rightArea === 0) return tile.type;
  const onLeft = tile.c + tile.spanC / 2 < settings.cols / 2;
  const here = onLeft ? sides.left : sides.right;
  const other = onLeft ? sides.right : sides.left;
  if (here + 0.02 < other && tile.type === 0) return 1;
  if (here > other + 0.02 && tile.type === 1) return 0;
  return tile.type;
}


function touches(tile, c, r) {
  const side = tile.c + tile.spanC === c && r >= tile.r && r < tile.r + tile.spanR;
  const above = tile.r + tile.spanR === r && c >= tile.c && c < tile.c + tile.spanC;
  return side || above;
}


function sideLightness(list) {
  let left = 0;
  let right = 0;
  let leftArea = 0;
  let rightArea = 0;
  for (let i = 0; i < list.length; i++) {
    const tile = list[i];
    const area = tile.spanC * tile.spanR;
    const light = moduleLightness(tile);
    if (tile.c + tile.spanC / 2 < settings.cols / 2) {
      left += light * area;
      leftArea += area;
    } else {
      right += light * area;
      rightArea += area;
    }
  }
  return {
    left: leftArea === 0 ? 0 : left / leftArea,
    right: rightArea === 0 ? 0 : right / rightArea,
    leftArea: leftArea,
    rightArea: rightArea,
  };
}


function lightnessBalance(list) {
  const sides = sideLightness(list);
  let top = 0;
  let bottom = 0;
  let topArea = 0;
  let bottomArea = 0;
  for (let i = 0; i < list.length; i++) {
    const tile = list[i];
    const area = tile.spanC * tile.spanR;
    const light = moduleLightness(tile);
    if (tile.r + tile.spanR / 2 < settings.rows / 2) {
      top += light * area;
      topArea += area;
    } else {
      bottom += light * area;
      bottomArea += area;
    }
  }
  const horiz =
    sides.leftArea === 0 || sides.rightArea === 0 ? 0 : abs(sides.left - sides.right);
  const vert =
    topArea === 0 || bottomArea === 0 ? 0 : abs(top / topArea - bottom / bottomArea);
  const excess = max(0, (horiz + vert) / 2 - 0.08);
  return clamp01(1 - excess / 0.35);
}


function neighborRhythm(list) {
  let edges = 0;
  let different = 0;
  for (let i = 0; i < list.length; i++) {
    for (let j = i + 1; j < list.length; j++) {
      if (!sharesEdge(list[i], list[j])) continue;
      edges += 1;
      if (list[i].type !== list[j].type) different += 1;
    }
  }
  if (edges === 0) return 1;
  return clamp01(1 - abs(different / edges - 0.62) / 0.62);
}


function sharesEdge(a, b) {
  const vertical = a.c + a.spanC === b.c || b.c + b.spanC === a.c;
  const rows = a.r < b.r + b.spanR && b.r < a.r + a.spanR;
  const horizontal = a.r + a.spanR === b.r || b.r + b.spanR === a.r;
  const cols = a.c < b.c + b.spanC && b.c < a.c + a.spanC;
  return (vertical && rows) || (horizontal && cols);
}


function lineConnectivity(list) {
  const lines = [];
  for (let i = 0; i < list.length; i++) {
    if (list[i].type === 2 || list[i].type === 3) lines.push(list[i]);
  }
  if (lines.length === 0) return 1;
  let connected = 0;
  for (let i = 0; i < lines.length; i++) {
    let hit = false;
    for (let j = 0; j < lines.length; j++) {
      if (i !== j && continues(lines[i], lines[j])) hit = true;
    }
    if (hit) connected += 1;
  }
  return connected / lines.length;
}


function continues(a, b) {
  if (a.type !== b.type) return false;
  if (a.type === 2) {
    const side = a.c + a.spanC === b.c || b.c + b.spanC === a.c;
    const rows = a.r < b.r + b.spanR && b.r < a.r + a.spanR;
    return side && rows;
  }
  const side = a.r + a.spanR === b.r || b.r + b.spanR === a.r;
  const cols = a.c < b.c + b.spanC && b.c < a.c + a.spanC;
  return side && cols;
}


function structuralDisorder(list) {
  const total = settings.cols * settings.rows;
  if (total === 0) return 0;
  let merged = 0;
  const grid = [];
  for (let r = 0; r < settings.rows; r++) {
    grid[r] = [];
    for (let c = 0; c < settings.cols; c++) grid[r][c] = -1;
  }
  for (let i = 0; i < list.length; i++) {
    const tile = list[i];
    const area = tile.spanC * tile.spanR;
    if (area > 1) merged += area;
    for (let dy = 0; dy < tile.spanR; dy++) {
      for (let dx = 0; dx < tile.spanC; dx++) grid[tile.r + dy][tile.c + dx] = tile.type;
    }
  }
  let longest = 1;
  let run = 1;
  let previous = -2;
  for (let r = 0; r < grid.length; r++) {
    for (let c = 0; c < grid[r].length; c++) {
      const type = grid[r][c];
      if (type >= 0 && type === previous) {
        run += 1;
        if (run > longest) longest = run;
      } else {
        run = 1;
        previous = type;
      }
    }
  }
  const runPenalty = min(1, max(0, longest - 1) / settings.cols);
  return clamp01(0.65 * (merged / total) + 0.35 * runPenalty);
}


function moduleLightness(tile) {
  const paper = 1;
  const ink = 0;
  const accent = luminance(223, 60, 130);
  const gray = luminance(90, 87, 87);
  if (tile.type === 0) return tile.accent ? accent : gray;
  const w = tile.spanC * settings.cellW;
  const h = tile.spanR * settings.cellW * settings.ratio;
  if (tile.type === 1) {
    const border = min(0.35, (2 * (w + h) * settings.lineWidth) / (w * h));
    return ink * border + paper * (1 - border);
  }
  const gap = settings.cellW / settings.divisions;
  if (tile.type === 2 || tile.type === 3) {
    const coverage = min(0.5, settings.lineWidth / gap);
    const line = tile.accent ? ink * 0.75 + accent * 0.25 : ink;
    return line * coverage + paper * (1 - coverage);
  }
  const size = gap * 0.38;
  const coverage = min(0.5, (size * size) / (gap * gap));
  const dot = tile.accent ? accent : ink;
  return dot * coverage + paper * (1 - coverage);
}


function luminance(r, g, b) {
  const linear = (value) => {
    const channel = value / 255;
    return channel <= 0.04045 ? channel / 12.92 : pow((channel + 0.055) / 1.055, 2.4);
  };
  return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
}


function clamp01(value) {
  if (value < 0) return 0;
  if (value > 1) return 1;
  return value;
}

// Five elements. 0 gray field, 1 white field, 2 horizontal line, 3 vertical line, 4 dot.
// A line keeps both ends fixed and bends only in the middle.


const INK = "#000000";
const PINK = "#DF3C82";
const GRAY = "#5A5757";


function drawModule(tile) {
  const x = tile.c * settings.cellW;
  const y = tile.r * settings.cellW * settings.ratio;
  const w = tile.spanC * settings.cellW;
  const h = tile.spanR * settings.cellW * settings.ratio;


  if (tile.type === 0) {
    noStroke();
    fill(tile.accent ? PINK : GRAY);
    rect(x, y, w, h);
  } else if (tile.type === 1) {
    noStroke();
    fill(255);
    rect(x, y, w, h);
    noFill();
    stroke(INK);
    strokeWeight(settings.lineWidth);
    rect(
      x + settings.lineWidth / 2,
      y + settings.lineWidth / 2,
      w - settings.lineWidth,
      h - settings.lineWidth,
    );
  } else if (tile.type === 2) {
    drawLines(tile, x, y, w, h, false);
  } else if (tile.type === 3) {
    drawLines(tile, x, y, w, h, true);
    if (tile.connector) drawConnector(tile, x, y, w, h);
  } else {
    drawDots(tile, x, y, w, h);
  }
}


function drawLines(tile, x, y, w, h, vertical) {
  const gap = settings.cellW / settings.divisions;
  let index = 0;
  const limit = vertical ? w : h;
  for (let at = gap / 2; at < limit; at += gap) {
    const color = tile.accent && index % 4 === 0 ? PINK : INK;
    if (vertical) curvedLine(x + at, y, x + at, y + h, tile.id + index * 13, color);
    else curvedLine(x, y + at, x + w, y + at, tile.id + index * 13, color);
    index += 1;
  }
}


function drawConnector(tile, x, y, w, h) {
  const gap = settings.cellW / settings.divisions;
  const count = floor(w / gap);
  if (count < 2) return;
  const index = floor(noise(tile.id * 0.01, 41) * (count - 1));
  const xx = x + gap / 2 + index * gap;
  const yy = y + h * (0.25 + noise(tile.id * 0.01, 42) * 0.5);
  stroke(INK);
  strokeWeight(settings.lineWidth);
  strokeCap(ROUND);
  line(xx, yy, xx + gap, yy);
}


function drawDots(tile, x, y, w, h) {
  const gap = settings.cellW / settings.divisions;
  const size = gap * 0.38;
  noStroke();
  fill(tile.accent ? PINK : INK);
  for (let yy = gap / 2; yy < h; yy += gap) {
    for (let xx = gap / 2; xx < w; xx += gap) {
      rect(xx + x - size / 2, yy + y - size / 2, size, size);
    }
  }
}


function curvedLine(x1, y1, x2, y2, id, color) {
  const dx = x2 - x1;
  const dy = y2 - y1;
  const len = mag(dx, dy);
  if (len === 0) return;
  const nx = -dy / len;
  const ny = dx / len;
  const phase = noise(id * 0.013, 4) * TWO_PI;
  const strength = map(noise(id * 0.019, 8), 0, 1, 0.45, 1);
  const amplitude = settings.bend * tensionOf() * strength;


  stroke(color);
  strokeWeight(settings.lineWidth);
  strokeCap(ROUND);
  strokeJoin(ROUND);
  noFill();
  beginShape();
  for (let i = 0; i <= 32; i++) {
    const t = i / 32;
    const envelope = sin(PI * t);
    const offset = amplitude * envelope * sanjoWave(t, phase);
    vertex(lerp(x1, x2, t) + nx * offset, lerp(y1, y2, t) + ny * offset);
  }
  endShape();
}


function sanjoWave(t, phase) {
  return sin(t * PI * 1.3 + phase) * 0.75 + sin(t * PI * 3.1 + phase * 0.7) * 0.25;
}