// Panels: an input panel is a column of switches, buttons and clocks, an // output panel a column of lamps. A panel can be wired like any other part, // or docked to a component: an input panel on its left gets a row per free // input, an output panel on its right a row per output. A docked panel moves // with its component and follows it when the component gains or loses pins. import { chipPins, panelOffsets, rowPin, shapeOf, type DefLookup } from './geometry' import { pinName } from './labels' import { lookup, uid } from './ops' import type { CircuitNode, ComponentDef, PanelRow, Project } from './types' /** Free space between a docked panel and its component, in grid units. */ const DOCK_GAP = 3 export function newPanelRows(count = 4): PanelRow[] { return Array.from({ length: count }, () => ({ id: uid('r'), type: 'switch' as const })) } export const isPanel = (n: CircuitNode) => n.kind === 'panel' || n.kind === 'outpanel' /** Panels docked to one of the given chip nodes. */ export function dockedPanels(def: ComponentDef, chipIds: Set): CircuitNode[] { return def.nodes.filter(n => isPanel(n) && n.attach && chipIds.has(n.attach)) } interface ChipInput { key: string label: string dy: number } /** The pins of a chip a panel docks to: its inputs for an input panel, its outputs for an output panel. */ function chipInputs(chip: CircuitNode, get: DefLookup, side: 'in' | 'out' = 'in'): ChipInput[] | null { const child = chip.kind === 'chip' && chip.chip ? get(chip.chip) : undefined if (!child) return null const pins = chipPins(child) const labels = new Map((side === 'in' ? pins.inputs : pins.outputs).map(p => [p.key, p.label])) const shape = shapeOf(chip, get) return (side === 'in' ? shape.inputs : shape.outputs).map(p => ({ key: p.key, label: labels.get(p.key) ?? p.label, dy: p.dy })) } const sideOf = (panel: CircuitNode) => (panel.kind === 'outpanel' ? 'out' : 'in') /** A wire between a docked panel's row and its chip's pin, the right way round. */ function dockWire(panel: CircuitNode, chipId: string, key: string) { return panel.kind === 'outpanel' ? { id: uid('w'), from: { node: chipId, pin: key }, to: { node: panel.id, pin: key } } : { id: uid('w'), from: { node: panel.id, pin: key }, to: { node: chipId, pin: key } } } /** Lines the rows up with the chip's pins and names them after the pins. */ function layout(panel: CircuitNode, pins: ChipInput[]) { const byKey = new Map(pins.map(p => [p.key, p])) const order = new Map(pins.map((p, i) => [p.key, i])) const rows = (panel.rows ?? []).filter(r => byKey.has(r.id)).sort((a, b) => order.get(a.id)! - order.get(b.id)!) const top = rows.length ? byKey.get(rows[0]!.id)!.dy : 0 for (const r of rows) { const p = byKey.get(r.id)! r.dy = p.dy - top r.name = p.label } panel.rows = rows return top } /** * Docks a new panel to a placed component: an input panel on its left with * a switch for every input that is not wired yet, or an output panel on its * right with a lamp for every output. Returns the panel, or null when there * is nothing to show. */ export function attachPanel(project: Project, def: ComponentDef, chipId: string, side: 'in' | 'out' = 'in'): CircuitNode | null { const get = lookup(project) const chip = def.nodes.find(n => n.id === chipId) const pins = chip && chipInputs(chip, get, side) if (!chip || !pins) return null // Inputs take one wire; outputs can feed a lamp as well as anything else. const wired = side === 'in' ? new Set(def.wires.filter(w => w.to.node === chipId).map(w => w.to.pin)) : new Set() const free = pins.filter(p => !wired.has(p.key)) if (!free.length) return null const panel: CircuitNode = { id: uid('n'), kind: side === 'in' ? 'panel' : 'outpanel', x: 0, y: 0, attach: chipId, rows: free.map(p => ({ id: p.key, type: 'switch' })), } if (free.length < pins.length) panel.skip = pins.filter(p => wired.has(p.key)).map(p => p.key) const top = layout(panel, pins) const chipBody = shapeOf(chip, get).body panel.x = side === 'in' ? chip.x - DOCK_GAP - shapeOf(panel, get).body.w : chip.x + chipBody.x + chipBody.w + DOCK_GAP panel.y = chip.y + top def.nodes.push(panel) for (const r of panel.rows!) def.wires.push(dockWire(panel, chipId, r.id)) return panel } /** * Keeps docked panels in step with their components: rows for pins that are * gone are dropped, new free pins get a switch, and rows stay lined up with * the pins. A panel whose component was removed is undocked. Runs on every * structural change; wires to dropped rows are cleaned up afterwards. */ export function syncPanels(project: Project) { const get = lookup(project) for (const def of project.components) { nameFreeRows(def, get) if (!def.nodes.some(n => isPanel(n) && n.attach)) continue const nodes = new Map(def.nodes.map(n => [n.id, n])) for (const panel of def.nodes) { if (!isPanel(panel) || !panel.attach) continue const side = sideOf(panel) const chip = nodes.get(panel.attach) const pins = chip && chipInputs(chip, get, side) if (!chip || !pins) { delete panel.attach delete panel.skip continue } const keys = new Set(pins.map(p => p.key)) const rows = panel.rows ?? [] const skip = (panel.skip ?? []).filter(k => keys.has(k)) const known = new Set([...rows.map(r => r.id), ...skip]) const wired = side === 'in' ? new Set(def.wires.filter(w => w.to.node === chip.id).map(w => w.to.pin)) : new Set() for (const p of pins) { if (known.has(p.key)) continue if (wired.has(p.key)) skip.push(p.key) else { rows.push({ id: p.key, type: 'switch' }) def.wires.push(dockWire(panel, chip.id, p.key)) } } panel.rows = rows if (skip.length) panel.skip = skip else delete panel.skip const top = layout(panel, pins) // Keep the first row on its pin, wherever the panel was moved sideways. if (panel.rows.length) panel.y = chip.y + top } } } /** * Rows of free panels without a name of their own take the name of the pin * they are wired to: an output panel's row the one that feeds it, an input * panel's row the one it drives. */ function nameFreeRows(def: ComponentDef, get: DefLookup) { const panels = def.nodes.filter(n => isPanel(n) && !n.attach && n.rows?.some(r => !r.label?.trim())) if (!panels.length) return const nodes = new Map(def.nodes.map(n => [n.id, n])) for (const p of panels) { for (const r of p.rows!) { if (r.label?.trim()) continue const w = p.kind === 'outpanel' ? def.wires.find(x => x.to.node === p.id && x.to.pin === r.id) : def.wires.find(x => x.from.node === p.id && x.from.pin === r.id) const other = w && (p.kind === 'outpanel' ? w.from : w.to) const node = other && nodes.get(other.node) const name = node && (pinName(node, other.pin, get) ?? (['input', 'button', 'clock', 'output', 'lamp'].includes(node.kind) ? node.label?.trim() : undefined)) if (name) r.name = name } } } /** Removes one row; on a docked panel that pin is left alone from then on. */ export function removeRow(def: ComponentDef, panel: CircuitNode, rowId: string) { panel.rows = (panel.rows ?? []).filter(r => r.id !== rowId) def.wires = def.wires.filter(w => !(w.from.node === panel.id && w.from.pin === rowId) && !(w.to.node === panel.id && w.to.pin === rowId)) if (panel.attach) panel.skip = [...new Set([...(panel.skip ?? []), rowId])] } /** * A new row at place `index` in a free panel's order (0: above the first, * rows.length: below the last), the same kind as its neighbour. It takes the * place of the row it goes above; that row and the ones below move down one, * keeping the gaps between them. */ export function insertPanelRow(panel: CircuitNode, index: number): PanelRow { const rows = panel.rows ?? [] const at = panelOffsets(rows) const i = Math.max(0, Math.min(Math.round(index), rows.length)) const row = newPanelRows(1)[0]! row.type = rows[i]?.type ?? rows[i - 1]?.type ?? 'switch' const place = i < rows.length ? at[i]! : at.length ? at[at.length - 1]! + 1 : 0 rows.forEach((r, k) => (r.dy = k < i ? at[k]! : at[k]! + 1)) row.dy = place rows.splice(i, 0, row) panel.rows = rows return row } /** * Moves a row of a free panel from one place in the order to another. The * places stay where they are (gaps too); the rows trade them, and each row * keeps its wires. False when nothing moved. */ export function movePanelRow(panel: CircuitNode, from: number, to: number): boolean { const rows = panel.rows ?? [] if (from === to || from < 0 || to < 0 || from >= rows.length || to >= rows.length) return false const at = panelOffsets(rows) const [r] = rows.splice(from, 1) rows.splice(to, 0, r!) rows.forEach((x, k) => (x.dy = at[k]!)) return true } /** A docked panel's pins drive the component; undocking keeps rows, wires and position. */ export function detachPanel(panel: CircuitNode) { delete panel.attach delete panel.skip } /** * Joins panels into one: the top one keeps its rows, the others' rows follow * below in order, packed without gaps, with their wires. The joined panel * is free (no longer docked). Returns it with the pin keys that changed * (old → new), so circuits that place this one can keep their wires; null * for fewer than two panels. */ export function mergePanels(def: ComponentDef, ids: string[]): { panel: CircuitNode; renamed: Map } | null { const sel = def.nodes.filter(n => isPanel(n) && ids.includes(n.id)) // Input panels join input panels, output panels output panels. const kind = sel[0]?.kind const panels = sel.filter(n => n.kind === kind).sort((a, b) => a.y - b.y || a.x - b.x) if (panels.length < 2) return null const [target, ...rest] = panels as [CircuitNode, ...CircuitNode[]] const rows = target.rows ?? [] const used = new Set(rows.map(r => r.id)) const renamed = new Map() for (const p of rest) { const theirs = p.rows ?? [] theirs.forEach(r => { const id = used.has(r.id) ? uid('r') : r.id used.add(id) for (const w of def.wires) { if (w.from.node === p.id && w.from.pin === r.id) w.from = { node: target.id, pin: id } if (w.to.node === p.id && w.to.pin === r.id) w.to = { node: target.id, pin: id } } renamed.set(rowPin(p.id, r.id), rowPin(target.id, id)) rows.push({ ...r, id }) }) } // One row under the other, no space between. for (const r of rows) delete r.dy target.rows = rows delete target.attach delete target.skip const gone = new Set(rest.map(p => p.id)) def.nodes = def.nodes.filter(n => !gone.has(n.id)) def.wires = def.wires.filter(w => !gone.has(w.from.node) && !gone.has(w.to.node)) return { panel: target, renamed } } const SOURCES = new Set(['input', 'button', 'clock']) const SINKS = new Set(['output', 'lamp']) /** * Turns separate switches, buttons and clocks into one input panel, or * output pins and lamps into one output panel: a row each, top to bottom, * with their names, settings and wires, packed without gaps. Returns the panel and the pin keys that changed * (old → new) for circuits that place this one; null when the parts are * not all of one side or fewer than two. */ export function combineIntoPanel(def: ComponentDef, ids: string[], get: DefLookup): { panel: CircuitNode; renamed: Map } | null { const sel = def.nodes.filter(n => ids.includes(n.id)).sort((a, b) => a.y - b.y || a.x - b.x) const out = sel.length > 0 && sel.every(n => SINKS.has(n.kind)) if (sel.length < 2 || !(out || sel.every(n => SOURCES.has(n.kind)))) return null const panel: CircuitNode = { id: uid('n'), kind: out ? 'outpanel' : 'panel', x: 0, y: sel[0]!.y, rows: [] } // Pins stay pins; switches, buttons, clocks and lamps that were not pins stay inside. const pinKind = out ? 'output' : 'input' if (!sel.some(n => n.kind === pinKind)) panel.inner = true const renamed = new Map() for (const n of sel) { const row: PanelRow = { id: n.id, type: n.kind === 'button' ? 'button' : n.kind === 'clock' ? 'clock' : 'switch' } const label = n.label?.trim() if (label && !n.autoLabel) row.label = label else if (label) row.name = label if (n.on) row.on = true if (n.key) row.key = n.key if (n.hz) row.hz = n.hz if (n.color) row.color = n.color panel.rows!.push(row) if (n.kind === pinKind) renamed.set(n.id, rowPin(panel.id, n.id)) for (const w of def.wires) { // A lamp's or output pin's pass-through leaves the row on the right, as before. if (w.from.node === n.id) w.from = { node: panel.id, pin: n.id } if (w.to.node === n.id) w.to = { node: panel.id, pin: n.id } } } // Where the parts' pins were: switches' outputs on the panel's right edge, lamps' inputs on its left. const w = shapeOf(panel, get).body.w panel.x = out ? Math.min(...sel.map(n => n.x)) : Math.max(...sel.map(n => n.x + (shapeOf(n, get).outputs[0]?.dx ?? 2))) - w const gone = new Set(sel.map(n => n.id)) def.nodes = [...def.nodes.filter(n => !gone.has(n.id)), panel] return { panel, renamed } }