logigate/app/lib/logic/panels.ts

135 lines
5.3 KiB
TypeScript
Raw Normal View History

// Input panels: one part with a column of switches, buttons and clocks.
// A panel can be wired like any other part, or docked to a component, where
// it gets one row per free input pin. A docked panel moves with its
// component and follows it when the component gains or loses pins.
import { chipPins, shapeOf, type DefLookup } from './geometry'
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 }))
}
/** Panels docked to one of the given chip nodes. */
export function dockedPanels(def: ComponentDef, chipIds: Set<string>): CircuitNode[] {
return def.nodes.filter(n => n.kind === 'panel' && n.attach && chipIds.has(n.attach))
}
interface ChipInput {
key: string
label: string
dy: number
}
function chipInputs(chip: CircuitNode, get: DefLookup): ChipInput[] | null {
const child = chip.kind === 'chip' && chip.chip ? get(chip.chip) : undefined
if (!child) return null
const labels = new Map(chipPins(child).inputs.map(p => [p.key, p.label]))
return shapeOf(chip, get).inputs.map(p => ({ key: p.key, label: labels.get(p.key) ?? p.label, dy: p.dy }))
}
/** 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 the left of a placed component, with a switch for
* every input that is not wired yet. Returns the panel, or null when every
* input is already in use.
*/
export function attachPanel(project: Project, def: ComponentDef, chipId: string): CircuitNode | null {
const get = lookup(project)
const chip = def.nodes.find(n => n.id === chipId)
const pins = chip && chipInputs(chip, get)
if (!chip || !pins) return null
const wired = new Set(def.wires.filter(w => w.to.node === chipId).map(w => w.to.pin))
const free = pins.filter(p => !wired.has(p.key))
if (!free.length) return null
const panel: CircuitNode = {
id: uid('n'),
kind: 'panel',
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)
panel.x = chip.x - DOCK_GAP - shapeOf(panel, get).body.w
panel.y = chip.y + top
def.nodes.push(panel)
for (const r of panel.rows!) def.wires.push({ id: uid('w'), from: { node: panel.id, pin: r.id }, to: { node: chipId, pin: 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) {
if (!def.nodes.some(n => n.kind === 'panel' && n.attach)) continue
const nodes = new Map(def.nodes.map(n => [n.id, n]))
for (const panel of def.nodes) {
if (panel.kind !== 'panel' || !panel.attach) continue
const chip = nodes.get(panel.attach)
const pins = chip && chipInputs(chip, get)
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 = new Set(def.wires.filter(w => w.to.node === chip.id).map(w => w.to.pin))
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({ id: uid('w'), from: { node: panel.id, pin: p.key }, to: { node: chip.id, pin: 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
}
}
}
/** 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))
if (panel.attach) panel.skip = [...new Set([...(panel.skip ?? []), rowId])]
}
/** 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
}