137 lines
7.5 KiB
JavaScript
137 lines
7.5 KiB
JavaScript
// 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 };
|
|
}
|