BlueGit

timfa questward

Files

questward / client / src / editor / dialogueCanvas.js

dialogueCanvas.js

dialogueCanvas.js 19.2 KiB Download Raw
1/**
2 * Desktop node-graph canvas for dialogue steps.
3 * Pan empty space, drag cards, wheel zoom, wire outputs → inputs.
4 */
5
6const CARD_W = 168;
7const CARD_H = 72;
8const PORT_R = 7;
9const EDGE_PAD = 36;
10const MIN_ZOOM = 0.35;
11const MAX_ZOOM = 2.25;
12const AUTO_PAN = 14;
13
14/**
15 * @param {{
16 * getDraft: () => object | null,
17 * onOpenStep: (stepId: string) => void,
18 * onCreateStep: (worldX: number, worldY: number) => void,
19 * onChange: () => void
20 * }} options
21 */
22export function createDialogueCanvas ({ getDraft, onOpenStep, onCreateStep, onChange })
23{
24 const wrap = document.createElement("div");
25 wrap.className = "dialogue-canvas-wrap";
26
27 const viewport = document.createElement("div");
28 viewport.className = "dialogue-canvas-viewport";
29 viewport.tabIndex = 0;
30
31 const world = document.createElement("div");
32 world.className = "dialogue-canvas-world";
33
34 const edgesSvg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
35 edgesSvg.classList.add("dialogue-canvas-edges");
36 edgesSvg.setAttribute("overflow", "visible");
37
38 const cardsLayer = document.createElement("div");
39 cardsLayer.className = "dialogue-canvas-cards";
40
41 const rubberPath = document.createElementNS("http://www.w3.org/2000/svg", "path");
42 rubberPath.classList.add("dialogue-canvas-rubber");
43 rubberPath.setAttribute("fill", "none");
44
45 const ctxMenu = document.createElement("div");
46 ctxMenu.className = "dialogue-canvas-context";
47 ctxMenu.hidden = true;
48 const createBtn = document.createElement("button");
49 createBtn.type = "button";
50 createBtn.textContent = "Create new step";
51 ctxMenu.append(createBtn);
52
53 const tooltip = document.createElement("div");
54 tooltip.className = "dialogue-canvas-tooltip";
55 tooltip.hidden = true;
56
57 world.append(edgesSvg, cardsLayer);
58 edgesSvg.append(rubberPath);
59 viewport.append(world);
60 wrap.append(viewport, ctxMenu, tooltip);
61
62 /** @type {{ x: number, y: number, zoom: number }} */
63 let view = { x: 40, y: 40, zoom: 1 };
64 /** @type {null | {
65 * mode: "pan" | "card" | "wire",
66 * startClientX: number,
67 * startClientY: number,
68 * originViewX?: number,
69 * originViewY?: number,
70 * step?: object,
71 * originEditorX?: number,
72 * originEditorY?: number,
73 * moved: boolean,
74 * portKey?: string,
75 * fromStepId?: string,
76 * portIndex?: number
77 * }} */
78 let drag = null;
79 /** @type {null | { stepId: string, portIndex: number, portKey: string }} */
80 let wiring = null;
81 let ctxWorld = { x: 0, y: 0 };
82 /** @type {number | null} */
83 let autoPanRaf = null;
84 let lastPointer = { x: 0, y: 0 };
85
86 function applyTransform ()
87 {
88 world.style.transform = `translate(${view.x}px, ${view.y}px) scale(${view.zoom})`;
89 }
90
91 function clientToWorld (clientX, clientY)
92 {
93 const rect = viewport.getBoundingClientRect();
94 return {
95 x: (clientX - rect.left - view.x) / view.zoom,
96 y: (clientY - rect.top - view.y) / view.zoom
97 };
98 }
99
100 function hideContext ()
101 {
102 ctxMenu.hidden = true;
103 }
104
105 function hideTooltip ()
106 {
107 tooltip.hidden = true;
108 }
109
110 function showTooltip (text, clientX, clientY)
111 {
112 if (!text)
113 {
114 hideTooltip();
115 return;
116 }
117 tooltip.hidden = false;
118 tooltip.textContent = text;
119 const rect = wrap.getBoundingClientRect();
120 tooltip.style.left = `${clientX - rect.left + 12}px`;
121 tooltip.style.top = `${clientY - rect.top + 12}px`;
122 }
123
124 function stepPosition (step, index)
125 {
126 const x = Number.isFinite(step.editorX) ? step.editorX : 40 + (index % 4) * (CARD_W + 48);
127 const y = Number.isFinite(step.editorY) ? step.editorY : 40 + Math.floor(index / 4) * (CARD_H + 64);
128 return { x, y };
129 }
130
131 function outputPorts (step)
132 {
133 const exit = step?.exit ?? { kind: "end" };
134 if (exit.kind === "continue")
135 {
136 return [{
137 key: "continue",
138 label: "Continue",
139 nextStepId: exit.nextStepId ?? null,
140 setNext (id)
141 {
142 exit.nextStepId = id;
143 }
144 }];
145 }
146 if (exit.kind === "triggers")
147 {
148 return (exit.triggers ?? []).map((trig, i) => ({
149 key: `trigger:${i}`,
150 label: trig.label || trig.trigger || `Trigger ${i + 1}`,
151 nextStepId: trig.nextStepId ?? null,
152 setNext (id)
153 {
154 trig.nextStepId = id;
155 }
156 }));
157 }
158 if (exit.kind === "branches")
159 {
160 return (exit.branches ?? []).map((branch, i) => ({
161 key: `branch:${i}`,
162 label: branch.label?.trim() ? branch.label : `Branch ${i + 1}`,
163 nextStepId: branch.nextStepId ?? null,
164 setNext (id)
165 {
166 branch.nextStepId = id;
167 }
168 }));
169 }
170 return [];
171 }
172
173 function portWorldPos (step, index, portIndex, kind)
174 {
175 const pos = stepPosition(step, index);
176 if (kind === "in")
177 {
178 return { x: pos.x + CARD_W / 2, y: pos.y };
179 }
180 const ports = outputPorts(step);
181 const n = Math.max(1, ports.length);
182 const spacing = CARD_W / (n + 1);
183 return {
184 x: pos.x + spacing * (portIndex + 1),
185 y: pos.y + CARD_H
186 };
187 }
188
189 function bezier (x1, y1, x2, y2)
190 {
191 const dy = Math.max(40, Math.abs(y2 - y1) * 0.45);
192 return `M ${x1} ${y1} C ${x1} ${y1 + dy}, ${x2} ${y2 - dy}, ${x2} ${y2}`;
193 }
194
195 function clearWiring ()
196 {
197 wiring = null;
198 rubberPath.setAttribute("d", "");
199 rubberPath.classList.remove("active");
200 wrap.classList.remove("dialogue-canvas-wiring");
201 for (const el of cardsLayer.querySelectorAll(".dialogue-canvas-input.show"))
202 { el.classList.remove("show"); }
203 }
204
205 function setWiring (stepId, portIndex, portKey)
206 {
207 wiring = { stepId, portIndex, portKey };
208 wrap.classList.add("dialogue-canvas-wiring");
209 for (const el of cardsLayer.querySelectorAll(".dialogue-canvas-input"))
210 {
211 if (el.getAttribute("data-step-id") !== stepId)
212 { el.classList.add("show"); }
213 }
214 }
215
216 function stopAutoPan ()
217 {
218 if (autoPanRaf != null)
219 {
220 cancelAnimationFrame(autoPanRaf);
221 autoPanRaf = null;
222 }
223 }
224
225 function tickAutoPan ()
226 {
227 autoPanRaf = null;
228 if (!drag || drag.mode !== "card")
229 { return; }
230 const rect = viewport.getBoundingClientRect();
231 let dx = 0;
232 let dy = 0;
233 if (lastPointer.x < rect.left + EDGE_PAD)
234 { dx = AUTO_PAN; }
235 else if (lastPointer.x > rect.right - EDGE_PAD)
236 { dx = -AUTO_PAN; }
237 if (lastPointer.y < rect.top + EDGE_PAD)
238 { dy = AUTO_PAN; }
239 else if (lastPointer.y > rect.bottom - EDGE_PAD)
240 { dy = -AUTO_PAN; }
241 if (dx || dy)
242 {
243 view.x += dx;
244 view.y += dy;
245 applyTransform();
246 const worldPt = clientToWorld(lastPointer.x, lastPointer.y);
247 drag.step.editorX = worldPt.x - CARD_W / 2;
248 drag.step.editorY = worldPt.y - CARD_H / 2;
249 refreshCardsOnly();
250 redrawEdges();
251 }
252 autoPanRaf = requestAnimationFrame(tickAutoPan);
253 }
254
255 function redrawEdges ()
256 {
257 const draft = getDraft();
258 for (const el of [...edgesSvg.children])
259 {
260 if (el !== rubberPath)
261 { el.remove(); }
262 }
263 if (rubberPath.parentNode !== edgesSvg)
264 { edgesSvg.append(rubberPath); }
265 if (!draft?.steps?.length)
266 { return; }
267 draft.steps.forEach((step, index) =>
268 {
269 const ports = outputPorts(step);
270 ports.forEach((port, portIndex) =>
271 {
272 if (!port.nextStepId)
273 { return; }
274 const targetIndex = draft.steps.findIndex((s) => s.stepId === port.nextStepId);
275 if (targetIndex < 0)
276 { return; }
277 const from = portWorldPos(step, index, portIndex, "out");
278 const to = portWorldPos(draft.steps[targetIndex], targetIndex, 0, "in");
279 const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
280 path.classList.add("dialogue-canvas-edge");
281 const rewiring = !!wiring
282 && wiring.stepId === step.stepId
283 && wiring.portIndex === portIndex;
284 if (rewiring)
285 { path.classList.add("is-rewiring"); }
286 path.setAttribute("d", bezier(from.x, from.y, to.x, to.y));
287 path.setAttribute("fill", "none");
288 edgesSvg.insertBefore(path, rubberPath);
289 });
290 });
291 }
292
293 function refreshCardsOnly ()
294 {
295 const draft = getDraft();
296 if (!draft)
297 {
298 cardsLayer.replaceChildren();
299 return;
300 }
301 const existing = new Map(
302 [...cardsLayer.querySelectorAll(".dialogue-canvas-card")]
303 .map((el) => [el.getAttribute("data-step-id"), el])
304 );
305 const keep = new Set();
306 draft.steps.forEach((step, index) =>
307 {
308 keep.add(step.stepId);
309 let card = existing.get(step.stepId);
310 if (!card)
311 {
312 card = buildCard(step, index);
313 cardsLayer.append(card);
314 }
315 else
316 { updateCard(card, step, index); }
317 const pos = stepPosition(step, index);
318 card.style.left = `${pos.x}px`;
319 card.style.top = `${pos.y}px`;
320 });
321 for (const [id, el] of existing)
322 {
323 if (!keep.has(id))
324 { el.remove(); }
325 }
326 }
327
328 function buildCard (step, index)
329 {
330 const card = document.createElement("div");
331 card.className = "dialogue-canvas-card";
332 card.setAttribute("data-step-id", step.stepId);
333
334 const input = document.createElement("button");
335 input.type = "button";
336 input.className = "dialogue-canvas-input";
337 input.title = "Connect here";
338 input.setAttribute("data-step-id", step.stepId);
339 input.addEventListener("pointerdown", (event) =>
340 {
341 event.stopPropagation();
342 event.preventDefault();
343 if (!wiring)
344 { return; }
345 if (wiring.stepId === step.stepId)
346 { return; }
347 const draft = getDraft();
348 const from = draft?.steps?.find((s) => s.stepId === wiring.stepId);
349 if (!from)
350 { return; }
351 const ports = outputPorts(from);
352 const port = ports[wiring.portIndex];
353 if (!port)
354 { return; }
355 port.setNext(step.stepId);
356 clearWiring();
357 onChange();
358 refresh();
359 });
360
361 const label = document.createElement("div");
362 label.className = "dialogue-canvas-card-label";
363
364 const meta = document.createElement("div");
365 meta.className = "dialogue-canvas-card-meta";
366
367 const portsRow = document.createElement("div");
368 portsRow.className = "dialogue-canvas-ports";
369
370 card.append(input, label, meta, portsRow);
371
372 card.addEventListener("pointerdown", (event) =>
373 {
374 if (event.button !== 0)
375 { return; }
376 if (event.target.closest(".dialogue-canvas-port, .dialogue-canvas-input"))
377 { return; }
378 event.preventDefault();
379 hideContext();
380 const draft = getDraft();
381 const live = draft?.steps?.find((s) => s.stepId === step.stepId);
382 if (!live)
383 { return; }
384 const pos = stepPosition(live, draft.steps.indexOf(live));
385 if (!Number.isFinite(live.editorX))
386 { live.editorX = pos.x; }
387 if (!Number.isFinite(live.editorY))
388 { live.editorY = pos.y; }
389 drag = {
390 mode: "card",
391 startClientX: event.clientX,
392 startClientY: event.clientY,
393 step: live,
394 originEditorX: live.editorX,
395 originEditorY: live.editorY,
396 moved: false
397 };
398 lastPointer = { x: event.clientX, y: event.clientY };
399 card.classList.add("dragging");
400 card.setPointerCapture(event.pointerId);
401 stopAutoPan();
402 autoPanRaf = requestAnimationFrame(tickAutoPan);
403 });
404
405 updateCard(card, step, index);
406 return card;
407 }
408
409 function updateCard (card, step, index)
410 {
411 card.setAttribute("data-step-id", step.stepId);
412 const draft = getDraft();
413 const isEntry = draft && (draft.entryStepId === step.stepId
414 || (!draft.entryStepId && draft.steps[0] === step));
415 card.classList.toggle("is-entry", !!isEntry);
416 const label = card.querySelector(".dialogue-canvas-card-label");
417 if (label)
418 { label.textContent = step.label || step.stepId; }
419 const meta = card.querySelector(".dialogue-canvas-card-meta");
420 if (meta)
421 {
422 const kind = step.exit?.kind ?? "end";
423 meta.textContent = isEntry ? `entry · ${kind}` : kind;
424 }
425 const input = card.querySelector(".dialogue-canvas-input");
426 if (input)
427 {
428 input.setAttribute("data-step-id", step.stepId);
429 input.classList.toggle("show", !!wiring && wiring.stepId !== step.stepId);
430 }
431 const portsRow = card.querySelector(".dialogue-canvas-ports");
432 if (!portsRow)
433 { return; }
434 portsRow.replaceChildren();
435 const ports = outputPorts(step);
436 ports.forEach((port, portIndex) =>
437 {
438 const btn = document.createElement("button");
439 btn.type = "button";
440 btn.className = "dialogue-canvas-port";
441 btn.title = port.label;
442 btn.classList.toggle("linked", !!port.nextStepId);
443 btn.classList.toggle("selected",
444 !!wiring && wiring.stepId === step.stepId && wiring.portIndex === portIndex);
445 btn.addEventListener("pointerdown", (event) =>
446 {
447 event.stopPropagation();
448 event.preventDefault();
449 hideContext();
450 // Clicking an output always starts/continues wire mode (existing link stays until
451 // a new input is chosen; that edge is drawn red via is-rewiring).
452 setWiring(step.stepId, portIndex, port.key);
453 drag = {
454 mode: "wire",
455 startClientX: event.clientX,
456 startClientY: event.clientY,
457 moved: false,
458 fromStepId: step.stepId,
459 portIndex,
460 portKey: port.key
461 };
462 const from = portWorldPos(step, index, portIndex, "out");
463 const worldPt = clientToWorld(event.clientX, event.clientY);
464 rubberPath.classList.add("active");
465 rubberPath.setAttribute("d", bezier(from.x, from.y, worldPt.x, worldPt.y));
466 refreshCardsOnly();
467 redrawEdges();
468 });
469 btn.addEventListener("pointerenter", (event) =>
470 {
471 showTooltip(port.label, event.clientX, event.clientY);
472 });
473 btn.addEventListener("pointerleave", () => hideTooltip());
474 btn.addEventListener("pointermove", (event) =>
475 {
476 showTooltip(port.label, event.clientX, event.clientY);
477 });
478 portsRow.append(btn);
479 });
480 }
481
482 function refresh ()
483 {
484 applyTransform();
485 refreshCardsOnly();
486 redrawEdges();
487 }
488
489 function onPointerMove (event)
490 {
491 lastPointer = { x: event.clientX, y: event.clientY };
492 if (!drag)
493 {
494 if (wiring)
495 {
496 const draft = getDraft();
497 const fromStep = draft?.steps?.find((s) => s.stepId === wiring.stepId);
498 if (!fromStep)
499 { return; }
500 const index = draft.steps.indexOf(fromStep);
501 const from = portWorldPos(fromStep, index, wiring.portIndex, "out");
502 const worldPt = clientToWorld(event.clientX, event.clientY);
503 rubberPath.setAttribute("d", bezier(from.x, from.y, worldPt.x, worldPt.y));
504 }
505 return;
506 }
507 const dx = event.clientX - drag.startClientX;
508 const dy = event.clientY - drag.startClientY;
509 if (Math.hypot(dx, dy) > 4)
510 { drag.moved = true; }
511 if (drag.mode === "pan")
512 {
513 view.x = drag.originViewX + dx;
514 view.y = drag.originViewY + dy;
515 applyTransform();
516 return;
517 }
518 if (drag.mode === "card")
519 {
520 drag.step.editorX = drag.originEditorX + dx / view.zoom;
521 drag.step.editorY = drag.originEditorY + dy / view.zoom;
522 refreshCardsOnly();
523 redrawEdges();
524 return;
525 }
526 if (drag.mode === "wire")
527 {
528 const draft = getDraft();
529 const fromStep = draft?.steps?.find((s) => s.stepId === drag.fromStepId);
530 if (!fromStep)
531 { return; }
532 const index = draft.steps.indexOf(fromStep);
533 const from = portWorldPos(fromStep, index, drag.portIndex, "out");
534 const worldPt = clientToWorld(event.clientX, event.clientY);
535 rubberPath.setAttribute("d", bezier(from.x, from.y, worldPt.x, worldPt.y));
536 }
537 }
538
539 function onPointerUp (event)
540 {
541 if (!drag)
542 { return; }
543 const finished = drag;
544 drag = null;
545 stopAutoPan();
546 for (const el of cardsLayer.querySelectorAll(".dragging"))
547 { el.classList.remove("dragging"); }
548 if (finished.mode === "card")
549 {
550 if (!finished.moved)
551 { onOpenStep(finished.step.stepId); }
552 else
553 { onChange(); }
554 refresh();
555 return;
556 }
557 if (finished.mode === "wire")
558 {
559 // Keep wiring selected until input click or cancel
560 if (!wiring)
561 { clearWiring(); }
562 refresh();
563 return;
564 }
565 if (finished.mode === "pan" && !finished.moved && event.button === 0)
566 {
567 clearWiring();
568 refresh();
569 }
570 }
571
572 viewport.addEventListener("pointerdown", (event) =>
573 {
574 if (event.button === 2)
575 { return; }
576 if (event.button !== 0)
577 { return; }
578 if (event.target.closest(".dialogue-canvas-card, .dialogue-canvas-context"))
579 { return; }
580 hideContext();
581 drag = {
582 mode: "pan",
583 startClientX: event.clientX,
584 startClientY: event.clientY,
585 originViewX: view.x,
586 originViewY: view.y,
587 moved: false
588 };
589 viewport.setPointerCapture(event.pointerId);
590 });
591
592 viewport.addEventListener("contextmenu", (event) =>
593 {
594 event.preventDefault();
595 // RMB cancels an in-progress wire/rewire.
596 if (wiring)
597 {
598 clearWiring();
599 hideContext();
600 refresh();
601 return;
602 }
603 if (event.target.closest(".dialogue-canvas-card"))
604 { return; }
605 const worldPt = clientToWorld(event.clientX, event.clientY);
606 ctxWorld = worldPt;
607 const rect = wrap.getBoundingClientRect();
608 ctxMenu.hidden = false;
609 ctxMenu.style.left = `${event.clientX - rect.left}px`;
610 ctxMenu.style.top = `${event.clientY - rect.top}px`;
611 });
612
613 createBtn.addEventListener("click", () =>
614 {
615 hideContext();
616 onCreateStep(ctxWorld.x, ctxWorld.y);
617 });
618
619 viewport.addEventListener("wheel", (event) =>
620 {
621 event.preventDefault();
622 const rect = viewport.getBoundingClientRect();
623 const mx = event.clientX - rect.left;
624 const my = event.clientY - rect.top;
625 const before = {
626 x: (mx - view.x) / view.zoom,
627 y: (my - view.y) / view.zoom
628 };
629 const factor = event.deltaY < 0 ? 1.08 : 1 / 1.08;
630 view.zoom = Math.min(MAX_ZOOM, Math.max(MIN_ZOOM, view.zoom * factor));
631 view.x = mx - before.x * view.zoom;
632 view.y = my - before.y * view.zoom;
633 applyTransform();
634 }, { passive: false });
635
636 window.addEventListener("pointermove", onPointerMove);
637 window.addEventListener("pointerup", onPointerUp);
638 window.addEventListener("pointercancel", onPointerUp);
639 window.addEventListener("keydown", (event) =>
640 {
641 if (event.key === "Escape")
642 {
643 clearWiring();
644 hideContext();
645 refresh();
646 }
647 });
648
649 applyTransform();
650
651 return {
652 el: wrap,
653 refresh,
654 clearWiring: () =>
655 {
656 clearWiring();
657 refresh();
658 },
659 destroy ()
660 {
661 stopAutoPan();
662 window.removeEventListener("pointermove", onPointerMove);
663 window.removeEventListener("pointerup", onPointerUp);
664 window.removeEventListener("pointercancel", onPointerUp);
665 wrap.remove();
666 }
667 };
668}
669
670export function blankDialogueStep (stepId, editorX, editorY)
671{
672 const step = {
673 stepId,
674 label: stepId,
675 lines: [{ speaker: "npc", text: "…", effects: [] }],
676 itemRewards: [],
677 itemTakes: [],
678 questRewards: [],
679 exit: { kind: "end" }
680 };
681 if (Number.isFinite(editorX))
682 { step.editorX = editorX; }
683 if (Number.isFinite(editorY))
684 { step.editorY = editorY; }
685 return step;
686}
687
688/** Clear nextStepId references to a deleted step. */
689export function scrubDialogueStepLinks (draft, removedStepId)
690{
691 if (!draft?.steps)
692 { return; }
693 for (const step of draft.steps)
694 {
695 const exit = step.exit;
696 if (!exit)
697 { continue; }
698 if (exit.kind === "continue" && exit.nextStepId === removedStepId)
699 { exit.nextStepId = null; }
700 if (exit.kind === "triggers")
701 {
702 for (const trig of exit.triggers ?? [])
703 {
704 if (trig.nextStepId === removedStepId)
705 { trig.nextStepId = null; }
706 }
707 }
708 if (exit.kind === "branches")
709 {
710 for (const branch of exit.branches ?? [])
711 {
712 if (branch.nextStepId === removedStepId)
713 { branch.nextStepId = null; }
714 }
715 }
716 }
717}
718
719export function stepHasEdges (draft, step)
720{
721 const exit = step?.exit ?? { kind: "end" };
722 let outgoing = false;
723 if (exit.kind === "continue")
724 { outgoing = !!exit.nextStepId; }
725 else if (exit.kind === "triggers")
726 { outgoing = (exit.triggers ?? []).some((t) => !!t.nextStepId); }
727 else if (exit.kind === "branches")
728 { outgoing = (exit.branches ?? []).some((b) => !!b.nextStepId); }
729 const incoming = (draft?.steps ?? []).some((other) =>
730 {
731 if (other === step)
732 { return false; }
733 const e = other.exit;
734 if (!e)
735 { return false; }
736 if (e.kind === "continue")
737 { return e.nextStepId === step.stepId; }
738 if (e.kind === "triggers")
739 { return (e.triggers ?? []).some((t) => t.nextStepId === step.stepId); }
740 if (e.kind === "branches")
741 { return (e.branches ?? []).some((b) => b.nextStepId === step.stepId); }
742 return false;
743 });
744 return incoming || outgoing;
745}