// Building blocks: placing, integrity, removing, lines and rectangles of blocks.
// ---------- Blocks ----------
function blockOf(x, y) { return { bx: Math.floor(x / BS), by: Math.floor(y / BS) }; }
function blockCellList(bx, by) { const out = []; for (let y = by * BS; y < by * BS + BS; y++) for (let x = bx * BS; x < bx * BS + BS; x++) out.push(y * W + x); return out; }
function pieceCost(code, v) { return code === BP_WALL ? wallCost(v, BS * BS) : PIECE_BY_CODE[code].cost; }
function canPlaceBlock(bx, by) {
  if (bx < 0 || by < 0 || bx >= BW || by >= BH) return 'Out of bounds';
  if (blockP[by * BW + bx]) return 'Something is already built there';
  for (const i of blockCellList(bx, by)) {
    if (mach[i] || part[i]) return 'Something is already built there';
    if (PH[mat[i]] === PH_SOLID) return 'Needs open space; clear the rock first.';
    if (occ[i]) return 'A bar is in the way';
  }
  return '';
}
// v: wall material (loose id) for walls, direction for belts and tubes
function placeBlock(code, v, bx, by, free, extra) {
  const err = canPlaceBlock(bx, by); if (err) return err;
  if (code === BP_WALL && !WALL_OF[v]) return 'Pick a wall material with R';
  const cost = pieceCost(code, v);
  if (!free) { if (!canAfford(cost, 1)) return needText(cost, 1); payCost(cost, 1); }
  const cells = blockCellList(bx, by);
  if (code !== BP_PIPE) evictCells(cells, by * BS); // a pipe is thin: what is there stays and flows past it
  for (const i of cells) {
    const y = (i / W) | 0, x = i % W;
    if (code === BP_WALL) setCell(i, WALL_OF[v], AMB[y], 0);
    else if (code === BP_BELT) { setCell(i, v === 0 ? BELTL : BELTR, AMB[y], 0); markPow(i, true); }
    else if (code === BP_SHAFT) { setCell(i, SHAFT, AMB[y], 0); markPow(i, true); }
    else if (isProcCode(code)) setCell(i, code === BP_GRIND ? GRINDER : SAWB, AMB[y], 0);
    else if (code === BP_GATE) setCell(i, GATE, AMB[y], 0);
    else if (code === BP_GRATE) { part[i] = P_GRATE; wakeXY(x, y); }
    else if (code === BP_TUBE) { part[i] = [P_TU, P_TR, P_TD, P_TL][v & 3]; markPow(i, true); wakeXY(x, y); }
    else if (code === BP_FILTER) { part[i] = P_FILTER; wakeXY(x, y); }
    else if (code === BP_PIPE) { part[i] = P_PIPE; wakeXY(x, y); }
    else if (isPipeCode(code)) setCell(i, PIPE, AMB[y], 0);
  }
  if (isPipeCode(code)) pipesDirty = true;
  blockP[by * BW + bx] = code; blockV[by * BW + bx] = v;
  if (code === BP_FILTER) { blockV[by * BW + bx] = v & 128; filterCfg.set(by * BW + bx, filterRec(extra)); filtersDirty = true; }
  if (isProcCode(code)) procDirty = true;
  stats.placed++;
  undoNote({ t: 'block+', bx, by, code });
  return '';
}
// How many of a block's cells still look like the piece the registry says is there
function blockIntegrity(b) {
  const code = blockP[b], v = blockV[b];
  if (!code) return 0;
  const bx = b % BW, by = (b / BW) | 0;
  let n = 0;
  for (const i of blockCellList(bx, by)) {
    const m = mat[i], p = part[i];
    if (code === BP_WALL) { if (PH[m] === PH_SOLID && !(flags[i] & F_NAT) && !PARTMAT[m]) n++; }
    else if (code === BP_BELT) { if (m === BELTL || m === BELTR) n++; }
    else if (code === BP_SHAFT) { if (m === SHAFT) n++; }
    else if (isProcCode(code)) { if (m === (code === BP_GRIND ? GRINDER : SAWB)) n++; }
    else if (code === BP_GATE) { if (m === GATE || p === P_GOPEN) n++; }
    else if (code === BP_GRATE) { if (p === P_GRATE) n++; }
    else if (code === BP_TUBE) { if (p >= P_TU && p <= P_TR) n++; }
    else if (code === BP_FILTER) { if (p === P_FILTER) n++; }
    else if (isPipeCode(code)) { if (m === PIPE || p === P_PIPE) n++; }
  }
  void v;
  return n;
}
function removeBlock(bx, by) {
  const b = by * BW + bx, code = blockP[b], v = blockV[b];
  if (!code) return 0;
  undoNote({ t: 'block-', bx, by, code, v, extra: code === BP_FILTER ? filterInfo(b) : undefined });
  // a pipe taken out spills its share of what the line holds
  const spill = isPipeCode(code) ? pipeTakeShare(b) : null;
  let n = 0, metal = 0;
  for (const i of blockCellList(bx, by)) {
    const m = mat[i], p = part[i];
    if (code === BP_WALL) {
      if (PH[m] === PH_SOLID && !(flags[i] & F_NAT) && !PARTMAT[m] && m !== SPRING) {
        if (BAR_OF[m] && PH[v] === PH_ITEM) { metal++; setCell(i, EMPTY, temp[i], 0); }
        else if (YLD[m] && bagAdd(YLD[m], 1, false) === 0) { setCell(i, YLD[m], temp[i], 0); droppedLast++; } // bag full: it crumbles in place
        else setCell(i, EMPTY, temp[i], 0);
        n++;
      }
    } else if (isPipeCode(code)) {
      if (p === P_PIPE) { part[i] = 0; wakeIdx(i); n++; }
      else if (m === PIPE) { setCell(i, EMPTY, temp[i], 0); n++; }
    } else if (code === BP_BELT || code === BP_SHAFT || code === BP_GATE || isProcCode(code)) {
      if (m === BELTL || m === BELTR || m === SHAFT || m === GATE || m === GRINDER || m === SAWB) { setCell(i, EMPTY, temp[i], 0); markPow(i, false); n++; }
      if (p === P_GOPEN) { part[i] = 0; n++; wakeIdx(i); }
    } else if (p) { part[i] = 0; markPow(i, false); wakeIdx(i); n++; }
  }
  if (code === BP_WALL && metal) giveOrDrop(BAR_OF[WALL_OF[v]] || BARCU, Math.floor(metal / GRAINS_PER_BAR), bx * BS + 2, by * BS + 2);
  else if (code !== BP_WALL && n >= 8) refundAt(PIECE_BY_CODE[code].cost, 1, bx * BS + 2, by * BS + 2);
  if (code === BP_FILTER) { filtersDirty = true; filterCfg.delete(b); }
  if (isProcCode(code)) { procDirty = true; procState.delete(b); }
  blockP[b] = 0; blockV[b] = 0;
  if (isPipeCode(code)) {
    pipesDirty = true;
    if (spill) { let k = spill.n; for (let y = by * BS + BS - 1; y >= by * BS && k > 0; y--) for (let x = bx * BS; x < bx * BS + BS && k > 0; x++) { const i = y * W + x; if (mat[i] === EMPTY) { setCell(i, spill.m, spill.T, 0); k--; } } }
  }
  return n;
}
// Straight line of blocks along the dominant axis
function blockLine(bx0, by0, bx1, by1) {
  const out = [];
  if (Math.abs(bx1 - bx0) >= Math.abs(by1 - by0)) { const s = bx1 >= bx0 ? 1 : -1; for (let x = bx0; ; x += s) { out.push([x, by0]); if (x === bx1) break; } }
  else { const s = by1 >= by0 ? 1 : -1; for (let y = by0; ; y += s) { out.push([bx0, y]); if (y === by1) break; } }
  return out;
}
function blockRect(bx0, by0, bx1, by1) {
  const out = [];
  for (let y = Math.min(by0, by1); y <= Math.max(by0, by1); y++) for (let x = Math.min(bx0, bx1); x <= Math.max(bx0, bx1); x++) out.push([x, y]);
  return out;
}
function blockInReach(bx, by) { return inReach(bx * BS + BS / 2, by * BS + BS / 2); }
// Is block b already exactly this piece (same kind, variant and, for a filter, settings)?
function blockIs(b, code, v, extra) {
  if (blockP[b] !== code) return false;
  if (code === BP_FILTER) return (blockV[b] & 128) === (v & 128) && sameFilter(filterInfo(b), cleanFilterCfg(extra));
  return blockV[b] === v;
}
// replace: a block already built in the way is taken down (and refunded) to make room
function placeBlocks(code, v, list, extra, replace) {
  let n = 0, last = '';
  for (const [bx, by] of list) {
    if (!blockInReach(bx, by)) { last = 'Out of reach'; continue; }
    const b = by * BW + bx;
    if (replace && blockP[b]) {
      if (blockIs(b, code, v, extra)) continue;
      if (blockP[b] === BP_FILTER && code === BP_FILTER) { undoNote({ t: 'filter', bx, by, v: blockV[b], extra: filterInfo(b) }); blockV[b] = v & 128; setFilter(b, extra); filtersDirty = true; n++; continue; } // just re-set it
      if (!canAfford(pieceCost(code, v), 1)) { last = needText(pieceCost(code, v), 1); break; }
      removeBlock(bx, by);
    }
    const r = placeBlock(code, v, bx, by, false, extra);
    if (r) { last = r; if (r.startsWith('Not enough') || r.startsWith('Pick')) break; } else n++;
  }
  return { n, status: n ? '' : last };
}