BlueGit

timfa questward

Files

questward / client / src / editor / dialogueCanvas.js

dialogueCanvas.js

dialogueCanvas.js 18.9 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 path.setAttribute("d", bezier(from.x, from.y, to.x, to.y));
282 path.setAttribute("fill", "none");
283 edgesSvg.insertBefore(path, rubberPath);
284 });
285 });
286 }
287
288 function refreshCardsOnly ()
289 {
290 const draft = getDraft();
291 if (!draft)
292 {
293 cardsLayer.replaceChildren();
294 return;
295 }
296 const existing = new Map(
297 [...cardsLayer.querySelectorAll(".dialogue-canvas-card")]
298 .map((el) => [el.getAttribute("data-step-id"), el])
299 );
300 const keep = new Set();
301 draft.steps.forEach((step, index) =>
302 {
303 keep.add(step.stepId);
304 let card = existing.get(step.stepId);
305 if (!card)
306 {
307 card = buildCard(step, index);
308 cardsLayer.append(card);
309 }
310 else
311 { updateCard(card, step, index); }
312 const pos = stepPosition(step, index);
313 card.style.left = `${pos.x}px`;
314 card.style.top = `${pos.y}px`;
315 });
316 for (const [id, el] of existing)
317 {
318 if (!keep.has(id))
319 { el.remove(); }
320 }
321 }
322
323 function buildCard (step, index)
324 {
325 const card = document.createElement("div");
326 card.className = "dialogue-canvas-card";
327 card.setAttribute("data-step-id", step.stepId);
328
329 const input = document.createElement("button");
330 input.type = "button";
331 input.className = "dialogue-canvas-input";
332 input.title = "Connect here";
333 input.setAttribute("data-step-id", step.stepId);
334 input.addEventListener("pointerdown", (event) =>
335 {
336 event.stopPropagation();
337 event.preventDefault();
338 if (!wiring)
339 { return; }
340 if (wiring.stepId === step.stepId)
341 { return; }
342 const draft = getDraft();
343 const from = draft?.steps?.find((s) => s.stepId === wiring.stepId);
344 if (!from)
345 { return; }
346 const ports = outputPorts(from);
347 const port = ports[wiring.portIndex];
348 if (!port)
349 { return; }
350 port.setNext(step.stepId);
351 clearWiring();
352 onChange();
353 refresh();
354 });
355
356 const label = document.createElement("div");
357 label.className = "dialogue-canvas-card-label";
358
359 const meta = document.createElement("div");
360 meta.className = "dialogue-canvas-card-meta";
361
362 const portsRow = document.createElement("div");
363 portsRow.className = "dialogue-canvas-ports";
364
365 card.append(input, label, meta, portsRow);
366
367 card.addEventListener("pointerdown", (event) =>
368 {
369 if (event.button !== 0)
370 { return; }
371 if (event.target.closest(".dialogue-canvas-port, .dialogue-canvas-input"))
372 { return; }
373 event.preventDefault();
374 hideContext();
375 const draft = getDraft();
376 const live = draft?.steps?.find((s) => s.stepId === step.stepId);
377 if (!live)
378 { return; }
379 const pos = stepPosition(live, draft.steps.indexOf(live));
380 if (!Number.isFinite(live.editorX))
381 { live.editorX = pos.x; }
382 if (!Number.isFinite(live.editorY))
383 { live.editorY = pos.y; }
384 drag = {
385 mode: "card",
386 startClientX: event.clientX,
387 startClientY: event.clientY,
388 step: live,
389 originEditorX: live.editorX,
390 originEditorY: live.editorY,
391 moved: false
392 };
393 lastPointer = { x: event.clientX, y: event.clientY };
394 card.classList.add("dragging");
395 card.setPointerCapture(event.pointerId);
396 stopAutoPan();
397 autoPanRaf = requestAnimationFrame(tickAutoPan);
398 });
399
400 updateCard(card, step, index);
401 return card;
402 }
403
404 function updateCard (card, step, index)
405 {
406 card.setAttribute("data-step-id", step.stepId);
407 const draft = getDraft();
408 const isEntry = draft && (draft.entryStepId === step.stepId
409 || (!draft.entryStepId && draft.steps[0] === step));
410 card.classList.toggle("is-entry", !!isEntry);
411 const label = card.querySelector(".dialogue-canvas-card-label");
412 if (label)
413 { label.textContent = step.label || step.stepId; }
414 const meta = card.querySelector(".dialogue-canvas-card-meta");
415 if (meta)
416 {
417 const kind = step.exit?.kind ?? "end";
418 meta.textContent = isEntry ? `entry · ${kind}` : kind;
419 }
420 const input = card.querySelector(".dialogue-canvas-input");
421 if (input)
422 {
423 input.setAttribute("data-step-id", step.stepId);
424 input.classList.toggle("show", !!wiring && wiring.stepId !== step.stepId);
425 }
426 const portsRow = card.querySelector(".dialogue-canvas-ports");
427 if (!portsRow)
428 { return; }
429 portsRow.replaceChildren();
430 const ports = outputPorts(step);
431 ports.forEach((port, portIndex) =>
432 {
433 const btn = document.createElement("button");
434 btn.type = "button";
435 btn.className = "dialogue-canvas-port";
436 btn.title = port.label;
437 btn.classList.toggle("linked", !!port.nextStepId);
438 btn.classList.toggle("selected",
439 !!wiring && wiring.stepId === step.stepId && wiring.portIndex === portIndex);
440 btn.addEventListener("pointerdown", (event) =>
441 {
442 event.stopPropagation();
443 event.preventDefault();
444 hideContext();
445 if (wiring && wiring.stepId === step.stepId && wiring.portIndex === portIndex)
446 {
447 clearWiring();
448 refresh();
449 return;
450 }
451 setWiring(step.stepId, portIndex, port.key);
452 drag = {
453 mode: "wire",
454 startClientX: event.clientX,
455 startClientY: event.clientY,
456 moved: false,
457 fromStepId: step.stepId,
458 portIndex,
459 portKey: port.key
460 };
461 const from = portWorldPos(step, index, portIndex, "out");
462 const worldPt = clientToWorld(event.clientX, event.clientY);
463 rubberPath.classList.add("active");
464 rubberPath.setAttribute("d", bezier(from.x, from.y, worldPt.x, worldPt.y));
465 refreshCardsOnly();
466 });
467 btn.addEventListener("pointerenter", (event) =>
468 {
469 showTooltip(port.label, event.clientX, event.clientY);
470 });
471 btn.addEventListener("pointerleave", () => hideTooltip());
472 btn.addEventListener("pointermove", (event) =>
473 {
474 showTooltip(port.label, event.clientX, event.clientY);
475 });
476 portsRow.append(btn);
477 });
478 }
479
480 function refresh ()
481 {
482 applyTransform();
483 refreshCardsOnly();
484 redrawEdges();
485 }
486
487 function onPointerMove (event)
488 {
489 lastPointer = { x: event.clientX, y: event.clientY };
490 if (!drag)
491 {
492 if (wiring)
493 {
494 const draft = getDraft();
495 const fromStep = draft?.steps?.find((s) => s.stepId === wiring.stepId);
496 if (!fromStep)
497 { return; }
498 const index = draft.steps.indexOf(fromStep);
499 const from = portWorldPos(fromStep, index, wiring.portIndex, "out");
500 const worldPt = clientToWorld(event.clientX, event.clientY);
501 rubberPath.setAttribute("d", bezier(from.x, from.y, worldPt.x, worldPt.y));
502 }
503 return;
504 }
505 const dx = event.clientX - drag.startClientX;
506 const dy = event.clientY - drag.startClientY;
507 if (Math.hypot(dx, dy) > 4)
508 { drag.moved = true; }
509 if (drag.mode === "pan")
510 {
511 view.x = drag.originViewX + dx;
512 view.y = drag.originViewY + dy;
513 applyTransform();
514 return;
515 }
516 if (drag.mode === "card")
517 {
518 drag.step.editorX = drag.originEditorX + dx / view.zoom;
519 drag.step.editorY = drag.originEditorY + dy / view.zoom;
520 refreshCardsOnly();
521 redrawEdges();
522 return;
523 }
524 if (drag.mode === "wire")
525 {
526 const draft = getDraft();
527 const fromStep = draft?.steps?.find((s) => s.stepId === drag.fromStepId);
528 if (!fromStep)
529 { return; }
530 const index = draft.steps.indexOf(fromStep);
531 const from = portWorldPos(fromStep, index, drag.portIndex, "out");
532 const worldPt = clientToWorld(event.clientX, event.clientY);
533 rubberPath.setAttribute("d", bezier(from.x, from.y, worldPt.x, worldPt.y));
534 }
535 }
536
537 function onPointerUp (event)
538 {
539 if (!drag)
540 { return; }
541 const finished = drag;
542 drag = null;
543 stopAutoPan();
544 for (const el of cardsLayer.querySelectorAll(".dragging"))
545 { el.classList.remove("dragging"); }
546 if (finished.mode === "card")
547 {
548 if (!finished.moved)
549 { onOpenStep(finished.step.stepId); }
550 else
551 { onChange(); }
552 refresh();
553 return;
554 }
555 if (finished.mode === "wire")
556 {
557 // Keep wiring selected until input click or cancel
558 if (!wiring)
559 { clearWiring(); }
560 refresh();
561 return;
562 }
563 if (finished.mode === "pan" && !finished.moved && event.button === 0)
564 {
565 clearWiring();
566 refresh();
567 }
568 }
569
570 viewport.addEventListener("pointerdown", (event) =>
571 {
572 if (event.button === 2)
573 { return; }
574 if (event.button !== 0)
575 { return; }
576 if (event.target.closest(".dialogue-canvas-card, .dialogue-canvas-context"))
577 { return; }
578 hideContext();
579 drag = {
580 mode: "pan",
581 startClientX: event.clientX,
582 startClientY: event.clientY,
583 originViewX: view.x,
584 originViewY: view.y,
585 moved: false
586 };
587 viewport.setPointerCapture(event.pointerId);
588 });
589
590 viewport.addEventListener("contextmenu", (event) =>
591 {
592 event.preventDefault();
593 if (event.target.closest(".dialogue-canvas-card"))
594 { return; }
595 const worldPt = clientToWorld(event.clientX, event.clientY);
596 ctxWorld = worldPt;
597 const rect = wrap.getBoundingClientRect();
598 ctxMenu.hidden = false;
599 ctxMenu.style.left = `${event.clientX - rect.left}px`;
600 ctxMenu.style.top = `${event.clientY - rect.top}px`;
601 });
602
603 createBtn.addEventListener("click", () =>
604 {
605 hideContext();
606 onCreateStep(ctxWorld.x, ctxWorld.y);
607 });
608
609 viewport.addEventListener("wheel", (event) =>
610 {
611 event.preventDefault();
612 const rect = viewport.getBoundingClientRect();
613 const mx = event.clientX - rect.left;
614 const my = event.clientY - rect.top;
615 const before = {
616 x: (mx - view.x) / view.zoom,
617 y: (my - view.y) / view.zoom
618 };
619 const factor = event.deltaY < 0 ? 1.08 : 1 / 1.08;
620 view.zoom = Math.min(MAX_ZOOM, Math.max(MIN_ZOOM, view.zoom * factor));
621 view.x = mx - before.x * view.zoom;
622 view.y = my - before.y * view.zoom;
623 applyTransform();
624 }, { passive: false });
625
626 window.addEventListener("pointermove", onPointerMove);
627 window.addEventListener("pointerup", onPointerUp);
628 window.addEventListener("pointercancel", onPointerUp);
629 window.addEventListener("keydown", (event) =>
630 {
631 if (event.key === "Escape")
632 {
633 clearWiring();
634 hideContext();
635 refresh();
636 }
637 });
638
639 applyTransform();
640
641 return {
642 el: wrap,
643 refresh,
644 clearWiring: () =>
645 {
646 clearWiring();
647 refresh();
648 },
649 destroy ()
650 {
651 stopAutoPan();
652 window.removeEventListener("pointermove", onPointerMove);
653 window.removeEventListener("pointerup", onPointerUp);
654 window.removeEventListener("pointercancel", onPointerUp);
655 wrap.remove();
656 }
657 };
658}
659
660export function blankDialogueStep (stepId, editorX, editorY)
661{
662 const step = {
663 stepId,
664 label: stepId,
665 lines: [{ speaker: "npc", text: "…", effects: [] }],
666 itemRewards: [],
667 itemTakes: [],
668 questRewards: [],
669 exit: { kind: "end" }
670 };
671 if (Number.isFinite(editorX))
672 { step.editorX = editorX; }
673 if (Number.isFinite(editorY))
674 { step.editorY = editorY; }
675 return step;
676}
677
678/** Clear nextStepId references to a deleted step. */
679export function scrubDialogueStepLinks (draft, removedStepId)
680{
681 if (!draft?.steps)
682 { return; }
683 for (const step of draft.steps)
684 {
685 const exit = step.exit;
686 if (!exit)
687 { continue; }
688 if (exit.kind === "continue" && exit.nextStepId === removedStepId)
689 { exit.nextStepId = null; }
690 if (exit.kind === "triggers")
691 {
692 for (const trig of exit.triggers ?? [])
693 {
694 if (trig.nextStepId === removedStepId)
695 { trig.nextStepId = null; }
696 }
697 }
698 if (exit.kind === "branches")
699 {
700 for (const branch of exit.branches ?? [])
701 {
702 if (branch.nextStepId === removedStepId)
703 { branch.nextStepId = null; }
704 }
705 }
706 }
707}
708
709export function stepHasEdges (draft, step)
710{
711 const exit = step?.exit ?? { kind: "end" };
712 let outgoing = false;
713 if (exit.kind === "continue")
714 { outgoing = !!exit.nextStepId; }
715 else if (exit.kind === "triggers")
716 { outgoing = (exit.triggers ?? []).some((t) => !!t.nextStepId); }
717 else if (exit.kind === "branches")
718 { outgoing = (exit.branches ?? []).some((b) => !!b.nextStepId); }
719 const incoming = (draft?.steps ?? []).some((other) =>
720 {
721 if (other === step)
722 { return false; }
723 const e = other.exit;
724 if (!e)
725 { return false; }
726 if (e.kind === "continue")
727 { return e.nextStepId === step.stepId; }
728 if (e.kind === "triggers")
729 { return (e.triggers ?? []).some((t) => t.nextStepId === step.stepId); }
730 if (e.kind === "branches")
731 { return (e.branches ?? []).some((b) => b.nextStepId === step.stepId); }
732 return false;
733 });
734 return incoming || outgoing;
735}