109 lines
5.3 KiB
TypeScript
109 lines
5.3 KiB
TypeScript
// Checking a circuit for mistakes that still simulate but rarely mean what
|
|
// was intended: inputs left open (they read 0), parts that drive nothing,
|
|
// pins that share a name, and signals nothing sends or two parts send.
|
|
|
|
import { chipPins, shapeOf, type DefLookup } from './geometry'
|
|
import { KIND_NAMES } from './progress'
|
|
import type { CircuitNode, ComponentDef, Project } from './types'
|
|
|
|
export type IssueLevel = 'error' | 'warn' | 'info'
|
|
|
|
export interface Issue {
|
|
level: IssueLevel
|
|
text: string
|
|
/** Parts to show for it; the first one is centred. */
|
|
nodes: string[]
|
|
}
|
|
|
|
/** Parts whose open inputs are worth a warning (a cable bundle's spare wires are not). */
|
|
export const CHECKED_INPUTS = new Set(['nand', 'chip', 'output', 'lamp', 'hex', 'pixel', 'tag'])
|
|
|
|
function partName(n: CircuitNode, get: DefLookup): string {
|
|
const own = !n.autoLabel && n.label?.trim()
|
|
const kind = n.kind === 'chip' ? ((n.chip && get(n.chip)?.name) ?? 'Missing component') : (KIND_NAMES[n.kind] ?? n.kind)
|
|
if (n.kind === 'tag' || n.kind === 'ref') return `${kind} "${n.label?.trim() || '?'}"`
|
|
return own ? `${kind} ${own}` : (n.label?.trim() ? `${kind} ${n.label.trim()}` : kind)
|
|
}
|
|
|
|
/** Input pins of a part that have no wire. */
|
|
export function openInputs(def: ComponentDef, n: CircuitNode, get: DefLookup): string[] {
|
|
if (!CHECKED_INPUTS.has(n.kind)) return []
|
|
const wired = new Set(def.wires.filter(w => w.to.node === n.id).map(w => w.to.pin))
|
|
return shapeOf(n, get).inputs.filter(p => !p.bus && !wired.has(p.key)).map(p => p.key)
|
|
}
|
|
|
|
export function checkCircuit(def: ComponentDef, get: DefLookup): Issue[] {
|
|
const issues: Issue[] = []
|
|
const fed = new Set(def.wires.map(w => `${w.from.node}:${w.from.pin}`))
|
|
const name = (n: CircuitNode) => partName(n, get)
|
|
|
|
for (const n of def.nodes) {
|
|
if (n.kind === 'chip' && (!n.chip || !get(n.chip))) {
|
|
issues.push({ level: 'error', text: 'A placed component no longer exists', nodes: [n.id] })
|
|
continue
|
|
}
|
|
const open = openInputs(def, n, get)
|
|
if (open.length) {
|
|
const shape = shapeOf(n, get)
|
|
const labels = open.map(k => shape.inputs.find(p => p.key === k)?.label || k)
|
|
const all = open.length === shape.inputs.length
|
|
const text =
|
|
n.kind === 'chip' || n.kind === 'nand' || n.kind === 'hex'
|
|
? `${name(n)}: ${all ? 'no input connected' : `${labels.join(', ')} not connected`} (reads 0)`
|
|
: `${name(n)}: nothing connected`
|
|
issues.push({ level: 'warn', text, nodes: [n.id] })
|
|
}
|
|
if (n.kind === 'split' && !def.wires.some(w => w.to.node === n.id)) issues.push({ level: 'warn', text: 'Cable split without a cable', nodes: [n.id] })
|
|
// Parts that drive nothing.
|
|
if ((n.kind === 'input' || n.kind === 'button' || n.kind === 'clock' || n.kind === 'nand') && !fed.has(`${n.id}:q`)) {
|
|
issues.push({ level: 'info', text: n.kind === 'nand' ? 'NAND gate: its output goes nowhere' : `${name(n)}: goes nowhere`, nodes: [n.id] })
|
|
}
|
|
if (n.kind === 'chip' && n.chip) {
|
|
const outs = chipPins(get(n.chip)!).outputs
|
|
if (outs.length && !outs.some(p => fed.has(`${n.id}:${p.key}`))) issues.push({ level: 'info', text: `${name(n)}: none of its outputs is used`, nodes: [n.id] })
|
|
}
|
|
}
|
|
|
|
// Pins of the same name can't be told apart from outside.
|
|
for (const kind of ['input', 'output'] as const) {
|
|
const by = new Map<string, CircuitNode[]>()
|
|
for (const n of def.nodes) {
|
|
const l = n.kind === kind ? n.label?.trim() : ''
|
|
if (l) by.set(l.toLowerCase(), [...(by.get(l.toLowerCase()) ?? []), n])
|
|
}
|
|
for (const list of by.values()) {
|
|
if (list.length > 1) issues.push({ level: 'warn', text: `${list.length} ${kind} pins are called ${list[0]!.label!.trim()}`, nodes: list.map(n => n.id) })
|
|
}
|
|
}
|
|
|
|
// Signals: sent once, used somewhere.
|
|
const tags = new Map<string, CircuitNode[]>()
|
|
const refs = new Map<string, CircuitNode[]>()
|
|
for (const n of def.nodes) {
|
|
const l = n.label?.trim() ?? ''
|
|
if (n.kind === 'tag') tags.set(l, [...(tags.get(l) ?? []), n])
|
|
if (n.kind === 'ref') refs.set(l, [...(refs.get(l) ?? []), n])
|
|
}
|
|
for (const [l, list] of tags) {
|
|
if (!l) issues.push({ level: 'warn', text: 'A "Send signal" has no name', nodes: list.map(n => n.id) })
|
|
else if (list.length > 1) issues.push({ level: 'error', text: `Signal "${l}" is sent by ${list.length} parts: they drive it against each other`, nodes: list.map(n => n.id) })
|
|
else if (!refs.has(l)) issues.push({ level: 'info', text: `Signal "${l}" is sent but not used`, nodes: list.map(n => n.id) })
|
|
}
|
|
for (const [l, list] of refs) {
|
|
if (!tags.has(l)) issues.push({ level: 'error', text: l ? `Nothing sends signal "${l}" (reads 0)` : 'A "Use signal" has no name', nodes: list.map(n => n.id) })
|
|
}
|
|
|
|
const rank: Record<IssueLevel, number> = { error: 0, warn: 1, info: 2 }
|
|
return issues.sort((a, b) => rank[a.level] - rank[b.level])
|
|
}
|
|
|
|
/**
|
|
* Components made in this project that no other circuit places. Some are
|
|
* circuits you work in directly; the rest can go. The examples are left out.
|
|
*/
|
|
export function unusedComponents(project: Project): ComponentDef[] {
|
|
const used = new Set<string>()
|
|
for (const d of project.components) for (const n of d.nodes) if (n.kind === 'chip' && n.chip && n.chip !== d.id) used.add(n.chip)
|
|
return project.components.filter(d => !used.has(d.id) && !d.id.startsWith('ex-') && !d.challenge)
|
|
}
|