302 lines
12 KiB
JavaScript
302 lines
12 KiB
JavaScript
"use strict";
|
|
|
|
// Layer: ui/physics-shape-editor
|
|
// Shared button labels/templates for rotator, reciprocator, and poison-block
|
|
// segment editors. Low-level editor pointer behavior remains in placement log.
|
|
(function (global) {
|
|
const MODE_LABELS = Object.freeze({
|
|
line: "\uD83D\uDCCF \u76F4\u7DDA",
|
|
free: "\u270E \u81EA\u7531\u63CF\u753B",
|
|
erase: "\u232B \u6D88\u3057\u30B4\u30E0",
|
|
});
|
|
const TEMPLATE_LABELS = Object.freeze({
|
|
bar: "\u2503 \u68D2",
|
|
cross: "\uFF0B \u5341\u5B57",
|
|
circle: "\u25CB \u5186",
|
|
});
|
|
const ACTION_LABELS = Object.freeze({
|
|
undo: "\u21B6 \u4E00\u3064\u623B\u3059",
|
|
clear: "\uD83D\uDDD1 \u5168\u6D88\u3057",
|
|
});
|
|
function templateSegments(name) {
|
|
if (name === "bar") return [[-130, 0, 130, 0]];
|
|
if (name === "cross") return [[-118, 0, 118, 0], [0, -90, 0, 90]];
|
|
if (name === "circle") {
|
|
const segments = [];
|
|
const n = 18, r = 108;
|
|
for (let i = 0; i < n; i += 1) {
|
|
const a = i / n * Math.PI * 2;
|
|
const b = (i + 1) / n * Math.PI * 2;
|
|
segments.push([Math.cos(a) * r, Math.sin(a) * r, Math.cos(b) * r, Math.sin(b) * r]);
|
|
}
|
|
return segments;
|
|
}
|
|
return null;
|
|
}
|
|
function decorateToolbar(dialog, prefix = "rotator") {
|
|
if (!dialog) return false;
|
|
for (const btn of dialog.querySelectorAll(`[data-${prefix}-mode]`)) {
|
|
const key = btn.dataset[`${prefix}Mode`];
|
|
if (MODE_LABELS[key]) { btn.textContent = MODE_LABELS[key]; btn.title = MODE_LABELS[key].replace(/^[^\s]+\s*/, ""); }
|
|
}
|
|
for (const btn of dialog.querySelectorAll(`[data-${prefix}-template]`)) {
|
|
const key = btn.dataset[`${prefix}Template`];
|
|
if (TEMPLATE_LABELS[key]) { btn.textContent = TEMPLATE_LABELS[key]; btn.title = TEMPLATE_LABELS[key].replace(/^[^\s]+\s*/, ""); }
|
|
}
|
|
const undo = dialog.querySelector(`#${prefix}Undo`);
|
|
const clear = dialog.querySelector(`#${prefix}Clear`);
|
|
if (undo) undo.textContent = ACTION_LABELS.undo;
|
|
if (clear) clear.textContent = ACTION_LABELS.clear;
|
|
return true;
|
|
}
|
|
function pointSegmentDistance(p, seg) {
|
|
if (!p || !Array.isArray(seg) || seg.length < 4) return Infinity;
|
|
return global.TarinaiGeometry.pointSegmentDistance(p.x, p.y, seg[0], seg[1], seg[2], seg[3]);
|
|
}
|
|
|
|
function canvasLocalPoint(canvas, e, cx = canvas?.width / 2 || 0, cy = canvas?.height / 2 || 0) {
|
|
if (!canvas || !e) return { x: 0, y: 0 };
|
|
const rect = canvas.getBoundingClientRect();
|
|
const sx = canvas.width / Math.max(1, rect.width);
|
|
const sy = canvas.height / Math.max(1, rect.height);
|
|
return { x: (e.clientX - rect.left) * sx - cx, y: (e.clientY - rect.top) * sy - cy };
|
|
}
|
|
|
|
function cleanSegments(segments = [], opts = {}) {
|
|
const limit = Math.max(1, Number(opts.limit || 96) || 96);
|
|
const bound = Math.max(1, Number(opts.bound || 420) || 420);
|
|
const minLength = Math.max(0, Number(opts.minLength || 4) || 4);
|
|
const fallback = Array.isArray(opts.fallback) ? opts.fallback : [-78, 0, 78, 0];
|
|
const out = [];
|
|
for (const seg of segments || []) {
|
|
if (!Array.isArray(seg) || seg.length < 4) continue;
|
|
const x1 = Math.max(-bound, Math.min(bound, Number(seg[0]) || 0));
|
|
const y1 = Math.max(-bound, Math.min(bound, Number(seg[1]) || 0));
|
|
const x2 = Math.max(-bound, Math.min(bound, Number(seg[2]) || 0));
|
|
const y2 = Math.max(-bound, Math.min(bound, Number(seg[3]) || 0));
|
|
if (Math.hypot(x2 - x1, y2 - y1) >= minLength) out.push([x1, y1, x2, y2]);
|
|
if (out.length >= limit) break;
|
|
}
|
|
if (!out.length) out.push(fallback.slice(0, 4));
|
|
return out;
|
|
}
|
|
|
|
function drawEditorBase(ctx, canvas, cx = canvas?.width / 2 || 0, cy = canvas?.height / 2 || 0) {
|
|
if (!ctx || !canvas) return false;
|
|
ctx.clearRect(0, 0, canvas.width, canvas.height);
|
|
ctx.save();
|
|
ctx.fillStyle = "#f7f3ea";
|
|
ctx.fillRect(0, 0, canvas.width, canvas.height);
|
|
ctx.translate(cx, cy);
|
|
ctx.strokeStyle = "rgba(100,80,60,0.16)";
|
|
ctx.lineWidth = 1;
|
|
for (let x = -cx; x <= cx; x += 40) { ctx.beginPath(); ctx.moveTo(x, -cy); ctx.lineTo(x, cy); ctx.stroke(); }
|
|
for (let y = -cy; y <= cy; y += 40) { ctx.beginPath(); ctx.moveTo(-cx, y); ctx.lineTo(cx, y); ctx.stroke(); }
|
|
ctx.strokeStyle = "rgba(70,60,50,0.38)";
|
|
ctx.lineWidth = 1.5;
|
|
ctx.beginPath(); ctx.moveTo(-cx, 0); ctx.lineTo(cx, 0); ctx.moveTo(0, -cy); ctx.lineTo(0, cy); ctx.stroke();
|
|
return true;
|
|
}
|
|
|
|
function drawSegments(ctx, segments = [], opts = {}) {
|
|
if (!ctx) return false;
|
|
const lineWidth = Math.max(1, Number(opts.lineWidth || 12) || 12);
|
|
ctx.lineCap = "round";
|
|
ctx.lineJoin = "round";
|
|
ctx.strokeStyle = opts.strokeStyle || "rgba(80,150,205,0.92)";
|
|
ctx.lineWidth = lineWidth;
|
|
ctx.beginPath();
|
|
for (const seg of segments || []) { ctx.moveTo(seg[0], seg[1]); ctx.lineTo(seg[2], seg[3]); }
|
|
ctx.stroke();
|
|
if (opts.highlight !== false) {
|
|
ctx.strokeStyle = opts.highlightStyle || "rgba(255,255,255,0.58)";
|
|
ctx.lineWidth = Math.max(1.3, lineWidth * 0.20);
|
|
ctx.beginPath();
|
|
for (const seg of segments || []) { ctx.moveTo(seg[0], seg[1]); ctx.lineTo(seg[2], seg[3]); }
|
|
ctx.stroke();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function eraseSegmentsAt(segments = [], point, radius) {
|
|
const before = segments.length;
|
|
const next = (segments || []).filter(seg => pointSegmentDistance(point, seg) > radius);
|
|
return { segments: next, changed: next.length !== before };
|
|
}
|
|
|
|
function syncInputPair(a, b, onChange = null) {
|
|
if (!a || !b) return false;
|
|
const sync = (from, to) => {
|
|
to.value = from.value;
|
|
if (typeof onChange === "function") onChange();
|
|
};
|
|
a.oninput = () => sync(a, b);
|
|
b.oninput = () => sync(b, a);
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
function drawDraftSegment(ctx, draft, lineWidth, opts = {}) {
|
|
if (!ctx || !draft) return false;
|
|
ctx.setLineDash(opts.dash || [7, 5]);
|
|
ctx.strokeStyle = opts.strokeStyle || "rgba(60,130,210,0.85)";
|
|
ctx.lineWidth = Math.max(2, Number(lineWidth || 12) * 0.45);
|
|
ctx.beginPath();
|
|
ctx.moveTo(draft[0], draft[1]);
|
|
ctx.lineTo(draft[2], draft[3]);
|
|
ctx.stroke();
|
|
ctx.setLineDash([]);
|
|
return true;
|
|
}
|
|
|
|
function drawErasePreview(ctx, cx, cy, point, radius, opts = {}) {
|
|
if (!ctx || !point) return false;
|
|
ctx.save();
|
|
ctx.translate(cx || 0, cy || 0);
|
|
ctx.globalAlpha = opts.alpha ?? 0.42;
|
|
ctx.strokeStyle = opts.strokeStyle || "rgba(210,70,60,0.86)";
|
|
ctx.lineWidth = opts.lineWidth || 1.6;
|
|
ctx.setLineDash(opts.dash || [4, 4]);
|
|
ctx.beginPath();
|
|
ctx.arc(point.x, point.y, radius, 0, Math.PI * 2);
|
|
ctx.stroke();
|
|
ctx.restore();
|
|
return true;
|
|
}
|
|
|
|
function createSegmentEditorController(opts = {}) {
|
|
const dialog = opts.dialog;
|
|
const canvas = opts.canvas;
|
|
const ctx = opts.ctx || canvas?.getContext?.("2d");
|
|
if (!dialog || !canvas || !ctx) return null;
|
|
const prefix = opts.prefix || "rotator";
|
|
const cx = opts.cx ?? canvas.width / 2;
|
|
const cy = opts.cy ?? canvas.height / 2;
|
|
const fallback = Array.isArray(opts.fallback) ? opts.fallback : [-78, 0, 78, 0];
|
|
let mode = "line";
|
|
let segments = (opts.segments || []).map(seg => Array.isArray(seg) ? seg.slice(0, 4) : seg).filter(seg => Array.isArray(seg) && seg.length >= 4);
|
|
let draft = null;
|
|
let drawing = false;
|
|
|
|
const lineWidth = () => Math.max(1, Number(typeof opts.lineWidth === "function" ? opts.lineWidth() : opts.lineWidth || 12) || 12);
|
|
const strokeStyle = () => typeof opts.strokeStyle === "function" ? opts.strokeStyle() : opts.strokeStyle;
|
|
const clean = () => { segments = cleanSegments(segments, { fallback, limit: opts.limit, bound: opts.bound, minLength: opts.minLength }); };
|
|
const toLocal = (e) => canvasLocalPoint(canvas, e, cx, cy);
|
|
|
|
const draw = () => {
|
|
drawEditorBase(ctx, canvas, cx, cy);
|
|
if (typeof opts.drawBeforeSegments === "function") opts.drawBeforeSegments(ctx, { cx, cy, lineWidth: lineWidth(), segments: segments.slice() });
|
|
const lw = lineWidth();
|
|
drawSegments(ctx, segments, { lineWidth: lw, strokeStyle: strokeStyle() || "rgba(80,150,205,0.92)" });
|
|
drawDraftSegment(ctx, draft, lw, opts.draft || {});
|
|
if (typeof opts.drawCenter === "function") opts.drawCenter(ctx, { cx, cy, lineWidth: lw, segments: segments.slice() });
|
|
ctx.restore();
|
|
return true;
|
|
};
|
|
|
|
const setMode = (next) => {
|
|
mode = next === "free" || next === "erase" ? next : "line";
|
|
for (const btn of dialog.querySelectorAll(`[data-${prefix}-mode]`)) btn.classList.toggle("active", btn.dataset[`${prefix}Mode`] === mode);
|
|
canvas.style.cursor = mode === "erase" ? "cell" : "crosshair";
|
|
return mode;
|
|
};
|
|
|
|
const eraseAt = (p) => {
|
|
const radius = Math.max(1, typeof opts.eraseRadius === "function" ? opts.eraseRadius(lineWidth()) : Number(opts.eraseRadius || 24) || 24);
|
|
const erased = eraseSegmentsAt(segments, p, radius);
|
|
segments = erased.segments;
|
|
if (erased.changed) { draft = null; draw(); return true; }
|
|
draw();
|
|
drawErasePreview(ctx, cx, cy, p, radius, opts.erasePreview || {});
|
|
return false;
|
|
};
|
|
|
|
const setTemplate = (name) => {
|
|
const shared = templateSegments(name);
|
|
if (shared) segments = shared.map(seg => seg.slice(0, 4));
|
|
clean();
|
|
draw();
|
|
};
|
|
|
|
dialog.querySelectorAll(`[data-${prefix}-mode]`).forEach(btn => { btn.onclick = () => setMode(btn.dataset[`${prefix}Mode`]); });
|
|
dialog.querySelectorAll(`[data-${prefix}-template]`).forEach(btn => { btn.onclick = () => setTemplate(btn.dataset[`${prefix}Template`]); });
|
|
|
|
canvas.onpointerdown = (e) => {
|
|
canvas.setPointerCapture?.(e.pointerId);
|
|
const p = toLocal(e);
|
|
drawing = true;
|
|
if (mode === "erase") { draft = null; eraseAt(p); return; }
|
|
draft = [p.x, p.y, p.x, p.y];
|
|
if (mode === "free") segments.push([p.x, p.y, p.x, p.y]);
|
|
draw();
|
|
};
|
|
canvas.onpointermove = (e) => {
|
|
if (!drawing) return;
|
|
const p = toLocal(e);
|
|
if (mode === "erase") { eraseAt(p); return; }
|
|
if (!draft) return;
|
|
if (mode === "free") {
|
|
const last = segments[segments.length - 1];
|
|
if (!last) return;
|
|
const lx = last[2], ly = last[3];
|
|
if (Math.hypot(p.x - lx, p.y - ly) >= 5) {
|
|
last[2] = p.x; last[3] = p.y;
|
|
segments.push([p.x, p.y, p.x, p.y]);
|
|
}
|
|
} else {
|
|
draft[2] = p.x; draft[3] = p.y;
|
|
}
|
|
draw();
|
|
};
|
|
canvas.onpointerup = (e) => {
|
|
if (!drawing) return;
|
|
drawing = false;
|
|
const p = toLocal(e);
|
|
if (mode === "erase") { draft = null; draw(); return; }
|
|
if (!draft) return;
|
|
if (mode === "line") {
|
|
const seg = [draft[0], draft[1], p.x, p.y];
|
|
if (Math.hypot(seg[2] - seg[0], seg[3] - seg[1]) >= 4) segments.push(seg);
|
|
}
|
|
draft = null;
|
|
clean();
|
|
draw();
|
|
};
|
|
|
|
const undo = dialog.querySelector(`#${prefix}Undo`);
|
|
const clear = dialog.querySelector(`#${prefix}Clear`);
|
|
if (undo) undo.onclick = () => { segments.pop(); clean(); draw(); };
|
|
if (clear) clear.onclick = () => { segments = []; draft = null; draw(); };
|
|
|
|
const close = () => {
|
|
canvas.style.cursor = "";
|
|
canvas.onpointerdown = canvas.onpointermove = canvas.onpointerup = null;
|
|
};
|
|
|
|
setMode(opts.initialMode || "line");
|
|
return {
|
|
cleanSegments: clean,
|
|
close,
|
|
draw,
|
|
getSegments: () => segments.map(seg => seg.slice(0, 4)),
|
|
setMode,
|
|
setSegments(next = []) { segments = next.map(seg => Array.isArray(seg) ? seg.slice(0, 4) : seg).filter(seg => Array.isArray(seg) && seg.length >= 4); draft = null; draw(); },
|
|
};
|
|
}
|
|
|
|
global.TarinaiPhysicsShapeEditorSystem = Object.freeze({
|
|
decorateToolbar,
|
|
templateSegments,
|
|
pointSegmentDistance,
|
|
canvasLocalPoint,
|
|
cleanSegments,
|
|
drawEditorBase,
|
|
drawSegments,
|
|
eraseSegmentsAt,
|
|
syncInputPair,
|
|
drawDraftSegment,
|
|
drawErasePreview,
|
|
createSegmentEditorController,
|
|
});
|
|
})(typeof window !== "undefined" ? window : globalThis);
|