1117 lines
52 KiB
JavaScript
1117 lines
52 KiB
JavaScript
"use strict";
|
|
|
|
// Resizable grid-based combinational logic board. Internal wiring is a graph of
|
|
// straight segments. Junctions are explicit movable nodes and terminals may
|
|
// fan out to any number of connections.
|
|
(function (global) {
|
|
const SIDES = Object.freeze(["left", "right", "top", "bottom"]);
|
|
const GATE_TYPES = Object.freeze(["and", "not", "rectifier", "on"]);
|
|
const GRID = 40;
|
|
const DEFAULT_COLS = 10;
|
|
const DEFAULT_ROWS = 10;
|
|
const MIN_COLS = 6;
|
|
const MAX_COLS = 20;
|
|
const MIN_ROWS = 4;
|
|
const MAX_ROWS = 20;
|
|
const HALF_W = 32;
|
|
const HALF_H = 32;
|
|
const CANVAS_W = DEFAULT_COLS * GRID;
|
|
const CANVAS_H = DEFAULT_ROWS * GRID;
|
|
const MAX_NODES = 36;
|
|
const MAX_WIRES = 384;
|
|
|
|
const clone = value => {
|
|
try { return JSON.parse(JSON.stringify(value)); } catch (_) { return null; }
|
|
};
|
|
const clamp = global.TarinaiCoreHelpers?.clampNumber || ((v, a, b) => Math.max(a, Math.min(b, Number(v) || 0)));
|
|
const safeRotation = value => ((Math.round(Number(value) || 0) % 4) + 4) % 4;
|
|
const safeSide = value => SIDES.includes(value) ? value : "left";
|
|
const nodeType = value => GATE_TYPES.includes(value) ? value : "and";
|
|
const nodeInputCount = type => type === "and" ? 2 : ((type === "not" || type === "rectifier") ? 1 : 0);
|
|
const safeCols = value => Math.round(clamp(value ?? DEFAULT_COLS, MIN_COLS, MAX_COLS));
|
|
const safeRows = value => Math.round(clamp(value ?? DEFAULT_ROWS, MIN_ROWS, MAX_ROWS));
|
|
const canvasWidth = config => safeCols(config?.cols) * GRID;
|
|
const canvasHeight = config => safeRows(config?.rows) * GRID;
|
|
const snap = value => Math.round((Number(value) || 0) / GRID) * GRID;
|
|
const isVerticalSide = side => side === "left" || side === "right";
|
|
const sideExtent = (config, side) => isVerticalSide(side) ? canvasHeight(config) : canvasWidth(config);
|
|
const safeOffset = (config, side, value) => {
|
|
const extent = sideExtent(config, side);
|
|
return clamp(snap(value), GRID, Math.max(GRID, extent - GRID));
|
|
};
|
|
const portLimit = config => Math.max(1, safeRows(config?.rows) - 1);
|
|
const pointToken = (config, x, y) => `p:${Math.round(clamp(snap(x), GRID, canvasWidth(config) - GRID))}:${Math.round(clamp(snap(y), GRID, canvasHeight(config) - GRID))}`;
|
|
|
|
function boardHalfWidth(boardOrConfig) {
|
|
const config = boardOrConfig?.type === "circuit_board" ? ensureConfig(boardOrConfig) : (boardOrConfig || defaultConfig());
|
|
return 64 * safeCols(config.cols) / 20;
|
|
}
|
|
|
|
function boardHalfHeight(boardOrConfig) {
|
|
const config = boardOrConfig?.type === "circuit_board" ? ensureConfig(boardOrConfig) : (boardOrConfig || defaultConfig());
|
|
return 64 * safeRows(config.rows) / 20;
|
|
}
|
|
|
|
function updateBoardPhysicalSize(board) {
|
|
if (!board || board.type !== "circuit_board") return;
|
|
const hw = boardHalfWidth(board.circuitConfig || defaultConfig());
|
|
const hh = boardHalfHeight(board.circuitConfig || defaultConfig());
|
|
board.r = Math.max(18, Math.hypot(hw, hh));
|
|
board.radius = board.r;
|
|
}
|
|
|
|
function parsePointToken(config, token) {
|
|
const match = /^p:(-?\d+):(-?\d+)$/.exec(String(token || ""));
|
|
if (!match) return null;
|
|
return {
|
|
x: clamp(snap(match[1]), GRID, canvasWidth(config) - GRID),
|
|
y: clamp(snap(match[2]), GRID, canvasHeight(config) - GRID),
|
|
};
|
|
}
|
|
|
|
function spacedOffsets(config, side, count) {
|
|
const extent = sideExtent(config, side);
|
|
const usable = Math.max(GRID, extent - GRID * 2);
|
|
const total = Math.max(1, count);
|
|
if (total === 1) return [safeOffset(config, side, extent * 0.5)];
|
|
return Array.from({ length: total }, (_, index) => safeOffset(config, side, GRID + usable * index / (total - 1)));
|
|
}
|
|
|
|
function defaultPorts(config, direction) {
|
|
const count = direction === "input" ? 3 : 2;
|
|
const side = direction === "input" ? "left" : "right";
|
|
const prefix = direction === "input" ? "I" : "O";
|
|
return spacedOffsets(config, side, Math.min(count, portLimit(config))).map((offset, index) => ({ id: `${prefix}${index + 1}`, side, offset }));
|
|
}
|
|
|
|
function defaultConfig() {
|
|
const config = { v: 4, cols: DEFAULT_COLS, rows: DEFAULT_ROWS, inputs: [], outputs: [], nodes: [], wires: [] };
|
|
config.inputs = defaultPorts(config, "input");
|
|
config.outputs = defaultPorts(config, "output");
|
|
return config;
|
|
}
|
|
|
|
function normalizeNodeId(value, used, index) {
|
|
let id = /^[a-z0-9_-]{1,24}$/i.test(String(value || "")) ? String(value) : `g${index + 1}`;
|
|
if (!used.has(id)) { used.add(id); return id; }
|
|
let suffix = 2;
|
|
while (used.has(`${id}_${suffix}`)) suffix += 1;
|
|
id = `${id}_${suffix}`;
|
|
used.add(id);
|
|
return id;
|
|
}
|
|
|
|
function normalizePorts(config, rawPorts, direction) {
|
|
const source = Array.isArray(rawPorts) ? rawPorts : [];
|
|
const maximum = portLimit(config);
|
|
const prefix = direction === "input" ? "I" : "O";
|
|
const fallbackSide = direction === "input" ? "left" : "right";
|
|
const used = new Set();
|
|
const result = [];
|
|
for (let index = 0; index < source.length && result.length < maximum; index += 1) {
|
|
const raw = source[index] || {};
|
|
let id = /^[A-Za-z][A-Za-z0-9_-]{0,11}$/.test(String(raw.id || "")) ? String(raw.id) : `${prefix}${index + 1}`;
|
|
if (used.has(id)) {
|
|
let n = 1;
|
|
while (used.has(`${prefix}${n}`)) n += 1;
|
|
id = `${prefix}${n}`;
|
|
}
|
|
used.add(id);
|
|
const side = safeSide(raw.side || fallbackSide);
|
|
result.push({ id, side, offset: safeOffset(config, side, raw.offset ?? ((index + 1) * GRID * 2)) });
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function rotateOffset(x, y, rotation) {
|
|
const r = safeRotation(rotation);
|
|
if (r === 1) return { x: -y, y: x };
|
|
if (r === 2) return { x: -x, y: -y };
|
|
if (r === 3) return { x: y, y: -x };
|
|
return { x, y };
|
|
}
|
|
|
|
function nodeBodySize(type) {
|
|
if (type === "not" || type === "rectifier") return { width: 44, height: 30 };
|
|
if (type === "on") return { width: 38, height: 38 };
|
|
return { width: 80, height: 80 };
|
|
}
|
|
|
|
function nodePlacementBounds(config, type, rotation = 0) {
|
|
const size = nodeBodySize(type);
|
|
const r = safeRotation(rotation);
|
|
const bodyHalfW = (r % 2) ? size.height * 0.5 : size.width * 0.5;
|
|
const bodyHalfH = (r % 2) ? size.width * 0.5 : size.height * 0.5;
|
|
const probe = { id: "__probe__", type, x: 0, y: 0, rotation: r };
|
|
const pins = nodePins(probe);
|
|
let minPinX = 0, maxPinX = 0, minPinY = 0, maxPinY = 0;
|
|
for (const pin of pins) {
|
|
minPinX = Math.min(minPinX, pin.x); maxPinX = Math.max(maxPinX, pin.x);
|
|
minPinY = Math.min(minPinY, pin.y); maxPinY = Math.max(maxPinY, pin.y);
|
|
}
|
|
const width = canvasWidth(config), height = canvasHeight(config);
|
|
const minX = Math.max(bodyHalfW, GRID - minPinX);
|
|
const maxX = Math.min(width - bodyHalfW, width - GRID - maxPinX);
|
|
const minY = Math.max(bodyHalfH, GRID - minPinY);
|
|
const maxY = Math.min(height - bodyHalfH, height - GRID - maxPinY);
|
|
return {
|
|
minX: Math.ceil(minX / GRID) * GRID,
|
|
maxX: Math.floor(maxX / GRID) * GRID,
|
|
minY: Math.ceil(minY / GRID) * GRID,
|
|
maxY: Math.floor(maxY / GRID) * GRID,
|
|
};
|
|
}
|
|
|
|
function clampNodePosition(config, type, rotation, x, y) {
|
|
const bounds = nodePlacementBounds(config, type, rotation);
|
|
return {
|
|
x: clamp(snap(x), bounds.minX, Math.max(bounds.minX, bounds.maxX)),
|
|
y: clamp(snap(y), bounds.minY, Math.max(bounds.minY, bounds.maxY)),
|
|
};
|
|
}
|
|
|
|
function canvasPortPosition(config, port) {
|
|
const side = safeSide(port?.side);
|
|
const offset = safeOffset(config, side, port?.offset ?? sideExtent(config, side) * 0.5);
|
|
if (side === "left") return { x: GRID, y: offset };
|
|
if (side === "right") return { x: canvasWidth(config) - GRID, y: offset };
|
|
if (side === "top") return { x: offset, y: GRID };
|
|
return { x: offset, y: canvasHeight(config) - GRID };
|
|
}
|
|
|
|
function externalPins(config) {
|
|
return [
|
|
...config.inputs.map(port => ({ token: `i:${port.id}`, role: "source", direction: "input", kind: "external", label: port.id, port, ...canvasPortPosition(config, port) })),
|
|
...config.outputs.map(port => ({ token: `o:${port.id}`, role: "target", direction: "output", kind: "external", label: port.id, port, ...canvasPortPosition(config, port) })),
|
|
];
|
|
}
|
|
|
|
function nodePins(node) {
|
|
const pins = [];
|
|
const count = nodeInputCount(node.type);
|
|
const pushPin = (pin, role, ox, oy) => {
|
|
const rotated = rotateOffset(ox, oy, node.rotation);
|
|
pins.push({ token: `n:${node.id}:${pin}`, role, kind: "node", node, pin, x: snap(node.x + rotated.x), y: snap(node.y + rotated.y) });
|
|
};
|
|
if (count === 1) pushPin("a", "target", -GRID, 0);
|
|
if (count === 2) {
|
|
pushPin("a", "target", -GRID, -GRID);
|
|
pushPin("b", "target", -GRID, GRID);
|
|
}
|
|
pushPin("o", "source", GRID, 0);
|
|
return pins;
|
|
}
|
|
|
|
function allPins(config) {
|
|
return [...externalPins(config), ...config.nodes.flatMap(nodePins)];
|
|
}
|
|
|
|
function pinByToken(config, token) {
|
|
return allPins(config).find(pin => pin.token === token) || null;
|
|
}
|
|
|
|
function endpointPosition(config, token) {
|
|
const pin = pinByToken(config, token);
|
|
if (pin) return { x: pin.x, y: pin.y, pin };
|
|
const point = parsePointToken(config, token);
|
|
return point ? { ...point, pin: null } : null;
|
|
}
|
|
|
|
function validEndpoint(config, token) {
|
|
return Boolean(endpointPosition(config, token));
|
|
}
|
|
|
|
function wireKey(a, b) {
|
|
return a < b ? `${a}|${b}` : `${b}|${a}`;
|
|
}
|
|
|
|
function remapPointTokens(config, wires) {
|
|
return (wires || []).map(wire => {
|
|
const map = token => {
|
|
const match = /^p:(-?\d+):(-?\d+)$/.exec(String(token || ""));
|
|
return match ? pointToken(config, Number(match[1]), Number(match[2])) : String(token || "");
|
|
};
|
|
return { a: map(wire?.a), b: map(wire?.b) };
|
|
});
|
|
}
|
|
|
|
function normalizeConfig(value) {
|
|
// Save compatibility is intentionally not provided for older board formats.
|
|
if (!value || typeof value !== "object" || Number(value.v) !== 4) return defaultConfig();
|
|
const config = {
|
|
v: 4,
|
|
cols: safeCols(value.cols),
|
|
rows: safeRows(value.rows),
|
|
inputs: [],
|
|
outputs: [],
|
|
nodes: [],
|
|
wires: [],
|
|
};
|
|
config.inputs = normalizePorts(config, value.inputs, "input");
|
|
config.outputs = normalizePorts(config, value.outputs, "output");
|
|
const used = new Set();
|
|
config.nodes = (Array.isArray(value.nodes) ? value.nodes : []).slice(0, MAX_NODES).map((node, index) => {
|
|
const type = nodeType(node?.type);
|
|
const rotation = safeRotation(node?.rotation);
|
|
const pos = clampNodePosition(config, type, rotation, node?.x ?? (GRID * 3 + (index % 4) * GRID * 2), node?.y ?? (GRID * 2 + Math.floor(index / 4) * GRID * 2));
|
|
return { id: normalizeNodeId(node?.id, used, index), type, x: pos.x, y: pos.y, rotation };
|
|
});
|
|
const seen = new Set();
|
|
for (const wire of remapPointTokens(config, Array.isArray(value.wires) ? value.wires : []).slice(0, MAX_WIRES)) {
|
|
const a = String(wire?.a || "");
|
|
const b = String(wire?.b || "");
|
|
if (!validEndpoint(config, a) || !validEndpoint(config, b) || a === b) continue;
|
|
const key = wireKey(a, b);
|
|
if (seen.has(key)) continue;
|
|
seen.add(key);
|
|
config.wires.push({ a, b });
|
|
}
|
|
return config;
|
|
}
|
|
|
|
function ensureConfig(board) {
|
|
if (!board) return defaultConfig();
|
|
board.circuitConfig = normalizeConfig(board.circuitConfig);
|
|
updateBoardPhysicalSize(board);
|
|
return board.circuitConfig;
|
|
}
|
|
|
|
function serializeConfig(boardOrConfig) {
|
|
const value = boardOrConfig?.type === "circuit_board" ? ensureConfig(boardOrConfig) : normalizeConfig(boardOrConfig);
|
|
return clone(value) || defaultConfig();
|
|
}
|
|
|
|
function applySerializedConfig(board, value) {
|
|
if (!board) return false;
|
|
board.circuitConfig = normalizeConfig(value);
|
|
board._circuitTerminals = null;
|
|
board._circuitInputState = Object.create(null);
|
|
board._circuitNodeState = Object.create(null);
|
|
board._circuitOutputState = Object.create(null);
|
|
updateBoardPhysicalSize(board);
|
|
return true;
|
|
}
|
|
|
|
function ports(board) {
|
|
const config = ensureConfig(board);
|
|
return [
|
|
...config.inputs.map(port => ({ ...port, direction: "input", portId: `i:${port.id}`, label: `\u5165\u529b ${port.id}` })),
|
|
...config.outputs.map(port => ({ ...port, direction: "output", portId: `o:${port.id}`, label: `\u51fa\u529b ${port.id}` })),
|
|
];
|
|
}
|
|
|
|
function localPortPosition(port, boardOrConfig = null) {
|
|
const config = boardOrConfig?.type === "circuit_board" ? ensureConfig(boardOrConfig) : (boardOrConfig || defaultConfig());
|
|
const side = safeSide(port?.side);
|
|
const extent = sideExtent(config, side);
|
|
const offset = safeOffset(config, side, port?.offset ?? extent * 0.5);
|
|
const t = clamp(offset / Math.max(1, extent), 0, 1);
|
|
const halfW = boardHalfWidth(config);
|
|
const halfH = boardHalfHeight(config);
|
|
if (side === "left") return { x: -halfW, y: -halfH + t * halfH * 2 };
|
|
if (side === "right") return { x: halfW, y: -halfH + t * halfH * 2 };
|
|
if (side === "top") return { x: -halfW + t * halfW * 2, y: -halfH };
|
|
return { x: -halfW + t * halfW * 2, y: halfH };
|
|
}
|
|
|
|
function portById(board, portId) {
|
|
return ports(board).find(port => port.portId === portId) || null;
|
|
}
|
|
|
|
function portWorld(board, portOrId) {
|
|
const port = typeof portOrId === "string" ? portById(board, portOrId) : portOrId;
|
|
if (!board || !port) return null;
|
|
const local = localPortPosition(port, board);
|
|
const angle = Number(board.angle || 0) || 0;
|
|
const c = Math.cos(angle), s = Math.sin(angle);
|
|
return { x: board.x + local.x * c - local.y * s, y: board.y + local.x * s + local.y * c, localX: local.x, localY: local.y, port };
|
|
}
|
|
|
|
function nearestPort(board, x, y, maxDistance = 25) {
|
|
let best = null;
|
|
let bestD = Number(maxDistance) || 25;
|
|
for (const port of ports(board)) {
|
|
const point = portWorld(board, port);
|
|
const d = Math.hypot((Number(x) || 0) - point.x, (Number(y) || 0) - point.y);
|
|
if (d <= bestD) { bestD = d; best = { ...point, distance: d }; }
|
|
}
|
|
return best;
|
|
}
|
|
|
|
function isPortExternallyConnected(board, portId, worldRef = board?.world || global.world) {
|
|
if (!board || !portId || !worldRef?.items) return false;
|
|
for (const link of worldRef.items) {
|
|
if (!link || link.dead || !["wire", "insulated_wire"].includes(link.type)) continue;
|
|
for (let index = 0; index < 2; index += 1) {
|
|
const endpoint = global.TarinaiPhysicsBodySystem?.endpoint?.(link, index) || link.physicsConstraint?.endpoints?.[index] || null;
|
|
if (endpoint?.id === board.id && endpoint?.portId === portId) return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function remapAttachedWireEndpoints(board, worldRef = board?.world || global.world) {
|
|
if (!board || !worldRef?.items) return 0;
|
|
let changed = 0;
|
|
for (const link of worldRef.items) {
|
|
if (!link || link.dead || !["wire", "insulated_wire"].includes(link.type)) continue;
|
|
for (let index = 0; index < 2; index += 1) {
|
|
const endpoint = global.TarinaiPhysicsBodySystem?.endpoint?.(link, index) || link.physicsConstraint?.endpoints?.[index] || null;
|
|
if (!endpoint || endpoint.id !== board.id || !endpoint.portId) continue;
|
|
const point = portWorld(board, endpoint.portId);
|
|
if (!point) continue;
|
|
endpoint.localX = point.localX;
|
|
endpoint.localY = point.localY;
|
|
endpoint.x = point.x;
|
|
endpoint.y = point.y;
|
|
endpoint.center = false;
|
|
changed += 1;
|
|
}
|
|
}
|
|
const pending = worldRef.pendingLinkEndpoint;
|
|
if (pending?.id === board.id && pending.portId) {
|
|
const point = portWorld(board, pending.portId);
|
|
if (point) {
|
|
pending.localX = point.localX;
|
|
pending.localY = point.localY;
|
|
pending.x = point.x;
|
|
pending.y = point.y;
|
|
pending.center = false;
|
|
changed += 1;
|
|
}
|
|
}
|
|
if (changed) worldRef.markSpatialDirty?.("circuit-board-port-remap");
|
|
return changed;
|
|
}
|
|
|
|
function terminal(board, portId) {
|
|
if (!board) return null;
|
|
const port = portById(board, portId);
|
|
if (!port) return null;
|
|
if (!board._circuitTerminals || typeof board._circuitTerminals !== "object") board._circuitTerminals = Object.create(null);
|
|
let result = board._circuitTerminals[portId];
|
|
if (!result) result = board._circuitTerminals[portId] = { kind: "circuit_terminal", type: "circuit_terminal", board, boardId: board.id || "", portId, direction: port.direction, signalActive: false };
|
|
result.board = board;
|
|
result.boardId = board.id || "";
|
|
result.direction = port.direction;
|
|
result.signalActive = port.direction === "output" ? Boolean(board._circuitOutputState?.[port.id]) : Boolean(board._circuitInputState?.[port.id]);
|
|
return result;
|
|
}
|
|
|
|
function evaluate(board, inputValues = null) {
|
|
const config = ensureConfig(board);
|
|
const inputs = Object.create(null);
|
|
for (const port of config.inputs) inputs[port.id] = Boolean(inputValues ? inputValues[port.id] : board?._circuitInputState?.[port.id]);
|
|
|
|
const parent = new Map();
|
|
const rank = new Map();
|
|
const add = token => { if (!parent.has(token)) { parent.set(token, token); rank.set(token, 0); } };
|
|
const find = token => {
|
|
add(token);
|
|
let root = token;
|
|
while (parent.get(root) !== root) root = parent.get(root);
|
|
let current = token;
|
|
while (parent.get(current) !== current) { const next = parent.get(current); parent.set(current, root); current = next; }
|
|
return root;
|
|
};
|
|
const union = (a, b) => {
|
|
let ra = find(a), rb = find(b);
|
|
if (ra === rb) return;
|
|
const ar = rank.get(ra) || 0, br = rank.get(rb) || 0;
|
|
if (ar < br) { const t = ra; ra = rb; rb = t; }
|
|
parent.set(rb, ra);
|
|
if (ar === br) rank.set(ra, ar + 1);
|
|
};
|
|
for (const pin of allPins(config)) add(pin.token);
|
|
for (const wire of config.wires) { add(wire.a); add(wire.b); union(wire.a, wire.b); }
|
|
|
|
const members = new Map();
|
|
for (const token of parent.keys()) {
|
|
const root = find(token);
|
|
if (!members.has(root)) members.set(root, []);
|
|
members.get(root).push(token);
|
|
}
|
|
const nodeMap = new Map(config.nodes.map(node => [node.id, node]));
|
|
const dependencies = new Map(config.nodes.map(node => [node.id, new Set()]));
|
|
for (const node of config.nodes) {
|
|
for (const pinName of nodeInputCount(node.type) === 2 ? ["a", "b"] : (nodeInputCount(node.type) === 1 ? ["a"] : [])) {
|
|
const root = find(`n:${node.id}:${pinName}`);
|
|
for (const member of members.get(root) || []) {
|
|
const match = /^n:([^:]+):o$/.exec(member);
|
|
if (match && dependencies.has(match[1])) dependencies.get(node.id).add(match[1]);
|
|
}
|
|
}
|
|
}
|
|
const unstableNodes = new Set();
|
|
{
|
|
let index = 0;
|
|
const indices = new Map(), low = new Map(), stack = [], onStack = new Set();
|
|
const visit = id => {
|
|
indices.set(id, index); low.set(id, index); index += 1; stack.push(id); onStack.add(id);
|
|
for (const dep of dependencies.get(id) || []) {
|
|
if (!indices.has(dep)) { visit(dep); low.set(id, Math.min(low.get(id), low.get(dep))); }
|
|
else if (onStack.has(dep)) low.set(id, Math.min(low.get(id), indices.get(dep)));
|
|
}
|
|
if (low.get(id) !== indices.get(id)) return;
|
|
const component = [];
|
|
while (stack.length) {
|
|
const value = stack.pop(); onStack.delete(value); component.push(value);
|
|
if (value === id) break;
|
|
}
|
|
if (component.length > 1 || (component.length === 1 && dependencies.get(component[0])?.has(component[0]))) {
|
|
for (const value of component) unstableNodes.add(value);
|
|
}
|
|
};
|
|
for (const node of config.nodes) if (!indices.has(node.id)) visit(node.id);
|
|
}
|
|
const nodeValues = Object.create(null);
|
|
const netValues = new Map();
|
|
const visitingNodes = new Set();
|
|
const visitingNets = new Set();
|
|
|
|
function driverValue(token) {
|
|
if (token.startsWith("i:")) return Boolean(inputs[token.slice(2)]);
|
|
const match = /^n:([^:]+):o$/.exec(token);
|
|
return match ? nodeValue(match[1]) : false;
|
|
}
|
|
|
|
function netValue(token) {
|
|
const root = find(token);
|
|
if (netValues.has(root)) return Boolean(netValues.get(root));
|
|
if (visitingNets.has(root)) return false;
|
|
visitingNets.add(root);
|
|
let value = false;
|
|
for (const member of members.get(root) || [token]) {
|
|
if (member.startsWith("i:") || /^n:[^:]+:o$/.test(member)) {
|
|
if (driverValue(member)) { value = true; break; }
|
|
}
|
|
}
|
|
visitingNets.delete(root);
|
|
netValues.set(root, Boolean(value));
|
|
return Boolean(value);
|
|
}
|
|
|
|
function nodeValue(id) {
|
|
if (Object.prototype.hasOwnProperty.call(nodeValues, id)) return Boolean(nodeValues[id]);
|
|
if (visitingNodes.has(id)) return false;
|
|
const node = nodeMap.get(id);
|
|
if (!node) return false;
|
|
if (unstableNodes.has(id)) { nodeValues[id] = false; return false; }
|
|
visitingNodes.add(id);
|
|
let value = false;
|
|
if (node.type === "on") value = true;
|
|
else {
|
|
const a = netValue(`n:${id}:a`);
|
|
if (node.type === "not") value = !a;
|
|
else if (node.type === "rectifier") value = a;
|
|
else value = a && netValue(`n:${id}:b`);
|
|
}
|
|
visitingNodes.delete(id);
|
|
nodeValues[id] = Boolean(value);
|
|
return Boolean(value);
|
|
}
|
|
|
|
const outputs = Object.create(null);
|
|
for (const port of config.outputs) outputs[port.id] = netValue(`o:${port.id}`);
|
|
if (board) {
|
|
board._circuitInputState = inputs;
|
|
board._circuitNodeState = nodeValues;
|
|
board._circuitOutputState = outputs;
|
|
for (const port of config.outputs) {
|
|
const term = terminal(board, `o:${port.id}`);
|
|
if (term) term.signalActive = Boolean(outputs[port.id]);
|
|
}
|
|
}
|
|
return { inputs, nodes: nodeValues, outputs };
|
|
}
|
|
|
|
function nearestPin(config, x, y, maxDistance = 17) {
|
|
let best = null;
|
|
let bestD = maxDistance;
|
|
for (const pin of allPins(config)) {
|
|
const d = Math.hypot(x - pin.x, y - pin.y);
|
|
if (d <= bestD) { bestD = d; best = { ...pin, distance: d }; }
|
|
}
|
|
return best;
|
|
}
|
|
|
|
function junctionTokens(config) {
|
|
const degree = new Map();
|
|
for (const wire of config.wires) {
|
|
for (const token of [wire.a, wire.b]) if (parsePointToken(config, token)) degree.set(token, (degree.get(token) || 0) + 1);
|
|
}
|
|
return [...degree.entries()].map(([token, count]) => ({ token, count, ...parsePointToken(config, token) }));
|
|
}
|
|
|
|
function nearestJunction(config, x, y, maxDistance = 16) {
|
|
let best = null;
|
|
let bestD = maxDistance;
|
|
for (const junction of junctionTokens(config)) {
|
|
const d = Math.hypot(x - junction.x, y - junction.y);
|
|
if (d <= bestD) { bestD = d; best = { ...junction, distance: d }; }
|
|
}
|
|
return best;
|
|
}
|
|
|
|
function nodeAt(config, x, y) {
|
|
for (let i = config.nodes.length - 1; i >= 0; i -= 1) {
|
|
const node = config.nodes[i];
|
|
const rotation = safeRotation(node.rotation);
|
|
const dx = x - node.x, dy = y - node.y;
|
|
const local = rotateOffset(dx, dy, (4 - rotation) % 4);
|
|
const size = nodeBodySize(node.type);
|
|
if (Math.abs(local.x) <= size.width * 0.5 && Math.abs(local.y) <= size.height * 0.5) return node;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
const distanceToSegment = (px, py, ax, ay, bx, by) => global.TarinaiGeometry.pointSegmentDistance(px, py, ax, ay, bx, by);
|
|
|
|
function wirePath(config, wire) {
|
|
const a = endpointPosition(config, wire.a);
|
|
const b = endpointPosition(config, wire.b);
|
|
return a && b ? [a, b] : [];
|
|
}
|
|
|
|
function wireAt(config, x, y, maxDistance = 9) {
|
|
let best = null;
|
|
let bestD = maxDistance;
|
|
for (let i = config.wires.length - 1; i >= 0; i -= 1) {
|
|
const path = wirePath(config, config.wires[i]);
|
|
if (path.length < 2) continue;
|
|
const d = distanceToSegment(x, y, path[0].x, path[0].y, path[1].x, path[1].y);
|
|
if (d <= bestD) { bestD = d; best = { wire: config.wires[i], index: i, distance: d }; }
|
|
}
|
|
return best;
|
|
}
|
|
|
|
function gcd(a, b) {
|
|
a = Math.abs(Math.round(a)); b = Math.abs(Math.round(b));
|
|
while (b) { const t = a % b; a = b; b = t; }
|
|
return a || 1;
|
|
}
|
|
|
|
function nearestGridPointOnWire(config, wire, x, y, maxDistance = 18) {
|
|
const path = wirePath(config, wire);
|
|
if (path.length < 2) return null;
|
|
const a = path[0], b = path[1];
|
|
const ux = Math.round((b.x - a.x) / GRID), uy = Math.round((b.y - a.y) / GRID);
|
|
const steps = gcd(ux, uy);
|
|
let best = null, bestD = maxDistance;
|
|
for (let i = 0; i <= steps; i += 1) {
|
|
const px = snap(a.x + (b.x - a.x) * i / steps);
|
|
const py = snap(a.y + (b.y - a.y) * i / steps);
|
|
const d = Math.hypot(x - px, y - py);
|
|
if (d <= bestD) { bestD = d; best = { x: px, y: py, distance: d }; }
|
|
}
|
|
return best;
|
|
}
|
|
|
|
function pointOnSegment(point, a, b) {
|
|
return distanceToSegment(point.x, point.y, a.x, a.y, b.x, b.y) < 0.6
|
|
&& point.x >= Math.min(a.x, b.x) - 0.6 && point.x <= Math.max(a.x, b.x) + 0.6
|
|
&& point.y >= Math.min(a.y, b.y) - 0.6 && point.y <= Math.max(a.y, b.y) + 0.6;
|
|
}
|
|
|
|
function splitWiresAtPoint(config, x, y) {
|
|
const token = pointToken(config, x, y);
|
|
const point = parsePointToken(config, token);
|
|
const next = [];
|
|
let changed = false;
|
|
for (const wire of config.wires) {
|
|
const path = wirePath(config, wire);
|
|
if (path.length < 2 || !pointOnSegment(point, path[0], path[1]) || wire.a === token || wire.b === token) {
|
|
next.push(wire); continue;
|
|
}
|
|
const aPos = endpointPosition(config, wire.a), bPos = endpointPosition(config, wire.b);
|
|
if ((aPos.x === point.x && aPos.y === point.y) || (bPos.x === point.x && bPos.y === point.y)) { next.push(wire); continue; }
|
|
next.push({ a: wire.a, b: token }, { a: token, b: wire.b });
|
|
changed = true;
|
|
}
|
|
if (changed) config.wires = next.slice(0, MAX_WIRES);
|
|
return token;
|
|
}
|
|
|
|
function moveJunction(config, oldToken, x, y) {
|
|
const nextToken = pointToken(config, x, y);
|
|
if (!parsePointToken(config, oldToken) || nextToken === oldToken) return nextToken;
|
|
for (const wire of config.wires) {
|
|
if (wire.a === oldToken) wire.a = nextToken;
|
|
if (wire.b === oldToken) wire.b = nextToken;
|
|
}
|
|
const seen = new Set();
|
|
config.wires = config.wires.filter(wire => {
|
|
if (wire.a === wire.b) return false;
|
|
const key = wireKey(wire.a, wire.b);
|
|
if (seen.has(key)) return false;
|
|
seen.add(key);
|
|
return true;
|
|
});
|
|
return nextToken;
|
|
}
|
|
|
|
function anchorAt(config, x, y, allowEmpty = false) {
|
|
const pin = nearestPin(config, x, y, 18);
|
|
if (pin) return { token: pin.token, x: pin.x, y: pin.y, kind: "pin" };
|
|
const junction = nearestJunction(config, x, y, 18);
|
|
if (junction) return { token: junction.token, x: junction.x, y: junction.y, kind: "junction" };
|
|
let best = null;
|
|
for (const wire of config.wires) {
|
|
const candidate = nearestGridPointOnWire(config, wire, x, y, 18);
|
|
if (candidate && (!best || candidate.distance < best.distance)) best = { ...candidate, wire };
|
|
}
|
|
if (best) return { token: pointToken(config, best.x, best.y), x: best.x, y: best.y, kind: "wire" };
|
|
if (!allowEmpty) return null;
|
|
const px = clamp(snap(x), GRID, canvasWidth(config) - GRID), py = clamp(snap(y), GRID, canvasHeight(config) - GRID);
|
|
return { token: pointToken(config, px, py), x: px, y: py, kind: "empty" };
|
|
}
|
|
|
|
function canvasPoint(canvas, event) {
|
|
const rect = canvas.getBoundingClientRect();
|
|
return { x: (event.clientX - rect.left) * canvas.width / Math.max(1, rect.width), y: (event.clientY - rect.top) * canvas.height / Math.max(1, rect.height) };
|
|
}
|
|
|
|
function terminalPlacement(config, x, y) {
|
|
const width = canvasWidth(config), height = canvasHeight(config);
|
|
const distances = [
|
|
{ side: "left", d: x },
|
|
{ side: "right", d: width - x },
|
|
{ side: "top", d: y },
|
|
{ side: "bottom", d: height - y },
|
|
].sort((a, b) => a.d - b.d);
|
|
const side = distances[0].side;
|
|
const axis = isVerticalSide(side) ? y : x;
|
|
return { side, offset: safeOffset(config, side, axis) };
|
|
}
|
|
|
|
function nextPortId(config, direction) {
|
|
const prefix = direction === "input" ? "I" : "O";
|
|
const portsList = direction === "input" ? config.inputs : config.outputs;
|
|
const used = new Set(portsList.map(port => port.id));
|
|
let index = 1;
|
|
while (used.has(`${prefix}${index}`)) index += 1;
|
|
return `${prefix}${index}`;
|
|
}
|
|
|
|
function ensureDialog() {
|
|
if (typeof document === "undefined") return null;
|
|
let dialog = document.getElementById("circuitBoardEditor");
|
|
if (dialog) return dialog;
|
|
dialog = document.createElement("div");
|
|
dialog.id = "circuitBoardEditor";
|
|
dialog.className = "rotator-editor circuit-grid-editor hidden";
|
|
dialog.innerHTML = `<div class="rotator-editor-panel circuit-grid-panel" role="dialog" aria-modal="true" aria-labelledby="circuitBoardTitle">
|
|
<div class="rotator-editor-titlebar"><h2 id="circuitBoardTitle">\u57fa\u76e4</h2><button class="rotator-editor-close" type="button" data-action="close" aria-label="\u9589\u3058\u308b">\u00d7</button></div>
|
|
<div class="circuit-port-count-controls">
|
|
<label>\u6a2a\u5e45 <button type="button" data-grid-delta="cols:-1">\u2212</button><input id="circuitGridCols" type="number" min="${MIN_COLS}" max="${MAX_COLS}" step="1"><button type="button" data-grid-delta="cols:1">\uff0b</button></label>
|
|
<label>\u7e26\u5e45 <button type="button" data-grid-delta="rows:-1">\u2212</button><input id="circuitGridRows" type="number" min="${MIN_ROWS}" max="${MAX_ROWS}" step="1"><button type="button" data-grid-delta="rows:1">\uff0b</button></label>
|
|
</div>
|
|
<div class="rotator-editor-tools circuit-grid-tools" role="toolbar" aria-label="\u56de\u8def\u7de8\u96c6">
|
|
<button type="button" data-circuit-tool="select">\u2196 \u79fb\u52d5</button>
|
|
<button type="button" data-circuit-tool="wire" class="active">\u2501 \u914d\u7dda</button>
|
|
<button type="button" data-circuit-tool="input_port">IN \u7aef\u5b50</button>
|
|
<button type="button" data-circuit-tool="output_port">OUT \u7aef\u5b50</button>
|
|
<button type="button" data-circuit-tool="and">AND</button>
|
|
<button type="button" data-circuit-tool="not">NOT</button>
|
|
<button type="button" data-circuit-tool="rectifier">\u6574\u6d41</button>
|
|
<button type="button" data-circuit-tool="on" title="\u5e38\u6642ON\u306e\u5b9a\u6570\u4fe1\u53f7\u3092\u51fa\u529b\u3057\u307e\u3059\u3002">ON</button>
|
|
<button type="button" data-circuit-tool="rotate">\u21bb \u56de\u8ee2</button>
|
|
<button type="button" data-circuit-tool="erase">\u232b \u6d88\u3057\u30b4\u30e0</button>
|
|
<button type="button" data-action="undo">\u21b6 \u4e00\u3064\u623b\u3059</button>
|
|
<button type="button" data-action="clear">\ud83d\uddd1 \u5168\u6d88\u3057</button>
|
|
</div>
|
|
<div class="circuit-grid-canvas-wrap"><canvas id="circuitGridCanvas" width="${CANVAS_W}" height="${CANVAS_H}" aria-label="\u57fa\u76e4\u306e\u56de\u8def\u7de8\u96c6"></canvas></div>
|
|
<p class="rotator-editor-hint circuit-grid-hint">IN/OUT\u7aef\u5b50\u30c4\u30fc\u30eb\u3067\u57fa\u76e4\u5916\u5468\u306b\u76f4\u63a5\u7aef\u5b50\u3092\u7f6e\u304d\u3001\u79fb\u52d5\u30c4\u30fc\u30eb\u3067\u56db\u8fba\u306e\u4efb\u610f\u4f4d\u7f6e\u3078\u79fb\u52d5\u3067\u304d\u307e\u3059\u3002\u6d88\u3057\u30b4\u30e0\u3067\u672a\u63a5\u7d9a\u7aef\u5b50\u3092\u524a\u9664\u3067\u304d\u307e\u3059\u3002\u914d\u7dda\u306f2\u70b9\u3092\u9078\u3093\u3067\u76f4\u7dda\u3067\u5f15\u304d\u3001\u65e2\u5b58\u7dda\u4e0a\u304b\u3089\u5206\u5c90\u3067\u304d\u307e\u3059\u3002NOT\u3092\u542b\u3080\u5faa\u74b0\u56de\u8def\u306f\u72b6\u614b\u304c\u5b89\u5b9a\u3057\u306a\u3044\u305f\u3081OFF\u3068\u3057\u3066\u6271\u3044\u307e\u3059\u3002\u56de\u8def\u90e8\u54c1\u306e\u8a2d\u7f6e\u524d\u306fQ/E\u306790\u5ea6\u305a\u3064\u56de\u8ee2\u3067\u304d\u307e\u3059\u3002ON\u306f\u5e38\u6642ON\u306e\u5b9a\u6570\u4fe1\u53f7\u6e90\u3067\u3059\u3002</p>
|
|
<div class="rotator-editor-actions"><button class="btn" type="button" data-action="reset">\u521d\u671f\u5316</button><button class="btn" type="button" data-action="cancel">\u30ad\u30e3\u30f3\u30bb\u30eb</button><button class="btn primary" type="button" data-action="save">\u53cd\u6620</button></div>
|
|
</div>`;
|
|
document.body.appendChild(dialog);
|
|
return dialog;
|
|
}
|
|
|
|
function openEditor(board, worldRef = global.world) {
|
|
if (!board || board.type !== "circuit_board") return false;
|
|
const dialog = ensureDialog();
|
|
const canvas = dialog?.querySelector("#circuitGridCanvas");
|
|
if (!dialog || !canvas) return false;
|
|
const ctx = canvas.getContext("2d");
|
|
let draft = serializeConfig(board);
|
|
let tool = "wire";
|
|
let wireDraft = null;
|
|
let drag = null;
|
|
let placementRotation = 0;
|
|
let hoverPoint = null;
|
|
const undo = [];
|
|
const colsInput = dialog.querySelector("#circuitGridCols");
|
|
const rowsInput = dialog.querySelector("#circuitGridRows");
|
|
|
|
const snapshot = () => {
|
|
undo.push(clone(draft));
|
|
if (undo.length > 40) undo.shift();
|
|
};
|
|
const restoreUndo = () => {
|
|
if (!undo.length) return;
|
|
draft = normalizeConfig(undo.pop());
|
|
wireDraft = null;
|
|
syncControls();
|
|
resizeCanvas();
|
|
draw();
|
|
};
|
|
const syncControls = () => {
|
|
if (colsInput) colsInput.value = String(draft.cols);
|
|
if (rowsInput) rowsInput.value = String(draft.rows);
|
|
};
|
|
const resizeCanvas = () => {
|
|
const width = canvasWidth(draft), height = canvasHeight(draft);
|
|
if (canvas.width !== width) canvas.width = width;
|
|
if (canvas.height !== height) canvas.height = height;
|
|
};
|
|
const setTool = next => {
|
|
const changedTool = tool !== next;
|
|
tool = next;
|
|
if (changedTool) placementRotation = 0;
|
|
wireDraft = null;
|
|
drag = null;
|
|
dialog.querySelectorAll("[data-circuit-tool]").forEach(button => button.classList.toggle("active", button.dataset.circuitTool === tool));
|
|
canvas.style.cursor = tool === "select" ? "grab" : (tool === "erase" ? "not-allowed" : "crosshair");
|
|
draw();
|
|
};
|
|
const drawGrid = () => {
|
|
ctx.clearRect(0, 0, canvas.width, canvas.height);
|
|
ctx.fillStyle = "#14231b"; ctx.fillRect(0, 0, canvas.width, canvas.height);
|
|
ctx.strokeStyle = "rgba(196,225,203,0.12)"; ctx.lineWidth = 1;
|
|
for (let x = 0; x <= canvas.width; x += GRID) { ctx.beginPath(); ctx.moveTo(x, 0); ctx.lineTo(x, canvas.height); ctx.stroke(); }
|
|
for (let y = 0; y <= canvas.height; y += GRID) { ctx.beginPath(); ctx.moveTo(0, y); ctx.lineTo(canvas.width, y); ctx.stroke(); }
|
|
ctx.strokeStyle = "rgba(225,195,80,0.55)"; ctx.lineWidth = 2; ctx.strokeRect(1, 1, canvas.width - 2, canvas.height - 2);
|
|
};
|
|
const drawLine = (a, b, preview = false) => {
|
|
ctx.strokeStyle = preview ? "rgba(255,236,125,0.62)" : "rgba(223,192,71,0.94)";
|
|
ctx.lineWidth = preview ? 2 : 3;
|
|
if (preview) ctx.setLineDash([8, 6]);
|
|
ctx.beginPath(); ctx.moveTo(a.x, a.y); ctx.lineTo(b.x, b.y); ctx.stroke(); ctx.setLineDash([]);
|
|
};
|
|
const drawWire = wire => {
|
|
const path = wirePath(draft, wire);
|
|
if (path.length === 2) drawLine(path[0], path[1], false);
|
|
};
|
|
const drawNode = (node, options = {}) => {
|
|
const size = nodeBodySize(node.type);
|
|
const labels = { and: "AND", not: "NOT", rectifier: ">|", on: "ON" };
|
|
ctx.save();
|
|
if (options.preview) ctx.globalAlpha *= 0.48;
|
|
ctx.translate(node.x, node.y); ctx.rotate(safeRotation(node.rotation) * Math.PI * 0.5);
|
|
ctx.fillStyle = node.type === "on" ? "#765f27" : "#26352d";
|
|
ctx.strokeStyle = options.preview ? "rgba(255,236,125,0.96)" : "rgba(226,239,228,0.92)"; ctx.lineWidth = options.preview ? 3 : 2;
|
|
if (options.preview) ctx.setLineDash([7, 5]);
|
|
const x = -size.width * 0.5, y = -size.height * 0.5, r = Math.min(9, size.height * 0.3);
|
|
ctx.beginPath(); ctx.moveTo(x + r, y); ctx.lineTo(x + size.width - r, y); ctx.quadraticCurveTo(x + size.width, y, x + size.width, y + r); ctx.lineTo(x + size.width, y + size.height - r); ctx.quadraticCurveTo(x + size.width, y + size.height, x + size.width - r, y + size.height); ctx.lineTo(x + r, y + size.height); ctx.quadraticCurveTo(x, y + size.height, x, y + size.height - r); ctx.lineTo(x, y + r); ctx.quadraticCurveTo(x, y, x + r, y); ctx.closePath(); ctx.fill(); ctx.stroke();
|
|
ctx.fillStyle = "#f6fbf7"; ctx.font = `bold ${node.type === "and" ? 15 : 11}px ui-rounded, sans-serif`; ctx.textAlign = "center"; ctx.textBaseline = "middle";
|
|
ctx.fillText(labels[node.type] || "AND", 0, 0);
|
|
ctx.setLineDash([]);
|
|
ctx.restore();
|
|
};
|
|
const drawPlacementPreview = () => {
|
|
if (!hoverPoint) return;
|
|
if (GATE_TYPES.includes(tool)) {
|
|
const pos = clampNodePosition(draft, tool, placementRotation, hoverPoint.x, hoverPoint.y);
|
|
const ghost = { id: "__placement_preview__", type: tool, x: pos.x, y: pos.y, rotation: placementRotation };
|
|
drawNode(ghost, { preview: true });
|
|
ctx.save();
|
|
ctx.globalAlpha = 0.62;
|
|
for (const pin of nodePins(ghost)) {
|
|
ctx.fillStyle = pin.role === "source" ? "#68c8ff" : "#ff9a62";
|
|
if (tool === "on" && pin.role === "source") ctx.fillStyle = "#ffe45c";
|
|
ctx.strokeStyle = "rgba(8,22,14,0.95)"; ctx.lineWidth = 2;
|
|
ctx.beginPath(); ctx.arc(pin.x, pin.y, 7, 0, Math.PI * 2); ctx.fill(); ctx.stroke();
|
|
}
|
|
ctx.restore();
|
|
return;
|
|
}
|
|
if (tool === "input_port" || tool === "output_port") {
|
|
const direction = tool === "input_port" ? "input" : "output";
|
|
const placement = nearestAvailablePortPlacement(direction, hoverPoint.x, hoverPoint.y);
|
|
if (!placement) return;
|
|
const pos = canvasPortPosition(draft, placement);
|
|
ctx.save(); ctx.globalAlpha = 0.58;
|
|
ctx.fillStyle = direction === "input" ? "#68c8ff" : "#ff9a62";
|
|
ctx.strokeStyle = "rgba(255,236,125,0.96)"; ctx.lineWidth = 3; ctx.setLineDash([6, 4]);
|
|
ctx.beginPath(); ctx.arc(pos.x, pos.y, 10, 0, Math.PI * 2); ctx.fill(); ctx.stroke();
|
|
ctx.setLineDash([]); ctx.restore();
|
|
}
|
|
};
|
|
|
|
const drawPins = () => {
|
|
for (const pin of allPins(draft)) {
|
|
const external = pin.kind === "external";
|
|
const externalConnected = external ? isPortExternallyConnected(board, pin.token, worldRef) : true;
|
|
ctx.fillStyle = pin.role === "source" ? "#68c8ff" : "#ff9a62";
|
|
if (pin.node?.type === "on" && pin.role === "source") ctx.fillStyle = "#ffe45c";
|
|
if (external && !externalConnected) ctx.fillStyle = "#3d4842";
|
|
ctx.strokeStyle = external && !externalConnected ? "rgba(111,126,117,0.72)" : "rgba(8,22,14,0.95)"; ctx.lineWidth = 2;
|
|
ctx.beginPath(); ctx.arc(pin.x, pin.y, external ? 9 : 7, 0, Math.PI * 2); ctx.fill(); ctx.stroke();
|
|
if (external) {
|
|
ctx.fillStyle = externalConnected ? "#f5fbf5" : "#748078"; ctx.font = "bold 13px ui-rounded, sans-serif"; ctx.textBaseline = "middle";
|
|
const side = pin.port?.side || "left";
|
|
ctx.textAlign = side === "left" ? "left" : (side === "right" ? "right" : "center");
|
|
const dx = side === "left" ? 14 : (side === "right" ? -14 : 0);
|
|
const dy = side === "top" ? 16 : (side === "bottom" ? -16 : 0);
|
|
ctx.fillText(pin.label, pin.x + dx, pin.y + dy);
|
|
}
|
|
}
|
|
for (const junction of junctionTokens(draft)) {
|
|
if (junction.count < 2) continue;
|
|
ctx.fillStyle = "#e8c440"; ctx.strokeStyle = "rgba(8,22,14,0.95)"; ctx.lineWidth = 1.5;
|
|
ctx.beginPath(); ctx.arc(junction.x, junction.y, junction.count >= 3 ? 7 : 5, 0, Math.PI * 2); ctx.fill(); ctx.stroke();
|
|
}
|
|
};
|
|
function draw() {
|
|
resizeCanvas();
|
|
drawGrid();
|
|
for (const wire of draft.wires) drawWire(wire);
|
|
for (const node of draft.nodes) drawNode(node);
|
|
drawPins();
|
|
drawPlacementPreview();
|
|
if (wireDraft) {
|
|
const start = endpointPosition(draft, wireDraft.startToken);
|
|
if (start) drawLine(start, wireDraft.preview, true);
|
|
}
|
|
}
|
|
|
|
function addNode(type, x, y, rotation = 0) {
|
|
if (draft.nodes.length >= MAX_NODES) { global.showToast?.("\u56de\u8def\u90e8\u54c1\u306f36\u500b\u307e\u3067\u3067\u3059\u3002"); return false; }
|
|
snapshot();
|
|
const id = `g${Date.now().toString(36).slice(-6)}${draft.nodes.length.toString(36)}`;
|
|
const safePlacementRotation = safeRotation(rotation);
|
|
const pos = clampNodePosition(draft, type, safePlacementRotation, x, y);
|
|
draft.nodes.push({ id, type, x: pos.x, y: pos.y, rotation: safePlacementRotation });
|
|
draft = normalizeConfig(draft); draw(); return true;
|
|
}
|
|
|
|
function addStraightConnection(startToken, endToken) {
|
|
if (!startToken || !endToken || startToken === endToken || draft.wires.length >= MAX_WIRES) return false;
|
|
const key = wireKey(startToken, endToken);
|
|
if (draft.wires.some(wire => wireKey(wire.a, wire.b) === key)) return false;
|
|
draft.wires.push({ a: startToken, b: endToken });
|
|
return true;
|
|
}
|
|
|
|
function eraseAt(x, y) {
|
|
const external = nearestPin(draft, x, y, 18);
|
|
if (external?.kind === "external") return removePort(external);
|
|
const junction = nearestJunction(draft, x, y, 13);
|
|
if (junction) {
|
|
snapshot();
|
|
draft.wires = draft.wires.filter(wire => wire.a !== junction.token && wire.b !== junction.token);
|
|
draw(); return true;
|
|
}
|
|
const node = nodeAt(draft, x, y);
|
|
if (node) {
|
|
snapshot();
|
|
draft.nodes = draft.nodes.filter(value => value.id !== node.id);
|
|
draft.wires = draft.wires.filter(wire => !wire.a.startsWith(`n:${node.id}:`) && !wire.b.startsWith(`n:${node.id}:`));
|
|
draw(); return true;
|
|
}
|
|
const hitWire = wireAt(draft, x, y, 10);
|
|
if (hitWire) { snapshot(); draft.wires.splice(hitWire.index, 1); draw(); return true; }
|
|
return false;
|
|
}
|
|
|
|
function portToken(direction, id) {
|
|
return `${direction === "input" ? "i" : "o"}:${id}`;
|
|
}
|
|
|
|
function portSlotKey(side, offset) {
|
|
return `${side}:${safeOffset(draft, side, offset)}`;
|
|
}
|
|
|
|
function nearestAvailablePortPlacement(direction, x, y, ignoreToken = "") {
|
|
const occupied = new Set();
|
|
for (const port of draft.inputs) if (`i:${port.id}` !== ignoreToken) occupied.add(portSlotKey(port.side, port.offset));
|
|
for (const port of draft.outputs) if (`o:${port.id}` !== ignoreToken) occupied.add(portSlotKey(port.side, port.offset));
|
|
const candidates = [];
|
|
for (const side of SIDES) {
|
|
for (let offset = GRID; offset <= sideExtent(draft, side) - GRID; offset += GRID) {
|
|
const key = portSlotKey(side, offset);
|
|
if (occupied.has(key)) continue;
|
|
const pos = canvasPortPosition(draft, { side, offset });
|
|
candidates.push({ side, offset, distance: Math.hypot(pos.x - x, pos.y - y) });
|
|
}
|
|
}
|
|
candidates.sort((a, b) => a.distance - b.distance);
|
|
return candidates[0] || null;
|
|
}
|
|
|
|
function addPort(direction, x, y) {
|
|
const list = direction === "input" ? draft.inputs : draft.outputs;
|
|
const limit = portLimit(draft);
|
|
if (list.length >= limit) {
|
|
global.showToast?.(`\u7e26\u5e45${draft.rows}\u30de\u30b9\u3067\u306f${direction === "input" ? "\u5165\u529b" : "\u51fa\u529b"}\u7aef\u5b50\u306f${limit}\u500b\u307e\u3067\u3067\u3059\u3002`);
|
|
return false;
|
|
}
|
|
const placement = nearestAvailablePortPlacement(direction, x, y);
|
|
if (!placement) { global.showToast?.("\u7aef\u5b50\u3092\u7f6e\u3051\u308b\u7a7a\u304d\u4f4d\u7f6e\u304c\u3042\u308a\u307e\u305b\u3093\u3002"); return false; }
|
|
snapshot();
|
|
list.push({ id: nextPortId(draft, direction), side: placement.side, offset: placement.offset });
|
|
draft = normalizeConfig(draft);
|
|
draw();
|
|
return true;
|
|
}
|
|
|
|
function removePort(pin) {
|
|
if (!pin?.kind || pin.kind !== "external") return false;
|
|
if (isPortExternallyConnected(board, pin.token, worldRef)) {
|
|
global.showToast?.("\u96fb\u7dda\u3092\u5916\u3057\u3066\u304b\u3089\u7aef\u5b50\u3092\u524a\u9664\u3057\u3066\u304f\u3060\u3055\u3044\u3002");
|
|
return false;
|
|
}
|
|
snapshot();
|
|
const list = pin.direction === "input" ? draft.inputs : draft.outputs;
|
|
const index = list.findIndex(port => port.id === pin.port?.id);
|
|
if (index < 0) return false;
|
|
const [removed] = list.splice(index, 1);
|
|
const token = portToken(pin.direction, removed.id);
|
|
draft.wires = draft.wires.filter(wire => wire.a !== token && wire.b !== token);
|
|
draft = normalizeConfig(draft);
|
|
draw();
|
|
return true;
|
|
}
|
|
|
|
function resizeGrid(cols, rows) {
|
|
const nextCols = safeCols(cols);
|
|
const nextRows = safeRows(rows);
|
|
const requiredRows = Math.max(draft.inputs.length, draft.outputs.length) + 1;
|
|
if (nextRows < requiredRows) {
|
|
global.showToast?.(`\u73fe\u5728\u306e\u7aef\u5b50\u6570\u3092\u4fdd\u3064\u306b\u306f\u7e26\u5e45${requiredRows}\u30de\u30b9\u4ee5\u4e0a\u304c\u5fc5\u8981\u3067\u3059\u3002`);
|
|
syncControls();
|
|
return;
|
|
}
|
|
if (nextCols === draft.cols && nextRows === draft.rows) return;
|
|
snapshot();
|
|
draft.cols = nextCols;
|
|
draft.rows = nextRows;
|
|
draft = normalizeConfig(draft);
|
|
syncControls();
|
|
resizeCanvas();
|
|
draw();
|
|
}
|
|
|
|
canvas.onpointerdown = event => {
|
|
const p = canvasPoint(canvas, event);
|
|
hoverPoint = p;
|
|
if (tool === "select") {
|
|
const external = nearestPin(draft, p.x, p.y, 20);
|
|
const junction = nearestJunction(draft, p.x, p.y, 15);
|
|
const node = nodeAt(draft, p.x, p.y);
|
|
if (external?.kind === "external") { snapshot(); drag = { kind: "port", token: external.token }; canvas.style.cursor = "grabbing"; return; }
|
|
if (junction) { snapshot(); drag = { kind: "junction", token: junction.token }; canvas.style.cursor = "grabbing"; return; }
|
|
if (node) { snapshot(); drag = { kind: "node", id: node.id, dx: p.x - node.x, dy: p.y - node.y }; canvas.style.cursor = "grabbing"; return; }
|
|
return;
|
|
}
|
|
if (tool === "erase") { eraseAt(p.x, p.y); return; }
|
|
if (tool === "rotate") {
|
|
const node = nodeAt(draft, p.x, p.y);
|
|
if (node) { snapshot(); node.rotation = safeRotation(node.rotation + 1); const pos = clampNodePosition(draft, node.type, node.rotation, node.x, node.y); node.x = pos.x; node.y = pos.y; draw(); }
|
|
return;
|
|
}
|
|
if (tool === "input_port") { addPort("input", p.x, p.y); return; }
|
|
if (tool === "output_port") { addPort("output", p.x, p.y); return; }
|
|
if (GATE_TYPES.includes(tool)) { addNode(tool, p.x, p.y, placementRotation); return; }
|
|
if (tool !== "wire") return;
|
|
if (!wireDraft) {
|
|
const anchor = anchorAt(draft, p.x, p.y, false);
|
|
if (!anchor) return;
|
|
snapshot();
|
|
if (anchor.kind === "wire") splitWiresAtPoint(draft, anchor.x, anchor.y);
|
|
wireDraft = { startToken: anchor.token, preview: { x: anchor.x, y: anchor.y } };
|
|
draw();
|
|
return;
|
|
}
|
|
const end = anchorAt(draft, p.x, p.y, true);
|
|
if (!end) { wireDraft = null; draw(); return; }
|
|
if (end.kind === "wire") splitWiresAtPoint(draft, end.x, end.y);
|
|
addStraightConnection(wireDraft.startToken, end.token);
|
|
wireDraft = null;
|
|
draft = normalizeConfig(draft);
|
|
draw();
|
|
};
|
|
|
|
canvas.onpointermove = event => {
|
|
const p = canvasPoint(canvas, event);
|
|
hoverPoint = p;
|
|
if (drag?.kind === "node") {
|
|
const node = draft.nodes.find(value => value.id === drag.id);
|
|
if (node) { const pos = clampNodePosition(draft, node.type, node.rotation, p.x - drag.dx, p.y - drag.dy); node.x = pos.x; node.y = pos.y; draw(); }
|
|
return;
|
|
}
|
|
if (drag?.kind === "junction") {
|
|
drag.token = moveJunction(draft, drag.token, p.x, p.y);
|
|
draw();
|
|
return;
|
|
}
|
|
if (drag?.kind === "port") {
|
|
const port = [...draft.inputs.map(value => ({ ...value, _direction: "input" })), ...draft.outputs.map(value => ({ ...value, _direction: "output" }))]
|
|
.find(value => `${value._direction === "input" ? "i" : "o"}:${value.id}` === drag.token);
|
|
const actual = port?._direction === "input" ? draft.inputs.find(value => value.id === port.id) : draft.outputs.find(value => value.id === port?.id);
|
|
if (actual) {
|
|
const next = nearestAvailablePortPlacement(port._direction, p.x, p.y, drag.token);
|
|
if (next) { actual.side = next.side; actual.offset = next.offset; draw(); }
|
|
}
|
|
return;
|
|
}
|
|
if (wireDraft) wireDraft.preview = { x: clamp(snap(p.x), GRID, canvas.width - GRID), y: clamp(snap(p.y), GRID, canvas.height - GRID) };
|
|
draw();
|
|
};
|
|
|
|
canvas.onpointerup = () => {
|
|
if (drag) { draft = normalizeConfig(draft); drag = null; canvas.style.cursor = "grab"; syncControls(); draw(); }
|
|
};
|
|
canvas.onpointercancel = () => { drag = null; wireDraft = null; draw(); };
|
|
canvas.onpointerleave = () => { hoverPoint = null; if (!drag) draw(); };
|
|
canvas.oncontextmenu = event => { event.preventDefault(); if (wireDraft) { wireDraft = null; draw(); } };
|
|
const handleEditorKeydown = event => {
|
|
const key = String(event.key || "").toLowerCase();
|
|
if ((key !== "q" && key !== "e") || !GATE_TYPES.includes(tool)) return;
|
|
const tag = String(event.target?.tagName || "").toLowerCase();
|
|
if (tag === "input" || tag === "textarea" || event.target?.isContentEditable) return;
|
|
event.preventDefault(); event.stopPropagation();
|
|
placementRotation = safeRotation(placementRotation + (key === "q" ? -1 : 1));
|
|
draw();
|
|
};
|
|
document.addEventListener("keydown", handleEditorKeydown, true);
|
|
|
|
dialog.querySelectorAll("[data-circuit-tool]").forEach(button => { button.onclick = () => setTool(button.dataset.circuitTool); });
|
|
dialog.querySelectorAll("[data-grid-delta]").forEach(button => {
|
|
button.onclick = () => {
|
|
const [axis, deltaRaw] = String(button.dataset.gridDelta || "").split(":");
|
|
const delta = Number(deltaRaw || 0);
|
|
resizeGrid(axis === "cols" ? draft.cols + delta : draft.cols, axis === "rows" ? draft.rows + delta : draft.rows);
|
|
};
|
|
});
|
|
if (colsInput) colsInput.onchange = () => resizeGrid(colsInput.value, draft.rows);
|
|
if (rowsInput) rowsInput.onchange = () => resizeGrid(draft.cols, rowsInput.value);
|
|
dialog.querySelector("[data-action=undo]").onclick = restoreUndo;
|
|
dialog.querySelector("[data-action=clear]").onclick = () => { snapshot(); draft.nodes = []; draft.wires = []; draw(); };
|
|
dialog.querySelector("[data-action=reset]").onclick = () => { snapshot(); draft = defaultConfig(); syncControls(); resizeCanvas(); draw(); };
|
|
const close = () => {
|
|
dialog.classList.add("hidden");
|
|
document.removeEventListener("keydown", handleEditorKeydown, true);
|
|
canvas.onpointerdown = null; canvas.onpointermove = null; canvas.onpointerup = null; canvas.onpointercancel = null; canvas.onpointerleave = null; canvas.oncontextmenu = null;
|
|
};
|
|
dialog.querySelector("[data-action=close]").onclick = close;
|
|
dialog.querySelector("[data-action=cancel]").onclick = close;
|
|
dialog.querySelector("[data-action=save]").onclick = () => {
|
|
applySerializedConfig(board, draft); evaluate(board); remapAttachedWireEndpoints(board, worldRef);
|
|
if (worldRef) { worldRef.drawListDirty = true; worldRef.markSpatialDirty?.("circuit-board-edited"); worldRef.log?.("\u57fa\u76e4\u306e\u56de\u8def\u3092\u7d44\u307f\u66ff\u3048\u305f\u3002", "observe"); }
|
|
global.showToast?.("\u57fa\u76e4\u306e\u56de\u8def\u3092\u53cd\u6620\u3057\u307e\u3057\u305f\u3002");
|
|
global.render?.(); close();
|
|
};
|
|
dialog.onclick = event => { if (event.target === dialog) close(); };
|
|
syncControls(); resizeCanvas(); setTool("wire"); dialog.classList.remove("hidden"); draw();
|
|
return true;
|
|
}
|
|
|
|
global.TarinaiCircuitBoardSystem = Object.freeze({
|
|
GATE_TYPES, HALF_W, HALF_H, CANVAS_W, CANVAS_H, GRID, DEFAULT_COLS, DEFAULT_ROWS, MIN_COLS, MAX_COLS, MIN_ROWS, MAX_ROWS,
|
|
defaultConfig, normalizeConfig, ensureConfig, serializeConfig, applySerializedConfig,
|
|
ports, portById, localPortPosition, portWorld, nearestPort, terminal, evaluate, openEditor,
|
|
allPins, pinByToken, wirePath, endpointPosition, boardHalfWidth, boardHalfHeight, portLimit, nodeBodySize, nodePlacementBounds, clampNodePosition, junctionTokens, moveJunction, remapAttachedWireEndpoints, isPortExternallyConnected,
|
|
});
|
|
})(typeof window !== "undefined" ? window : globalThis);
|