Fix issue #101: Add lights to maps
All checks were successful
Test / test (push) Successful in 2s

This commit is contained in:
Gitea OpenCode Agent
2026-10-16 01:59:57 +00:00
parent c9ee16f2f2
commit 8510a93027
13 changed files with 1552 additions and 14 deletions

View File

@@ -5,6 +5,7 @@ import { ClearWindow, CreateWindow, GetFirstWindowId } from '@/services/Windows'
import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu';
import { BuildNoteOptions, OptionLabel, ToImagePoint, ToScreenPoint } from '~/services/MapPins';
import { ActorDragId, CellCentre, IsActorDrag, MoveByCells, TokenSize } from '~/services/MapTokens';
import { CastLight, SnapToGridVertex, WallAt } from '~/services/MapLighting';
import { DisplayToast } from '~/services/Toaster';
import Server, { getBaseUrl } from '~/services/Server';
import { emitter } from '~/services/Emitter';
@@ -29,6 +30,15 @@ const zoom = ref(1);
const pan = ref({ x: 0, y: 0 });
const imageSize = ref({ width: 0, height: 0 });
const showGrid = ref(true);
// Lighting over the map: the dark the lights are carved out of. Off by default, so a map reads as the
// picture it is until whoever is running the table asks for the dark.
const showLighting = ref(false);
// Drawing walls instead of panning the map: a wall is dragged from one corner of the grid to another.
const wallMode = ref(false);
// The wall being drawn — the corner it starts at and the one the pointer has reached. It is written
// once, when the pointer lets go, so drawing a wall is not one request per mouse move.
const drawingWall = ref(null);
let wallPointerId = null;
const dragging = ref(false);
const minZoom = 0.05;
@@ -114,6 +124,8 @@ let lastPointer = { x: 0, y: 0 };
function onPointerDown(event) {
if (event.button !== 0 || !viewport.value) return;
// The wall tool takes the pointer for itself: holding the map then draws a wall instead of moving it.
if (wallMode.value && startWallDrag(event)) return;
dragging.value = true;
pointerId = event.pointerId;
lastPointer = { x: event.clientX, y: event.clientY };
@@ -121,12 +133,14 @@ function onPointerDown(event) {
}
function onPointerMove(event) {
if (moveWallDrag(event)) return;
if (!dragging.value || event.pointerId !== pointerId) return;
pan.value = { x: pan.value.x + (event.clientX - lastPointer.x), y: pan.value.y + (event.clientY - lastPointer.y) };
lastPointer = { x: event.clientX, y: event.clientY };
}
function onPointerUp(event) {
async function onPointerUp(event) {
if (await endWallDrag(event)) return;
if (event.pointerId !== pointerId) return;
dragging.value = false;
pointerId = null;
@@ -195,20 +209,37 @@ function onMapContextMenu(event) {
const spot = ToImagePoint({ x: event.clientX - bounds.left, y: event.clientY - bounds.top }, viewState());
if (!spot) return;
if (!noteOptions.value.length) {
ShowContextMenu([{ name: t('campaigns.map.pins.none'), action: () => HideContextMenu() }]);
return;
const items = [];
if (!noteOptions.value.length) items.push({ name: t('campaigns.map.pins.none'), action: () => HideContextMenu() });
else {
items.push({
name: t('campaigns.map.pins.add'),
icon: '/icons/iconoir/regular/map-pin-plus.svg',
context: noteOptions.value.map((option) => ({
name: option.label,
icon: '/icons/iconoir/regular/notes.svg',
action: () => { HideContextMenu(); savePin(option.value, spot); }
}))
});
}
ShowContextMenu([{
name: t('campaigns.map.pins.add'),
icon: '/icons/iconoir/regular/map-pin-plus.svg',
context: noteOptions.value.map((option) => ({
name: option.label,
icon: '/icons/iconoir/regular/notes.svg',
action: () => { HideContextMenu(); savePin(option.value, spot); }
}))
}]);
items.push({ divider: true });
items.push({
name: t('campaigns.map.lights.add'),
icon: '/icons/iconoir/regular/fire-flame.svg',
action: () => { HideContextMenu(); placeLight(spot); }
});
// A wall is a line, not a marker to hold: right clicking along it is how it is taken off again.
const wall = WallAt(spot, walls.value, WALL_PICK_PX / Math.max(0.05, zoom.value));
if (wall) {
items.push({
name: t('campaigns.map.walls.remove'),
icon: '/icons/iconoir/regular/xmark-circle.svg',
action: () => { HideContextMenu(); removeWall(wall); }
});
}
ShowContextMenu(items);
}
function onPinContextMenu(pin) {
@@ -503,6 +534,328 @@ function handleActorEntry({ entityType, entry }) {
actors.value = [entry, ...actors.value.filter((current) => String(current._id) !== String(entry._id))];
}
// --- Lights, and the walls that stop them ---
// A light shines from one spot of the image and is as free to place as a pin. The walls of the map are
// what cuts its reach into a shadow: CastLight works out the shape a light paints and the canvas below
// paints that shape out of the dark laid over the map.
// A new light covers this much of the map it is placed on, and half of that is bright light.
const LIGHT_CELLS = 3;
// How near a line a right click has to come to mean that wall, in screen pixels (it is divided by the
// zoom to become image pixels, so picking a wall is as easy zoomed out as zoomed in).
const WALL_PICK_PX = 10;
const lightingCanvas = ref(null);
const lights = computed(() => map.value?.lights ?? []);
const walls = computed(() => map.value?.walls ?? []);
// The light a pointer is holding, and the spot it holds it at: like a token, the move stays local until
// the pointer lets go, so dragging a light across the map is one save and not one per mouse move.
const movingLight = ref(null);
let lightPointerId = null;
// A colour from the theme the canvas paints with. The canvas cannot be styled with `var(--color-…)`
// like a stylesheet, so it asks the document for the same variable the stylesheets use.
function themeColor(name, fallback) {
if (typeof window === 'undefined' || typeof getComputedStyle !== 'function') return fallback;
return getComputedStyle(document.documentElement).getPropertyValue(name).trim() || fallback;
}
// A hex colour with an alpha end ('#ffc46b' + '4d'), because a canvas gradient needs its stops spelled
// out. Anything that is not a plain hex colour is painted as it is.
function withAlpha(color, alpha) {
const value = String(color ?? '').trim();
if (/^#[0-9a-f]{6}$/i.test(value)) return `${value}${alpha}`;
if (/^#[0-9a-f]{3}$/i.test(value)) return `#${value.slice(1)}${value.slice(1)}${alpha}`;
return value;
}
// The light a marker is drawn for: the spot it is being held at while a pointer drags it, and its own
// spot otherwise.
function heldLight(light) {
if (movingLight.value && String(movingLight.value.light?._id) === String(light?._id)) return movingLight.value;
return { x: Number(light?.x) || 0, y: Number(light?.y) || 0 };
}
function lightStyle(light) {
const point = ToScreenPoint(heldLight(light), viewState());
return { left: `${point.x}px`, top: `${point.y}px` };
}
// The reach a light is given when it is placed: enough of the map to matter at the grid it stands on.
function defaultLightReach() {
const cell = Math.max(1, Number(map.value?.gridSize) || 50);
const radius = Math.round(cell * LIGHT_CELLS);
return { radius, bright: Math.round(radius / 2) };
}
async function placeLight(spot) {
const reach = defaultLightReach();
await updateMap('/map/place-light', {
id: map.value?._id, x: spot.x, y: spot.y, ...reach
}, t('campaigns.map.lights.error'));
}
async function removeLight(light) {
await updateMap('/map/remove-light', { id: map.value?._id, light: light?._id }, t('campaigns.map.lights.error'));
}
function onLightPointerDown(event, light) {
// Holding a light moves the light, never the map.
event.stopPropagation();
if (event.button !== 0) return;
lightPointerId = event.pointerId;
event.currentTarget.setPointerCapture?.(event.pointerId);
movingLight.value = { light: { ...light }, x: Number(light.x) || 0, y: Number(light.y) || 0 };
}
function onLightPointerMove(event) {
if (!movingLight.value || event.pointerId !== lightPointerId) return;
const spot = imagePointOf(event);
// Dragged off the image, the light keeps its spot: a light is never lost over the edge.
if (!spot) return;
movingLight.value = { ...movingLight.value, x: spot.x, y: spot.y };
}
async function onLightPointerUp(event) {
if (!movingLight.value || event.pointerId !== lightPointerId) return;
const { light, x, y } = movingLight.value;
lightPointerId = null;
movingLight.value = null;
event.currentTarget?.releasePointerCapture?.(event.pointerId);
if (x === Number(light.x) && y === Number(light.y)) return;
await updateMap('/map/update-light', { id: map.value?._id, light: light._id, x, y }, t('campaigns.map.lights.error'));
}
function onLightContextMenu(light) {
ShowContextMenu([{
name: t('campaigns.map.lights.remove'),
icon: '/icons/iconoir/regular/xmark-circle.svg',
action: () => { HideContextMenu(); removeLight(light); }
}]);
}
// Delete takes a focused light off the map, like it does a focused token.
async function onLightKeydown(event, light) {
if (event.key === 'Delete' || event.key === 'Backspace') {
event.preventDefault();
await removeLight(light);
}
}
// --- Drawing walls ---
// With the wall tool on, the pointer draws instead of panning: it is held down at one corner of the
// grid and let go at another, and the wall between those two corners is what gets saved.
// Holds down the first corner of a wall, or says the wall tool has nothing to hold (off the image).
function startWallDrag(event) {
const spot = imagePointOf(event);
if (!spot) return false;
const corner = SnapToGridVertex(spot, grid.value);
if (!corner) return false;
wallPointerId = event.pointerId;
viewport.value?.setPointerCapture?.(event.pointerId);
drawingWall.value = { x1: corner.x, y1: corner.y, x2: corner.x, y2: corner.y };
return true;
}
function moveWallDrag(event) {
if (!drawingWall.value || event.pointerId !== wallPointerId) return false;
const spot = imagePointOf(event);
// Off the image the wall keeps the end it had: a wall cannot hang outside of the map.
if (!spot) return true;
const corner = SnapToGridVertex(spot, grid.value);
if (!corner) return true;
if (corner.x === drawingWall.value.x2 && corner.y === drawingWall.value.y2) return true;
drawingWall.value = { ...drawingWall.value, x2: corner.x, y2: corner.y };
return true;
}
async function endWallDrag(event) {
if (!drawingWall.value || event.pointerId !== wallPointerId) return false;
const wall = drawingWall.value;
wallPointerId = null;
drawingWall.value = null;
viewport.value?.releasePointerCapture?.(event.pointerId);
// Dragged out and back to the same corner is not a wall: it stops nothing and cannot be picked
// up again, so it is dropped where it was drawn.
if (wall.x1 === wall.x2 && wall.y1 === wall.y2) return true;
await saveWall(wall);
return true;
}
async function saveWall(wall) {
await updateMap('/map/wall', { id: map.value?._id, ...wall }, t('campaigns.map.walls.error'));
}
async function removeWall(wall) {
await updateMap('/map/remove-wall', { id: map.value?._id, wall: wall?._id }, t('campaigns.map.walls.error'));
}
// --- Painting the lights ---
// One canvas over the map, drawn in screen pixels like the pins and the tokens, and repainted whenever
// the view or the map changes. With the lighting on it lays the dark over the image and erases the shape
// of every light out of it, so what is left dark is exactly what its walls hide. With the lighting off
// the same shapes are drawn as thin outlines, which is what makes reaching for a light's size possible
// while it is still being placed.
function imageScreenRect() {
const origin = ToScreenPoint({ x: 0, y: 0 }, viewState());
return {
x: origin.x,
y: origin.y,
width: imageSize.value.width * zoom.value,
height: imageSize.value.height * zoom.value
};
}
function tracePolygon(context, points, view) {
context.beginPath();
points.forEach((point, index) => {
const screen = ToScreenPoint(point, view);
if (index) context.lineTo(screen.x, screen.y);
else context.moveTo(screen.x, screen.y);
});
context.closePath();
}
function paintDarkness(context, image) {
const view = viewState();
context.save();
context.fillStyle = themeColor('--color-map-darkness', '#000000d9');
context.fillRect(image.x, image.y, image.width, image.height);
// The lights erase the dark they stand in: only how much a gradient is transparent matters here, so
// a light fades from fully lit at its middle to nothing at the end of its reach.
context.globalCompositeOperation = 'destination-out';
for (const light of lights.value) {
const shape = CastLight(light, walls.value);
if (!shape.length) continue;
const centre = ToScreenPoint(heldLight(light), view);
const reach = Math.max(1, (Number(light.radius) || 0) * zoom.value);
const core = Math.max(0, Math.min(1, (Number(light.bright) || 0) / (Number(light.radius) || 1)));
context.save();
tracePolygon(context, shape, view);
context.clip();
const gradient = context.createRadialGradient(centre.x, centre.y, 0, centre.x, centre.y, reach);
gradient.addColorStop(0, '#000000ff');
gradient.addColorStop(core, '#000000f5');
gradient.addColorStop(1, '#00000000');
context.fillStyle = gradient;
context.fillRect(image.x, image.y, image.width, image.height);
context.restore();
}
// The tint of a coloured light, laid back over the light it colours: a lantern reads warm and a
// spell cold, and a light with no colour of its own leaves the map as it is.
context.globalCompositeOperation = 'source-over';
for (const light of lights.value) {
if (!light.color) continue;
const shape = CastLight(light, walls.value);
if (!shape.length) continue;
const centre = ToScreenPoint(heldLight(light), view);
const reach = Math.max(1, (Number(light.radius) || 0) * zoom.value);
context.save();
tracePolygon(context, shape, view);
context.clip();
const gradient = context.createRadialGradient(centre.x, centre.y, 0, centre.x, centre.y, reach);
gradient.addColorStop(0, withAlpha(light.color, '33'));
gradient.addColorStop(1, withAlpha(light.color, '00'));
context.fillStyle = gradient;
context.fillRect(image.x, image.y, image.width, image.height);
context.restore();
}
context.restore();
}
function paintLightOutlines(context) {
const view = viewState();
context.save();
context.lineWidth = 1;
for (const light of lights.value) {
const shape = CastLight(light, walls.value);
if (!shape.length) continue;
tracePolygon(context, shape, view);
context.strokeStyle = withAlpha(light.color || '#ffffff', '59');
context.stroke();
}
context.restore();
}
function paintWalls(context) {
if (!walls.value.length && !drawingWall.value) return;
const view = viewState();
context.save();
context.lineCap = 'round';
context.strokeStyle = themeColor('--color-map-wall', '#e06c75');
// The wall tool asks for a firmer line: it is the tool that has to see what it has drawn already.
context.lineWidth = wallMode.value ? 3 : 2;
for (const wall of walls.value) {
const from = ToScreenPoint({ x: Number(wall.x1) || 0, y: Number(wall.y1) || 0 }, view);
const to = ToScreenPoint({ x: Number(wall.x2) || 0, y: Number(wall.y2) || 0 }, view);
context.beginPath();
context.moveTo(from.x, from.y);
context.lineTo(to.x, to.y);
context.stroke();
}
// The wall being drawn, along the grid corners the pointer has reached so far.
if (drawingWall.value) {
context.setLineDash([6, 4]);
const from = ToScreenPoint({ x: drawingWall.value.x1, y: drawingWall.value.y1 }, view);
const to = ToScreenPoint({ x: drawingWall.value.x2, y: drawingWall.value.y2 }, view);
context.beginPath();
context.moveTo(from.x, from.y);
context.lineTo(to.x, to.y);
context.stroke();
}
context.restore();
}
function drawLighting() {
const canvas = lightingCanvas.value;
const bounds = viewport.value?.getBoundingClientRect();
if (!canvas || !bounds) return;
const width = Math.max(1, Math.round(bounds.width));
const height = Math.max(1, Math.round(bounds.height));
if (canvas.width !== width) canvas.width = width;
if (canvas.height !== height) canvas.height = height;
const context = canvas.getContext?.('2d');
if (!context) return;
context.clearRect(0, 0, width, height);
if (!imageUrl.value) return;
if (showLighting.value) paintDarkness(context, imageScreenRect());
else paintLightOutlines(context);
paintWalls(context);
}
// Every move of the view, and every light or wall that changes, is painted again.
watch(
[zoom, pan, imageSize, showLighting, wallMode, drawingWall, lights, walls, imageUrl],
() => nextTick(drawLighting),
{ deep: true }
);
onMounted(() => {
window.addEventListener('resize', drawLighting);
nextTick(drawLighting);
});
onBeforeUnmount(() => {
window.removeEventListener('resize', drawLighting);
});
// A different map was anchored while this pane was already mounted.
watch(() => props.map, (incoming, previous) => {
if (incoming === previous) return;
@@ -510,6 +863,9 @@ watch(() => props.map, (incoming, previous) => {
imageSize.value = { width: 0, height: 0 };
movingToken.value = null;
draggingActor.value = false;
movingLight.value = null;
drawingWall.value = null;
wallPointerId = null;
});
watch(campaignId, () => {
@@ -550,6 +906,14 @@ onBeforeUnmount(() => {
:aria-label="$t('campaigns.map.toggle-grid')" :aria-pressed="showGrid.toString()" @click="showGrid = !showGrid">
<img class="tool-icon" src="/icons/iconoir/regular/view-grid.svg" alt="" aria-hidden="true">
</button>
<button class="viewer-tool" :class="{ selected: showLighting }" type="button" :title="$t('campaigns.map.toggle-lighting')"
:aria-label="$t('campaigns.map.toggle-lighting')" :aria-pressed="showLighting.toString()" @click="showLighting = !showLighting">
<img class="tool-icon" src="/icons/iconoir/regular/light-bulb-on.svg" alt="" aria-hidden="true">
</button>
<button class="viewer-tool" :class="{ selected: wallMode }" type="button" :title="$t('campaigns.map.toggle-walls')"
:aria-label="$t('campaigns.map.toggle-walls')" :aria-pressed="wallMode.toString()" @click="wallMode = !wallMode">
<img class="tool-icon" src="/icons/iconoir/regular/linear.svg" alt="" aria-hidden="true">
</button>
<button class="viewer-tool" type="button" :title="$t('campaigns.map.zoom-out')" :aria-label="$t('campaigns.map.zoom-out')" @click="zoomFromToolbar(false)">
<img class="tool-icon" src="/icons/iconoir/regular/minus.svg" alt="" aria-hidden="true">
</button>
@@ -573,7 +937,7 @@ onBeforeUnmount(() => {
<div
ref="viewport"
class="map-viewport"
:class="{ dragging }"
:class="{ dragging, 'wall-mode': wallMode }"
@wheel.prevent="onWheel"
@pointerdown="onPointerDown"
@pointermove="onPointerMove"
@@ -587,6 +951,28 @@ onBeforeUnmount(() => {
<template v-if="imageUrl">
<img class="map-image" :src="imageUrl" :style="stageStyle" :alt="map?.name" draggable="false" @load="onImageLoaded">
<div class="map-grid" :style="gridStyle" aria-hidden="true"></div>
<canvas ref="lightingCanvas" class="map-lighting" aria-hidden="true"></canvas>
<div class="map-lights">
<button
v-for="light in lights"
:key="light._id"
class="map-light"
:class="{ moving: movingLight && String(movingLight.light?._id) === String(light._id) }"
type="button"
:style="lightStyle(light)"
:title="$t('campaigns.map.lights.light')"
:aria-label="$t('campaigns.map.lights.light')"
draggable="false"
@pointerdown="onLightPointerDown($event, light)"
@pointermove="onLightPointerMove"
@pointerup="onLightPointerUp"
@pointercancel="onLightPointerUp"
@contextmenu.stop.prevent="onLightContextMenu(light)"
@keydown="onLightKeydown($event, light)"
>
<img class="light-icon" src="/icons/iconoir/regular/fire-flame.svg" alt="" aria-hidden="true">
</button>
</div>
<div class="map-pins">
<button
v-for="pin in pins"
@@ -629,6 +1015,7 @@ onBeforeUnmount(() => {
</button>
</div>
<div v-if="draggingActor" class="map-drop-hint">{{ $t('campaigns.map.tokens.drop-hint') }}</div>
<div v-if="wallMode" class="map-drop-hint">{{ $t('campaigns.map.walls.hint') }}</div>
</template>
<div v-else class="map-empty">
{{ $t('campaigns.map.no-image') }}
@@ -654,6 +1041,23 @@ onBeforeUnmount(() => {
.map-viewport.dragging { cursor: grabbing; }
.map-image { position: absolute; top: 0; left: 0; max-width: none; transform-origin: top left; user-select: none; }
.map-grid { position: absolute; top: 0; left: 0; opacity: .55; pointer-events: none; }
.map-viewport.wall-mode { cursor: crosshair; }
/* The lights are painted on a canvas over the image and in screen space, like the pins: the dark over
the map and the shape each light cuts in it are redrawn whenever the view moves (see drawLighting).
The canvas never catches the mouse; the light markers below do that. */
.map-lighting { position: absolute; top: 0; left: 0; pointer-events: none; }
.map-lights { position: absolute; inset: 0; pointer-events: none; }
.map-light {
position: absolute; transform: translate(-50%, -50%); pointer-events: auto;
display: flex; align-items: center; justify-content: center; width: 26px; height: 26px;
margin: 0; padding: 0; border: 1px solid var(--color-link); border-radius: 50%;
background: var(--color-background-soft); color: var(--color-text);
cursor: grab; user-select: none; box-shadow: 0px 0px 6px -1px rgba(0,0,0,0.55);
}
.map-light:hover { background: var(--color-button-hover); }
.map-light:focus-visible { outline: 1px solid var(--color-link); outline-offset: 2px; }
.map-light.moving { cursor: grabbing; }
.light-icon { width: 14px; height: 14px; filter: invert(var(--color-icon-invert)); }
/* Pins live in image pixels but are drawn in screen space (see ToScreenPoint), so the overlay stays
unscaled and their markers are readable at every zoom. Only the markers catch the mouse. */
.map-pins { position: absolute; inset: 0; pointer-events: none; }