Self-review: markers on the desktop too, and drop tiles when the dimension changes

I split the three maps again, one PR after merging them. Structures went into the
shared web engine and the routes, and the desktop — which is an admin surface and
the one an operator uses most — got none of it. It has the toggle, the filter and
the same markers now, drawn from the same `structureKind` grouping so a village
is the same dot everywhere.

Worse, and older than this PR: tiles are keyed by chunk alone, and the nether
uses the same coordinates as the overworld. Switching dimension kept the tiles,
so one world's terrain was drawn under another world's players — shipped in #119
and true on every surface. Both caches are dropped when the dimension changes.

The markers were also drawn before the grid and the heatmap, so a grid line
crossed every one of them. They go after both and before the players: a marker
under a line reads as a smudge, and a player must never be behind one.

Author: CaYatur

src/main/ipc/register.ts

@@ -302,10 +302,17 @@ export function registerIpc(): void {
   H(IPC.bridgeInstall, (_e, id: string) =>
     bridgeInstall.installBridge(id, { by: 'desktop', source: 'panel' })
   )
-  H(IPC.mapTiles, (_e, id: string, dim: string, chunks: { cx: number; cz: number }[]) =>
-    // Capped here too: the renderer is trusted, but a bug there should not be
-    // able to queue a whole world any more than a web caller can.
-    worldTiles.requestTiles(id, dim, (chunks ?? []).slice(0, worldTiles.MAX_TILES_PER_REQUEST))
+  H(
+    IPC.mapTiles,
+    (_e, id: string, dim: string, chunks: { cx: number; cz: number }[], marks?: boolean) =>
+      // Capped here too: the renderer is trusted, but a bug there should not be
+      // able to queue a whole world any more than a web caller can.
+      worldTiles.requestTiles(
+        id,
+        dim,
+        (chunks ?? []).slice(0, worldTiles.MAX_TILES_PER_REQUEST),
+        { marks: !!marks }
+      )
   )
 
   // --- java installs ---

src/preload/index.ts

@@ -80,7 +80,7 @@ const api: MsmsApi = {
 
   bridgeStatus: (id) => ipcRenderer.invoke(IPC.bridgeStatus, id),
   installBridge: (id) => ipcRenderer.invoke(IPC.bridgeInstall, id),
-  mapTiles: (id, dim, chunks) => ipcRenderer.invoke(IPC.mapTiles, id, dim, chunks),
+  mapTiles: (id, dim, chunks, marks) => ipcRenderer.invoke(IPC.mapTiles, id, dim, chunks, marks),
 
   listJava: (refresh) => ipcRenderer.invoke(IPC.javaList, refresh),
   resolveJava: (override) => ipcRenderer.invoke(IPC.javaResolve, override),

src/renderer/src/components/LiveMap.tsx

@@ -4,6 +4,7 @@ import { Map as MapIcon, Flame } from 'lucide-react'
 import { fitView, heatmap, mapBounds, panBy, screenToWorld, worldToScreen, zoomAt } from '@shared/livemap'
 import type { LivePlayer, MapView, Viewport } from '@shared/livemap'
 import { avatarUrl } from '@shared/profile'
+import type { StructureMark } from '@shared/regionFormat'
 import type { BridgeStatus } from '@shared/bridgeRelease'
 import { BridgeNotice } from './BridgeNotice'
 
@@ -23,6 +24,16 @@ import { BridgeNotice } from './BridgeNotice'
 
 const CELL_CHOICES = [16, 32, 64, 128]
 
+/** Matches the web map's, so a village is the same dot in all three (#131). */
+const MARK_STYLE: Record<string, [string, string]> = {
+  village: ['#e3b341', 'V'],
+  dungeon: ['#b5504f', 'D'],
+  temple: ['#c58bd6', 'T'],
+  fortress: ['#8b6f4e', 'F'],
+  mine: ['#9aa0a6', 'M'],
+  other: ['#6fa8dc', '?']
+}
+
 /**
  * A chunk tile baked into a 16x16 offscreen canvas, shaded by the step to the
  * column north of it. Baking once per chunk rather than per frame is the
@@ -175,6 +186,12 @@ export function LiveMap({ serverId }: { serverId: string }): JSX.Element {
   // toggle to get the obvious thing.
   const [heads, setHeads] = useState(true)
   const [world, setWorld] = useState(true)
+  // Structures, same as the web surfaces have them — off by default, and an
+  // operator may switch them on without a setting because they can already read
+  // the world folder (#131).
+  const [marks, setMarks] = useState(false)
+  const [markKind, setMarkKind] = useState('')
+  const markStore = useRef(new Map<string, StructureMark[]>())
   const headCache = useRef(new Map<string, HTMLImageElement | false>())
   const tiles = useRef(new Map<string, HTMLCanvasElement | null>())
   const tilesPending = useRef(false)
@@ -205,29 +222,41 @@ export function LiveMap({ serverId }: { serverId: string }): JSX.Element {
     trimTiles(tiles.current, visibleChunks())
     tilesPending.current = true
     window.msms
-      .mapTiles(serverId, dim, want)
+      .mapTiles(serverId, dim, want, marks)
       .then((r) => {
         tilesPending.current = false
         for (const w of want) {
           const k = w.cx + ',' + w.cz
           const t = r.tiles[k]
-          if (t) tiles.current.set(k, bakeTile(t))
-          else if (!r.pending) tiles.current.set(k, null)
+          if (t) {
+            tiles.current.set(k, bakeTile(t))
+            if (t.m) markStore.current.set(k, t.m)
+          } else if (!r.pending) tiles.current.set(k, null)
         }
         setTick2((n) => n + 1)
       })
       .catch(() => {
         tilesPending.current = false
       })
-  }, [world, view, vp, dim, serverId, visibleChunks, tick2])
+  }, [world, view, vp, dim, serverId, visibleChunks, tick2, marks])
 
   // A different server or dimension is a different world; nothing carries over.
+  // The nether shares the overworld's coordinates, so keeping tiles across a
+  // dimension change would draw one world's terrain under another's players.
   useEffect(() => {
     tiles.current.clear()
+    markStore.current.clear()
     setView(null)
     fitFor.current = ''
   }, [serverId, dim])
 
+  // Tiles already held were fetched without markers, so they carry none.
+  useEffect(() => {
+    if (!marks) return
+    tiles.current.clear()
+    markStore.current.clear()
+  }, [marks])
+
   useEffect(() => {
     const cv = canvasRef.current
     if (!cv) return
@@ -316,6 +345,30 @@ export function LiveMap({ serverId }: { serverId: string }): JSX.Element {
       }
     }
 
+    // After the grid and the heatmap, before the players.
+    if (marks) {
+      g.textAlign = 'center'
+      g.textBaseline = 'middle'
+      g.font = `bold ${10 * dpr}px Inter, system-ui, sans-serif`
+      for (const c of visibleChunks()) {
+        for (const mk of markStore.current.get(c.cx + ',' + c.cz) ?? []) {
+          if (markKind && mk.kind !== markKind) continue
+          const st = MARK_STYLE[mk.kind] ?? MARK_STYLE.other
+          const x = px(mk.x)
+          const y = pz(mk.z)
+          g.beginPath()
+          g.arc(x, y, 7 * dpr, 0, Math.PI * 2)
+          g.fillStyle = st[0]
+          g.fill()
+          g.lineWidth = 1.5 * dpr
+          g.strokeStyle = 'rgba(0,0,0,.6)'
+          g.stroke()
+          g.fillStyle = '#101014'
+          g.fillText(st[1], x, y + 0.5 * dpr)
+        }
+      }
+    }
+
     g.font = `${11 * dpr}px Inter, system-ui, sans-serif`
     g.textAlign = 'center'
     g.textBaseline = 'bottom'
@@ -341,7 +394,7 @@ export function LiveMap({ serverId }: { serverId: string }): JSX.Element {
       g.fillStyle = 'rgba(255,255,255,.92)'
       g.fillText(p.name, x, y - (head ? 12 : 7) * dpr)
     }
-  }, [shown, bounds, heat, cell, showHeat, view, vp, dim, heads, world, tick2, visibleChunks])
+  }, [shown, bounds, heat, cell, showHeat, view, vp, dim, heads, world, marks, markKind, tick2, visibleChunks])
 
   const localPoint = (e: React.MouseEvent): { x: number; y: number } => {
     const r = (e.target as HTMLCanvasElement).getBoundingClientRect()
@@ -401,6 +454,19 @@ export function LiveMap({ serverId }: { serverId: string }): JSX.Element {
         <button className={`btn sm ${world ? 'primary' : ''}`} onClick={() => setWorld((v) => !v)}>
           {t('map.world')}
         </button>
+        <button className={`btn sm ${marks ? 'primary' : ''}`} onClick={() => setMarks((v) => !v)}>
+          {t('map.structures')}
+        </button>
+        {marks && (
+          <select className="select" style={{ width: 150 }} value={markKind} onChange={(e) => setMarkKind(e.target.value)}>
+            <option value="">{t('map.allStructures')}</option>
+            {(['village', 'dungeon', 'temple', 'fortress', 'mine'] as const).map((k) => (
+              <option key={k} value={k}>
+                {t('map.structure_' + k)}
+              </option>
+            ))}
+          </select>
+        )}
         <button className="btn sm" onClick={() => setView(null)}>
           {t('map.resetView')}
         </button>

src/renderer/src/locales/en.ts

@@ -126,6 +126,13 @@ export default {
       'No live positions yet — this server has no MSMS-Bridge plugin. Positions arrive over the server console, so installing it opens no extra port.',
     heads: 'Heads',
     goTo: 'Centre the map here',
+    structures: 'Structures',
+    allStructures: 'All structures',
+    structure_village: 'Villages',
+    structure_dungeon: 'Dungeons & ruins',
+    structure_temple: 'Temples',
+    structure_fortress: 'Fortresses',
+    structure_mine: 'Mineshafts',
     world: 'World',
     resetView: 'Reset view',
     installBridge: 'Install MSMS-Bridge {{version}}',

src/renderer/src/locales/tr.ts

@@ -128,6 +128,13 @@ const tr: typeof en = {
       'Henüz canlı konum yok — bu sunucuda MSMS-Bridge eklentisi yok. Konumlar sunucu konsolu üzerinden geldiği için kurmak ek bir port açmaz.',
     heads: 'Kafalar',
     goTo: 'Haritayı buraya ortala',
+    structures: 'Yapılar',
+    allStructures: 'Tüm yapılar',
+    structure_village: 'Köyler',
+    structure_dungeon: 'Zindanlar ve kalıntılar',
+    structure_temple: 'Tapınaklar',
+    structure_fortress: 'Kaleler',
+    structure_mine: 'Maden ocakları',
     world: 'Dünya',
     resetView: 'Görünümü sıfırla',
     installBridge: 'MSMS-Bridge {{version}} kur',

src/shared/ipc.ts

@@ -42,6 +42,7 @@ import type { AlertRule, NewAlertRule } from './alerts'
 import type { McVersion, BuildInfo, CreateServerOptions, CreateProgress } from './versions'
 import type { ModEntry, ModrinthDetail, ModrinthHit, ModUpdateReport } from './mods'
 import type { BridgeInstallResult, BridgeStatus } from './bridgeRelease'
+import type { StructureMark } from './regionFormat'
 import type {
   WebStatus,
   WebUserView,
@@ -345,8 +346,12 @@ export interface MsmsApi {
   mapTiles(
     id: string,
     dim: string,
-    chunks: { cx: number; cz: number }[]
-  ): Promise<{ tiles: Record<string, { c: number[]; h: number[] }>; pending: number }>
+    chunks: { cx: number; cz: number }[],
+    marks?: boolean
+  ): Promise<{
+    tiles: Record<string, { c: number[]; h: number[]; m?: StructureMark[] }>
+    pending: number
+  }>
 
   listJava(refresh?: boolean): Promise<JavaInstall[]>
   /** The Java that will actually launch, given a per-server override ('' = auto). */

src/shared/mapUi.ts

@@ -183,6 +183,10 @@ function mapRefresh(){
      that is not one. Keeping the last good frame beats blanking the canvas on
      one dropped poll. */
   if(!d||typeof d.dimension!=='string')return;
+  /* Tiles are keyed by chunk alone, and the nether uses the same coordinates as
+     the overworld — so switching dimension without dropping them draws one
+     world's terrain under another world's players. */
+  if(MAP.dim!==d.dimension){MAP_TILES={};MAP_MARKS={}}
   MAP.data=d;MAP.dim=d.dimension;
   var dot=document.getElementById('mpDot'),state=document.getElementById('mpState');
   dot.className='mp-dot'+(d.bridge?' on':'');
@@ -427,7 +431,6 @@ function mapDraw(){
  /* The world first: everything else is drawn on top of it. */
  mapDrawTiles(g,w,h);
  mapFetchTiles();
- mapDrawMarks(g,w,h,dpr);
  var px=function(x){return mapW2S({x:x,z:0}).x*sx};
  var pz=function(z){return mapW2S({x:0,z:z}).y*sy};
  /* A grid that adapts to the zoom: a fixed 64-block step is invisible when
@@ -447,6 +450,9 @@ function mapDraw(){
   for(var i=0;i<d.heatmap.length;i++){var c=d.heatmap[i];
    g.fillStyle='rgba(220,39,39,'+(0.12+0.55*(c.count/max)).toFixed(3)+')';
    g.fillRect(px(c.x),pz(c.z),Math.max(2*dpr,cw),Math.max(2*dpr,ch))}}
+ /* After the grid and the heatmap, before the players: a marker under a grid
+    line reads as a smudge, and a player must never be hidden behind one. */
+ mapDrawMarks(g,w,h,dpr);
  var ps=d.players||[];
  g.font=(11*dpr)+'px Inter,system-ui,sans-serif';g.textAlign='center';g.textBaseline='bottom';
  for(var j=0;j<ps.length;j++){var p=ps[j];var x=px(p.x),y=pz(p.z);