2614 lines
93 KiB
TypeScript
2614 lines
93 KiB
TypeScript
// Editor state: the project library, the open project, selection, undo
|
||
// history, share links and the running simulation of the open circuit.
|
||
// One shared instance for the whole page.
|
||
|
||
import { nandCounts, runSteps, stats, tableCsv, TRANSISTORS_PER_NAND, truthTable, type Stats, type TestResult, type TruthTable } from '~/lib/logic/analyze'
|
||
import {
|
||
bundleWires,
|
||
cableFromPins,
|
||
cableIntoPins,
|
||
cablePanel,
|
||
dissolveCable,
|
||
pinGroups,
|
||
pluggedInto,
|
||
plugInto,
|
||
syncCables,
|
||
type PinGroup,
|
||
} from '~/lib/logic/cables'
|
||
import { fitLinks, fitSpots } from '~/lib/logic/fit'
|
||
import { rememberPart } from '~/lib/recent'
|
||
import { checkCircuit } from '~/lib/logic/check'
|
||
import { loadSoundSettings, saveSoundSettings, sfx, type Sound, type SoundSettings } from '~/lib/audio'
|
||
import { challengeName, challengeOpen, defUsable, isCampaign, KIND_NAMES, kindUnlocked, NEEDS, unlockedBy } from '~/lib/logic/progress'
|
||
import { apiId, makePuzzle, scoreSolution, weekKey, weeklyId } from '~/lib/logic/puzzles'
|
||
import { baseOf, MAX_GATE_INPUTS, NAND_BASE, wideGate } from '~/lib/logic/wide'
|
||
import { CHALLENGES, challengeSteps, type Challenge } from '~/lib/logic/challenges'
|
||
import { latchedTo, latchInto, latchTarget, syncLatches } from '~/lib/logic/latch'
|
||
import { cleanBundle, importBundle, importProblem, LIBRARY_LIMITS, libraryBundle, ownedEntry, publishProblem, type LibraryBundle, type LibraryMeta } from '~/lib/logic/library'
|
||
import { compile, INVERTIBLE, invertedPins, rowSource } from '~/lib/logic/compile'
|
||
import { chipPins, MAX_BITS, panelOffsets, pinKindOf, shapeOf, type Pt } from '~/lib/logic/geometry'
|
||
import { adoptName, continueSeries, newPinLabel, uniqueLabel, usedLabels } from '~/lib/logic/labels'
|
||
import { attachPanel, combineIntoPanel, detachPanel, dockedPanels, insertPanelRow, mergePanels, movePanelRow, newPanelRows, removeRow, syncPanels } from '~/lib/logic/panels'
|
||
import {
|
||
addExamples,
|
||
containsDef,
|
||
copySelection,
|
||
createProject,
|
||
deleteComponent,
|
||
duplicateComponent,
|
||
lookup,
|
||
makeUnique,
|
||
pinKeys,
|
||
mergeComponents,
|
||
newComponent,
|
||
packageSelection,
|
||
pasteClip,
|
||
pruneWires,
|
||
startChallenge,
|
||
startPuzzle,
|
||
swapNode,
|
||
uid,
|
||
unlinkWires,
|
||
unpackChip,
|
||
type Clip,
|
||
type SwapTarget,
|
||
} from '~/lib/logic/ops'
|
||
import { arrangeNodes, byPosition, numberedNames, seriesLinks, type Arrange, type Link } from '~/lib/logic/bulk'
|
||
import { parseProject, toProject } from '~/lib/logic/project'
|
||
import { Simulator } from '~/lib/logic/sim'
|
||
import {
|
||
cachedAccount,
|
||
currentId,
|
||
libraryKeys,
|
||
listProjects,
|
||
loadProject,
|
||
migrateLegacy,
|
||
newLocalId,
|
||
pendingDeletes,
|
||
removeProject,
|
||
saveMeta,
|
||
saveProject,
|
||
setCachedAccount,
|
||
setCurrentId,
|
||
setLibraryKey,
|
||
setPendingDeletes,
|
||
type AccountUser,
|
||
type ProjectMeta,
|
||
} from '~/lib/logic/storage'
|
||
import type { CircuitNode, ComponentDef, ConnectorType, LampColor, LibraryOrigin, NodeKind, PanelControl, PanelRow, PinRef, Project, PuzzleSpec, WireColor } from '~/lib/logic/types'
|
||
|
||
/** A challenge check plus how many transistors the solution uses. */
|
||
/** How everyone did on a puzzle, from the server. */
|
||
export interface PuzzleSummary {
|
||
players: number
|
||
histogram: { t: number; n: number }[]
|
||
you?: { t: number; d: number | null; rank: number }
|
||
/** The best ten, named as the players chose (empty: anonymous). */
|
||
top?: { name: string; t: number; d: number | null; you?: true }[]
|
||
}
|
||
|
||
export type MenuPage = 'main' | 'load' | 'free' | 'campaign' | 'challenges' | 'leaderboard'
|
||
|
||
export interface ChallengeCheck extends TestResult {
|
||
transistors: number
|
||
/** Parts this first solve made usable (campaign). */
|
||
unlocked?: string[]
|
||
/** Challenges it opened. */
|
||
nextUp?: string[]
|
||
/** Fewest transistors of any passing solution so far, this one included. */
|
||
best?: number
|
||
/** Set when this one beat an earlier record: that record. */
|
||
record?: number
|
||
}
|
||
|
||
/** One pin waiting to be wired in "connect one by one". */
|
||
export interface LinkEnd {
|
||
node: string
|
||
pin: string
|
||
dir: 'in' | 'out'
|
||
label: string
|
||
}
|
||
|
||
export interface Placing {
|
||
kind: NodeKind
|
||
chip?: string
|
||
/** Port: its connector type. */
|
||
conn?: string
|
||
keep?: boolean
|
||
}
|
||
|
||
export interface View {
|
||
x: number
|
||
y: number
|
||
zoom: number
|
||
}
|
||
|
||
export type LinkState = 'none' | 'viewer' | 'dirty' | 'saving' | 'saved' | 'error'
|
||
|
||
const BUDGET = 300_000
|
||
|
||
function create() {
|
||
// ── Library ───────────────────────────────────────────────────────
|
||
migrateLegacy()
|
||
const projects = ref<ProjectMeta[]>(listProjects())
|
||
|
||
function initial(): { meta: ProjectMeta; project: Project } {
|
||
const list = listProjects()
|
||
const id = currentId()
|
||
for (const m of [list.find(m => m.id === id), ...list]) {
|
||
if (!m) continue
|
||
const p = loadProject(m.id)
|
||
if (p) return { meta: m, project: p }
|
||
}
|
||
const project = createProject({ examples: true })
|
||
const meta: ProjectMeta = { id: newLocalId(), name: project.name, updated: Date.now(), starter: true }
|
||
// The starter project of a first visit is saved only once something
|
||
// changes in it. Signed in on a new device, the account's saves load
|
||
// instead, so an untouched starter never becomes a second copy.
|
||
placeholder = true
|
||
return { meta, project }
|
||
}
|
||
|
||
let placeholder = false
|
||
|
||
const start = initial()
|
||
// The starter project of a first visit is in the list now.
|
||
projects.value = listProjects()
|
||
const meta = ref<ProjectMeta>(start.meta)
|
||
const project = ref<Project>(start.project)
|
||
setCurrentId(start.meta.id)
|
||
|
||
const getDef = computed(() => lookup(project.value))
|
||
const def = computed(() => getDef.value(project.value.openId) ?? project.value.components[0]!)
|
||
|
||
const selection = ref<string[]>([])
|
||
const wireSel = ref<string[]>([])
|
||
const placing = ref<Placing | null>(null)
|
||
const nav = ref<string[]>([])
|
||
const views = reactive<Record<string, View>>({})
|
||
const notice = ref<{ text: string; kind: 'ok' | 'error' } | null>(null)
|
||
const labelFocus = ref(0)
|
||
const showHelp = ref(false)
|
||
const dialog = ref<null | 'connector' | 'share' | 'account' | 'versions' | 'table' | 'publish' | 'settings' | 'search' | 'face' | 'library' | 'library-publish'>(null)
|
||
/** The component whose box is being drawn in the face designer. */
|
||
const faceFor = ref<string | null>(null)
|
||
function designFace(defId: string) {
|
||
faceFor.value = defId
|
||
dialog.value = 'face'
|
||
}
|
||
/** Tab of the panel on the left: this circuit, or its pins. The selection has its own panel on the right. */
|
||
const panelTab = ref<'circuit' | 'pins'>('circuit')
|
||
/** Whether the panel on the left is open; remembered in this browser. */
|
||
const panelOpen = ref(true)
|
||
try {
|
||
panelOpen.value = localStorage.getItem('logigate:panel') !== 'closed'
|
||
} catch {}
|
||
function togglePanel(open = !panelOpen.value) {
|
||
panelOpen.value = open
|
||
try {
|
||
localStorage.setItem('logigate:panel', open ? 'open' : 'closed')
|
||
} catch {}
|
||
}
|
||
/** Asks the canvas to centre on a part. */
|
||
const focusRequest = ref<{ id: string; n: number } | null>(null)
|
||
/** Pins being wired one after another; `at` is the one the next click connects. */
|
||
const linking = ref<{ queue: LinkEnd[]; at: number } | null>(null)
|
||
/** Project whose savegames the versions dialog shows. */
|
||
const versionsFor = ref<string | null>(null)
|
||
|
||
let noticeTimer: ReturnType<typeof setTimeout> | undefined
|
||
function notify(text: string, kind: 'ok' | 'error' = 'ok') {
|
||
notice.value = { text, kind }
|
||
clearTimeout(noticeTimer)
|
||
noticeTimer = setTimeout(() => (notice.value = null), 3500)
|
||
}
|
||
|
||
function clearSelection() {
|
||
selection.value = []
|
||
wireSel.value = []
|
||
}
|
||
|
||
// ── Saving ────────────────────────────────────────────────────────
|
||
let saveTimer: ReturnType<typeof setTimeout> | undefined
|
||
let changed = false
|
||
function persistNow() {
|
||
clearTimeout(saveTimer)
|
||
saveTimer = undefined
|
||
// An untouched starter project is not saved (see initial()).
|
||
if (placeholder) return
|
||
meta.value = {
|
||
...meta.value,
|
||
name: project.value.name,
|
||
updated: Date.now(),
|
||
...(project.value.mode ? { mode: project.value.mode } : {}),
|
||
...(changed ? { dirty: true, starter: undefined } : {}),
|
||
}
|
||
if (!saveProject(toRaw(meta.value), toRaw(project.value))) notify('Browser storage is full. Export your project to keep it.', 'error')
|
||
projects.value = listProjects()
|
||
if (changed) scheduleCloud()
|
||
changed = false
|
||
}
|
||
|
||
function persist() {
|
||
placeholder = false
|
||
changed = true
|
||
clearTimeout(saveTimer)
|
||
saveTimer = setTimeout(persistNow, 300)
|
||
scheduleSync()
|
||
}
|
||
|
||
// ── History ───────────────────────────────────────────────────────
|
||
const snap = () => JSON.stringify({ components: project.value.components, solved: project.value.solved, connectors: project.value.connectors })
|
||
let last = snap()
|
||
const undoStack: string[] = []
|
||
const redoStack: string[] = []
|
||
const canUndo = ref(false)
|
||
const canRedo = ref(false)
|
||
|
||
function resetHistory() {
|
||
syncLatches(project.value)
|
||
syncCables(project.value)
|
||
undoStack.length = 0
|
||
redoStack.length = 0
|
||
last = snap()
|
||
canUndo.value = false
|
||
canRedo.value = false
|
||
}
|
||
|
||
/**
|
||
* Record a change. Structural changes (parts, wires) rebuild the simulation.
|
||
* Latched parts and cables follow every change: a moved part takes them along.
|
||
*/
|
||
function commit(structural = true) {
|
||
if (structural) {
|
||
syncPanels(project.value)
|
||
pruneWires(project.value)
|
||
}
|
||
syncLatches(project.value)
|
||
syncCables(project.value)
|
||
const s = snap()
|
||
if (s === last) return
|
||
undoStack.push(last)
|
||
if (undoStack.length > 200) undoStack.shift()
|
||
redoStack.length = 0
|
||
last = s
|
||
canUndo.value = true
|
||
canRedo.value = false
|
||
forkIfViewer()
|
||
persist()
|
||
if (structural) scheduleRebuild()
|
||
}
|
||
|
||
function restore(s: string) {
|
||
const data = JSON.parse(s) as Pick<Project, 'components' | 'solved' | 'connectors'>
|
||
project.value.components = data.components
|
||
project.value.solved = data.solved
|
||
if (data.connectors) project.value.connectors = data.connectors
|
||
else delete project.value.connectors
|
||
if (!project.value.components.some(d => d.id === project.value.openId)) project.value.openId = project.value.components[0]!.id
|
||
last = s
|
||
selection.value = selection.value.filter(id => def.value.nodes.some(n => n.id === id))
|
||
wireSel.value = wireSel.value.filter(id => def.value.wires.some(w => w.id === id))
|
||
canUndo.value = undoStack.length > 0
|
||
canRedo.value = redoStack.length > 0
|
||
persist()
|
||
scheduleRebuild()
|
||
}
|
||
|
||
function undo() {
|
||
const s = undoStack.pop()
|
||
if (s === undefined) return
|
||
redoStack.push(last)
|
||
restore(s)
|
||
}
|
||
|
||
function redo() {
|
||
const s = redoStack.pop()
|
||
if (s === undefined) return
|
||
undoStack.push(last)
|
||
restore(s)
|
||
}
|
||
|
||
// ── Simulation ────────────────────────────────────────────────────
|
||
const sim = shallowRef<Simulator | null>(null)
|
||
let simRoot = ''
|
||
const tick = ref(0)
|
||
const status = ref<'stable' | 'busy' | 'oscillating'>('stable')
|
||
const running = ref(true)
|
||
const hz = ref(2)
|
||
const cycles = ref(0)
|
||
const errors = ref<string[]>([])
|
||
const circuitStats = ref<Stats>({ nands: 0, sequential: false, delay: 0 })
|
||
const pressed = new Set<string>()
|
||
|
||
function rebuild() {
|
||
const d = def.value
|
||
const nl = compile(getDef.value, d.id)
|
||
const key = `${meta.value.id}/${d.id}`
|
||
const carry = sim.value && simRoot === key ? sim.value.carry() : undefined
|
||
const s = new Simulator(nl, carry)
|
||
for (const n of d.nodes) {
|
||
if (n.kind === 'input') s.setSource(n.id, !!n.on)
|
||
else if (n.kind === 'button') s.setSource(n.id, pressed.has(n.id))
|
||
else if (n.kind === 'panel') {
|
||
for (const r of n.rows ?? []) {
|
||
const key = rowSource(n.id, r.id)
|
||
if (r.type === 'switch') s.setSource(key, !!r.on)
|
||
else if (r.type === 'button') s.setSource(key, pressed.has(key))
|
||
}
|
||
}
|
||
}
|
||
s.run(BUDGET)
|
||
if (simRoot !== key) cycles.value = 0
|
||
sim.value = s
|
||
simRoot = key
|
||
errors.value = nl.errors
|
||
circuitStats.value = stats(nl)
|
||
tick.value++
|
||
}
|
||
|
||
let rebuildQueued = false
|
||
function scheduleRebuild() {
|
||
if (rebuildQueued) return
|
||
rebuildQueued = true
|
||
queueMicrotask(() => {
|
||
rebuildQueued = false
|
||
rebuild()
|
||
})
|
||
}
|
||
|
||
/** Value at a pin of the open circuit. Reactive through `tick`. */
|
||
function val(nodeId: string, pin: string): number {
|
||
void tick.value
|
||
return sim.value?.pin(nodeId, pin) ?? 0
|
||
}
|
||
|
||
/** Value at a lamp or display inside a chip of the open circuit. */
|
||
function faceVal(chipNode: string, inner: string, pin: string): number {
|
||
void tick.value
|
||
return sim.value?.face(chipNode, inner, pin) ?? 0
|
||
}
|
||
|
||
let raf = 0
|
||
function startLoop() {
|
||
let lastT = performance.now()
|
||
let acc: number[] = []
|
||
let unsettled = 0
|
||
let lastChanges = -1
|
||
const frame = (t: number) => {
|
||
const dt = Math.min(100, t - lastT)
|
||
lastT = t
|
||
const s = sim.value
|
||
if (s) {
|
||
let rises = 0
|
||
let tickHz = 0
|
||
const n = s.nl.clocks.length
|
||
if (running.value && n) {
|
||
if (acc.length !== n) acc = new Array(n).fill(0)
|
||
// Ticks count the first clock that follows the top-bar speed (or the first clock).
|
||
const counted = Math.max(0, s.nl.clockHz.indexOf(0))
|
||
tickHz = s.nl.clockHz[counted] || hz.value
|
||
const fastest: number[] = []
|
||
for (let i = 0; i < n; i++) {
|
||
const f = s.nl.clockHz[i] || hz.value
|
||
if (f <= 0) {
|
||
fastest.push(i)
|
||
continue
|
||
}
|
||
acc[i]! += dt
|
||
const half = 500 / f
|
||
for (let k = 0; acc[i]! >= half && k < 16; k++) {
|
||
acc[i]! -= half
|
||
s.run(BUDGET)
|
||
if (s.toggleClock(i) && i === counted) rises++
|
||
}
|
||
if (acc[i]! > half) acc[i] = 0
|
||
}
|
||
if (fastest.length) {
|
||
const end = performance.now() + 10
|
||
while (performance.now() < end) {
|
||
if (!s.run(BUDGET)) break
|
||
for (const i of fastest) if (s.toggleClock(i) && i === counted) rises++
|
||
}
|
||
}
|
||
}
|
||
if (rises) cycles.value += rises
|
||
if (rises && sound.value.ticks && tickHz > 0 && tickHz <= 8) play('tick')
|
||
const settled = s.run(BUDGET)
|
||
unsettled = settled ? 0 : unsettled + 1
|
||
status.value = settled ? 'stable' : unsettled > 30 ? 'oscillating' : 'busy'
|
||
if (s.changes !== lastChanges) {
|
||
lastChanges = s.changes
|
||
tick.value++
|
||
}
|
||
}
|
||
raf = requestAnimationFrame(frame)
|
||
}
|
||
raf = requestAnimationFrame(frame)
|
||
return () => cancelAnimationFrame(raf)
|
||
}
|
||
|
||
/** One full clock cycle (rise and fall), each half settled. */
|
||
function step() {
|
||
const s = sim.value
|
||
if (!s) return
|
||
s.run(BUDGET)
|
||
if (s.clock) {
|
||
s.setClock(0)
|
||
s.run(BUDGET)
|
||
}
|
||
s.setClock(1)
|
||
s.run(BUDGET)
|
||
cycles.value++
|
||
s.setClock(0)
|
||
s.run(BUDGET)
|
||
tick.value++
|
||
}
|
||
|
||
// ── Navigation ────────────────────────────────────────────────────
|
||
function open(id: string, push = true) {
|
||
if (id === def.value.id || !getDef.value(id)) return
|
||
if (push) nav.value.push(def.value.id)
|
||
project.value.openId = id
|
||
clearSelection()
|
||
placing.value = null
|
||
linking.value = null
|
||
persist()
|
||
rebuild()
|
||
}
|
||
|
||
function back() {
|
||
const id = nav.value.pop()
|
||
if (id) open(id, false)
|
||
}
|
||
|
||
/** The project's top circuit: "main", or else the first one no other circuit uses. */
|
||
const mainId = computed(() => {
|
||
const list = project.value.components
|
||
if (list.some(d => d.id === 'main')) return 'main'
|
||
const used = new Set(list.flatMap(d => d.nodes.filter(n => n.kind === 'chip' && n.chip).map(n => n.chip!)))
|
||
return (list.find(d => !used.has(d.id) && !d.challenge) ?? list[0]!).id
|
||
})
|
||
|
||
/** Back to the top circuit; the way back is forgotten. */
|
||
function goMain() {
|
||
nav.value = []
|
||
open(mainId.value, false)
|
||
}
|
||
|
||
/** Back to step `i` of the way here (0 is where it started). */
|
||
function goTo(i: number) {
|
||
const id = nav.value[i]
|
||
if (!id) return
|
||
nav.value = nav.value.slice(0, i)
|
||
open(id, false)
|
||
}
|
||
|
||
// ── Editing ───────────────────────────────────────────────────────
|
||
/** Asks the canvas to open quick add in its middle (search in the parts bar). */
|
||
const partSearch = ref(0)
|
||
|
||
/** A part being dragged in from the parts list, so the canvas can show where it would connect. */
|
||
const dragPart = ref<Placing | null>(null)
|
||
|
||
/** Places a part; `links` are wires to make at once, with "ghost" standing for the new part. */
|
||
function addNode(p: Placing, x: number, y: number, links: Link[] = []): CircuitNode {
|
||
const node: CircuitNode = { id: uid('n'), kind: p.kind, x, y }
|
||
if (p.chip) node.chip = p.chip
|
||
if (p.conn) node.conn = p.conn
|
||
if (p.kind === 'input' || p.kind === 'output') {
|
||
node.label = newPinLabel(def.value, p.kind)
|
||
node.autoLabel = true
|
||
}
|
||
if (p.kind === 'note') node.label = 'Note'
|
||
if (p.kind === 'tag') {
|
||
node.label = uniqueLabel('SIG', usedLabels(def.value, 'signal'))
|
||
node.autoLabel = true
|
||
}
|
||
// A new reference uses the signal sent last.
|
||
if (p.kind === 'ref') node.label = def.value.nodes.filter(n => n.kind === 'tag' && n.label?.trim()).at(-1)?.label?.trim() ?? ''
|
||
if (p.kind === 'panel' || p.kind === 'outpanel') node.rows = newPanelRows()
|
||
if (p.kind === 'bundle' || p.kind === 'split') node.bits = 4
|
||
def.value.nodes.push(node)
|
||
rememberPart(p.kind, p.chip)
|
||
const swap = (r: PinRef) => (r.node === 'ghost' ? { node: node.id, pin: r.pin } : r)
|
||
const made = links.filter(l => addWire(swap(l.from), swap(l.to))).length
|
||
selection.value = [node.id]
|
||
wireSel.value = []
|
||
commit()
|
||
play(made ? 'connect' : 'place')
|
||
if (made) notify(`Placed and connected ${made} wire${made === 1 ? '' : 's'}`)
|
||
return node
|
||
}
|
||
|
||
function canPlace(chipId: string) {
|
||
const d = getDef.value(chipId)
|
||
return !containsDef(project.value, chipId, def.value.id) && (!d || defUsable(project.value, d))
|
||
}
|
||
|
||
/** In a campaign, basic parts are earned; elsewhere everything can be placed. */
|
||
function canPlaceKind(kind: NodeKind) {
|
||
return kindUnlocked(project.value, kind)
|
||
}
|
||
|
||
// ── Sound ─────────────────────────────────────────────────────────
|
||
const sound = ref<SoundSettings>(loadSoundSettings())
|
||
function play(s: Sound) {
|
||
sfx(s, sound.value)
|
||
}
|
||
function setSound(patch: Partial<SoundSettings>) {
|
||
sound.value = { ...sound.value, ...patch }
|
||
saveSoundSettings(sound.value)
|
||
if (patch.on || patch.volume !== undefined) play('on')
|
||
}
|
||
|
||
/** What a pin plugs into: '' a single wire, 'bus' a cable end, 'c:<id>' a port of that connector type. Wires join pins of one kind. */
|
||
function pinKind(nodeId: string, pin: string, dir: 'in' | 'out'): string {
|
||
const n = def.value.nodes.find(x => x.id === nodeId)
|
||
if (!n) return ''
|
||
const s = shapeOf(n, getDef.value)
|
||
const p = (dir === 'in' ? s.inputs : s.outputs).find(p => p.key === pin)
|
||
return p ? pinKindOf(p) : ''
|
||
}
|
||
|
||
/** True when the pin is a cable end or a port. */
|
||
const isBus = (nodeId: string, pin: string, dir: 'in' | 'out') => pinKind(nodeId, pin, dir) !== ''
|
||
|
||
/** Adds one wire (replacing whatever fed that input) without recording an undo step. False for a cable/wire mismatch. */
|
||
function addWire(from: PinRef, to: PinRef, pts?: Pt[]): boolean {
|
||
const d = def.value
|
||
if (pinKind(from.node, from.pin, 'out') !== pinKind(to.node, to.pin, 'in')) return false
|
||
const old = d.wires.find(w => w.to.node === to.node && w.to.pin === to.pin)
|
||
d.wires = d.wires.filter(w => w !== old)
|
||
const wire: (typeof d.wires)[number] = { id: uid('w'), from, to }
|
||
if (pts?.length) wire.pts = pts
|
||
const sameNet = d.wires.find(w => w.from.node === from.node && w.from.pin === from.pin && w.color)
|
||
if (sameNet?.color) wire.color = sameNet.color
|
||
d.wires.push(wire)
|
||
// An unnamed switch, lamp or pin takes the name of the component pin it now connects to.
|
||
const fn = d.nodes.find(n => n.id === from.node)
|
||
const tn = d.nodes.find(n => n.id === to.node)
|
||
if (fn && tn) {
|
||
adoptName(d, fn, from.pin, tn, to.pin, getDef.value)
|
||
adoptName(d, tn, to.pin, fn, from.pin, getDef.value)
|
||
}
|
||
return true
|
||
}
|
||
|
||
/** Why two pins can't be joined, in words. */
|
||
function mismatch(from: PinRef, to: PinRef): string {
|
||
const name = (k: string) => (k.startsWith('c:') ? (getDef.value.conn?.(k.slice(2))?.name ?? 'connector') : '')
|
||
const a = name(pinKind(from.node, from.pin, 'out'))
|
||
const b = name(pinKind(to.node, to.pin, 'in'))
|
||
if (a || b) return a && b ? `A ${a} port only plugs into a ${a} port, not ${b}` : `A ${a || b} port only takes a ${a || b} cable from another ${a || b} port`
|
||
return 'A cable runs from a bundle to a split; single wires go to the bundle’s and split’s side pins'
|
||
}
|
||
|
||
function connect(from: PinRef, to: PinRef, pts?: Pt[]) {
|
||
if (!addWire(from, to, pts)) {
|
||
play('error')
|
||
return notify(mismatch(from, to), 'error')
|
||
}
|
||
wireSel.value = []
|
||
commit()
|
||
play('connect')
|
||
}
|
||
|
||
/**
|
||
* Moves a wire's end to another pin: the wire now runs from `from` to
|
||
* `to`, keeping its colour. An input that had a wire gets this one instead.
|
||
*/
|
||
function rewire(wireId: string, from: PinRef, to: PinRef) {
|
||
const d = def.value
|
||
const old = d.wires.find(w => w.id === wireId)
|
||
if (!old) return
|
||
if (old.from.node === from.node && old.from.pin === from.pin && old.to.node === to.node && old.to.pin === to.pin) return
|
||
if (pinKind(from.node, from.pin, 'out') !== pinKind(to.node, to.pin, 'in')) {
|
||
play('error')
|
||
return notify(mismatch(from, to), 'error')
|
||
}
|
||
d.wires = d.wires.filter(w => w !== old)
|
||
addWire(from, to)
|
||
const made = d.wires[d.wires.length - 1]!
|
||
if (old.color && !made.color) made.color = old.color
|
||
wireSel.value = [made.id]
|
||
selection.value = []
|
||
commit()
|
||
play('connect')
|
||
}
|
||
|
||
/** Several wires as one undo step. */
|
||
function connectMany(links: Link[]) {
|
||
const made = links.filter(l => addWire(l.from, l.to)).length
|
||
if (!made) return
|
||
wireSel.value = []
|
||
commit()
|
||
play('connect')
|
||
if (made > 1) notify(`Connected ${made} wires`)
|
||
}
|
||
|
||
/** Asks the canvas for the open circuit as a sheet: printed (or saved as PDF), or as an SVG file. */
|
||
const sheetRequest = ref<{ mode: 'print' | 'svg'; n: number } | null>(null)
|
||
function exportSheet(mode: 'print' | 'svg') {
|
||
sheetRequest.value = { mode, n: (sheetRequest.value?.n ?? 0) + 1 }
|
||
}
|
||
|
||
/** What looks wrong in the open circuit, worst first; a loop that never settles too. */
|
||
const issues = computed(() => {
|
||
const list = checkCircuit(def.value, getDef.value)
|
||
if (status.value === 'oscillating') list.unshift({ level: 'warn', text: 'The circuit keeps changing: a loop that never settles', nodes: [] })
|
||
return list
|
||
})
|
||
|
||
/** Shows the parts of a problem: selects them and centres on the first. */
|
||
function showIssue(nodes: string[]) {
|
||
if (!nodes.length) return
|
||
focusNode(nodes[0]!)
|
||
selection.value = nodes
|
||
}
|
||
|
||
/** Where the selected parts fit as a group (green boxes on the canvas), nearest first. */
|
||
const fits = computed(() => (selection.value.length < 2 ? [] : fitSpots(def.value, getDef.value, selection.value)))
|
||
/** The fit pointed at: which spot, and its first pin. */
|
||
const fitHover = ref<{ spot: number; start: number } | null>(null)
|
||
watch(fits, () => (fitHover.value = null))
|
||
|
||
function connectFit(spot: number, start: number) {
|
||
const s = fits.value[spot]
|
||
if (!s) return
|
||
fitHover.value = null
|
||
connectMany(fitLinks(s, start))
|
||
}
|
||
|
||
/**
|
||
* The selected parts to another part's pins, in order: their outputs to
|
||
* its inputs (dir 'out'), or its outputs to their inputs (dir 'in').
|
||
*/
|
||
function connectSelectionTo(targetId: string, dir: 'in' | 'out') {
|
||
const target = def.value.nodes.find(n => n.id === targetId)
|
||
const first = def.value.nodes.filter(n => selection.value.includes(n.id) && n.id !== targetId).sort(byPosition)[0]
|
||
if (!target || !first) return
|
||
const mine = dir === 'out' ? pinKeys(first, getDef.value).outs[0] : pinKeys(first, getDef.value).ins[0]
|
||
const theirs = dir === 'out' ? pinKeys(target, getDef.value).ins[0] : pinKeys(target, getDef.value).outs[0]
|
||
if (!mine || !theirs) return notify('No matching pins to connect', 'error')
|
||
connectMany(seriesLinks(def.value, getDef.value, selection.value, { node: first.id, pin: mine, dir }, { node: target.id, pin: theirs }))
|
||
}
|
||
|
||
/** Parts plus the panels docked to them: they move, copy and delete together. */
|
||
function withDocked(ids: Iterable<string>): Set<string> {
|
||
const set = new Set(ids)
|
||
for (const p of dockedPanels(def.value, set)) set.add(p.id)
|
||
return set
|
||
}
|
||
|
||
/** What moves along when parts move: docked panels and plugged-in cable ends, and what is plugged into those. */
|
||
function withFollowers(ids: Iterable<string>): Set<string> {
|
||
const set = new Set(ids)
|
||
for (let size = -1; size !== set.size; ) {
|
||
size = set.size
|
||
for (const p of [...dockedPanels(def.value, set), ...pluggedInto(def.value, set), ...latchedTo(def.value, set)]) set.add(p.id)
|
||
}
|
||
return set
|
||
}
|
||
|
||
function deleteSelected() {
|
||
const d = def.value
|
||
if (!selection.value.length && !wireSel.value.length) return
|
||
const ids = withDocked(selection.value)
|
||
const wires = new Set(wireSel.value)
|
||
d.nodes = d.nodes.filter(n => !ids.has(n.id))
|
||
d.wires = d.wires.filter(w => !ids.has(w.from.node) && !ids.has(w.to.node) && !wires.has(w.id))
|
||
clearSelection()
|
||
commit()
|
||
play('delete')
|
||
}
|
||
|
||
const selectedWires = computed(() => {
|
||
const ids = new Set(wireSel.value)
|
||
return def.value.wires.filter(w => ids.has(w.id))
|
||
})
|
||
|
||
function setWireColor(color: WireColor | undefined) {
|
||
for (const w of selectedWires.value) {
|
||
if (color) w.color = color
|
||
else delete w.color
|
||
}
|
||
commit(false)
|
||
}
|
||
|
||
function autoRoute() {
|
||
for (const w of selectedWires.value) delete w.pts
|
||
commit(false)
|
||
}
|
||
|
||
/** Select every wire that carries the same signal (same source pin). */
|
||
function selectNet(wireId: string) {
|
||
const w = def.value.wires.find(x => x.id === wireId)
|
||
if (!w) return
|
||
wireSel.value = def.value.wires.filter(x => x.from.node === w.from.node && x.from.pin === w.from.pin).map(x => x.id)
|
||
}
|
||
|
||
function swap(nodeId: string, target: SwapTarget) {
|
||
const removed = swapNode(project.value, def.value, nodeId, target)
|
||
commit()
|
||
if (removed) notify(`Swapped. ${removed} wire${removed === 1 ? '' : 's'} had no matching pin and were removed.`)
|
||
}
|
||
|
||
/** Gives a placed gate `n` inputs, by swapping in its wide version (made on first use). */
|
||
function setInputs(node: CircuitNode, n: number) {
|
||
const base = baseOf(node, getDef.value)
|
||
if (!base) return
|
||
if (base !== NAND_BASE && containsDef(project.value, base, def.value.id)) return notify('A component cannot contain itself', 'error')
|
||
const target = wideGate(project.value, base, Math.round(n))
|
||
if (!target) return notify(`Gates can have 2 to ${MAX_GATE_INPUTS} inputs`, 'error')
|
||
if (target.kind === 'chip' && target.chip === node.chip) return
|
||
if (target.kind === 'nand' && node.kind === 'nand') return
|
||
swap(node.id, target)
|
||
}
|
||
|
||
function unlink(ids: string[]) {
|
||
const n = unlinkWires(def.value, new Set(ids))
|
||
commit()
|
||
notify(n ? `Removed ${n} wire${n === 1 ? '' : 's'}` : 'Nothing was connected')
|
||
}
|
||
|
||
function unpack(nodeId: string) {
|
||
const res = unpackChip(project.value, def.value.id, nodeId)
|
||
if (!res.ok) return notify(res.error, 'error')
|
||
selection.value = res.nodes
|
||
wireSel.value = []
|
||
commit()
|
||
}
|
||
|
||
function makeIndependent(nodeId: string) {
|
||
const copy = makeUnique(project.value, def.value, nodeId)
|
||
if (!copy) return
|
||
commit()
|
||
notify(`This one now uses its own copy, "${copy.name}"`)
|
||
}
|
||
|
||
function toggleInput(node: CircuitNode) {
|
||
node.on = !node.on
|
||
sim.value?.setSource(node.id, node.on)
|
||
play(node.on ? 'on' : 'off')
|
||
persist()
|
||
}
|
||
|
||
function press(node: CircuitNode, down: boolean) {
|
||
if (down && !pressed.has(node.id)) play('press')
|
||
if (down) pressed.add(node.id)
|
||
else pressed.delete(node.id)
|
||
sim.value?.setSource(node.id, down)
|
||
}
|
||
|
||
/** Click on a panel row: flips a switch row. */
|
||
function toggleRow(node: CircuitNode, row: PanelRow) {
|
||
if (row.type !== 'switch' || node.kind !== 'panel') return
|
||
row.on = !row.on
|
||
sim.value?.setSource(rowSource(node.id, row.id), row.on)
|
||
play(row.on ? 'on' : 'off')
|
||
persist()
|
||
}
|
||
|
||
function pressRow(node: CircuitNode, row: PanelRow, down: boolean) {
|
||
if (row.type !== 'button' || node.kind !== 'panel') return
|
||
const key = rowSource(node.id, row.id)
|
||
if (down && !pressed.has(key)) play('press')
|
||
if (down) pressed.add(key)
|
||
else pressed.delete(key)
|
||
sim.value?.setSource(key, down)
|
||
}
|
||
|
||
// ── Panels ────────────────────────────────────────────────────────
|
||
/** Docks a panel to a component: switches for its free inputs (left), or lamps for its outputs (right). */
|
||
function addPanel(chipId: string, side: 'in' | 'out' = 'in') {
|
||
const panel = attachPanel(project.value, def.value, chipId, side)
|
||
if (!panel) return notify(side === 'in' ? 'Every input of this component is already connected' : 'This component has no outputs', 'error')
|
||
selection.value = [panel.id]
|
||
wireSel.value = []
|
||
commit()
|
||
const n = panel.rows!.length
|
||
notify(side === 'in' ? `Input panel with ${n} switch${n === 1 ? '' : 'es'} attached` : `Output panel with ${n} lamp${n === 1 ? '' : 's'} attached`)
|
||
}
|
||
|
||
/** Pins of the open circuit got new keys: circuits that place it keep their wires on them. */
|
||
function followPins(renamed: Map<string, string>) {
|
||
if (!renamed.size) return
|
||
const id = def.value.id
|
||
for (const d of project.value.components) {
|
||
const chips = new Set(d.nodes.filter(n => n.kind === 'chip' && n.chip === id).map(n => n.id))
|
||
if (!chips.size) continue
|
||
for (const w of d.wires) {
|
||
const to = chips.has(w.to.node) ? renamed.get(w.to.pin) : undefined
|
||
if (to) w.to = { node: w.to.node, pin: to }
|
||
const from = chips.has(w.from.node) ? renamed.get(w.from.pin) : undefined
|
||
if (from) w.from = { node: w.from.node, pin: from }
|
||
}
|
||
}
|
||
}
|
||
|
||
/** Joins the selected panels into one; circuits that place this one keep their wires to the rows. */
|
||
function mergeSelectedPanels() {
|
||
const res = mergePanels(def.value, selection.value)
|
||
if (!res) return notify('Select at least two panels of the same kind', 'error')
|
||
followPins(res.renamed)
|
||
selection.value = [res.panel.id]
|
||
wireSel.value = []
|
||
commit()
|
||
notify(`One panel with ${res.panel.rows?.length ?? 0} rows`)
|
||
}
|
||
|
||
/** The selected switches, buttons and clocks as one input panel, or output pins and lamps as one output panel. */
|
||
function combineSelected() {
|
||
const res = combineIntoPanel(def.value, selection.value, getDef.value)
|
||
if (!res) return notify('Select switches, buttons and clocks, or output pins and lamps (two or more)', 'error')
|
||
followPins(res.renamed)
|
||
selection.value = [res.panel.id]
|
||
wireSel.value = []
|
||
commit()
|
||
notify(`${res.panel.kind === 'outpanel' ? 'Output' : 'Input'} panel with ${res.panel.rows?.length ?? 0} rows`)
|
||
}
|
||
|
||
// ── Main menu ─────────────────────────────────────────────────────
|
||
/** The title menu shows when the app opens at /; links open straight into the editor. */
|
||
const screen = ref<'menu' | 'editor'>(location.pathname === '/' ? 'menu' : 'editor')
|
||
const menuPage = ref<MenuPage>('main')
|
||
/** The challenges list below its button in the top bar. */
|
||
const challengesOpen = ref(false)
|
||
|
||
function enterGame() {
|
||
screen.value = 'editor'
|
||
menuPage.value = 'main'
|
||
}
|
||
|
||
function showMenu(page: MenuPage = 'main') {
|
||
persistNow()
|
||
dialog.value = null
|
||
paused.value = null
|
||
menuPage.value = page
|
||
screen.value = 'menu'
|
||
}
|
||
|
||
// ── Pause menu ────────────────────────────────────────────────────
|
||
/** The in-game menu over the editor (Esc): its main list, or the saves to load. */
|
||
const paused = ref<null | 'main' | 'load'>(null)
|
||
|
||
function pause(page: 'main' | 'load' = 'main') {
|
||
placing.value = null
|
||
linking.value = null
|
||
paused.value = page
|
||
}
|
||
|
||
/** Saves now: in this browser, and in the account when signed in. */
|
||
async function saveNow() {
|
||
placeholder = false
|
||
changed = true
|
||
persistNow()
|
||
if (!account.value) return notify('Saved in this browser')
|
||
await syncAccount()
|
||
notify(cloudState.value === 'synced' ? 'Saved to your account' : 'Saved in this browser; the account will follow when it can be reached', cloudState.value === 'synced' ? 'ok' : 'error')
|
||
}
|
||
|
||
/** A project's mode, from its index entry, or (for projects saved before it was noted there) from the project. */
|
||
const modes = new Map<string, Project['mode'] | null>()
|
||
function projectMode(m: ProjectMeta): Project['mode'] | undefined {
|
||
if (m.mode) return m.mode
|
||
if (!modes.has(m.id)) modes.set(m.id, loadProject(m.id)?.mode ?? null)
|
||
return modes.get(m.id) ?? undefined
|
||
}
|
||
|
||
/** The newest project of a mode, if any. */
|
||
const newestOf = (mode: Project['mode']) => listProjects().filter(m => projectMode(m) === mode).sort((a, b) => b.updated - a.updated)[0]
|
||
|
||
/** The newest project of a mode, for the menu to show progress (the open one as it is now). */
|
||
function projectOf(mode: Project['mode']): Project | null {
|
||
const m = newestOf(mode)
|
||
if (!m) return null
|
||
return m.id === meta.value.id ? project.value : loadProject(m.id)
|
||
}
|
||
|
||
/** Into the campaign: the newest one, or a new one. */
|
||
function playCampaign() {
|
||
const m = newestOf('campaign')
|
||
if (m) switchProject(m.id)
|
||
else newProject(false, true)
|
||
challengesOpen.value = true
|
||
enterGame()
|
||
}
|
||
|
||
/** Into the challenges project (made on first use: NAND only, every challenge open). */
|
||
function intoChallenges() {
|
||
const m = newestOf('challenges')
|
||
if (m) switchProject(m.id)
|
||
else {
|
||
persistNow()
|
||
const p = createProject({ examples: false, name: 'Challenges' })
|
||
p.mode = 'challenges'
|
||
activate(addProject(p), p)
|
||
}
|
||
challengesOpen.value = true
|
||
}
|
||
|
||
function playChallenge(c: Challenge) {
|
||
intoChallenges()
|
||
beginChallenge(c)
|
||
enterGame()
|
||
}
|
||
|
||
/** The puzzle of the week, in the challenges project. */
|
||
function playWeekly() {
|
||
intoChallenges()
|
||
const spec = project.value.puzzles?.find(p => p.id === weeklyId(weekKey()))
|
||
if (spec) beginPuzzle(spec)
|
||
else void openPuzzle('weekly')
|
||
enterGame()
|
||
}
|
||
|
||
/** Name shown next to your scores on the leaderboards. */
|
||
const playerName = ref((() => {
|
||
try {
|
||
return localStorage.getItem('logigate:player-name') ?? ''
|
||
} catch {
|
||
return ''
|
||
}
|
||
})())
|
||
|
||
async function setPlayerName(name: string) {
|
||
const res = await api<{ name: string }>('POST', '/api/players/name', { player: playerId(), name })
|
||
playerName.value = res.name
|
||
try {
|
||
localStorage.setItem('logigate:player-name', res.name)
|
||
} catch {}
|
||
}
|
||
|
||
/** A puzzle and its leaderboard from the server ("weekly", "week-2026-43" or a link id). */
|
||
async function fetchBoard(id: string): Promise<{ id: string; spec: PuzzleSpec; summary: PuzzleSummary } | null> {
|
||
try {
|
||
return await api('GET', `/api/puzzles/${encodeURIComponent(id)}?player=${encodeURIComponent(playerId())}`)
|
||
} catch {
|
||
return null
|
||
}
|
||
}
|
||
|
||
/** Puts pixels on a named screen of the component's box ('' for the main screen). */
|
||
function setScreen(ids: string[], name: string) {
|
||
const v = name.trim()
|
||
for (const n of nodesById(ids)) {
|
||
if (n.kind !== 'pixel') continue
|
||
if (v) n.screen = v
|
||
else delete n.screen
|
||
}
|
||
commit(false)
|
||
}
|
||
|
||
/** Every row of an input panel the same kind: all switches, all buttons or all clocks. */
|
||
function setRowsType(panel: CircuitNode, type: PanelControl) {
|
||
for (const r of panel.rows ?? []) {
|
||
r.type = type
|
||
if (type !== 'switch') delete r.on
|
||
if (type !== 'clock') delete r.hz
|
||
}
|
||
commit()
|
||
}
|
||
|
||
function undock(panel: CircuitNode) {
|
||
detachPanel(panel)
|
||
commit()
|
||
}
|
||
|
||
function setRowType(row: PanelRow, type: PanelControl) {
|
||
row.type = type
|
||
if (type !== 'switch') delete row.on
|
||
if (type !== 'clock') delete row.hz
|
||
commit()
|
||
}
|
||
|
||
/** Swaps a row of a free panel with its neighbour; the rows keep their places, so the switches trade them. */
|
||
function moveRow(panel: CircuitNode, index: number, by: -1 | 1) {
|
||
const rows = panel.rows ?? []
|
||
const j = index + by
|
||
if (panel.attach || j < 0 || j >= rows.length) return
|
||
const at = panelOffsets(rows)
|
||
;[rows[index], rows[j]] = [rows[j]!, rows[index]!]
|
||
rows.forEach((r, i) => (r.dy = at[i]!))
|
||
commit()
|
||
}
|
||
|
||
/** Empty rows above a row of a free panel; the rows below move along. */
|
||
function setRowGap(panel: CircuitNode, index: number, gap: number) {
|
||
const rows = panel.rows ?? []
|
||
if (panel.attach || index < 1 || index >= rows.length) return
|
||
const at = panelOffsets(rows)
|
||
const shift = at[index - 1]! + 1 + Math.max(0, Math.min(20, Math.round(gap) || 0)) - at[index]!
|
||
rows.forEach((r, i) => (r.dy = i < index ? at[i]! : at[i]! + shift))
|
||
commit()
|
||
}
|
||
|
||
/** A keyboard key for a panel row (empty to clear it). */
|
||
function setRowKey(row: PanelRow, key: string | undefined) {
|
||
if (key) row.key = key
|
||
else delete row.key
|
||
commit(false)
|
||
}
|
||
|
||
function setRowColor(row: PanelRow, color: LampColor | undefined) {
|
||
if (color) row.color = color
|
||
else delete row.color
|
||
commit(false)
|
||
}
|
||
|
||
// ── Cable ends ────────────────────────────────────────────────────
|
||
/** The part a cable end's single wires all run to (for a bundle: come from), if just one. */
|
||
function plugTarget(end: CircuitNode): CircuitNode | undefined {
|
||
const wires = end.kind === 'bundle' ? def.value.wires.filter(w => w.to.node === end.id) : def.value.wires.filter(w => w.from.node === end.id)
|
||
const ids = new Set(wires.map(w => (end.kind === 'bundle' ? w.from.node : w.to.node)))
|
||
const part = ids.size === 1 ? def.value.nodes.find(n => n.id === [...ids][0]) : undefined
|
||
return part && part.kind !== 'bundle' && part.kind !== 'split' ? part : undefined
|
||
}
|
||
|
||
function plugEnd(end: CircuitNode) {
|
||
const part = plugTarget(end)
|
||
if (!part || !plugInto(def.value, end, part.id, getDef.value)) {
|
||
return notify('Its wires must all run to the pins of one part, in the same order as the cable', 'error')
|
||
}
|
||
commit()
|
||
}
|
||
|
||
/** Pulls a cable end out of its part: it steps two squares away and its wires show again. */
|
||
function unplugEnd(end: CircuitNode) {
|
||
if (!end.plug) return
|
||
delete end.plug
|
||
end.x += end.kind === 'bundle' ? 2 : -2
|
||
commit()
|
||
}
|
||
|
||
/** Ends dragged away from the part they are plugged into come loose. */
|
||
function unplugMoved(ids: Set<string>) {
|
||
for (const n of def.value.nodes) {
|
||
if (n.plug && ids.has(n.id) && !ids.has(n.plug)) delete n.plug
|
||
if (n.latch && ids.has(n.id) && !ids.has(n.latch)) delete n.latch
|
||
}
|
||
}
|
||
|
||
/** The part a part could latch onto: wired to it, its pins lining up exactly. */
|
||
function latchTargetOf(n: CircuitNode): CircuitNode | undefined {
|
||
return n.latch ? undefined : latchTarget(def.value, n, getDef.value)
|
||
}
|
||
|
||
/** Latches a part onto the part it fits: it moves onto that part's pins and goes along with it. */
|
||
function latchPart(n: CircuitNode) {
|
||
const host = latchTarget(def.value, n, getDef.value)
|
||
if (!host || !latchInto(def.value, n, host.id, getDef.value)) {
|
||
return notify('Its pins must line up with the pins it is wired to, one for one', 'error')
|
||
}
|
||
commit()
|
||
play('connect')
|
||
}
|
||
|
||
/** Lets a latched part go: it steps two squares away and its wires show again. */
|
||
function unlatch(n: CircuitNode) {
|
||
const host = n.latch ? def.value.nodes.find(x => x.id === n.latch) : undefined
|
||
if (!host) return
|
||
delete n.latch
|
||
n.x += n.x >= host.x ? 2 : -2
|
||
commit()
|
||
}
|
||
|
||
function setPitch(end: CircuitNode, pitch: number) {
|
||
if (end.plug) return
|
||
const p = Math.max(1, Math.min(8, Math.round(pitch) || 1))
|
||
if (p === 1) delete end.pitch
|
||
else end.pitch = p
|
||
delete end.offsets
|
||
commit()
|
||
}
|
||
|
||
/**
|
||
* Pins of a part a new cable can plug onto: groups of its outputs (those
|
||
* not already in a plugged cable) and of its free inputs.
|
||
*/
|
||
function cableChoices(n: CircuitNode): { out: PinGroup[]; in: PinGroup[] } {
|
||
const none = { out: [], in: [] }
|
||
if (n.kind !== 'chip' && n.kind !== 'panel' && n.kind !== 'hex') return none
|
||
const s = shapeOf(n, getDef.value)
|
||
const d = def.value
|
||
const kinds = new Map(d.nodes.map(x => [x.id, x]))
|
||
const cabled = new Set(d.wires.filter(w => w.from.node === n.id && kinds.get(w.to.node)?.plug === n.id).map(w => w.from.pin))
|
||
// Inputs already fed by a plugged cable are taken; inputs with a plain wire can take a cable (the wire goes into it).
|
||
const fed = new Set(d.wires.filter(w => w.to.node === n.id && kinds.get(w.from.node)?.plug === n.id).map(w => w.to.pin))
|
||
const outs = s.outputs.filter(p => !p.bus).sort((a, b) => a.dy - b.dy)
|
||
const ins = n.kind === 'panel' ? [] : s.inputs.filter(p => !p.bus).sort((a, b) => a.dy - b.dy)
|
||
return { out: pinGroups(outs, k => !cabled.has(k)), in: pinGroups(ins, k => !fed.has(k)) }
|
||
}
|
||
|
||
/**
|
||
* A cable from some of a part's outputs. When each of them already has
|
||
* one wire, those wires go into the cable (both ends plug in where they
|
||
* can); otherwise a new cable starts there with a free end.
|
||
*/
|
||
function cableOut(nodeId: string, pins: string[]) {
|
||
const wires = def.value.wires.filter(w => w.from.node === nodeId && pins.includes(w.from.pin))
|
||
const per = new Map<string, number>()
|
||
for (const w of wires) per.set(w.from.pin, (per.get(w.from.pin) ?? 0) + 1)
|
||
if (wires.length >= 2 && pins.every(p => per.get(p) === 1)) return bundleSelected(wires.map(w => w.id))
|
||
const res = cableFromPins(def.value, nodeId, pins, getDef.value)
|
||
if (!res.ok) return notify(res.error, 'error')
|
||
selection.value = [res.split.id]
|
||
wireSel.value = []
|
||
commit()
|
||
notify(`Cable with ${res.split.bits} wires: drag its free end onto the pins where they go`)
|
||
}
|
||
|
||
/** A cable into some of a part's inputs: their wires go into it when they all have one, else a new cable into the free ones. */
|
||
function cableIn(nodeId: string, pins: string[]) {
|
||
const wires = def.value.wires.filter(w => w.to.node === nodeId && pins.includes(w.to.pin))
|
||
if (wires.length >= 2 && wires.length === pins.length) return bundleSelected(wires.map(w => w.id))
|
||
const res = cableIntoPins(def.value, nodeId, pins, getDef.value)
|
||
if (!res.ok) return notify(res.error, 'error')
|
||
selection.value = [res.bundle.id]
|
||
wireSel.value = []
|
||
commit()
|
||
notify(`Cable with ${res.bundle.bits} wires: drag its free end next to what drives them, or attach an input panel`)
|
||
}
|
||
|
||
function addCablePanel(bundleId: string) {
|
||
const panel = cablePanel(def.value, bundleId, getDef.value)
|
||
if (!panel) return notify('Every wire of this cable is already driven', 'error')
|
||
selection.value = [panel.id]
|
||
wireSel.value = []
|
||
commit()
|
||
notify(`Input panel with ${panel.rows!.length} switches plugged into the cable`)
|
||
}
|
||
|
||
function addRow(panel: CircuitNode) {
|
||
panel.rows = [...(panel.rows ?? []), ...newPanelRows(1)]
|
||
commit()
|
||
}
|
||
|
||
/** A new row at a place in a free panel's order (above the row there); returns it. */
|
||
function insertRow(panel: CircuitNode, index: number): PanelRow | undefined {
|
||
if (panel.attach) return
|
||
const row = insertPanelRow(panel, index)
|
||
commit()
|
||
return row
|
||
}
|
||
|
||
/** A row of a free panel dragged to another place in the order. */
|
||
function moveRowTo(panel: CircuitNode, from: number, to: number) {
|
||
if (panel.attach || !movePanelRow(panel, from, to)) return
|
||
commit()
|
||
}
|
||
|
||
function dropRow(panel: CircuitNode, rowId: string) {
|
||
removeRow(def.value, panel, rowId)
|
||
commit()
|
||
}
|
||
|
||
let clip: Clip | null = null
|
||
let pasteCount = 0
|
||
/** Something copied, ready to paste. */
|
||
const hasClip = ref(false)
|
||
|
||
function copy() {
|
||
if (!selection.value.length) return
|
||
clip = copySelection(def.value, withDocked(selection.value))
|
||
hasClip.value = true
|
||
pasteCount = 0
|
||
notify(`Copied ${clip.nodes.length} part${clip.nodes.length === 1 ? '' : 's'}`)
|
||
}
|
||
|
||
/** Pastes a little below the copy each time, or with its top left corner at `at`. */
|
||
function paste(at?: Pt) {
|
||
if (!clip) return
|
||
pasteCount++
|
||
const blocked = clip.nodes.filter(n => n.kind === 'chip' && n.chip && !canPlace(n.chip))
|
||
const usable: Clip = blocked.length ? { nodes: clip.nodes.filter(n => !blocked.includes(n)), wires: clip.wires } : clip
|
||
if (blocked.length) notify('Skipped parts that would contain this circuit itself', 'error')
|
||
const [dx, dy] = at && usable.nodes.length
|
||
? [Math.round(at[0]) - Math.min(...usable.nodes.map(n => n.x)), Math.round(at[1]) - Math.min(...usable.nodes.map(n => n.y))]
|
||
: [2 * pasteCount, 2 * pasteCount]
|
||
const ids = pasteClip(def.value, usable, dx, dy)
|
||
const fresh = new Set(ids)
|
||
continueSeries(def.value, def.value.nodes.filter(n => fresh.has(n.id)))
|
||
selection.value = ids
|
||
wireSel.value = []
|
||
commit()
|
||
}
|
||
|
||
function duplicate() {
|
||
copy()
|
||
paste()
|
||
}
|
||
|
||
// ── Connect one by one ────────────────────────────────────────────
|
||
/**
|
||
* Pins of the given parts, top to bottom, ready to be wired one after the
|
||
* other: their outputs, or their inputs when asked for (or when they have
|
||
* no outputs, like lamps).
|
||
*/
|
||
function linkQueue(ids: string[], want?: 'in' | 'out'): LinkEnd[] {
|
||
const nodes = def.value.nodes.filter(n => ids.includes(n.id) && n.kind !== 'note').sort((a, b) => a.y - b.y || a.x - b.x)
|
||
const shapes = nodes.map(n => ({ n, s: shapeOf(n, getDef.value) }))
|
||
const dir = want ?? (shapes.some(({ s }) => s.outputs.length) ? 'out' : 'in')
|
||
const queue: LinkEnd[] = []
|
||
for (const { n, s } of shapes) {
|
||
for (const p of dir === 'out' ? s.outputs : s.inputs) {
|
||
const label = p.label || n.label?.trim() || ''
|
||
queue.push({ node: n.id, pin: p.key, dir, label })
|
||
}
|
||
}
|
||
return queue
|
||
}
|
||
|
||
function startLinking(ids = selection.value, want?: 'in' | 'out') {
|
||
const queue = linkQueue(ids, want)
|
||
if (!queue.length) return notify('Nothing to connect: select parts with pins', 'error')
|
||
placing.value = null
|
||
linking.value = null
|
||
linking.value = { queue, at: 0 }
|
||
}
|
||
|
||
/**
|
||
* Wires the pin whose turn it is to `target`, then moves on to the next one.
|
||
* With `more` (Shift), the wire keeps following the mouse from the same
|
||
* signal for another connection: from the same output, or, when it started
|
||
* at an input, from the output just wired to it.
|
||
*/
|
||
function linkTo(target: PinRef, more = false) {
|
||
const l = linking.value
|
||
const cur = l?.queue[l.at]
|
||
if (!l || !cur) return
|
||
const here = { node: cur.node, pin: cur.pin }
|
||
if (cur.dir === 'out') connect(here, target)
|
||
else connect(target, here)
|
||
if (more && cur.dir === 'out') return
|
||
if (more && l.queue.length === 1) {
|
||
linking.value = { queue: [{ ...target, dir: 'out', label: '' }], at: 0 }
|
||
return
|
||
}
|
||
l.at++
|
||
if (l.at >= l.queue.length) {
|
||
linking.value = null
|
||
if (l.queue.length > 1) notify(`Connected ${l.queue.length} pins`)
|
||
}
|
||
}
|
||
|
||
function stopLinking() {
|
||
linking.value = null
|
||
}
|
||
|
||
// ── Tidy wiring ───────────────────────────────────────────────────
|
||
function setTidy(on: boolean) {
|
||
if (on) project.value.settings.tidy = true
|
||
else delete project.value.settings.tidy
|
||
persist()
|
||
}
|
||
|
||
/** Removes all hand-placed bends in the open circuit and lays every wire out tidily. */
|
||
function tidyAll() {
|
||
const bent = def.value.wires.filter(w => w.pts).length
|
||
for (const w of def.value.wires) delete w.pts
|
||
project.value.settings.tidy = true
|
||
commit(false)
|
||
persist()
|
||
notify(bent ? `Tidied. ${bent} hand-placed bend${bent === 1 ? ' was' : 's were'} removed (Ctrl+Z brings ${bent === 1 ? 'it' : 'them'} back)` : 'Tidy wiring is on')
|
||
}
|
||
|
||
/** Tidy wiring in every circuit of the project: all hand-placed bends go, one undo step. */
|
||
function tidyEverything() {
|
||
let bent = 0
|
||
let circuits = 0
|
||
for (const d of project.value.components) {
|
||
const n = d.wires.filter(w => w.pts).length
|
||
if (n) circuits++
|
||
bent += n
|
||
for (const w of d.wires) delete w.pts
|
||
}
|
||
project.value.settings.tidy = true
|
||
commit(false)
|
||
persist()
|
||
notify(
|
||
bent
|
||
? `Tidied every circuit: ${bent} hand-placed bend${bent === 1 ? '' : 's'} in ${circuits} circuit${circuits === 1 ? '' : 's'} removed (Ctrl+Z brings them back)`
|
||
: 'Every circuit is tidy',
|
||
)
|
||
}
|
||
|
||
function selectAll() {
|
||
selection.value = def.value.nodes.map(n => n.id)
|
||
wireSel.value = def.value.wires.map(w => w.id)
|
||
}
|
||
|
||
function packageSelected(name: string) {
|
||
const res = packageSelection(project.value, def.value.id, new Set(selection.value), name)
|
||
if (!res.ok) {
|
||
notify(res.error, 'error')
|
||
return
|
||
}
|
||
selection.value = [res.chipNode]
|
||
wireSel.value = []
|
||
commit()
|
||
notify(`Created component "${res.def.name}"`)
|
||
}
|
||
|
||
// ── Components ────────────────────────────────────────────────────
|
||
function createComponent(name = 'New part') {
|
||
const d = newComponent(project.value, name)
|
||
commit()
|
||
open(d.id)
|
||
labelFocus.value++
|
||
}
|
||
|
||
function removeComponent(id: string) {
|
||
const err = deleteComponent(project.value, id)
|
||
if (err) return notify(err, 'error')
|
||
nav.value = nav.value.filter(n => n !== id)
|
||
commit()
|
||
rebuild()
|
||
}
|
||
|
||
function copyComponent(id: string) {
|
||
const d = duplicateComponent(project.value, id)
|
||
if (!d) return
|
||
commit()
|
||
open(d.id)
|
||
}
|
||
|
||
function beginChallenge(c: Challenge) {
|
||
const existing = project.value.components.find(d => d.challenge === c.id)
|
||
if (existing) return open(existing.id)
|
||
if (!challengeOpen(project.value, c.id)) {
|
||
play('error')
|
||
return notify(`Solve ${(NEEDS[c.id] ?? []).filter(n => !project.value.solved.includes(n)).map(challengeName).join(' and ')} first`, 'error')
|
||
}
|
||
const d = startChallenge(project.value, c)
|
||
commit()
|
||
open(d.id)
|
||
}
|
||
|
||
/** The challenge or puzzle the open circuit is for. */
|
||
const task = computed(() => {
|
||
const id = def.value.challenge
|
||
if (!id) return null
|
||
const c = CHALLENGES.find(c => c.id === id)
|
||
if (c) return { id, challenge: c, puzzle: undefined, steps: challengeSteps(c) }
|
||
const p = project.value.puzzles?.find(p => p.id === id)
|
||
return p ? { id, challenge: undefined, puzzle: p, steps: p.steps } : null
|
||
})
|
||
|
||
function checkChallenge(): ChallengeCheck | null {
|
||
const t = task.value
|
||
if (!t) return null
|
||
const res = t.puzzle ? scoreSolution(toRaw(project.value.components), def.value.id, toRaw(t.puzzle)) : runSteps(getDef.value, def.value.id, t.steps)
|
||
const used = transistors(def.value.id)
|
||
const before = project.value.best?.[t.id]
|
||
if (!res.pass) {
|
||
play('fail')
|
||
return { ...res, transistors: used, best: before }
|
||
}
|
||
let changed = false
|
||
const first = !project.value.solved.includes(t.id)
|
||
const opened = first && t.challenge ? unlockedBy(project.value, t.id) : { challenges: [], kinds: [] }
|
||
if (first) {
|
||
project.value.solved.push(t.id)
|
||
changed = true
|
||
}
|
||
const record = before === undefined || used < before
|
||
if (record) {
|
||
project.value.best = { ...project.value.best, [t.id]: used }
|
||
changed = true
|
||
}
|
||
if (changed) {
|
||
commit(false)
|
||
persist()
|
||
}
|
||
const unlocked = isCampaign(project.value) && first && t.challenge ? [def.value.name, ...opened.kinds.map(k => KIND_NAMES[k] ?? k)] : []
|
||
const nextUp = opened.challenges.map(challengeName)
|
||
play(record && before !== undefined ? 'record' : 'solve')
|
||
if (unlocked.length || nextUp.length) play('unlock')
|
||
if (t.puzzle) void submitScore(t.puzzle)
|
||
return {
|
||
...res,
|
||
transistors: used,
|
||
best: record ? used : before,
|
||
record: record && before !== undefined ? before : undefined,
|
||
unlocked,
|
||
nextUp,
|
||
}
|
||
}
|
||
|
||
// ── Puzzles ───────────────────────────────────────────────────────
|
||
/** A random id for this browser, so the server can keep one best score per player. */
|
||
function playerId(): string {
|
||
try {
|
||
let id = localStorage.getItem('logigate:player')
|
||
if (!id) {
|
||
id = uid('p') + uid() + uid()
|
||
localStorage.setItem('logigate:player', id)
|
||
}
|
||
return id
|
||
} catch {
|
||
return 'anonymous-player'
|
||
}
|
||
}
|
||
|
||
/** How everyone did, per puzzle id, as last heard from the server. */
|
||
const boards = reactive<Record<string, PuzzleSummary>>({})
|
||
|
||
async function loadBoard(spec: PuzzleSpec) {
|
||
try {
|
||
const res = await api<{ summary: PuzzleSummary }>('GET', `/api/puzzles/${apiId(spec.id)}?player=${encodeURIComponent(playerId())}`)
|
||
boards[spec.id] = res.summary
|
||
} catch {}
|
||
}
|
||
|
||
async function submitScore(spec: PuzzleSpec) {
|
||
try {
|
||
const res = await api<{ score: { pass: boolean; transistors: number }; summary: PuzzleSummary }>('POST', `/api/puzzles/${apiId(spec.id)}/scores`, {
|
||
player: playerId(),
|
||
defId: def.value.id,
|
||
components: toRaw(project.value.components),
|
||
})
|
||
boards[spec.id] = res.summary
|
||
} catch (e) {
|
||
notify(`Your score could not be sent: ${(e as Error).message}`, 'error')
|
||
}
|
||
}
|
||
|
||
function beginPuzzle(spec: PuzzleSpec) {
|
||
const d = startPuzzle(project.value, spec)
|
||
commit()
|
||
open(d.id)
|
||
void loadBoard(spec)
|
||
}
|
||
|
||
/** Opens a puzzle from the server: a link id, or "weekly". */
|
||
async function openPuzzle(id: string) {
|
||
try {
|
||
const res = await api<{ spec: PuzzleSpec; summary: PuzzleSummary }>('GET', `/api/puzzles/${encodeURIComponent(id)}?player=${encodeURIComponent(playerId())}`)
|
||
boards[res.spec.id] = res.summary
|
||
beginPuzzle(res.spec)
|
||
notify(`Puzzle: ${res.spec.name}`)
|
||
} catch (e) {
|
||
notify((e as Error).message, 'error')
|
||
} finally {
|
||
syncUrl()
|
||
}
|
||
}
|
||
|
||
/** Publishes the open circuit as a puzzle; returns its link. */
|
||
async function publishPuzzle(name: string, goal: string): Promise<string> {
|
||
const spec = makePuzzle(toRaw(project.value.components), def.value.id, name, goal)
|
||
const res = await api<{ id: string }>('POST', '/api/puzzles', { puzzle: spec })
|
||
return `${location.origin}/puzzle/${res.id}`
|
||
}
|
||
|
||
// ── Public library ────────────────────────────────────────────────
|
||
/** Edit keys of the library entries this browser published. */
|
||
const libKeys = ref(libraryKeys())
|
||
|
||
/** The library entry a component is, when this browser published it from here (and so can update or remove it). */
|
||
function ownEntry(d: ComponentDef | undefined): string | undefined {
|
||
return d && ownedEntry(libKeys.value, meta.value.id, d.id)
|
||
}
|
||
|
||
/** Why the open circuit can't go to the library; null when it can. */
|
||
const libraryProblem = computed(() => publishProblem(project.value, def.value.id))
|
||
|
||
async function listLibrary(q = ''): Promise<{ entries: LibraryMeta[]; total: number }> {
|
||
return api('GET', `/api/library?q=${encodeURIComponent(q.trim())}`)
|
||
}
|
||
|
||
/**
|
||
* Publishes the open circuit to the library with everything it uses, or a
|
||
* new version when this browser published it before. The name and
|
||
* description go to the component too; the author is your leaderboard name.
|
||
*/
|
||
async function publishToLibrary(name: string, description: string, author: string): Promise<LibraryOrigin> {
|
||
const d = def.value
|
||
const problem = publishProblem(project.value, d.id)
|
||
if (problem) throw new Error(problem)
|
||
if (author.trim() !== playerName.value) await setPlayerName(author)
|
||
const text = description.trim().slice(0, LIBRARY_LIMITS.description)
|
||
d.name = name.trim().slice(0, LIBRARY_LIMITS.name) || d.name
|
||
if (text) d.description = text
|
||
else delete d.description
|
||
try {
|
||
const body = { player: playerId(), ...libraryBundle(toRaw(project.value), d.id) }
|
||
const own = ownEntry(d)
|
||
let res: { id: string; key?: string; version: number } | undefined
|
||
if (own) {
|
||
try {
|
||
res = await api('PUT', `/api/library/${own}`, body, libKeys.value[own]!.key)
|
||
} catch (e) {
|
||
// Gone from the library: it goes in again as a new entry.
|
||
if ((e as { status?: number }).status !== 404) throw e
|
||
setLibraryKey(own, null)
|
||
}
|
||
}
|
||
res ??= await api<{ id: string; key: string; version: number }>('POST', '/api/library', body)
|
||
if (res.key) setLibraryKey(res.id, { key: res.key, project: meta.value.id, def: d.id })
|
||
libKeys.value = libraryKeys()
|
||
d.from = { id: res.id, version: res.version, author: playerName.value }
|
||
return d.from
|
||
} finally {
|
||
commit(false)
|
||
}
|
||
}
|
||
|
||
/** Takes an entry this browser published out of the library; components here keep working, just without the mark. */
|
||
async function removeFromLibrary(id: string) {
|
||
try {
|
||
await api('DELETE', `/api/library/${id}`, undefined, libKeys.value[id]?.key)
|
||
} catch (e) {
|
||
if ((e as { status?: number }).status !== 404) throw e
|
||
}
|
||
setLibraryKey(id, null)
|
||
libKeys.value = libraryKeys()
|
||
for (const d of project.value.components) if (d.from?.id === id && !d.from.inside) delete d.from
|
||
commit(false)
|
||
}
|
||
|
||
async function fetchEntry(id: string): Promise<{ entry: LibraryMeta; bundle: LibraryBundle }> {
|
||
const problem = importProblem(project.value)
|
||
if (problem) throw new Error(problem)
|
||
const res = await api<{ entry: LibraryMeta; bundle: unknown }>('GET', `/api/library/${encodeURIComponent(id)}`)
|
||
return { entry: res.entry, bundle: cleanBundle(res.bundle) }
|
||
}
|
||
|
||
const originOf = (entry: LibraryMeta): LibraryOrigin => ({ id: entry.id, version: entry.version, author: entry.author })
|
||
|
||
/** Adds a library entry to the open project; returns the id of its component here, ready to place. */
|
||
async function addFromLibrary(id: string): Promise<string> {
|
||
const { entry, bundle } = await fetchEntry(id)
|
||
const res = importBundle(project.value, bundle, originOf(entry))
|
||
commit()
|
||
const along = res.added > 1 ? ` and ${res.added - 1} component${res.added === 2 ? '' : 's'} it uses` : ''
|
||
notify(res.added ? `Added "${entry.name}"${entry.author ? ` by ${entry.author}` : ''}${along}` : `"${entry.name}" is in this project already`)
|
||
return res.root
|
||
}
|
||
|
||
/** Brings a component from the library to the newest version of its entry, in place: wherever it is used follows. */
|
||
async function updateFromLibrary(defId: string) {
|
||
const d = getDef.value(defId)
|
||
if (!d?.from || d.from.inside) return
|
||
try {
|
||
const { entry, bundle } = await fetchEntry(d.from.id)
|
||
importBundle(project.value, bundle, originOf(entry), d.id)
|
||
commit()
|
||
notify(`"${d.name}" is now version ${entry.version} (Ctrl+Z goes back)`)
|
||
} catch (e) {
|
||
notify((e as Error).message, 'error')
|
||
}
|
||
}
|
||
|
||
/** The newest version of a library entry; null when the library can't be reached or no longer has it. */
|
||
async function libraryVersion(id: string): Promise<number | null> {
|
||
try {
|
||
return (await api<{ entry: LibraryMeta }>('GET', `/api/library/${encodeURIComponent(id)}?meta`)).entry.version
|
||
} catch {
|
||
return null
|
||
}
|
||
}
|
||
|
||
// ── Several parts at once ─────────────────────────────────────────
|
||
const nodesById = (ids: string[]) => {
|
||
const set = new Set(ids)
|
||
return def.value.nodes.filter(n => set.has(n.id))
|
||
}
|
||
|
||
/** Swaps every given part for the same new one, keeping wires on matching pins. One undo step. */
|
||
function swapMany(ids: string[], target: SwapTarget) {
|
||
let removed = 0
|
||
for (const n of nodesById(ids)) {
|
||
if (n.kind === target.kind && n.chip === target.chip) continue
|
||
removed += swapNode(project.value, def.value, n.id, target)
|
||
}
|
||
commit()
|
||
notify(removed ? `Swapped. ${removed} wire${removed === 1 ? '' : 's'} had no matching pin and were removed.` : `Swapped ${ids.length} parts`)
|
||
}
|
||
|
||
/** Names the parts top to bottom from a pattern (D# → D0, D1, …). An empty pattern clears their names. */
|
||
function renameMany(ids: string[], pattern: string, start = 0) {
|
||
const nodes = nodesById(ids).sort(byPosition)
|
||
const names = numberedNames(pattern, nodes.length, start)
|
||
nodes.forEach((n, i) => {
|
||
if (pattern.trim()) n.label = names[i]
|
||
else delete n.label
|
||
delete n.autoLabel
|
||
})
|
||
// Signal names decide what connects.
|
||
commit(nodes.some(n => n.kind === 'tag' || n.kind === 'ref'))
|
||
}
|
||
|
||
/** A name typed by hand (Pins list); empty lets connections name the part again. */
|
||
function setLabel(node: CircuitNode, label: string, row?: PanelRow) {
|
||
const v = label.trim()
|
||
if (row) {
|
||
if (v) row.label = v
|
||
else delete row.label
|
||
return commit()
|
||
}
|
||
if (v) node.label = v
|
||
else delete node.label
|
||
delete node.autoLabel
|
||
commit(false)
|
||
}
|
||
|
||
/** Sets the switches among the parts to 0 or 1, or flips each. */
|
||
function setSwitches(ids: string[], to: boolean | 'flip') {
|
||
for (const n of nodesById(ids)) {
|
||
if (n.kind !== 'input') continue
|
||
const on = to === 'flip' ? !n.on : to
|
||
if (!!n.on === on) continue
|
||
n.on = on
|
||
sim.value?.setSource(n.id, on)
|
||
}
|
||
play(to === false ? 'off' : 'on')
|
||
persist()
|
||
}
|
||
|
||
/** The same setting on every part (colour, frequency, note size); undefined removes it. */
|
||
function patchMany(ids: string[], patch: Pick<CircuitNode, 'color' | 'hz' | 'size'>, structural = false) {
|
||
for (const n of nodesById(ids)) {
|
||
for (const [k, v] of Object.entries(patch) as [keyof typeof patch, never][]) {
|
||
if (v === undefined) delete n[k]
|
||
else n[k] = v
|
||
}
|
||
}
|
||
commit(structural)
|
||
}
|
||
|
||
function arrangeSelected(how: Arrange) {
|
||
arrangeNodes(nodesById(selection.value), how)
|
||
commit(false)
|
||
}
|
||
|
||
/** Narrows the selection to some of its parts. */
|
||
function selectOnly(ids: string[]) {
|
||
selection.value = ids
|
||
wireSel.value = []
|
||
}
|
||
|
||
/** A reference to a signal, placed to the right of its tag and selected. */
|
||
function useSignal(tag: CircuitNode) {
|
||
const name = tag.label?.trim()
|
||
if (!name) return notify('Give the signal a name first', 'error')
|
||
const b = shapeOf(tag, getDef.value).body
|
||
const ref: CircuitNode = { id: uid('n'), kind: 'ref', x: Math.round(tag.x + b.x + b.w + 3), y: tag.y, label: name }
|
||
def.value.nodes.push(ref)
|
||
selection.value = [ref.id]
|
||
wireSel.value = []
|
||
commit()
|
||
play('place')
|
||
}
|
||
|
||
/** Every tag and reference of a signal. */
|
||
function selectSignal(name: string) {
|
||
selection.value = def.value.nodes.filter(n => (n.kind === 'tag' || n.kind === 'ref') && n.label?.trim() === name).map(n => n.id)
|
||
wireSel.value = []
|
||
}
|
||
|
||
/** Selects a part and centres the view on it. */
|
||
function focusNode(id: string) {
|
||
selection.value = [id]
|
||
wireSel.value = []
|
||
focusRequest.value = { id, n: (focusRequest.value?.n ?? 0) + 1 }
|
||
}
|
||
|
||
// ── Transistors ───────────────────────────────────────────────────
|
||
const nands = computed(() => nandCounts(project.value.components))
|
||
|
||
/** Transistors in a component at every depth, 4 per NAND gate. */
|
||
function transistors(defId: string): number {
|
||
return (nands.value.get(defId) ?? 0) * TRANSISTORS_PER_NAND
|
||
}
|
||
|
||
/** Transistors in one placed part: 4 for a NAND, its whole inside for a component, 0 for switches, lamps and cables. */
|
||
function transistorsOfNode(n: CircuitNode): number {
|
||
const child = n.kind === 'chip' && n.chip ? getDef.value(n.chip) : undefined
|
||
const bubbles = invertedPins(n, child ? chipPins(child) : undefined).length * TRANSISTORS_PER_NAND
|
||
if (n.kind === 'nand') return TRANSISTORS_PER_NAND + bubbles
|
||
return (n.kind === 'chip' && n.chip ? transistors(n.chip) : 0) + bubbles
|
||
}
|
||
|
||
/** Puts a bubble on an input (it reads the signal inverted, through one NAND), or takes it off. */
|
||
function toggleInvert(n: CircuitNode, pin: string) {
|
||
if (!INVERTIBLE.has(n.kind)) return
|
||
const set = new Set(n.invert ?? [])
|
||
if (!set.delete(pin)) set.add(pin)
|
||
if (set.size) n.invert = [...set]
|
||
else delete n.invert
|
||
commit()
|
||
}
|
||
|
||
// ── Connector types ─────────────────────────────────────────────
|
||
/** The connector type open in the connector dialog. */
|
||
const connectorFor = ref<string | null>(null)
|
||
|
||
/** A new connector type with two lines, opened for editing. */
|
||
function addConnector(): ConnectorType {
|
||
const names = new Set((project.value.connectors ?? []).map(c => c.name.toLowerCase()))
|
||
let name = 'Connector'
|
||
for (let i = 2; names.has(name.toLowerCase()); i++) name = `Connector ${i}`
|
||
const c: ConnectorType = { id: uid('k'), name, lines: [{ name: 'D0' }, { name: 'D1' }] }
|
||
project.value.connectors = [...(project.value.connectors ?? []), c]
|
||
commit()
|
||
editConnector(c.id)
|
||
return c
|
||
}
|
||
|
||
function editConnector(id: string) {
|
||
connectorFor.value = id
|
||
dialog.value = 'connector'
|
||
}
|
||
|
||
/** Where a connector type is used: ports in all circuits. */
|
||
function connectorUses(id: string): number {
|
||
return project.value.components.reduce((n, d) => n + d.nodes.filter(x => x.conn === id && (x.kind === 'portin' || x.kind === 'portout')).length, 0)
|
||
}
|
||
|
||
function removeConnector(id: string) {
|
||
const uses = connectorUses(id)
|
||
if (uses) return notify(`Still used by ${uses} port${uses === 1 ? '' : 's'}: change or delete those first`, 'error')
|
||
project.value.connectors = (project.value.connectors ?? []).filter(c => c.id !== id)
|
||
if (!project.value.connectors.length) delete project.value.connectors
|
||
if (connectorFor.value === id) dialog.value = null
|
||
commit()
|
||
}
|
||
|
||
// ── Cables ────────────────────────────────────────────────────────
|
||
/** Bundling with a chosen route: the next click places the start of the cable, the one after its end. */
|
||
const cabling = ref<{ wires: string[]; start?: Pt } | null>(null)
|
||
|
||
function startCable(wires = wireSel.value) {
|
||
if (wires.length < 2) return notify('Select at least two wires to bundle (Shift + click or drag a box)', 'error')
|
||
placing.value = null
|
||
linking.value = null
|
||
cabling.value = { wires: [...wires] }
|
||
}
|
||
|
||
function placeCable(at: Pt) {
|
||
const c = cabling.value
|
||
if (!c) return
|
||
if (!c.start) {
|
||
c.start = at
|
||
return
|
||
}
|
||
cabling.value = null
|
||
bundleSelected(c.wires, { start: c.start, end: at })
|
||
}
|
||
|
||
/** Colour of a cable's sleeve (every cable leaving that bundle); undefined for the default. */
|
||
function setCableColor(bundleId: string, color: WireColor | undefined) {
|
||
for (const w of def.value.wires) {
|
||
if (w.from.node !== bundleId) continue
|
||
if (color) w.color = color
|
||
else delete w.color
|
||
}
|
||
commit(false)
|
||
}
|
||
|
||
function bundleSelected(wires = wireSel.value, at?: { start: Pt; end: Pt }) {
|
||
const res = bundleWires(def.value, wires, getDef.value, at)
|
||
if (!res.ok) return notify(res.error, 'error')
|
||
selection.value = [res.bundle.id, res.split.id]
|
||
wireSel.value = []
|
||
commit()
|
||
notify(`${res.bundle.bits} wires bundled into one cable`)
|
||
}
|
||
|
||
function removeCable(bundleId: string) {
|
||
const n = dissolveCable(def.value, bundleId)
|
||
clearSelection()
|
||
commit()
|
||
notify(n ? `Cable removed; ${n} wire${n === 1 ? '' : 's'} run on their own again` : 'Cable removed')
|
||
}
|
||
|
||
function setBits(node: CircuitNode, bits: number) {
|
||
node.bits = Math.min(MAX_BITS, Math.max(2, Math.round(bits) || 2))
|
||
commit()
|
||
}
|
||
|
||
function table(): TruthTable | { error: string } {
|
||
return truthTable(getDef.value, def.value.id)
|
||
}
|
||
|
||
// ── Projects ──────────────────────────────────────────────────────
|
||
function activate(m: ProjectMeta, p: Project) {
|
||
placeholder = false
|
||
meta.value = m
|
||
project.value = p
|
||
setCurrentId(m.id)
|
||
resetHistory()
|
||
nav.value = []
|
||
clearSelection()
|
||
placing.value = null
|
||
linking.value = null
|
||
for (const k of Object.keys(views)) delete views[k]
|
||
linkState.value = m.link ? (m.link.key ? 'saved' : 'viewer') : 'none'
|
||
projects.value = listProjects()
|
||
syncUrl()
|
||
rebuild()
|
||
}
|
||
|
||
function switchProject(id: string) {
|
||
if (id === meta.value.id) return
|
||
persistNow()
|
||
const p = loadProject(id)
|
||
const m = listProjects().find(x => x.id === id)
|
||
if (!p || !m) return notify('Could not open that project', 'error')
|
||
activate(m, p)
|
||
}
|
||
|
||
function addProject(p: Project, link?: ProjectMeta['link']): ProjectMeta {
|
||
const m: ProjectMeta = { id: newLocalId(), name: p.name, updated: Date.now() }
|
||
if (link) m.link = link
|
||
saveProject(m, p)
|
||
scheduleCloud()
|
||
return m
|
||
}
|
||
|
||
function newProject(examples: boolean, campaign = false) {
|
||
persistNow()
|
||
const p = createProject({ examples, campaign })
|
||
activate(addProject(p), p)
|
||
if (campaign) notify('Campaign started: you have NAND. Open Challenges on the left and build NOT first.')
|
||
}
|
||
|
||
function duplicateProject(id: string) {
|
||
persistNow()
|
||
const p = loadProject(id)
|
||
if (!p) return
|
||
p.name = `${p.name} copy`
|
||
activate(addProject(p), p)
|
||
}
|
||
|
||
function deleteProject(id: string) {
|
||
const gone = listProjects().find(m => m.id === id)
|
||
if (gone?.cloud) {
|
||
setPendingDeletes([...pendingDeletes(), { owner: gone.cloud.owner, id }])
|
||
scheduleCloud()
|
||
}
|
||
removeProject(id)
|
||
projects.value = listProjects()
|
||
if (id !== meta.value.id) return
|
||
const next = projects.value[0]
|
||
const p = next && loadProject(next.id)
|
||
if (next && p) activate(next, p)
|
||
else {
|
||
const fresh = createProject({ examples: true })
|
||
activate(addProject(fresh), fresh)
|
||
}
|
||
}
|
||
|
||
function renameProject(id: string, name: string) {
|
||
const clean = name.trim().slice(0, 80) || 'Untitled'
|
||
if (id === meta.value.id) {
|
||
project.value.name = clean
|
||
persist()
|
||
return
|
||
}
|
||
const p = loadProject(id)
|
||
const m = listProjects().find(x => x.id === id)
|
||
if (!p || !m) return
|
||
p.name = clean
|
||
saveProject({ ...m, name: clean, dirty: true }, p)
|
||
projects.value = listProjects()
|
||
scheduleCloud()
|
||
}
|
||
|
||
function loadExamples() {
|
||
const n = addExamples(project.value)
|
||
commit()
|
||
notify(n ? `Added ${n} example parts` : 'All examples are already here')
|
||
}
|
||
|
||
function download(name: string, text: string, type = 'application/json') {
|
||
const blob = new Blob([text], { type })
|
||
const a = document.createElement('a')
|
||
a.href = URL.createObjectURL(blob)
|
||
a.download = name
|
||
a.click()
|
||
URL.revokeObjectURL(a.href)
|
||
}
|
||
|
||
const slug = (name: string, fallback: string) => name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || fallback
|
||
|
||
function exportJson() {
|
||
persistNow()
|
||
download(`${slug(project.value.name, 'project')}.logigate.json`, JSON.stringify(project.value, null, 1))
|
||
}
|
||
|
||
function exportTable(t: TruthTable) {
|
||
download(`${slug(def.value.name, 'circuit')}-truth-table.csv`, tableCsv(t), 'text/csv')
|
||
}
|
||
|
||
/** Opens a project file as a new project in the library. */
|
||
async function importAsProject(file: File) {
|
||
try {
|
||
const p = parseProject(await file.text())
|
||
if (p.name === 'Untitled') p.name = file.name.replace(/(\.logigate)?\.json$/i, '')
|
||
persistNow()
|
||
activate(addProject(p), p)
|
||
notify(`Opened ${file.name}`)
|
||
} catch (e) {
|
||
notify((e as Error).message, 'error')
|
||
}
|
||
}
|
||
|
||
/** Adds the components of a project file to the open project. */
|
||
async function importComponents(file: File) {
|
||
try {
|
||
const p = parseProject(await file.text())
|
||
const n = mergeComponents(project.value, p.components)
|
||
commit()
|
||
notify(n ? `Added ${n} component${n === 1 ? '' : 's'} from ${file.name}` : 'Nothing new in that file')
|
||
} catch (e) {
|
||
notify((e as Error).message, 'error')
|
||
}
|
||
}
|
||
|
||
// ── Share links ───────────────────────────────────────────────────
|
||
const linkState = ref<LinkState>(meta.value.link ? (meta.value.link.key ? 'saved' : 'viewer') : 'none')
|
||
const linkError = ref('')
|
||
const linkUrl = computed(() => (meta.value.link ? `${location.origin}/p/${meta.value.link.id}` : ''))
|
||
|
||
function syncUrl() {
|
||
const path = meta.value.link ? `/p/${meta.value.link.id}` : '/'
|
||
if (location.pathname !== path) history.replaceState(history.state, '', path)
|
||
}
|
||
|
||
async function api<T>(method: string, url: string, body?: unknown, key?: string): Promise<T> {
|
||
const res = await fetch(url, {
|
||
method,
|
||
headers: { 'content-type': 'application/json', ...(key ? { 'x-edit-key': key } : {}) },
|
||
body: body === undefined ? undefined : JSON.stringify(body),
|
||
})
|
||
const data = await res.json().catch(() => ({}))
|
||
if (!res.ok) throw Object.assign(new Error((data as { message?: string }).message || `Server error ${res.status}`), { status: res.status })
|
||
return data as T
|
||
}
|
||
|
||
async function createLink() {
|
||
persistNow()
|
||
linkState.value = 'saving'
|
||
try {
|
||
const res = await api<{ id: string; key: string }>('POST', '/api/p', { project: toRaw(project.value) })
|
||
meta.value = { ...meta.value, link: { id: res.id, key: res.key }, dirty: true }
|
||
saveMeta(toRaw(meta.value))
|
||
scheduleCloud()
|
||
projects.value = listProjects()
|
||
linkState.value = 'saved'
|
||
syncUrl()
|
||
} catch (e) {
|
||
linkError.value = (e as Error).message
|
||
linkState.value = 'error'
|
||
}
|
||
}
|
||
|
||
let syncTimer: ReturnType<typeof setTimeout> | undefined
|
||
let syncing = false
|
||
async function pushLink() {
|
||
const link = meta.value.link
|
||
if (!link?.key) return
|
||
if (syncing) return scheduleSync()
|
||
syncing = true
|
||
linkState.value = 'saving'
|
||
try {
|
||
await api('PUT', `/api/p/${link.id}`, { project: toRaw(project.value) }, link.key)
|
||
linkState.value = 'saved'
|
||
} catch (e) {
|
||
linkError.value = (e as Error).message
|
||
linkState.value = 'error'
|
||
} finally {
|
||
syncing = false
|
||
}
|
||
}
|
||
|
||
/** The person who made a link saves to it automatically, a few seconds after each change. */
|
||
function scheduleSync() {
|
||
if (!meta.value.link?.key) return
|
||
linkState.value = 'dirty'
|
||
clearTimeout(syncTimer)
|
||
syncTimer = setTimeout(pushLink, 2500)
|
||
}
|
||
|
||
/** Editing someone else's shared project turns it into your own copy. */
|
||
function forkIfViewer() {
|
||
if (!meta.value.link || meta.value.link.key) return
|
||
meta.value = { ...meta.value, link: undefined }
|
||
saveMeta(toRaw(meta.value))
|
||
linkState.value = 'none'
|
||
syncUrl()
|
||
notify('This is now your own copy. Share it to get your own link.')
|
||
}
|
||
|
||
/** Opens /p/:id: your own linked project, or a fresh copy of someone else's. */
|
||
async function openLink(id: string) {
|
||
const list = listProjects()
|
||
const own = list.find(m => m.link?.id === id && m.link.key)
|
||
if (own) {
|
||
if (own.id !== meta.value.id) switchProject(own.id)
|
||
return
|
||
}
|
||
try {
|
||
const res = await fetch(`/api/p/${encodeURIComponent(id)}`)
|
||
if (!res.ok) throw new Error(res.status === 404 ? 'This link does not exist' : 'Could not load the link')
|
||
const data = (await res.json()) as { project: unknown }
|
||
const p = toProject(data.project)
|
||
if (!placeholder) persistNow()
|
||
const viewer = list.find(m => m.link?.id === id && !m.link.key)
|
||
if (viewer) {
|
||
const m = { ...viewer, name: p.name, updated: Date.now() }
|
||
saveProject(m, p)
|
||
activate(m, p)
|
||
} else activate(addProject(p, { id }), p)
|
||
notify(`Opened "${p.name}" from a shared link`)
|
||
} catch (e) {
|
||
notify((e as Error).message, 'error')
|
||
if (placeholder) persistNow()
|
||
syncUrl()
|
||
}
|
||
}
|
||
|
||
async function copyText(text: string, done = 'Link copied') {
|
||
try {
|
||
await navigator.clipboard.writeText(text)
|
||
notify(done)
|
||
} catch {
|
||
notify('Copy failed: the browser did not allow it', 'error')
|
||
}
|
||
}
|
||
|
||
window.addEventListener('beforeunload', () => {
|
||
if (saveTimer) persistNow()
|
||
})
|
||
|
||
// ── Account ───────────────────────────────────────────────────────
|
||
// Signed in, every project in this browser is also kept in the account and
|
||
// other devices get it on their next sync. Each upload names the revision
|
||
// it started from; when another device saved in between, both versions are
|
||
// kept (the other one as a copy) instead of one silently replacing the other.
|
||
const account = ref<AccountUser | null>(cachedAccount())
|
||
/** False while a signed-in browser is still loading the account's saves at startup: the menu waits, so nothing is started twice. */
|
||
const savesReady = ref(!account.value)
|
||
const cloudState = ref<'off' | 'syncing' | 'synced' | 'offline' | 'error'>(account.value ? 'syncing' : 'off')
|
||
const cloudError = ref('')
|
||
|
||
function setAccount(user: AccountUser | null) {
|
||
account.value = user
|
||
setCachedAccount(user)
|
||
cloudState.value = user ? cloudState.value : 'off'
|
||
}
|
||
|
||
async function authCall<T>(method: string, url: string, body?: unknown): Promise<T> {
|
||
const res = await fetch(url, {
|
||
method,
|
||
headers: { 'content-type': 'application/json' },
|
||
body: body === undefined ? undefined : JSON.stringify(body),
|
||
})
|
||
const data = await res.json().catch(() => ({}))
|
||
if (res.status === 401 && url.startsWith('/api/me/')) {
|
||
setAccount(null)
|
||
notify('You were signed out. Sign in again to keep syncing.', 'error')
|
||
}
|
||
if (!res.ok && res.status !== 409) throw new Error((data as { message?: string }).message || `Server error ${res.status}`)
|
||
return { ...(data as object), status: res.status } as T
|
||
}
|
||
|
||
function localProject(m: ProjectMeta): Project | null {
|
||
if (m.id === meta.value.id) {
|
||
if (saveTimer) persistNow()
|
||
return toRaw(project.value)
|
||
}
|
||
return loadProject(m.id)
|
||
}
|
||
|
||
function updateMeta(id: string, patch: Partial<ProjectMeta>) {
|
||
const m = listProjects().find(x => x.id === id)
|
||
if (!m) return
|
||
const next = { ...m, ...patch }
|
||
if (patch.dirty === false) delete next.dirty
|
||
saveMeta(next)
|
||
if (id === meta.value.id) meta.value = { ...meta.value, ...patch }
|
||
}
|
||
|
||
interface CloudMeta {
|
||
id: string
|
||
name: string
|
||
updated: number
|
||
rev: number
|
||
link?: ProjectMeta['link']
|
||
}
|
||
|
||
/** Replaces this browser's copy of a project with the account's current one. */
|
||
async function takeRemote(m: ProjectMeta, uid: string, remote: CloudMeta) {
|
||
const res = await authCall<{ project?: Project; status: number }>('GET', `/api/me/projects/${m.id}`)
|
||
if (!res.project) return
|
||
const p = toProject(res.project)
|
||
const next: ProjectMeta = { ...m, name: p.name, updated: remote.updated, cloud: { owner: uid, rev: remote.rev } }
|
||
delete next.dirty
|
||
delete next.snapshot
|
||
saveProject(next, p)
|
||
if (m.id === meta.value.id) activate(next, p)
|
||
}
|
||
|
||
/**
|
||
* One save per project on every device. When another device saved the same
|
||
* project in between, the newer save wins everywhere, and the other one is
|
||
* kept as a savegame of that project (Load → savegames), never as a copy.
|
||
*/
|
||
async function upload(m: ProjectMeta, uid: string) {
|
||
const p = localProject(m)
|
||
if (!p) return
|
||
const baseRev = m.cloud?.owner === uid ? m.cloud.rev : 0
|
||
const body = { project: p, baseRev, link: m.link, snapshot: m.snapshot === true }
|
||
let res = await authCall<{ meta?: CloudMeta; conflict?: boolean; status: number }>('PUT', `/api/me/projects/${m.id}`, body)
|
||
if (res.conflict && res.meta) {
|
||
if (res.meta.updated > m.updated) {
|
||
// The other device's save is newer: this one becomes a savegame.
|
||
await authCall('POST', `/api/me/projects/${m.id}/versions`, { project: p, baseRev })
|
||
await takeRemote(m, uid, res.meta)
|
||
notify(`"${m.name}" was changed later on another device and is loaded now. Your version here is in its savegames.`)
|
||
return
|
||
}
|
||
// This save is newer: it wins, and the server keeps the other one as a savegame.
|
||
res = await authCall('PUT', `/api/me/projects/${m.id}`, { ...body, force: true, snapshot: true })
|
||
notify(`"${m.name}" was also changed on another device. Yours is newer and saved; the other one is in its savegames.`)
|
||
}
|
||
if (res.meta) updateMeta(m.id, { cloud: { owner: uid, rev: res.meta.rev }, dirty: false, snapshot: undefined })
|
||
}
|
||
|
||
let syncingAccount = false
|
||
let syncAgain = false
|
||
/** Brings this browser and the account up to date in both directions. */
|
||
async function syncAccount() {
|
||
const uid = account.value?.id
|
||
if (!uid) return
|
||
if (syncingAccount) {
|
||
syncAgain = true
|
||
return
|
||
}
|
||
syncingAccount = true
|
||
cloudState.value = 'syncing'
|
||
try {
|
||
if (saveTimer) persistNow()
|
||
for (const d of pendingDeletes().filter(d => d.owner === uid)) {
|
||
await authCall('DELETE', `/api/me/projects/${d.id}`).catch(() => {})
|
||
}
|
||
setPendingDeletes(pendingDeletes().filter(d => d.owner !== uid))
|
||
|
||
const remote = await authCall<{ projects: CloudMeta[]; deleted: { id: string }[]; status: number }>('GET', '/api/me/projects')
|
||
if (!account.value) return
|
||
|
||
// Deleted on another device.
|
||
for (const t of remote.deleted) {
|
||
const m = listProjects().find(x => x.id === t.id && x.cloud?.owner === uid)
|
||
if (m && !m.dirty) {
|
||
if (m.id === meta.value.id) {
|
||
notify(`"${m.name}" was deleted on another device`)
|
||
deleteProject(m.id)
|
||
} else removeProject(m.id)
|
||
}
|
||
}
|
||
|
||
// New or newer in the account.
|
||
for (const r of remote.projects) {
|
||
const m = listProjects().find(x => x.id === r.id)
|
||
if (m && ((m.cloud && m.cloud.owner !== uid) || m.dirty || (m.cloud?.rev ?? 0) >= r.rev)) continue
|
||
const res = await authCall<{ project?: Project; status: number }>('GET', `/api/me/projects/${r.id}`)
|
||
if (!res.project) continue
|
||
const p = toProject(res.project)
|
||
const next: ProjectMeta = { id: r.id, name: p.name, updated: r.updated, cloud: { owner: uid, rev: r.rev } }
|
||
const link = r.link ?? m?.link
|
||
if (link) next.link = link
|
||
saveProject(next, p)
|
||
if (r.id === meta.value.id) {
|
||
activate(next, p)
|
||
notify(`Updated "${p.name}" from another device`)
|
||
}
|
||
}
|
||
|
||
// Projects that are new here or changed here (not the untouched starter project).
|
||
for (const m of listProjects()) {
|
||
if ((m.cloud && m.cloud.owner !== uid) || (m.starter && !m.dirty)) continue
|
||
if (!m.cloud || m.dirty) await upload(m, uid)
|
||
}
|
||
|
||
// A new browser: open the account's latest project instead of the untouched starter.
|
||
if (meta.value.starter && !meta.value.dirty) {
|
||
const latest = listProjects().filter(m => m.cloud?.owner === uid).sort((a, b) => b.updated - a.updated)[0]
|
||
const p = latest && loadProject(latest.id)
|
||
if (latest && p) {
|
||
const starter = meta.value.id
|
||
activate(latest, p)
|
||
removeProject(starter)
|
||
}
|
||
}
|
||
projects.value = listProjects()
|
||
cloudState.value = 'synced'
|
||
cloudError.value = ''
|
||
} catch (e) {
|
||
cloudError.value = (e as Error).message
|
||
cloudState.value = navigator.onLine ? 'error' : 'offline'
|
||
} finally {
|
||
syncingAccount = false
|
||
if (syncAgain) {
|
||
syncAgain = false
|
||
void syncAccount()
|
||
}
|
||
}
|
||
}
|
||
|
||
let cloudTimer: ReturnType<typeof setTimeout> | undefined
|
||
function scheduleCloud() {
|
||
if (!account.value) return
|
||
clearTimeout(cloudTimer)
|
||
cloudTimer = setTimeout(syncAccount, 2000)
|
||
}
|
||
|
||
async function signIn(email: string, password: string, create: boolean) {
|
||
const res = await authCall<{ user?: AccountUser; message?: string; status: number }>('POST', create ? '/api/auth/register' : '/api/auth/login', { email, password })
|
||
if (!res.user) throw new Error(res.message || 'Could not sign in')
|
||
setAccount(res.user)
|
||
await syncAccount()
|
||
notify(create ? 'Account created. Your projects are now saved in it.' : `Signed in as ${res.user.email}`)
|
||
}
|
||
|
||
async function signOut(removeHere: boolean) {
|
||
const uid = account.value?.id
|
||
if (uid) await syncAccount()
|
||
await authCall('POST', '/api/auth/logout').catch(() => {})
|
||
setAccount(null)
|
||
if (removeHere && uid) {
|
||
for (const m of listProjects()) if (m.cloud?.owner === uid && !m.dirty) removeProject(m.id)
|
||
projects.value = listProjects()
|
||
if (!projects.value.some(m => m.id === meta.value.id)) deleteProject(meta.value.id)
|
||
}
|
||
notify('Signed out')
|
||
}
|
||
|
||
async function changePassword(current: string, next: string) {
|
||
await authCall('POST', '/api/auth/password', { current, next })
|
||
notify('Password changed. Other devices need to sign in again.')
|
||
}
|
||
|
||
async function deleteAccount(password: string) {
|
||
const uid = account.value?.id
|
||
await authCall('POST', '/api/auth/delete', { password })
|
||
setAccount(null)
|
||
// The projects stay in this browser, now as local-only projects.
|
||
for (const m of listProjects()) {
|
||
if (m.cloud?.owner !== uid) continue
|
||
const next = { ...m }
|
||
delete next.cloud
|
||
saveMeta(next)
|
||
}
|
||
if (meta.value.cloud?.owner === uid) {
|
||
const next = { ...meta.value }
|
||
delete next.cloud
|
||
meta.value = next
|
||
}
|
||
projects.value = listProjects()
|
||
notify('Account deleted. Your projects are still in this browser.')
|
||
}
|
||
|
||
// ── Savegames ─────────────────────────────────────────────────────
|
||
interface VersionInfo {
|
||
v: number
|
||
at: number
|
||
rev: number
|
||
name: string
|
||
size: number
|
||
}
|
||
|
||
async function listVersions(projectId: string): Promise<VersionInfo[]> {
|
||
const res = await authCall<{ versions: VersionInfo[]; status: number }>('GET', `/api/me/projects/${projectId}/versions`)
|
||
return res.versions ?? []
|
||
}
|
||
|
||
async function fetchVersion(projectId: string, v: number): Promise<Project> {
|
||
const res = await authCall<{ version?: { project: unknown }; status: number }>('GET', `/api/me/projects/${projectId}/versions/${v}`)
|
||
if (!res.version) throw new Error('Version not found')
|
||
return toProject(res.version.project)
|
||
}
|
||
|
||
/**
|
||
* Brings back a savegame: as a new project, or in place of the current
|
||
* state (which the server keeps as a savegame first, so this can be undone).
|
||
*/
|
||
async function restoreVersion(projectId: string, v: number, asCopy: boolean) {
|
||
if (projectId === meta.value.id && saveTimer) persistNow()
|
||
const p = await fetchVersion(projectId, v)
|
||
if (asCopy) {
|
||
p.name = `${p.name} (${new Date(v).toLocaleDateString()})`
|
||
activate(addProject(p), p)
|
||
notify(`Opened the saved version as "${p.name}"`)
|
||
return
|
||
}
|
||
const m = listProjects().find(x => x.id === projectId)
|
||
if (!m) return
|
||
const next: ProjectMeta = { ...m, name: p.name, updated: Date.now(), dirty: true, snapshot: true }
|
||
saveProject(next, p)
|
||
activate(next, p)
|
||
scheduleCloud()
|
||
notify('Restored. The state before is kept as a savegame too.')
|
||
}
|
||
|
||
async function listTrash(): Promise<{ id: string; name: string; deleted: number; v: number }[]> {
|
||
const res = await authCall<{ projects: { id: string; name: string; deleted: number; v: number }[]; status: number }>('GET', '/api/me/trash')
|
||
return res.projects ?? []
|
||
}
|
||
|
||
async function restoreDeleted(item: { id: string; v: number }) {
|
||
const p = await fetchVersion(item.id, item.v)
|
||
persistNow()
|
||
setPendingDeletes(pendingDeletes().filter(d => d.id !== item.id))
|
||
const m: ProjectMeta = { id: item.id, name: p.name, updated: Date.now(), dirty: true }
|
||
saveProject(m, p)
|
||
activate(m, p)
|
||
scheduleCloud()
|
||
notify(`"${p.name}" is back`)
|
||
}
|
||
|
||
/** Checks the session with the server, then syncs; again on focus and every minute. */
|
||
async function startAccount() {
|
||
try {
|
||
const res = await authCall<{ user: AccountUser | null; status: number }>('GET', '/api/auth/me')
|
||
setAccount(res.user)
|
||
if (res.user) await syncAccount()
|
||
} catch {
|
||
if (account.value) cloudState.value = 'offline'
|
||
} finally {
|
||
savesReady.value = true
|
||
}
|
||
let lastFocusSync = Date.now()
|
||
const onFocus = () => {
|
||
if (document.visibilityState === 'visible' && Date.now() - lastFocusSync > 10_000) {
|
||
lastFocusSync = Date.now()
|
||
void syncAccount()
|
||
}
|
||
}
|
||
document.addEventListener('visibilitychange', onFocus)
|
||
window.addEventListener('online', () => void syncAccount())
|
||
setInterval(() => document.visibilityState === 'visible' && void syncAccount(), 60_000)
|
||
}
|
||
|
||
function shape(node: CircuitNode) {
|
||
return shapeOf(node, getDef.value)
|
||
}
|
||
|
||
rebuild()
|
||
|
||
return {
|
||
project,
|
||
meta,
|
||
projects,
|
||
getDef,
|
||
def,
|
||
selection,
|
||
wireSel,
|
||
selectedWires,
|
||
clearSelection,
|
||
placing,
|
||
nav,
|
||
views,
|
||
notice,
|
||
labelFocus,
|
||
showHelp,
|
||
dialog,
|
||
notify,
|
||
commit,
|
||
persist,
|
||
undo,
|
||
redo,
|
||
canUndo,
|
||
canRedo,
|
||
sim,
|
||
tick,
|
||
status,
|
||
running,
|
||
hz,
|
||
cycles,
|
||
errors,
|
||
circuitStats,
|
||
val,
|
||
faceVal,
|
||
startLoop,
|
||
step,
|
||
rebuild,
|
||
open,
|
||
back,
|
||
mainId,
|
||
goMain,
|
||
goTo,
|
||
addNode,
|
||
canPlace,
|
||
connect,
|
||
deleteSelected,
|
||
setWireColor,
|
||
autoRoute,
|
||
selectNet,
|
||
toggleInput,
|
||
press,
|
||
toggleRow,
|
||
pressRow,
|
||
addPanel,
|
||
undock,
|
||
mergeSelectedPanels,
|
||
combineSelected,
|
||
setRowsType,
|
||
setScreen,
|
||
screen,
|
||
menuPage,
|
||
challengesOpen,
|
||
enterGame,
|
||
showMenu,
|
||
projectMode,
|
||
projectOf,
|
||
playCampaign,
|
||
playChallenge,
|
||
playWeekly,
|
||
playerName,
|
||
setPlayerName,
|
||
fetchBoard,
|
||
setRowType,
|
||
addRow,
|
||
dropRow,
|
||
insertRow,
|
||
moveRowTo,
|
||
withDocked,
|
||
withFollowers,
|
||
issues,
|
||
showIssue,
|
||
sheetRequest,
|
||
exportSheet,
|
||
faceFor,
|
||
designFace,
|
||
fits,
|
||
fitHover,
|
||
connectFit,
|
||
unplugMoved,
|
||
latchTargetOf,
|
||
latchPart,
|
||
unlatch,
|
||
moveRow,
|
||
setRowGap,
|
||
setRowKey,
|
||
setRowColor,
|
||
plugTarget,
|
||
plugEnd,
|
||
unplugEnd,
|
||
setPitch,
|
||
addCablePanel,
|
||
dragPart,
|
||
partSearch,
|
||
cableChoices,
|
||
cableOut,
|
||
cableIn,
|
||
linking,
|
||
startLinking,
|
||
linkTo,
|
||
stopLinking,
|
||
setTidy,
|
||
tidyAll,
|
||
tidyEverything,
|
||
exportTable,
|
||
transistors,
|
||
transistorsOfNode,
|
||
toggleInvert,
|
||
nands,
|
||
panelTab,
|
||
panelOpen,
|
||
togglePanel,
|
||
focusRequest,
|
||
swapMany,
|
||
connectMany,
|
||
connectSelectionTo,
|
||
rewire,
|
||
renameMany,
|
||
setLabel,
|
||
setSwitches,
|
||
patchMany,
|
||
arrangeSelected,
|
||
selectOnly,
|
||
focusNode,
|
||
useSignal,
|
||
selectSignal,
|
||
canPlaceKind,
|
||
paused,
|
||
pause,
|
||
saveNow,
|
||
savesReady,
|
||
setInputs,
|
||
sound,
|
||
setSound,
|
||
play,
|
||
task,
|
||
boards,
|
||
loadBoard,
|
||
beginPuzzle,
|
||
openPuzzle,
|
||
publishPuzzle,
|
||
ownEntry,
|
||
libraryProblem,
|
||
listLibrary,
|
||
publishToLibrary,
|
||
removeFromLibrary,
|
||
addFromLibrary,
|
||
updateFromLibrary,
|
||
libraryVersion,
|
||
libKeys,
|
||
isBus,
|
||
pinKind,
|
||
connectorFor,
|
||
addConnector,
|
||
editConnector,
|
||
connectorUses,
|
||
removeConnector,
|
||
bundleSelected,
|
||
cabling,
|
||
startCable,
|
||
placeCable,
|
||
setCableColor,
|
||
removeCable,
|
||
setBits,
|
||
swap,
|
||
unlink,
|
||
unpack,
|
||
makeIndependent,
|
||
copy,
|
||
paste,
|
||
hasClip,
|
||
duplicate,
|
||
selectAll,
|
||
packageSelected,
|
||
createComponent,
|
||
removeComponent,
|
||
copyComponent,
|
||
beginChallenge,
|
||
checkChallenge,
|
||
table,
|
||
switchProject,
|
||
newProject,
|
||
duplicateProject,
|
||
deleteProject,
|
||
renameProject,
|
||
loadExamples,
|
||
exportJson,
|
||
importAsProject,
|
||
importComponents,
|
||
linkState,
|
||
linkError,
|
||
linkUrl,
|
||
createLink,
|
||
pushLink,
|
||
openLink,
|
||
syncUrl,
|
||
account,
|
||
cloudState,
|
||
cloudError,
|
||
syncAccount,
|
||
signIn,
|
||
signOut,
|
||
changePassword,
|
||
deleteAccount,
|
||
startAccount,
|
||
versionsFor,
|
||
listVersions,
|
||
restoreVersion,
|
||
listTrash,
|
||
restoreDeleted,
|
||
copyText,
|
||
shape,
|
||
}
|
||
}
|
||
|
||
let editor: ReturnType<typeof create> | undefined
|
||
|
||
export function useEditor() {
|
||
editor ??= create()
|
||
return editor
|
||
}
|