From 7f0c19becd5979a16d9298cae9f6ff8a6f96d9c2 Mon Sep 17 00:00:00 2001
From: Catalin Mititiuc
Date: Wed, 24 Apr 2024 19:35:42 -0700
Subject: More functional refactor
---
src/modules/counter.js | 148 --------------------
src/modules/firingArc.js | 300 -----------------------------------------
src/modules/game.js | 8 +-
src/modules/game/counter.js | 148 ++++++++++++++++++++
src/modules/game/firingArc.js | 304 ++++++++++++++++++++++++++++++++++++++++++
src/modules/game/sightLine.js | 199 +++++++++++++++++++++++++++
src/modules/panzoom.js | 51 ++++---
src/modules/sightLine.js | 199 ---------------------------
8 files changed, 679 insertions(+), 678 deletions(-)
delete mode 100644 src/modules/counter.js
delete mode 100644 src/modules/firingArc.js
create mode 100644 src/modules/game/counter.js
create mode 100644 src/modules/game/firingArc.js
create mode 100644 src/modules/game/sightLine.js
delete mode 100644 src/modules/sightLine.js
(limited to 'src/modules')
diff --git a/src/modules/counter.js b/src/modules/counter.js
deleted file mode 100644
index 69552d8..0000000
--- a/src/modules/counter.js
+++ /dev/null
@@ -1,148 +0,0 @@
-const svgns = "http://www.w3.org/2000/svg";
-
-export default class Counter {
- constructor(svg) {
- this.svg = svg;
- this.selectedClass = 'selected';
- }
-
- dataSelector({ dataset: { allegiance, number }}) {
- return `[data-number="${number}"][data-allegiance="${allegiance}"]`;
- }
-
- position(x, y) {
- return `g[data-x="${x}"][data-y="${y}"]`;
- }
-
- counterPosition(x, y) {
- return `.counter[data-x="${x}"][data-x="${y}"]`;
- }
-
- traceSelector(counter) {
- return `polyline.move-trace${this.dataSelector(counter)}`;
- }
-
- getClones(counter) {
- return this.svg.querySelectorAll(`.counter.clone${this.dataSelector(counter)}`);
- }
-
- getCounter(selected) {
- return this.svg.querySelector(`.counter${this.dataSelector(selected)}:not(.clone)`);
- }
-
- getCounterAndClones(counter) {
- return this.svg.querySelectorAll(`.counter${this.dataSelector(counter)}`);
- }
-
- getTrace(counter) {
- return this.svg.querySelector(this.traceSelector(counter));
- }
-
- getCellPosition(cell) {
- let pt = new DOMPoint(0, 0),
- transform = getComputedStyle(cell).transform.match(/-?\d+\.?\d*/g),
- mtx = new DOMMatrix(transform);
- pt = pt.matrixTransform(mtx);
-
- transform = getComputedStyle(cell.parentElement).transform.match(/-?\d+\.?\d*/g);
- mtx = new DOMMatrix(transform);
- pt = pt.matrixTransform(mtx);
-
- return pt;
- }
-
- getBoard() {
- return this.svg.querySelector('.board');
- }
-
- place(selected, cell) {
- let points,
- counterNodeList = this.getCounterAndClones(selected);
-
- if (counterNodeList.length > 0 && selected.parentElement.hasAttribute('data-x')) {
- let trace = this.svg.querySelector(this.traceSelector(selected));
-
- let prevCoords = [
- selected.parentElement.dataset.x,
- selected.parentElement.parentElement.dataset.y
- ]
-
- let clone = selected.cloneNode(true);
- clone.classList.remove(this.selectedClass);
- clone.classList.add('clone');
-
- selected.dataset.previous = prevCoords;
- selected.parentElement.appendChild(clone);
- cell.appendChild(selected);
-
- selected.childNodes.forEach(n => {
- if (n.classList.contains('removed')) {
- n.remove();
- } else if ('preexisting' in n.dataset) {
- delete n.dataset.preexisting;
- }
- });
-
- let previous = this.getCellPosition(clone.parentElement),
- current = this.getCellPosition(selected.parentElement);
-
- if (!trace) {
- trace = document.createElementNS(svgns, 'polyline');
-
- points = `${previous.x},${previous.y} ${current.x},${current.y}`;
-
- trace.dataset.number = selected.dataset.number;
- trace.dataset.allegiance = selected.dataset.allegiance;
- trace.classList.add('move-trace');
-
- this.getBoard().prepend(trace);
- } else {
- points = `${trace.getAttribute('points')} ${current.x},${current.y}`;
- }
-
- trace.setAttributeNS(null, 'points', points);
- } else {
- selected.removeAttribute('data-x');
- cell.appendChild(selected);
- }
- }
-
- removeClones(counter) {
- this.getClones(counter).forEach(c => c.remove());
- }
-
- endMove(counter) {
- const trace = this.svg.querySelector(this.traceSelector(counter)),
- proneCounter = counter.querySelector('[href="#counter-prone"]');
-
- if (trace) {
- trace.remove();
- }
-
- delete counter.dataset.previous;
-
- if (proneCounter) {
- proneCounter.dataset.preexisting = '';
- }
-
- this.removeClones(counter);
- }
-
- hasProne(counter) {
- return !!counter.querySelector('[href="#counter-prone"]');
- }
-
- toggleProne(counter) {
- let proneCounter = counter.querySelector('[href="#counter-prone"]');
-
- if (!proneCounter) {
- proneCounter = document.createElementNS(svgns, 'use');
- proneCounter.setAttributeNS(null, 'href', '#counter-prone');
- counter.appendChild(proneCounter);
- } else if ('preexisting' in proneCounter.dataset) {
- proneCounter.classList.toggle('removed');
- } else {
- proneCounter.remove();
- }
- }
-}
diff --git a/src/modules/firingArc.js b/src/modules/firingArc.js
deleted file mode 100644
index 5e5d84a..0000000
--- a/src/modules/firingArc.js
+++ /dev/null
@@ -1,300 +0,0 @@
-const HORZ_POINT_DISTANCE = 1.005,
- VERT_POINT_DISTANCE = Math.sqrt(3) * HORZ_POINT_DISTANCE / 2,
-
- FIRING_ARC_SIZE = {
- 'small': Math.atan(HORZ_POINT_DISTANCE / (6 * VERT_POINT_DISTANCE)),
- 'medium': Math.atan((HORZ_POINT_DISTANCE / 2) / VERT_POINT_DISTANCE),
- 'large': Math.atan((21 * HORZ_POINT_DISTANCE) / (6 * VERT_POINT_DISTANCE))
-};
-
-function calculateAngle(xDiff, yDiff) {
- yDiff = -yDiff;
- let angle = Math.abs(Math.atan(yDiff / xDiff));
-
- if (xDiff < 0 && yDiff > 0) {
- angle = Math.PI - angle;
- } else if (xDiff < 0 && yDiff < 0) {
- angle = Math.PI + angle;
- } else if (xDiff > 0 && yDiff < 0) {
- angle = 2 * Math.PI - angle;
- }
-
- return angle;
-}
-
-function edgePoint(x1, y1, x2, y2, maxX, maxY) {
- let pointCoords,
- xDiff = x2 - x1,
- yDiff = y2 - y1,
- xIntercept = y => (y - y1) * xDiff / yDiff + x1,
- yIntercept = x => (x - x1) * yDiff / xDiff + y1;
-
- if (xDiff > 0 && yDiff > 0) {
- let x = xIntercept(maxY);
-
- pointCoords = x <= maxX ? [x, maxY] : [maxX, yIntercept(maxX)];
- } else if (xDiff > 0 && yDiff < 0) {
- let y = yIntercept(maxX);
-
- pointCoords = y >= 0 ? [maxX, y] : [xIntercept(0), 0];
- } else if (xDiff < 0 && yDiff < 0) {
- let x = xIntercept(0);
-
- pointCoords = x >= 0 ? [x, 0] : [0, yIntercept(0)];
- } else {
- let y = yIntercept(0);
-
- pointCoords = y <= maxY ? [0, y] : [xIntercept(maxY), maxY];
- }
-
- return pointCoords;
-}
-
-function position(e) {
- let activeFiringArc = this.querySelector('polygon.firing-arc.active');
-
- // TODO: handle exactly horizontal and vertical lines
-
- if (activeFiringArc) {
- let activeFiringArcOutline = this.querySelector(`#lines polygon[data-number="${activeFiringArc.dataset.number}"][data-allegiance="${activeFiringArc.dataset.allegiance}"]`),
- board = this.querySelector('#image-maps'),
- { width, height } = board.getBBox(),
- pt = new DOMPoint(e.clientX, e.clientY),
- { x: pointerX, y: pointerY } = pt.matrixTransform(board.getScreenCTM().inverse()),
- [maxXpx, maxYpx] = [width, height],
- { x: x1px, y: y1px } = activeFiringArc.points[0];
-
- let [x2px, y2px] = [
- pointerX / width * maxXpx,
- pointerY / height * maxYpx
- ];
-
- let xDiff = x2px - x1px;
- let yDiff = y2px - y1px;
- let angle = calculateAngle(xDiff, yDiff);
-
- let arcAngle = FIRING_ARC_SIZE[activeFiringArc.dataset.size];
- let distance = Math.sqrt((x2px - x1px) ** 2 + (y2px - y1px) ** 2);
- let yDelta = distance * Math.cos(angle) * Math.tan(arcAngle);
- let xDelta = distance * Math.sin(angle) * Math.tan(arcAngle);
-
- let [newY1, newX1] = [y2px + yDelta, x2px + xDelta];
- let [newY2, newX2] = [y2px - yDelta, x2px - xDelta];
-
- [newX1, newY1] = edgePoint(x1px, y1px, newX1, newY1, maxXpx, maxYpx);
- [newX2, newY2] = edgePoint(x1px, y1px, newX2, newY2, maxXpx, maxYpx);
-
- let oppositeEdgeConditions = [
- newX1 == 0 && newX2 == maxXpx,
- newX2 == 0 && newX1 == maxXpx,
- newY1 == 0 && newY2 == maxYpx,
- newY2 == 0 && newY1 == maxYpx
- ]
-
- let orthogonalEdgeConditions = [
- (newX1 == 0 || newX1 == maxXpx) && (newY2 == 0 || newY2 == maxYpx),
- (newX2 == 0 || newX2 == maxXpx) && (newY1 == 0 || newY1 == maxYpx),
- ]
-
- let points;
-
- if (oppositeEdgeConditions.some(e => e)) {
- let cornerPoints;
-
- if (xDiff > 0 && yDiff > 0) {
- if ((newY1 == 0 && newY2 == maxYpx) || (newY1 == maxYpx && newY2 == 0)) {
- cornerPoints = [[maxXpx, 0], [maxXpx, maxYpx]];
- } else {
- cornerPoints = [[maxXpx, maxYpx], [0, maxYpx]];
- }
- } else if (xDiff > 0 && yDiff < 0) {
- if ((newY1 == 0 && newY2 == maxYpx) || (newY1 == maxYpx && newY2 == 0)) {
- cornerPoints = [[maxXpx, 0], [maxXpx, maxYpx]];
- } else {
- cornerPoints = [[0, 0], [maxXpx, 0]];
- }
-
- } else if (xDiff < 0 && yDiff > 0) {
- if ((newY1 == 0 && newY2 == maxYpx) || (newY1 == maxYpx && newY2 == 0)) {
- cornerPoints = [[0, maxYpx], [0, 0]];
- } else {
- cornerPoints = [[maxXpx, maxYpx], [0, maxYpx]];
- }
-
- } else {
- if ((newY1 == 0 && newY2 == maxYpx) || (newY1 == maxYpx && newY2 == 0)) {
- cornerPoints = [[0, maxYpx], [0, 0]];
- } else {
- cornerPoints = [[0, 0], [maxXpx, 0]];
- }
-
- }
- points = `${x1px},${y1px} ${newX1},${newY1} ${cornerPoints[1]} ${cornerPoints[0]} ${newX2},${newY2}`;
- } else if (orthogonalEdgeConditions.some(e => e)) {
- let cornerPoints = [];
- let cp1, cp2;
-
- if (newX1 == 0 || newX1 == maxXpx) {
- cp1 = [newX1, yDiff > 0 ? maxYpx : 0];
- } else {
- cp1 = [xDiff > 0 ? maxXpx : 0, newY1];
- }
-
- if (newX2 == 0 || newX2 == maxXpx) {
- cp2 = [newX2, yDiff > 0 ? maxYpx : 0];
- } else {
- cp2 = [xDiff > 0 ? maxXpx : 0, newY2];
- }
-
- if (cp1[0] == cp2[0] && cp1[1] == cp2[1]) {
- cornerPoints.push(cp1);
- } else {
- cornerPoints.push(cp1);
- cornerPoints.push([xDiff > 0 ? maxXpx : 0, yDiff > 0 ? maxYpx : 0])
- cornerPoints.push(cp2);
- }
-
- points = `${x1px},${y1px} ${newX1},${newY1} ${cornerPoints.join(' ')} ${newX2},${newY2}`;
- } else {
- points = `${x1px},${y1px} ${newX1},${newY1} ${newX2},${newY2}`;
- }
-
- activeFiringArcOutline.setAttributeNS(null, 'points', points);
- activeFiringArc.setAttributeNS(null, 'points', points);
- }
-}
-
-export default class FiringArc {
- #firingArcVisibility = {
- davion: false,
- liao: false
- };
-
- constructor(svg) {
- this.svg = svg;
- }
-
- set(size, { dataset: { allegiance, number }}, { x, y }) {
- const svgns = "http://www.w3.org/2000/svg";
-
- let existingArcs = this.svg.querySelectorAll(
- `#firing-arcs [data-number="${number}"][data-allegiance="${allegiance}"]`
- );
-
- existingArcs.forEach(el => el.remove());
-
- let arcLayer = this.svg.querySelector('#shapes');
- let outlineLayer = this.svg.querySelector('#lines');
- let arcContainer = this.svg.querySelector('#firing-arcs');
-
- let grid = this.svg.querySelector('.board');
- const transform = getComputedStyle(grid).transform.match(/-?\d+\.?\d*/g);
- const pt = new DOMPoint(x, y);
- const mtx = new DOMMatrix(transform);
- let tPt = pt.matrixTransform(mtx);
-
- let pivotPoint = [tPt.x, tPt.y];
- let firingArc = document.createElementNS(svgns, 'polygon');
- let firingArcOutline = document.createElementNS(svgns, 'polygon');
-
- firingArc.classList.add('firing-arc', 'active');
- firingArc.dataset.number = number;
- firingArc.dataset.allegiance = allegiance;
- firingArc.dataset.size = size;
- firingArc.setAttributeNS(null, 'points', `${pivotPoint} ${pivotPoint} ${pivotPoint}`);
-
- firingArcOutline.dataset.number = number;
- firingArcOutline.dataset.allegiance = allegiance;
- firingArcOutline.setAttributeNS(null, 'points', `${pivotPoint} ${pivotPoint} ${pivotPoint}`);
-
- let clipShape = document.createElementNS(svgns, 'circle');
- clipShape.setAttributeNS(null, 'cx', tPt.x);
- clipShape.setAttributeNS(null, 'cy', tPt.y);
- clipShape.setAttributeNS(null, 'r', 100);
-
- let clipPath = document.createElementNS(svgns, 'clipPath');
- clipPath.setAttributeNS(null, 'id', `clip-path-${allegiance}-${number}`);
- clipPath.dataset.number = number;
- clipPath.dataset.allegiance = allegiance;
- clipPath.appendChild(clipShape);
-
- arcContainer.appendChild(clipPath);
- arcLayer.appendChild(firingArc);
- outlineLayer.appendChild(firingArcOutline);
-
- let firingArcPlacementListener = e => {
- this.svg.querySelectorAll('.firing-arc.active').forEach(el => el.classList.remove('active'));
- grid.removeAttribute('style');
- this.svg.removeEventListener('mousemove', position);
- firingArc.removeEventListener('click', firingArcPlacementListener);
- firingArc.removeEventListener('contextmenu', cancelFiringArcPlacement);
- };
-
- let cancelFiringArcPlacement = e => {
- e.preventDefault();
-
- firingArc.removeEventListener('click', firingArcPlacementListener);
- firingArc.removeEventListener('contextmenu', cancelFiringArcPlacement);
-
- let existingArcs = this.svg.querySelectorAll(
- `#firing-arcs [data-number="${number}"][data-allegiance="${allegiance}"]`
- );
-
- existingArcs.forEach(el => el.remove());
-
- grid.removeAttribute('style');
- this.svg.removeEventListener('mousemove', position);
- };
-
- grid.style.pointerEvents = 'none';
- this.svg.addEventListener('mousemove', position);
- firingArc.addEventListener('click', firingArcPlacementListener);
- firingArc.addEventListener('contextmenu', cancelFiringArcPlacement);
- }
-
- clear(allegiance) {
- const selector = `#firing-arcs [data-allegiance="${allegiance}"]`;
- this.svg.querySelectorAll(selector).forEach(el => el.remove());
- }
-
- get({ dataset: { allegiance, number }}) {
- return this.svg.querySelectorAll(`#firing-arcs polygon[data-number="${number}"][data-allegiance="${allegiance}"]`);
- }
-
- getUnclipped() {
- return this.svg.querySelectorAll('#firing-arcs polygon:not([clip-path])');
- }
-
- toggleVisibility(allegiance) {
- const vis = this.#firingArcVisibility[allegiance],
- clipPaths = this.svg.querySelectorAll(`clipPath[data-allegiance="${allegiance}"]`);
-
- clipPaths.forEach(cp => cp.style.display = !vis ? 'none' : '');
- this.#firingArcVisibility[allegiance] = !vis;
- }
-
- toggleCounterVisibility({ dataset: { number, allegiance }}, vis) {
- const cp = this.svg.querySelector(`#clip-path-${allegiance}-${number}`),
- display = vis ? 'none' : '';
-
- if (cp) {
- cp.style.display = this.#firingArcVisibility[allegiance] ? 'none' : display;
- }
- }
-
- clipAll() {
- let unclipped = this.getUnclipped();
-
- unclipped.forEach(el => {
- const { number, allegiance } = el.dataset,
- clipPathId = `clip-path-${allegiance}-${number}`,
- isVisible = this.#firingArcVisibility[allegiance];
-
- if (isVisible) {
- this.svg.querySelector(`#${clipPathId}`).style.display = 'none';
- }
-
- el.setAttributeNS(null, 'clip-path', `url(#${clipPathId})`);
- });
- }
-}
diff --git a/src/modules/game.js b/src/modules/game.js
index f9ce991..c22dc9d 100644
--- a/src/modules/game.js
+++ b/src/modules/game.js
@@ -1,6 +1,6 @@
-import FiringArc from './firingArc.js';
-import SightLine from './sightLine.js';
-import Counter from './counter.js';
+import firingArc from './game/firingArc.js';
+import SightLine from './game/sightLine.js';
+import Counter from './game/counter.js';
const svgns = "http://www.w3.org/2000/svg";
@@ -10,7 +10,7 @@ export default class Game {
constructor(svg) {
this.svg = svg;
- this.firingArc = new FiringArc(svg);
+ this.firingArc = new firingArc(svg);
this.sightLine = new SightLine(svg);
this.counter = new Counter(svg);
diff --git a/src/modules/game/counter.js b/src/modules/game/counter.js
new file mode 100644
index 0000000..69552d8
--- /dev/null
+++ b/src/modules/game/counter.js
@@ -0,0 +1,148 @@
+const svgns = "http://www.w3.org/2000/svg";
+
+export default class Counter {
+ constructor(svg) {
+ this.svg = svg;
+ this.selectedClass = 'selected';
+ }
+
+ dataSelector({ dataset: { allegiance, number }}) {
+ return `[data-number="${number}"][data-allegiance="${allegiance}"]`;
+ }
+
+ position(x, y) {
+ return `g[data-x="${x}"][data-y="${y}"]`;
+ }
+
+ counterPosition(x, y) {
+ return `.counter[data-x="${x}"][data-x="${y}"]`;
+ }
+
+ traceSelector(counter) {
+ return `polyline.move-trace${this.dataSelector(counter)}`;
+ }
+
+ getClones(counter) {
+ return this.svg.querySelectorAll(`.counter.clone${this.dataSelector(counter)}`);
+ }
+
+ getCounter(selected) {
+ return this.svg.querySelector(`.counter${this.dataSelector(selected)}:not(.clone)`);
+ }
+
+ getCounterAndClones(counter) {
+ return this.svg.querySelectorAll(`.counter${this.dataSelector(counter)}`);
+ }
+
+ getTrace(counter) {
+ return this.svg.querySelector(this.traceSelector(counter));
+ }
+
+ getCellPosition(cell) {
+ let pt = new DOMPoint(0, 0),
+ transform = getComputedStyle(cell).transform.match(/-?\d+\.?\d*/g),
+ mtx = new DOMMatrix(transform);
+ pt = pt.matrixTransform(mtx);
+
+ transform = getComputedStyle(cell.parentElement).transform.match(/-?\d+\.?\d*/g);
+ mtx = new DOMMatrix(transform);
+ pt = pt.matrixTransform(mtx);
+
+ return pt;
+ }
+
+ getBoard() {
+ return this.svg.querySelector('.board');
+ }
+
+ place(selected, cell) {
+ let points,
+ counterNodeList = this.getCounterAndClones(selected);
+
+ if (counterNodeList.length > 0 && selected.parentElement.hasAttribute('data-x')) {
+ let trace = this.svg.querySelector(this.traceSelector(selected));
+
+ let prevCoords = [
+ selected.parentElement.dataset.x,
+ selected.parentElement.parentElement.dataset.y
+ ]
+
+ let clone = selected.cloneNode(true);
+ clone.classList.remove(this.selectedClass);
+ clone.classList.add('clone');
+
+ selected.dataset.previous = prevCoords;
+ selected.parentElement.appendChild(clone);
+ cell.appendChild(selected);
+
+ selected.childNodes.forEach(n => {
+ if (n.classList.contains('removed')) {
+ n.remove();
+ } else if ('preexisting' in n.dataset) {
+ delete n.dataset.preexisting;
+ }
+ });
+
+ let previous = this.getCellPosition(clone.parentElement),
+ current = this.getCellPosition(selected.parentElement);
+
+ if (!trace) {
+ trace = document.createElementNS(svgns, 'polyline');
+
+ points = `${previous.x},${previous.y} ${current.x},${current.y}`;
+
+ trace.dataset.number = selected.dataset.number;
+ trace.dataset.allegiance = selected.dataset.allegiance;
+ trace.classList.add('move-trace');
+
+ this.getBoard().prepend(trace);
+ } else {
+ points = `${trace.getAttribute('points')} ${current.x},${current.y}`;
+ }
+
+ trace.setAttributeNS(null, 'points', points);
+ } else {
+ selected.removeAttribute('data-x');
+ cell.appendChild(selected);
+ }
+ }
+
+ removeClones(counter) {
+ this.getClones(counter).forEach(c => c.remove());
+ }
+
+ endMove(counter) {
+ const trace = this.svg.querySelector(this.traceSelector(counter)),
+ proneCounter = counter.querySelector('[href="#counter-prone"]');
+
+ if (trace) {
+ trace.remove();
+ }
+
+ delete counter.dataset.previous;
+
+ if (proneCounter) {
+ proneCounter.dataset.preexisting = '';
+ }
+
+ this.removeClones(counter);
+ }
+
+ hasProne(counter) {
+ return !!counter.querySelector('[href="#counter-prone"]');
+ }
+
+ toggleProne(counter) {
+ let proneCounter = counter.querySelector('[href="#counter-prone"]');
+
+ if (!proneCounter) {
+ proneCounter = document.createElementNS(svgns, 'use');
+ proneCounter.setAttributeNS(null, 'href', '#counter-prone');
+ counter.appendChild(proneCounter);
+ } else if ('preexisting' in proneCounter.dataset) {
+ proneCounter.classList.toggle('removed');
+ } else {
+ proneCounter.remove();
+ }
+ }
+}
diff --git a/src/modules/game/firingArc.js b/src/modules/game/firingArc.js
new file mode 100644
index 0000000..d2f18a5
--- /dev/null
+++ b/src/modules/game/firingArc.js
@@ -0,0 +1,304 @@
+// https://www.redblobgames.com/grids/hexagons/
+
+// Horizontal distance between hex centers is sqrt(3) * size. The vertical
+// distance is 3 / 2 * size. When we calculate horzDist / vertDist, the size
+// cancels out, leaving us with a unitless ratio of sqrt(3) / (3 / 2), or
+// 2 * sqrt(3) / 3.
+
+const svgns = "http://www.w3.org/2000/svg",
+ horzToVertDistRatio = 2 * Math.sqrt(3) / 3,
+
+ arcSize = {
+ 'small': Math.atan(horzToVertDistRatio / 6),
+ 'medium': Math.atan(horzToVertDistRatio / 2),
+ 'large': Math.atan(7 * horzToVertDistRatio / 2)
+ },
+
+ firingArcVisibility = {
+ davion: false,
+ liao: false
+ };
+
+let svg;
+
+function calculateAngle(xDiff, yDiff) {
+ yDiff = -yDiff;
+ let angle = Math.abs(Math.atan(yDiff / xDiff));
+
+ if (xDiff < 0 && yDiff > 0) {
+ angle = Math.PI - angle;
+ } else if (xDiff < 0 && yDiff < 0) {
+ angle = Math.PI + angle;
+ } else if (xDiff > 0 && yDiff < 0) {
+ angle = 2 * Math.PI - angle;
+ }
+
+ return angle;
+}
+
+function edgePoint(x1, y1, x2, y2, maxX, maxY) {
+ let pointCoords,
+ xDiff = x2 - x1,
+ yDiff = y2 - y1,
+ xIntercept = y => (y - y1) * xDiff / yDiff + x1,
+ yIntercept = x => (x - x1) * yDiff / xDiff + y1;
+
+ if (xDiff > 0 && yDiff > 0) {
+ let x = xIntercept(maxY);
+
+ pointCoords = x <= maxX ? [x, maxY] : [maxX, yIntercept(maxX)];
+ } else if (xDiff > 0 && yDiff < 0) {
+ let y = yIntercept(maxX);
+
+ pointCoords = y >= 0 ? [maxX, y] : [xIntercept(0), 0];
+ } else if (xDiff < 0 && yDiff < 0) {
+ let x = xIntercept(0);
+
+ pointCoords = x >= 0 ? [x, 0] : [0, yIntercept(0)];
+ } else {
+ let y = yIntercept(0);
+
+ pointCoords = y <= maxY ? [0, y] : [xIntercept(maxY), maxY];
+ }
+
+ return pointCoords;
+}
+
+function position(e) {
+ let activeFiringArc = this.querySelector('polygon.firing-arc.active');
+
+ // TODO: handle exactly horizontal and vertical lines
+
+ if (activeFiringArc) {
+ let activeFiringArcOutline = this.querySelector(`#lines polygon[data-number="${activeFiringArc.dataset.number}"][data-allegiance="${activeFiringArc.dataset.allegiance}"]`),
+ board = this.querySelector('#image-maps'),
+ { width, height } = board.getBBox(),
+ pt = new DOMPoint(e.clientX, e.clientY),
+ { x: pointerX, y: pointerY } = pt.matrixTransform(board.getScreenCTM().inverse()),
+ [maxXpx, maxYpx] = [width, height],
+ { x: x1px, y: y1px } = activeFiringArc.points[0];
+
+ let [x2px, y2px] = [
+ pointerX / width * maxXpx,
+ pointerY / height * maxYpx
+ ];
+
+ let xDiff = x2px - x1px;
+ let yDiff = y2px - y1px;
+ let angle = calculateAngle(xDiff, yDiff);
+
+ let arcAngle = arcSize[activeFiringArc.dataset.size];
+ let distance = Math.sqrt((x2px - x1px) ** 2 + (y2px - y1px) ** 2);
+ let yDelta = distance * Math.cos(angle) * Math.tan(arcAngle);
+ let xDelta = distance * Math.sin(angle) * Math.tan(arcAngle);
+
+ let [newY1, newX1] = [y2px + yDelta, x2px + xDelta];
+ let [newY2, newX2] = [y2px - yDelta, x2px - xDelta];
+
+ [newX1, newY1] = edgePoint(x1px, y1px, newX1, newY1, maxXpx, maxYpx);
+ [newX2, newY2] = edgePoint(x1px, y1px, newX2, newY2, maxXpx, maxYpx);
+
+ let oppositeEdgeConditions = [
+ newX1 == 0 && newX2 == maxXpx,
+ newX2 == 0 && newX1 == maxXpx,
+ newY1 == 0 && newY2 == maxYpx,
+ newY2 == 0 && newY1 == maxYpx
+ ]
+
+ let orthogonalEdgeConditions = [
+ (newX1 == 0 || newX1 == maxXpx) && (newY2 == 0 || newY2 == maxYpx),
+ (newX2 == 0 || newX2 == maxXpx) && (newY1 == 0 || newY1 == maxYpx),
+ ]
+
+ let points;
+
+ if (oppositeEdgeConditions.some(e => e)) {
+ let cornerPoints;
+
+ if (xDiff > 0 && yDiff > 0) {
+ if ((newY1 == 0 && newY2 == maxYpx) || (newY1 == maxYpx && newY2 == 0)) {
+ cornerPoints = [[maxXpx, 0], [maxXpx, maxYpx]];
+ } else {
+ cornerPoints = [[maxXpx, maxYpx], [0, maxYpx]];
+ }
+ } else if (xDiff > 0 && yDiff < 0) {
+ if ((newY1 == 0 && newY2 == maxYpx) || (newY1 == maxYpx && newY2 == 0)) {
+ cornerPoints = [[maxXpx, 0], [maxXpx, maxYpx]];
+ } else {
+ cornerPoints = [[0, 0], [maxXpx, 0]];
+ }
+
+ } else if (xDiff < 0 && yDiff > 0) {
+ if ((newY1 == 0 && newY2 == maxYpx) || (newY1 == maxYpx && newY2 == 0)) {
+ cornerPoints = [[0, maxYpx], [0, 0]];
+ } else {
+ cornerPoints = [[maxXpx, maxYpx], [0, maxYpx]];
+ }
+
+ } else {
+ if ((newY1 == 0 && newY2 == maxYpx) || (newY1 == maxYpx && newY2 == 0)) {
+ cornerPoints = [[0, maxYpx], [0, 0]];
+ } else {
+ cornerPoints = [[0, 0], [maxXpx, 0]];
+ }
+
+ }
+ points = `${x1px},${y1px} ${newX1},${newY1} ${cornerPoints[1]} ${cornerPoints[0]} ${newX2},${newY2}`;
+ } else if (orthogonalEdgeConditions.some(e => e)) {
+ let cornerPoints = [];
+ let cp1, cp2;
+
+ if (newX1 == 0 || newX1 == maxXpx) {
+ cp1 = [newX1, yDiff > 0 ? maxYpx : 0];
+ } else {
+ cp1 = [xDiff > 0 ? maxXpx : 0, newY1];
+ }
+
+ if (newX2 == 0 || newX2 == maxXpx) {
+ cp2 = [newX2, yDiff > 0 ? maxYpx : 0];
+ } else {
+ cp2 = [xDiff > 0 ? maxXpx : 0, newY2];
+ }
+
+ if (cp1[0] == cp2[0] && cp1[1] == cp2[1]) {
+ cornerPoints.push(cp1);
+ } else {
+ cornerPoints.push(cp1);
+ cornerPoints.push([xDiff > 0 ? maxXpx : 0, yDiff > 0 ? maxYpx : 0])
+ cornerPoints.push(cp2);
+ }
+
+ points = `${x1px},${y1px} ${newX1},${newY1} ${cornerPoints.join(' ')} ${newX2},${newY2}`;
+ } else {
+ points = `${x1px},${y1px} ${newX1},${newY1} ${newX2},${newY2}`;
+ }
+
+ activeFiringArcOutline.setAttributeNS(null, 'points', points);
+ activeFiringArc.setAttributeNS(null, 'points', points);
+ }
+}
+
+function setDataAttrs({ dataset: { allegiance, number }}, el) {
+ el.dataset.allegiance = allegiance;
+ el.dataset.number = number;
+}
+
+function getClipPathId({ dataset: { allegiance, number }}) {
+ return `clip-path-${allegiance}-${number}`;
+}
+
+function getUnclipped() {
+ return svg.querySelectorAll('#firing-arcs polygon:not([clip-path])');
+};
+
+export default function (el) {
+ svg = el;
+
+ this.set = function (size, counter, { x, y }) {
+ this.get(counter).forEach(fa => fa.remove());
+
+ let arcLayer = svg.querySelector('#shapes');
+ let outlineLayer = svg.querySelector('#lines');
+ let arcContainer = svg.querySelector('#firing-arcs');
+
+ let grid = svg.querySelector('.board');
+ const transform = getComputedStyle(grid).transform.match(/-?\d+\.?\d*/g);
+ const pt = new DOMPoint(x, y);
+ const mtx = new DOMMatrix(transform);
+ let tPt = pt.matrixTransform(mtx);
+
+ let pivotPoint = [tPt.x, tPt.y];
+ let firingArc = document.createElementNS(svgns, 'polygon');
+ let firingArcOutline = document.createElementNS(svgns, 'polygon');
+
+ setDataAttrs(counter, firingArc);
+ firingArc.dataset.size = size;
+ firingArc.classList.add('firing-arc', 'active');
+ firingArc.setAttributeNS(null, 'points', `${pivotPoint} ${pivotPoint} ${pivotPoint}`);
+
+ setDataAttrs(counter, firingArcOutline);
+ firingArcOutline.setAttributeNS(null, 'points', `${pivotPoint} ${pivotPoint} ${pivotPoint}`);
+
+ let clipShape = document.createElementNS(svgns, 'circle');
+ clipShape.setAttributeNS(null, 'cx', tPt.x);
+ clipShape.setAttributeNS(null, 'cy', tPt.y);
+ clipShape.setAttributeNS(null, 'r', 100);
+
+ let clipPath = document.createElementNS(svgns, 'clipPath');
+ setDataAttrs(counter, clipPath);
+ clipPath.setAttributeNS(null, 'id', getClipPathId(counter));
+ clipPath.appendChild(clipShape);
+
+ arcContainer.appendChild(clipPath);
+ arcLayer.appendChild(firingArc);
+ outlineLayer.appendChild(firingArcOutline);
+
+ let firingArcPlacementListener = e => {
+ svg.querySelectorAll('.firing-arc.active').forEach(el => el.classList.remove('active'));
+ grid.removeAttribute('style');
+ svg.removeEventListener('mousemove', position);
+ firingArc.removeEventListener('click', firingArcPlacementListener);
+ firingArc.removeEventListener('contextmenu', cancelFiringArcPlacement);
+ };
+
+ let cancelFiringArcPlacement = e => {
+ e.preventDefault();
+
+ firingArc.removeEventListener('click', firingArcPlacementListener);
+ firingArc.removeEventListener('contextmenu', cancelFiringArcPlacement);
+
+ this.get(counter).forEach(fa => fa.remove());
+
+ grid.removeAttribute('style');
+ svg.removeEventListener('mousemove', position);
+ };
+
+ grid.style.pointerEvents = 'none';
+ svg.addEventListener('mousemove', position);
+ firingArc.addEventListener('click', firingArcPlacementListener);
+ firingArc.addEventListener('contextmenu', cancelFiringArcPlacement);
+ };
+
+ this.clear = function (allegiance) {
+ const selector = `#firing-arcs [data-allegiance="${allegiance}"]`;
+ svg.querySelectorAll(selector).forEach(el => el.remove());
+ };
+
+ this.get = function ({ dataset: { allegiance, number }}) {
+ return svg.querySelectorAll(`#firing-arcs polygon[data-number="${number}"][data-allegiance="${allegiance}"]`);
+ };
+
+ this.toggleVisibility = function (allegiance) {
+ const vis = firingArcVisibility[allegiance],
+ clipPaths = svg.querySelectorAll(`clipPath[data-allegiance="${allegiance}"]`);
+
+ clipPaths.forEach(cp => cp.style.display = !vis ? 'none' : '');
+ firingArcVisibility[allegiance] = !vis;
+ };
+
+ this.toggleCounterVisibility = function ({ dataset: { number, allegiance }}, vis) {
+ const cp = svg.querySelector(`#clip-path-${allegiance}-${number}`),
+ display = vis ? 'none' : '';
+
+ if (cp) {
+ cp.style.display = firingArcVisibility[allegiance] ? 'none' : display;
+ }
+ };
+
+ this.clipAll = function () {
+ console.log('clipall')
+ let unclipped = getUnclipped();
+
+ unclipped.forEach(el => {
+ const { number, allegiance } = el.dataset,
+ clipPathId = `clip-path-${allegiance}-${number}`,
+ isVisible = firingArcVisibility[allegiance];
+
+ if (isVisible) {
+ svg.querySelector(`#${clipPathId}`).style.display = 'none';
+ }
+
+ el.setAttributeNS(null, 'clip-path', `url(#${clipPathId})`);
+ });
+ };
+}
diff --git a/src/modules/game/sightLine.js b/src/modules/game/sightLine.js
new file mode 100644
index 0000000..4790bd8
--- /dev/null
+++ b/src/modules/game/sightLine.js
@@ -0,0 +1,199 @@
+const svgns = "http://www.w3.org/2000/svg";
+
+function evenr_to_axial(x, y) {
+ return { q: x - (y + (y & 1)) / 2, r: y };
+}
+
+function axial_to_evenr(q, r) {
+ return { x: q + (r + (r & 1)) / 2, y: r };
+}
+
+function axial_distance(q1, r1, q2, r2) {
+ return (Math.abs(q1 - q2) + Math.abs(q1 + r1 - q2 - r2) + Math.abs(r1 - r2)) / 2;
+}
+
+function offset_distance(x1, y1, x2, y2) {
+ let { q: q1, r: r1 } = evenr_to_axial(x1, y1),
+ { q: q2, r: r2 } = evenr_to_axial(x2, y2);
+
+ return axial_distance(q1, r1, q2, r2);
+}
+
+function cube_to_axial(q, r, s) {
+ return { q: q, r: r };
+}
+
+function axial_to_cube(q, r) {
+ return { q: q, r: r, s: -q - r };
+}
+
+function cube_round(q, r, s) {
+ rQ = Math.round(q);
+ rR = Math.round(r);
+ rS = Math.round(s);
+
+ let q_diff = Math.abs(rQ - q),
+ r_diff = Math.abs(rR - r),
+ s_diff = Math.abs(rS - s);
+
+ if (q_diff > r_diff && q_diff > s_diff) {
+ rQ = -rR - rS;
+ } else if (r_diff > s_diff) {
+ rR = -rQ - rS;
+ } else {
+ rS = -rQ - rR;
+ }
+
+ return { q: rQ, r: rR, s: rS };
+}
+
+function axial_round(q, r) {
+ let cube = axial_to_cube(q, r),
+ round = cube_round(cube.q, cube.r, cube.s),
+ axial = cube_to_axial(round.q, round.r, round.s);
+
+ return { q: axial.q, r: axial.r };
+}
+
+function lerp(a, b, t) {
+ return a + (b - a) * t;
+}
+
+function axial_lerp(q1, r1, q2, r2, t) {
+ return { q: lerp(q1, q2, t), r: lerp(r1, r2, t) };
+}
+
+function linedraw(x1, y1, x2, y2) {
+ let axial1 = evenr_to_axial(x1, y1),
+ axial2 = evenr_to_axial(x2, y2),
+ n = offset_distance(x1, y1, x2, y2),
+ results = [];
+
+ for (let i = 0; i <= n; i++) {
+ let lerp = axial_lerp(axial1.q, axial1.r, axial2.q, axial2.r, 1.0 / n * i),
+ round = axial_round(lerp.q, lerp.r),
+ { x, y } = axial_to_evenr(round.q, round.r);
+
+ results.push([x, y]);
+ }
+
+ return results;
+}
+
+export default class SightLine {
+ constructor(svg) {
+ this.svg = svg;
+ }
+
+ getBoard() {
+ return this.svg.querySelector('.board');
+ }
+
+ getActiveHexes() {
+ return this.svg.querySelectorAll('use[href="#hex"].active');
+ }
+
+ clear() {
+ const board = this.getBoard(),
+ sl = board.querySelector('line.sight-line'),
+ target = board.querySelector(`use[href="#hex"].sight-line-target`);
+
+ if (sl) {
+ sl.remove();
+ }
+
+ if (target) {
+ target.classList.remove('sight-line-target');
+ }
+
+ this.clearHexes();
+ }
+
+ clearHexes() {
+ if (this.distanceCallback) {
+ this.distanceCallback();
+ }
+
+ this.getActiveHexes().forEach(el => el.classList.remove('active'));
+ }
+
+ draw(source, target) {
+ this.clear();
+
+ let pt = new DOMPoint(0, 0),
+ transform = getComputedStyle(source).transform.match(/-?\d+\.?\d*/g),
+ mtx = new DOMMatrix(transform);
+
+ pt = pt.matrixTransform(mtx);
+
+ transform = getComputedStyle(source.parentElement).transform.match(/-?\d+\.?\d*/g);
+ mtx = new DOMMatrix(transform);
+ pt = pt.matrixTransform(mtx);
+
+ let slX1 = pt.x,
+ slY1 = pt.y;
+
+ pt = new DOMPoint(0, 0);
+ transform = getComputedStyle(target).transform.match(/-?\d+\.?\d*/g);
+ mtx = new DOMMatrix(transform);
+
+ pt = pt.matrixTransform(mtx);
+
+ transform = getComputedStyle(target.parentElement).transform.match(/-?\d+\.?\d*/g);
+ mtx = new DOMMatrix(transform);
+ pt = pt.matrixTransform(mtx);
+
+ let slX2 = pt.x,
+ slY2 = pt.y;
+
+ let sightLine = document.createElementNS(svgns, 'line');
+
+ sightLine.classList.add('sight-line');
+ sightLine.classList.add('active');
+ sightLine.setAttributeNS(null, 'x1', slX1);
+ sightLine.setAttributeNS(null, 'y1', slY1);
+ sightLine.setAttributeNS(null, 'x2', slX2);
+ sightLine.setAttributeNS(null, 'y2', slY2);
+
+ this.getBoard().appendChild(sightLine);
+
+ let coords = [
+ source.dataset.x,
+ source.parentElement.dataset.y,
+ target.dataset.x,
+ target.parentElement.dataset.y
+ ].map(n => parseInt(n));
+
+ this.drawHexes(...coords);
+ }
+
+ update(cell, { x, y }) {
+ const sl = this.svg.querySelector('.sight-line'),
+ target = this.svg.querySelector('.sight-line-target').parentElement,
+ x1 = cell.dataset.x,
+ y1 = cell.parentElement.dataset.y,
+ x2 = target.dataset.x,
+ y2 = target.parentElement.dataset.y;
+
+ sl.setAttributeNS(null, 'x1', x);
+ sl.setAttributeNS(null, 'y1', y);
+
+ this.drawHexes(...[x1, y1, x2, y2].map(n => parseInt(n)));
+ }
+
+ drawHexes(...coords) {
+ this.clearHexes()
+
+ if (this.distanceCallback) {
+ this.distanceCallback(offset_distance(...coords));
+ }
+
+ let lineCoords = linedraw(...coords);
+
+ let s = lineCoords
+ .map(([x, y]) => `g[data-y="${y}"] g[data-x="${x}"] use[href="#hex"]`)
+ .join(', ');
+
+ this.svg.querySelectorAll(s).forEach(p => p.classList.add('active'));
+ }
+}
diff --git a/src/modules/panzoom.js b/src/modules/panzoom.js
index ae95171..dcc6b34 100644
--- a/src/modules/panzoom.js
+++ b/src/modules/panzoom.js
@@ -1,36 +1,33 @@
import { pan, zoom } from 'pan-zoom';
-export default class PanZoom {
- #storageKey = 'pan-zoom';
- #zoomFactor = 0.25;
-
- constructor(svg) {
- this.#restorePanZoomVal(svg);
- this.#addEventListeners(svg);
- this.#observePanZoomChanges(svg);
- }
+const storageKey = 'pan-zoom',
+ zoomFactor = 0.25;
+
+function restorePanZoomVal(svg) {
+ const storedPanZoomVal = localStorage.getItem(storageKey);
- #storePanZoomVal(transformMatrix) {
- localStorage.setItem(this.#storageKey, transformMatrix);
+ if (storedPanZoomVal) {
+ svg.style.transform = storedPanZoomVal;
}
+}
- #observePanZoomChanges(svg) {
- const observer =
- new MutationObserver(() => this.#storePanZoomVal(svg.style.transform));
+function addEventListeners(svg) {
+ svg.addEventListener('wheel', e => zoom(svg, e, zoomFactor), { passive: false });
+ svg.addEventListener('pointerdown', e => pan(svg, e), { passive: false });
+}
- observer.observe(svg, { attributeFilter: ['style'] });
- }
+function storePanZoomVal(transformMatrix) {
+ localStorage.setItem(storageKey, transformMatrix);
+}
- #restorePanZoomVal(svg) {
- const storedPanZoomVal = localStorage.getItem(this.#storageKey);
+function observePanZoomChanges(svg) {
+ const observer = new MutationObserver(() => storePanZoomVal(svg.style.transform));
- if (storedPanZoomVal) {
- svg.style.transform = storedPanZoomVal;
- }
- }
+ observer.observe(svg, { attributeFilter: ['style'] });
+}
- #addEventListeners(svg) {
- svg.addEventListener('wheel', e => zoom(svg, e, this.#zoomFactor), { passive: false });
- svg.addEventListener('pointerdown', e => pan(svg, e), { passive: false });
- }
-};
+export default function (svg) {
+ restorePanZoomVal(svg);
+ addEventListeners(svg);
+ observePanZoomChanges(svg);
+}
diff --git a/src/modules/sightLine.js b/src/modules/sightLine.js
deleted file mode 100644
index 4790bd8..0000000
--- a/src/modules/sightLine.js
+++ /dev/null
@@ -1,199 +0,0 @@
-const svgns = "http://www.w3.org/2000/svg";
-
-function evenr_to_axial(x, y) {
- return { q: x - (y + (y & 1)) / 2, r: y };
-}
-
-function axial_to_evenr(q, r) {
- return { x: q + (r + (r & 1)) / 2, y: r };
-}
-
-function axial_distance(q1, r1, q2, r2) {
- return (Math.abs(q1 - q2) + Math.abs(q1 + r1 - q2 - r2) + Math.abs(r1 - r2)) / 2;
-}
-
-function offset_distance(x1, y1, x2, y2) {
- let { q: q1, r: r1 } = evenr_to_axial(x1, y1),
- { q: q2, r: r2 } = evenr_to_axial(x2, y2);
-
- return axial_distance(q1, r1, q2, r2);
-}
-
-function cube_to_axial(q, r, s) {
- return { q: q, r: r };
-}
-
-function axial_to_cube(q, r) {
- return { q: q, r: r, s: -q - r };
-}
-
-function cube_round(q, r, s) {
- rQ = Math.round(q);
- rR = Math.round(r);
- rS = Math.round(s);
-
- let q_diff = Math.abs(rQ - q),
- r_diff = Math.abs(rR - r),
- s_diff = Math.abs(rS - s);
-
- if (q_diff > r_diff && q_diff > s_diff) {
- rQ = -rR - rS;
- } else if (r_diff > s_diff) {
- rR = -rQ - rS;
- } else {
- rS = -rQ - rR;
- }
-
- return { q: rQ, r: rR, s: rS };
-}
-
-function axial_round(q, r) {
- let cube = axial_to_cube(q, r),
- round = cube_round(cube.q, cube.r, cube.s),
- axial = cube_to_axial(round.q, round.r, round.s);
-
- return { q: axial.q, r: axial.r };
-}
-
-function lerp(a, b, t) {
- return a + (b - a) * t;
-}
-
-function axial_lerp(q1, r1, q2, r2, t) {
- return { q: lerp(q1, q2, t), r: lerp(r1, r2, t) };
-}
-
-function linedraw(x1, y1, x2, y2) {
- let axial1 = evenr_to_axial(x1, y1),
- axial2 = evenr_to_axial(x2, y2),
- n = offset_distance(x1, y1, x2, y2),
- results = [];
-
- for (let i = 0; i <= n; i++) {
- let lerp = axial_lerp(axial1.q, axial1.r, axial2.q, axial2.r, 1.0 / n * i),
- round = axial_round(lerp.q, lerp.r),
- { x, y } = axial_to_evenr(round.q, round.r);
-
- results.push([x, y]);
- }
-
- return results;
-}
-
-export default class SightLine {
- constructor(svg) {
- this.svg = svg;
- }
-
- getBoard() {
- return this.svg.querySelector('.board');
- }
-
- getActiveHexes() {
- return this.svg.querySelectorAll('use[href="#hex"].active');
- }
-
- clear() {
- const board = this.getBoard(),
- sl = board.querySelector('line.sight-line'),
- target = board.querySelector(`use[href="#hex"].sight-line-target`);
-
- if (sl) {
- sl.remove();
- }
-
- if (target) {
- target.classList.remove('sight-line-target');
- }
-
- this.clearHexes();
- }
-
- clearHexes() {
- if (this.distanceCallback) {
- this.distanceCallback();
- }
-
- this.getActiveHexes().forEach(el => el.classList.remove('active'));
- }
-
- draw(source, target) {
- this.clear();
-
- let pt = new DOMPoint(0, 0),
- transform = getComputedStyle(source).transform.match(/-?\d+\.?\d*/g),
- mtx = new DOMMatrix(transform);
-
- pt = pt.matrixTransform(mtx);
-
- transform = getComputedStyle(source.parentElement).transform.match(/-?\d+\.?\d*/g);
- mtx = new DOMMatrix(transform);
- pt = pt.matrixTransform(mtx);
-
- let slX1 = pt.x,
- slY1 = pt.y;
-
- pt = new DOMPoint(0, 0);
- transform = getComputedStyle(target).transform.match(/-?\d+\.?\d*/g);
- mtx = new DOMMatrix(transform);
-
- pt = pt.matrixTransform(mtx);
-
- transform = getComputedStyle(target.parentElement).transform.match(/-?\d+\.?\d*/g);
- mtx = new DOMMatrix(transform);
- pt = pt.matrixTransform(mtx);
-
- let slX2 = pt.x,
- slY2 = pt.y;
-
- let sightLine = document.createElementNS(svgns, 'line');
-
- sightLine.classList.add('sight-line');
- sightLine.classList.add('active');
- sightLine.setAttributeNS(null, 'x1', slX1);
- sightLine.setAttributeNS(null, 'y1', slY1);
- sightLine.setAttributeNS(null, 'x2', slX2);
- sightLine.setAttributeNS(null, 'y2', slY2);
-
- this.getBoard().appendChild(sightLine);
-
- let coords = [
- source.dataset.x,
- source.parentElement.dataset.y,
- target.dataset.x,
- target.parentElement.dataset.y
- ].map(n => parseInt(n));
-
- this.drawHexes(...coords);
- }
-
- update(cell, { x, y }) {
- const sl = this.svg.querySelector('.sight-line'),
- target = this.svg.querySelector('.sight-line-target').parentElement,
- x1 = cell.dataset.x,
- y1 = cell.parentElement.dataset.y,
- x2 = target.dataset.x,
- y2 = target.parentElement.dataset.y;
-
- sl.setAttributeNS(null, 'x1', x);
- sl.setAttributeNS(null, 'y1', y);
-
- this.drawHexes(...[x1, y1, x2, y2].map(n => parseInt(n)));
- }
-
- drawHexes(...coords) {
- this.clearHexes()
-
- if (this.distanceCallback) {
- this.distanceCallback(offset_distance(...coords));
- }
-
- let lineCoords = linedraw(...coords);
-
- let s = lineCoords
- .map(([x, y]) => `g[data-y="${y}"] g[data-x="${x}"] use[href="#hex"]`)
- .join(', ');
-
- this.svg.querySelectorAll(s).forEach(p => p.classList.add('active'));
- }
-}
--
cgit v1.2.3