70 lines
3.0 KiB
JavaScript
70 lines
3.0 KiB
JavaScript
// The rules behind the actor tokens of a map (drag an actor from the sidebar onto a map, move the
|
|
// token from cell to cell). Like the pins, a token is stored in image pixels, so these helpers only
|
|
// translate and snap: they hold no state and talk to no API.
|
|
|
|
// What the sidebar puts into a drag when an actor row is pulled out of it, so the map knows an actor
|
|
// is on its way and nothing else dropped on it (a note, a file) is taken for one.
|
|
const ACTOR_DRAG_TYPE = 'application/x-dragonroll-actor';
|
|
|
|
// The actor id carried by a drag event, or null when the drag carries no actor. `types` is what a
|
|
// dragover can see: the data itself is protected until the drop.
|
|
function IsActorDrag(event) {
|
|
return Array.from(event?.dataTransfer?.types ?? []).includes(ACTOR_DRAG_TYPE);
|
|
}
|
|
|
|
function ActorDragId(event) {
|
|
return String(event?.dataTransfer?.getData?.(ACTOR_DRAG_TYPE) ?? '').trim() || null;
|
|
}
|
|
|
|
// The middle of the grid cell a point of the image stands in, in image pixels: this is what a token
|
|
// is stored at, so it always stands in a square of the grid. The backend snaps the same way, so a
|
|
// token does not move when a drag lands.
|
|
function CellCentre(point, grid) {
|
|
const size = Math.max(1, Number(grid?.gridSize) || 50);
|
|
const offsetX = Number(grid?.offsetX) || 0;
|
|
const offsetY = Number(grid?.offsetY) || 0;
|
|
|
|
const x = Number(point?.x);
|
|
const y = Number(point?.y);
|
|
if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
|
|
|
|
// Spots off the top left corner count from the corner itself, and only whole pixels count: both
|
|
// the way the route reads a coordinate, so the token a drag shows is the token that gets saved.
|
|
const column = Math.floor((Math.max(0, Math.round(x)) - offsetX) / size);
|
|
const row = Math.floor((Math.max(0, Math.round(y)) - offsetY) / size);
|
|
return {
|
|
x: Math.max(0, Math.round(offsetX + (column + 0.5) * size)),
|
|
y: Math.max(0, Math.round(offsetY + (row + 0.5) * size))
|
|
};
|
|
}
|
|
|
|
// A token moved by whole cells (the arrow keys of a focused token): the same cell width the grid is
|
|
// drawn with, so a token steps from one square to the next and never in between.
|
|
function MoveByCells(centre, grid, columns, rows) {
|
|
const size = Math.max(1, Number(grid?.gridSize) || 50);
|
|
const x = Number(centre?.x);
|
|
const y = Number(centre?.y);
|
|
if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
|
|
|
|
return {
|
|
x: Math.max(0, Math.round(x + Number(columns) * size)),
|
|
y: Math.max(0, Math.round(y + Number(rows) * size))
|
|
};
|
|
}
|
|
|
|
// The side of a token in screen pixels: one grid cell, so a token covers the square it stands in at
|
|
// every zoom. Never smaller than an icon, or a zoomed-out map would hide its actors.
|
|
function TokenSize(grid, zoom) {
|
|
const cell = Math.max(1, Number(grid?.gridSize) || 50) * (Number(zoom) || 1);
|
|
return Math.round(Math.max(18, cell));
|
|
}
|
|
|
|
export {
|
|
ACTOR_DRAG_TYPE,
|
|
ActorDragId,
|
|
CellCentre,
|
|
IsActorDrag,
|
|
MoveByCells,
|
|
TokenSize
|
|
};
|