import React, { useState, useEffect, useContext, useRef, useCallback } from "react"; import { Row, Col, Button, Card, Space, Select, Switch, Slider, Typography } from "antd"; import { ControlContext, useInstances } from "@clusterio/web_ui"; import { GetRawTileRequest, GetChartTagsRequest, TileDataEvent, ChartTagData, ChartTagDataEvent, SignalID } from "../messages"; import * as zlib from "zlib"; import { renderTileToPixels, pixelsToImageData, rgb565ToRgb888, extractAvailableTicks, parseTileData, renderTileIncremental, ParsedTileData } from "../tile-utils"; const { Text } = Typography; interface ChartTagDataWithInstance extends ChartTagData { instance_id: number; } interface MergedChartTag { tag_number: number; start_tick: number | undefined; end_tick: number | undefined; force: string; surface: string; position: [number, number]; text: string; icon?: SignalID; last_user?: string; instance_id: number; } interface SurfaceForceData { surfaces: string[]; forces: string[]; } interface ViewState { centerX: number; centerY: number; zoomLevel: number; } interface TileState { currentTick: number; pixels: Uint16Array; parsedData: ParsedTileData; imageData: ImageData; } const CHUNK_SIZE = 32; // 32x32 pixels per chunk const TILE_SIZE = 256; // 256x256 pixels per tile (8x8 chunks) const CHUNKS_PER_TILE = 8; // Convert raw chart data to ImageData async function chartDataToImageData(chartData: string): Promise { // Decode base64 and decompress const compressedData = Buffer.from(chartData, "base64"); const decompressed = zlib.inflateSync(compressedData); // Create RGBA image data (32x32 pixels) const imageData = new Uint8ClampedArray(32 * 32 * 4); // Ensure we don't read beyond available data const maxPixels = Math.min(decompressed.length / 2, 32 * 32); for (let i = 0; i < maxPixels * 2; i += 2) { const rgb565Value = decompressed.readUInt16LE(i); const [r, g, b] = rgb565ToRgb888(rgb565Value); const pixelIndex = i / 2; const bufferIndex = pixelIndex * 4; imageData[bufferIndex] = r; imageData[bufferIndex + 1] = g; imageData[bufferIndex + 2] = b; imageData[bufferIndex + 3] = 255; // Alpha } // Fill remaining pixels with black if we have less data than expected for (let pixelIndex = maxPixels; pixelIndex < 32 * 32; pixelIndex++) { const bufferIndex = pixelIndex * 4; imageData[bufferIndex] = 0; // R imageData[bufferIndex + 1] = 0; // G imageData[bufferIndex + 2] = 0; // B imageData[bufferIndex + 3] = 255; // A } return new ImageData(imageData, 32, 32); } export default function CanvasMinimapPage() { // UI-related states (these need React re-renders) const [instances] = useInstances(); const [selectedInstance, setSelectedInstance] = useState(null); const [selectedSurface, setSelectedSurface] = useState("nauvis"); const [selectedForce, setSelectedForce] = useState("player"); const [surfaceForceData, setSurfaceForceData] = useState({ surfaces: [], forces: [] }); const [loading, setLoading] = useState(false); // Timelapse UI states (these need React re-renders for UI) const [isTimelapseMode, setIsTimelapseMode] = useState(false); const [availableTicks, setAvailableTicks] = useState([]); const [currentTick, setCurrentTick] = useState(null); const [isPlaying, setIsPlaying] = useState(false); const [playbackSpeed, setPlaybackSpeed] = useState(1); const [chartTagTimestamps, setChartTagTimestamps] = useState(0); // Chart tag states const [showChartTags, setShowChartTags] = useState(true); const [rawChartTags, setRawChartTags] = useState([]); const [mergedChartTags, setMergedChartTags] = useState([]); // Display state for zoom level (throttled updates to avoid excessive re-renders) const [displayZoom, setDisplayZoom] = useState(1); // Canvas refs const canvasRef = useRef(null); const containerRef = useRef(null); // View state as ref (no React re-renders needed) const viewStateRef = useRef({ centerX: 0, centerY: 0, zoomLevel: 1, }); // Mouse drag state refs (no React re-renders needed) const isDraggingRef = useRef(false); const lastMousePosRef = useRef<{ x: number; y: number } | null>(null); // Movement keys ref (no React re-renders needed) const keysPressed = useRef>(new Set()); // Cache refs const virtualTiles = useRef>(new Map()); const tileStateCache = useRef>(new Map()); const chunkCache = useRef>(new Map()); const loadingTiles = useRef>>(new Map()); // Animation frame ref const animationFrameRef = useRef(); // Timelapse playback timer ref const playbackTimerRef = useRef(); // Refs for current state access in event handlers const currentStateRef = useRef({ selectedInstance: null as number | null, selectedSurface: "nauvis", selectedForce: "player", isTimelapseMode: false, currentTick: null as number | null, availableTicks: [] as number[], showChartTags: true, mergedChartTags: [] as MergedChartTag[], chartTagTimestamps: 0, }); const control = useContext(ControlContext); // Merge raw chart tag data into timeline-friendly format const mergeChartTags = useCallback((rawTags: ChartTagDataWithInstance[]): MergedChartTag[] => { const tagMap = new Map(); for (const rawTag of rawTags) { // Create a unique key for each tag (tag_number + surface + force + instance) const key = `${rawTag.tag_number}_${rawTag.surface}_${rawTag.force}_${rawTag.instance_id}`; if (!tagMap.has(key)) { // Create new merged tag entry tagMap.set(key, { tag_number: rawTag.tag_number, start_tick: rawTag.start_tick, end_tick: rawTag.end_tick, force: rawTag.force, surface: rawTag.surface, position: rawTag.position, text: rawTag.text, icon: rawTag.icon, last_user: rawTag.last_user, instance_id: rawTag.instance_id, }); } else { // Merge with existing entry const existing = tagMap.get(key)!; // If this entry has a start_tick, use it if (rawTag.start_tick !== undefined) { existing.start_tick = rawTag.start_tick; // Also update other properties from the start entry existing.position = rawTag.position; existing.text = rawTag.text; existing.icon = rawTag.icon; existing.last_user = rawTag.last_user; } // If this entry has an end_tick, use it if (rawTag.end_tick !== undefined) { existing.end_tick = rawTag.end_tick; // Use the properties from the end entry as they might have been modified existing.position = rawTag.position; existing.text = rawTag.text; existing.icon = rawTag.icon; existing.last_user = rawTag.last_user; } } } return Array.from(tagMap.values()); }, []); // Update merged chart tags when raw tags change useEffect(() => { setMergedChartTags(mergeChartTags(rawChartTags)); }, [rawChartTags, mergeChartTags]); // Update current state ref when state changes useEffect(() => { currentStateRef.current = { selectedInstance, selectedSurface, selectedForce, isTimelapseMode, currentTick, availableTicks, showChartTags, mergedChartTags, chartTagTimestamps, }; }, [selectedInstance, selectedSurface, selectedForce, isTimelapseMode, currentTick, availableTicks, showChartTags, mergedChartTags, chartTagTimestamps]); // Define pixel-perfect zoom levels to eliminate seaming issues const ZOOM_LEVELS = [0.125, 0.25, 0.5, 0.75, 1, 1.25, 1.5, 2, 2.5, 3, 4, 5, 6, 8, 10]; const getClosestZoomLevel = (targetZoom: number): number => { return ZOOM_LEVELS.reduce((prev, curr) => Math.abs(curr - targetZoom) < Math.abs(prev - targetZoom) ? curr : prev ); }; const getNextZoomLevel = (currentZoom: number, direction: 'up' | 'down'): number => { const currentIndex = ZOOM_LEVELS.findIndex(zoom => Math.abs(zoom - currentZoom) < 0.001); if (direction === 'up') { return ZOOM_LEVELS[Math.min(currentIndex + 1, ZOOM_LEVELS.length - 1)]; } else { return ZOOM_LEVELS[Math.max(currentIndex - 1, 0)]; } }; // Throttled zoom display update to avoid excessive re-renders const throttledZoomUpdate = useRef(); // Helper to update view state without React re-render const updateViewState = (updates: Partial) => { Object.assign(viewStateRef.current, updates); // Update display zoom if zoom changed (throttled) if (updates.zoomLevel !== undefined) { if (throttledZoomUpdate.current) { clearTimeout(throttledZoomUpdate.current); } throttledZoomUpdate.current = setTimeout(() => { setDisplayZoom(viewStateRef.current.zoomLevel); }, 100); // Update display every 100ms max } }; // Helper to update cursor style directly const updateCursor = (isDragging: boolean) => { if (canvasRef.current) { canvasRef.current.style.cursor = isDragging ? "grabbing" : "grab"; } }; // Calculate which tiles are visible based on current view state const calculateVisibleTiles = () => { const canvas = canvasRef.current; if (!canvas) return null; const viewState = viewStateRef.current; const scale = viewState.zoomLevel; const width = canvas.width; const height = canvas.height; // Calculate visible world area const worldWidth = width / scale; const worldHeight = height / scale; const worldLeft = viewState.centerX - worldWidth / 2; const worldTop = viewState.centerY - worldHeight / 2; const worldRight = worldLeft + worldWidth; const worldBottom = worldTop + worldHeight; // Calculate which tiles are visible (with extra margin to ensure full coverage) const leftTile = Math.floor(worldLeft / TILE_SIZE) - 1; const topTile = Math.floor(worldTop / TILE_SIZE) - 1; const rightTile = Math.ceil(worldRight / TILE_SIZE) + 1; const bottomTile = Math.ceil(worldBottom / TILE_SIZE) + 1; return { leftTile, topTile, rightTile, bottomTile, scale, worldLeft, worldTop, worldRight, worldBottom }; }; // Timelapse functions const loadAvailableTicks = async () => { if (!selectedInstance) { return; } const visibleTiles = calculateVisibleTiles(); if (!visibleTiles) { console.warn("Canvas not available for tile culling calculation"); return; } try { const { leftTile, topTile, rightTile, bottomTile } = visibleTiles; const allTicks = new Set(); let tilesChecked = 0; let tilesWithData = 0; // Check all visible tiles for (let tileY = topTile; tileY <= bottomTile; tileY++) { for (let tileX = leftTile; tileX <= rightTile; tileX++) { try { const response = await control.send(new GetRawTileRequest( selectedInstance, selectedSurface, selectedForce, tileX, tileY )); tilesChecked++; if (response.tile_data) { const binaryString = atob(response.tile_data); const tileData = new Uint8Array(binaryString.length); for (let i = 0; i < binaryString.length; i++) { tileData[i] = binaryString.charCodeAt(i); } const ticks = extractAvailableTicks(tileData); if (ticks.length > 0) { tilesWithData++; ticks.forEach(tick => allTicks.add(tick)); } } } catch (err) { console.warn(`Failed to load tile ${tileX},${tileY}:`, err); } } } // Also include chart tag timestamps const currentState = currentStateRef.current; let tagsWithTicks = 0; if (currentState.mergedChartTags.length > 0) { for (const tag of currentState.mergedChartTags) { // Add start_tick if it exists (tag creation) if (tag.start_tick !== undefined) { allTicks.add(tag.start_tick); tagsWithTicks++; } // Add end_tick if it exists (tag deletion) if (tag.end_tick !== undefined) { allTicks.add(tag.end_tick); tagsWithTicks++; } } console.log(`Added ${tagsWithTicks} chart tag timestamps to timeline`); } setChartTagTimestamps(tagsWithTicks); const sortedTicks = Array.from(allTicks).sort((a, b) => a - b); setAvailableTicks(sortedTicks); // Set current tick to latest if not set if (sortedTicks.length > 0 && currentTick === null) { setCurrentTick(sortedTicks[sortedTicks.length - 1]); } } catch (err) { console.error("Failed to load available ticks:", err); } }; const toggleTimelapseMode = async (enabled: boolean) => { setIsTimelapseMode(enabled); setIsPlaying(false); if (enabled) { // Ensure chart tags are loaded before getting available ticks if (selectedInstance && selectedSurface && selectedForce) { await loadExistingChartTags(); } await loadAvailableTicks(); } else { setCurrentTick(null); setChartTagTimestamps(0); } // Clear caches when switching modes virtualTiles.current.clear(); tileStateCache.current.clear(); chunkCache.current.clear(); loadingTiles.current.clear(); }; const stepToTick = async (tickIndex: number) => { const currentState = currentStateRef.current; if (tickIndex >= 0 && tickIndex < currentState.availableTicks.length) { const newTick = currentState.availableTicks[tickIndex]; const oldTick = currentState.currentTick; if (oldTick === newTick) { return; // No change needed } // Use incremental updates for loaded tiles instead of clearing cache const updatePromises: Promise[] = []; for (const [tileKey, tileState] of tileStateCache.current) { updatePromises.push((async () => { try { // Apply incremental changes from current tick to new tick await renderTileIncremental( tileState.parsedData, tileState.pixels, tileState.currentTick, newTick ); // Update tile state tileState.currentTick = newTick; // Convert to ImageData and update virtual tile const newImageData = pixelsToImageData(tileState.pixels); tileState.imageData = newImageData; // Update virtual tile canvas if it exists const virtualTile = virtualTiles.current.get(tileKey); if (virtualTile) { const ctx = virtualTile.getContext('2d')!; ctx.putImageData(newImageData, 0, 0); } // Update chunk cache for this tile const [tileX, tileY] = tileKey.split(',').map(Number); for (let cy = 0; cy < CHUNKS_PER_TILE; cy++) { for (let cx = 0; cx < CHUNKS_PER_TILE; cx++) { const actualChunkX = tileX * CHUNKS_PER_TILE + cx; const actualChunkY = tileY * CHUNKS_PER_TILE + cy; const actualChunkKey = `${actualChunkX},${actualChunkY}`; // Extract chunk area from the full tile ImageData const chunkData = new Uint8ClampedArray(CHUNK_SIZE * CHUNK_SIZE * 4); for (let y = 0; y < CHUNK_SIZE; y++) { for (let x = 0; x < CHUNK_SIZE; x++) { const tilePixelIndex = ((cy * CHUNK_SIZE + y) * TILE_SIZE + (cx * CHUNK_SIZE + x)) * 4; const chunkPixelIndex = (y * CHUNK_SIZE + x) * 4; chunkData[chunkPixelIndex] = newImageData.data[tilePixelIndex]; // R chunkData[chunkPixelIndex + 1] = newImageData.data[tilePixelIndex + 1]; // G chunkData[chunkPixelIndex + 2] = newImageData.data[tilePixelIndex + 2]; // B chunkData[chunkPixelIndex + 3] = newImageData.data[tilePixelIndex + 3]; // A } } const chunkImageData = new ImageData(chunkData, CHUNK_SIZE, CHUNK_SIZE); chunkCache.current.set(actualChunkKey, chunkImageData); } } } catch (err) { console.error(`Failed to update tile ${tileKey} incrementally:`, err); // If incremental update fails, remove from cache to force full reload tileStateCache.current.delete(tileKey); virtualTiles.current.delete(tileKey); } })()); } // Wait for all tile updates to complete await Promise.all(updatePromises); setCurrentTick(newTick); } }; const stepForward = async () => { const currentState = currentStateRef.current; const currentIndex = currentState.availableTicks.findIndex(tick => tick === currentState.currentTick); if (currentIndex >= 0 && currentIndex < currentState.availableTicks.length - 1) { await stepToTick(currentIndex + 1); } }; const stepBackward = async () => { const currentState = currentStateRef.current; const currentIndex = currentState.availableTicks.findIndex(tick => tick === currentState.currentTick); if (currentIndex > 0) { await stepToTick(currentIndex - 1); } }; const togglePlayback = () => { setIsPlaying(!isPlaying); }; // Handle playback timer useEffect(() => { if (isPlaying && isTimelapseMode && availableTicks.length > 0) { playbackTimerRef.current = setInterval(async () => { const currentState = currentStateRef.current; const currentIndex = currentState.availableTicks.findIndex(tick => tick === currentState.currentTick); if (currentIndex >= 0 && currentIndex < currentState.availableTicks.length - 1) { await stepToTick(currentIndex + 1); } else { // Reached the end, stop playing setIsPlaying(false); } }, 1000 / playbackSpeed); } else { if (playbackTimerRef.current) { clearInterval(playbackTimerRef.current); playbackTimerRef.current = undefined; } } return () => { if (playbackTimerRef.current) { clearInterval(playbackTimerRef.current); } }; }, [isPlaying, isTimelapseMode, currentTick, playbackSpeed, availableTicks]); // Format tick as time const formatTickTime = (tick: number): string => { const seconds = Math.floor(tick / 60); const minutes = Math.floor(seconds / 60); const hours = Math.floor(minutes / 60); if (hours > 0) { return `${hours}h ${minutes % 60}m ${seconds % 60}s`; } else if (minutes > 0) { return `${minutes}m ${seconds % 60}s`; } else { return `${seconds}s`; } }; // Set default instance when instances become available useEffect(() => { if (instances.size > 0 && !selectedInstance) { const firstInstance = instances.values().next().value; if (firstInstance) { setSelectedInstance(firstInstance.id); } } }, [instances, selectedInstance]); // Load surface and force data on component mount useEffect(() => { loadSurfaceForceData(); }, []); // Set up keyboard and mouse event listeners (one-time setup) useEffect(() => { const handleKeyDown = (e: KeyboardEvent) => { const key = e.key.toLowerCase(); // Track movement keys for smooth animation if (['w', 'a', 's', 'd'].includes(key)) { keysPressed.current.add(key); return; } // Handle zoom keys immediately (not animated) switch (key) { case '+': case '=': // Handle both + and = key (since + requires shift) updateViewState({ zoomLevel: getNextZoomLevel(viewStateRef.current.zoomLevel, 'up') }); e.preventDefault(); // Prevent browser zoom break; case '-': case '_': // Handle both - and _ key (since _ requires shift) updateViewState({ zoomLevel: getNextZoomLevel(viewStateRef.current.zoomLevel, 'down') }); e.preventDefault(); // Prevent browser zoom break; case 'f': // Step backward in timeline (only in timelapse mode) if (currentStateRef.current.isTimelapseMode && currentStateRef.current.availableTicks.length > 0) { stepBackward(); e.preventDefault(); } break; case 'g': // Step forward in timeline (only in timelapse mode) if (currentStateRef.current.isTimelapseMode && currentStateRef.current.availableTicks.length > 0) { stepForward(); e.preventDefault(); } break; } }; const handleKeyUp = (e: KeyboardEvent) => { const key = e.key.toLowerCase(); // Remove movement keys when released if (['w', 'a', 's', 'd'].includes(key)) { keysPressed.current.delete(key); } }; const handleBlur = () => { // Clear all pressed keys when window loses focus to prevent stuck keys keysPressed.current.clear(); }; const handleWheel = (e: WheelEvent) => { e.preventDefault(); const direction = e.deltaY > 0 ? 'down' : 'up'; const newZoom = getNextZoomLevel(viewStateRef.current.zoomLevel, direction); updateViewState({ zoomLevel: newZoom }); }; document.addEventListener('keydown', handleKeyDown); document.addEventListener('keyup', handleKeyUp); window.addEventListener('blur', handleBlur); const canvasElement = canvasRef.current; if (canvasElement) { canvasElement.addEventListener('wheel', handleWheel, { passive: false }); } return () => { document.removeEventListener('keydown', handleKeyDown); document.removeEventListener('keyup', handleKeyUp); window.removeEventListener('blur', handleBlur); if (canvasElement) { canvasElement.removeEventListener('wheel', handleWheel); } }; }, []); // No dependencies - use refs for current state // Mouse event handlers for click and drag panning (one-time setup) useEffect(() => { const canvasElement = canvasRef.current; if (!canvasElement) { return; } const handleMouseDown = (e: MouseEvent) => { if (e.button === 0) { // Left mouse button isDraggingRef.current = true; lastMousePosRef.current = { x: e.clientX, y: e.clientY }; updateCursor(true); // Update state for cursor change e.preventDefault(); } }; const handleMouseMove = (e: MouseEvent) => { if (isDraggingRef.current && lastMousePosRef.current) { const deltaX = e.clientX - lastMousePosRef.current.x; const deltaY = e.clientY - lastMousePosRef.current.y; // Convert screen delta to world delta (invert because dragging right should move view left) const worldDeltaX = -deltaX / viewStateRef.current.zoomLevel; const worldDeltaY = -deltaY / viewStateRef.current.zoomLevel; updateViewState({ centerX: viewStateRef.current.centerX + worldDeltaX, centerY: viewStateRef.current.centerY + worldDeltaY }); lastMousePosRef.current = { x: e.clientX, y: e.clientY }; } }; const handleMouseUp = (e: MouseEvent) => { if (e.button === 0) { // Left mouse button isDraggingRef.current = false; lastMousePosRef.current = null; updateCursor(false); // Update state for cursor change } }; const handleMouseLeave = () => { // Stop dragging if mouse leaves canvas isDraggingRef.current = false; lastMousePosRef.current = null; updateCursor(false); // Update state for cursor change }; canvasElement.addEventListener('mousedown', handleMouseDown); canvasElement.addEventListener('mousemove', handleMouseMove); canvasElement.addEventListener('mouseup', handleMouseUp); canvasElement.addEventListener('mouseleave', handleMouseLeave); // Also listen to document for mouse events to handle dragging outside canvas document.addEventListener('mousemove', handleMouseMove); document.addEventListener('mouseup', handleMouseUp); return () => { canvasElement.removeEventListener('mousedown', handleMouseDown); canvasElement.removeEventListener('mousemove', handleMouseMove); canvasElement.removeEventListener('mouseup', handleMouseUp); canvasElement.removeEventListener('mouseleave', handleMouseLeave); document.removeEventListener('mousemove', handleMouseMove); document.removeEventListener('mouseup', handleMouseUp); }; }, [selectedInstance]); // Only need to re-setup when canvas becomes available // Render loop (one-time setup) useEffect(() => { const render = () => { if (canvasRef.current) { renderCanvas(); } animationFrameRef.current = requestAnimationFrame(render); }; animationFrameRef.current = requestAnimationFrame(render); return () => { if (animationFrameRef.current) { cancelAnimationFrame(animationFrameRef.current); } }; }, []); // No dependencies - render loop accesses current state via refs const loadSurfaceForceData = async () => { try { const response = await fetch(`${window.location.origin}/api/minimap/surfaces`); const data = await response.json(); setSurfaceForceData(data); if (data.surfaces.length > 0 && !selectedSurface) { setSelectedSurface(data.surfaces.includes("nauvis") ? "nauvis" : data.surfaces[0]); } if (data.forces.length > 0 && !selectedForce) { setSelectedForce(data.forces.includes("player") ? "player" : data.forces[0]); } } catch (err) { console.error("Failed to load surface/force data:", err); } }; // Load existing chart tags from disk const loadExistingChartTags = async () => { if (!selectedInstance || !selectedSurface || !selectedForce) { return; } try { const response = await control.send(new GetChartTagsRequest( selectedInstance, selectedSurface, selectedForce )); if (response.chart_tags && response.chart_tags.length > 0) { // Convert to ChartTagDataWithInstance format const existingTags: ChartTagDataWithInstance[] = response.chart_tags.map((tag: ChartTagData) => ({ ...tag, instance_id: selectedInstance, })); // Replace existing tags with loaded ones setRawChartTags(existingTags); console.log(`Loaded ${existingTags.length} existing chart tags`); } else { // Clear tags if no existing data setRawChartTags([]); } } catch (err) { console.error("Failed to load existing chart tags:", err); // Don't clear tags on error, keep what we have } }; // Load a tile from the server using raw tile data const loadTile = async (tileX: number, tileY: number): Promise => { // Get current state from ref const currentState = currentStateRef.current; // Early return if no instance is selected if (!currentState.selectedInstance) { return null; } const tileKey = `${tileX},${tileY}`; // Check tile state cache first if (tileStateCache.current.has(tileKey)) { const tileState = tileStateCache.current.get(tileKey)!; // Check if we need to update to current tick const targetTick = isTimelapseMode ? currentTick || 0 : tileState.parsedData.allTicks[tileState.parsedData.allTicks.length - 1] || 0; if (tileState.currentTick !== targetTick) { try { await renderTileIncremental( tileState.parsedData, tileState.pixels, tileState.currentTick, targetTick ); tileState.currentTick = targetTick; tileState.imageData = pixelsToImageData(tileState.pixels); } catch (err) { console.error(`Failed to update tile ${tileKey} to tick ${targetTick}:`, err); } } return tileState.imageData; } // Check if we're already loading this tile if (loadingTiles.current.has(tileKey)) { return loadingTiles.current.get(tileKey)!; } // Start loading the tile const loadPromise = (async () => { try { // Load the raw tile data from server const response = await control.send(new GetRawTileRequest( currentState.selectedInstance!, // We already checked for null above currentState.selectedSurface, currentState.selectedForce, tileX, tileY, currentState.isTimelapseMode ? currentState.currentTick || undefined : undefined )); if (!response.tile_data) { return null; } // Decode base64 tile data const binaryString = atob(response.tile_data); const tileData = new Uint8Array(binaryString.length); for (let i = 0; i < binaryString.length; i++) { tileData[i] = binaryString.charCodeAt(i); } // Parse the tile data into structured change records const parsedData = parseTileData(tileData); // Determine target tick const targetTick = isTimelapseMode ? (currentTick || 0) : (parsedData.allTicks[parsedData.allTicks.length - 1] || 0); // Render to target tick (undefined means latest for non-timelapse mode) const renderTick = isTimelapseMode ? targetTick : undefined; const pixels = await renderTileToPixels(tileData, renderTick); // Convert to ImageData const tileImageData = pixelsToImageData(pixels); // Create and cache the tile state const tileState: TileState = { currentTick: targetTick, pixels: pixels, parsedData: parsedData, imageData: tileImageData }; tileStateCache.current.set(tileKey, tileState); // Extract and cache all chunks from this tile for (let cy = 0; cy < CHUNKS_PER_TILE; cy++) { for (let cx = 0; cx < CHUNKS_PER_TILE; cx++) { const actualChunkX = tileX * CHUNKS_PER_TILE + cx; const actualChunkY = tileY * CHUNKS_PER_TILE + cy; const actualChunkKey = `${actualChunkX},${actualChunkY}`; // Extract chunk area from the full tile ImageData const chunkData = new Uint8ClampedArray(CHUNK_SIZE * CHUNK_SIZE * 4); for (let y = 0; y < CHUNK_SIZE; y++) { for (let x = 0; x < CHUNK_SIZE; x++) { const tilePixelIndex = ((cy * CHUNK_SIZE + y) * TILE_SIZE + (cx * CHUNK_SIZE + x)) * 4; const chunkPixelIndex = (y * CHUNK_SIZE + x) * 4; chunkData[chunkPixelIndex] = tileImageData.data[tilePixelIndex]; // R chunkData[chunkPixelIndex + 1] = tileImageData.data[tilePixelIndex + 1]; // G chunkData[chunkPixelIndex + 2] = tileImageData.data[tilePixelIndex + 2]; // B chunkData[chunkPixelIndex + 3] = tileImageData.data[tilePixelIndex + 3]; // A } } const chunkImageData = new ImageData(chunkData, CHUNK_SIZE, CHUNK_SIZE); chunkCache.current.set(actualChunkKey, chunkImageData); } } return tileImageData; } catch (err) { console.error(`Failed to load tile ${tileX},${tileY}:`, err); return null; } finally { // Remove from loading cache when done loadingTiles.current.delete(tileKey); } })(); // Cache the loading promise loadingTiles.current.set(tileKey, loadPromise); return loadPromise; }; // Update a single chunk (for live updates) - directly modify the virtual tile in memory const updateChunk = useCallback((chunkX: number, chunkY: number, imageData: ImageData) => { const chunkKey = `${chunkX},${chunkY}`; chunkCache.current.set(chunkKey, imageData); // Calculate which tile contains this chunk const tileX = Math.floor(chunkX / CHUNKS_PER_TILE); const tileY = Math.floor(chunkY / CHUNKS_PER_TILE); const tileKey = `${tileX},${tileY}`; // Calculate position within the tile const localChunkX = ((chunkX % CHUNKS_PER_TILE) + CHUNKS_PER_TILE) % CHUNKS_PER_TILE; const localChunkY = ((chunkY % CHUNKS_PER_TILE) + CHUNKS_PER_TILE) % CHUNKS_PER_TILE; const pixelX = localChunkX * CHUNK_SIZE; const pixelY = localChunkY * CHUNK_SIZE; // Update the virtual tile directly if it exists const virtualTile = virtualTiles.current.get(tileKey); if (virtualTile) { const ctx = virtualTile.getContext('2d')!; ctx.putImageData(imageData, pixelX, pixelY); } // Update the tile state if it exists const tileState = tileStateCache.current.get(tileKey); if (tileState) { // Update the tile ImageData directly const tileData = tileState.imageData.data; const chunkData = imageData.data; for (let y = 0; y < CHUNK_SIZE; y++) { for (let x = 0; x < CHUNK_SIZE; x++) { const chunkIndex = (y * CHUNK_SIZE + x) * 4; const tileIndex = ((pixelY + y) * TILE_SIZE + (pixelX + x)) * 4; tileData[tileIndex] = chunkData[chunkIndex]; // R tileData[tileIndex + 1] = chunkData[chunkIndex + 1]; // G tileData[tileIndex + 2] = chunkData[chunkIndex + 2]; // B tileData[tileIndex + 3] = chunkData[chunkIndex + 3]; // A } } } }, []); // Get or create a virtual tile const getVirtualTile = async (tileX: number, tileY: number): Promise => { // Get current state from ref const currentState = currentStateRef.current; // Don't create virtual tiles if no instance is selected if (!currentState.selectedInstance) { throw new Error("Cannot create virtual tile: no instance selected"); } const tileKey = `${tileX},${tileY}`; if (virtualTiles.current.has(tileKey)) { return virtualTiles.current.get(tileKey)!; } // Create new virtual tile const virtualCanvas = document.createElement('canvas'); virtualCanvas.width = TILE_SIZE; virtualCanvas.height = TILE_SIZE; const ctx = virtualCanvas.getContext('2d')!; // Always start with black background ctx.fillStyle = '#000000'; ctx.fillRect(0, 0, TILE_SIZE, TILE_SIZE); // Load the entire tile at once (much more efficient than loading chunks individually) const tileImageData = await loadTile(tileX, tileY); if (tileImageData) { // Draw the entire tile directly to the virtual canvas ctx.putImageData(tileImageData, 0, 0); } virtualTiles.current.set(tileKey, virtualCanvas); return virtualCanvas; }; // Render the canvas const renderCanvas = () => { const canvas = canvasRef.current; if (!canvas) return; // Get current state from ref to ensure consistency const currentState = currentStateRef.current; // Early return if no instance selected if (!currentState.selectedInstance) { // Draw dark background and return const ctx = canvas.getContext('2d') as CanvasRenderingContext2D; ctx.fillStyle = '#1a1a1a'; ctx.fillRect(0, 0, canvas.width, canvas.height); return; } // Apply smooth WASD movement if (keysPressed.current.size > 0) { // Adjust base speed for 60fps const moveSpeed = 20 / viewStateRef.current.zoomLevel; let deltaX = 0; let deltaY = 0; // Calculate movement delta based on currently pressed keys if (keysPressed.current.has('w')) deltaY -= moveSpeed; if (keysPressed.current.has('s')) deltaY += moveSpeed; if (keysPressed.current.has('a')) deltaX -= moveSpeed; if (keysPressed.current.has('d')) deltaX += moveSpeed; // Reduce speed if moving diagonally if (deltaX !== 0 && deltaY !== 0) { deltaX *= 0.7071; // sqrt(2) / 2 deltaY *= 0.7071; } // Apply movement if any keys are pressed if (deltaX !== 0 || deltaY !== 0) { updateViewState({ centerX: viewStateRef.current.centerX + deltaX, centerY: viewStateRef.current.centerY + deltaY }); } } const ctx = canvas.getContext('2d') as CanvasRenderingContext2D; ctx.imageSmoothingEnabled = false; // Get canvas dimensions const width = canvas.width; const height = canvas.height; // Clear canvas completely ctx.fillStyle = '#1a1a1a'; ctx.fillRect(0, 0, width, height); // Calculate visible tiles using shared function const visibleTiles = calculateVisibleTiles(); if (!visibleTiles) return; const { leftTile, topTile, rightTile, bottomTile, scale, worldLeft, worldTop } = visibleTiles; const scaledTileSize = TILE_SIZE * scale; const firstTileScreenX = Math.round((leftTile * TILE_SIZE - worldLeft) * scale); const firstTileScreenY = Math.round((topTile * TILE_SIZE - worldTop) * scale); // Pre-calculate all tile edge positions using exact integer steps const tileEdgesX: number[] = []; const tileEdgesY: number[] = []; // Build tile edges using clean integer arithmetic from the first tile position for (let i = 0; i <= (rightTile - leftTile + 1); i++) { tileEdgesX.push(firstTileScreenX + Math.round(i * scaledTileSize)); } for (let i = 0; i <= (bottomTile - topTile + 1); i++) { tileEdgesY.push(firstTileScreenY + Math.round(i * scaledTileSize)); } // Render visible tiles using the pre-calculated edge grid for (let tileY = topTile; tileY <= bottomTile; tileY++) { for (let tileX = leftTile; tileX <= rightTile; tileX++) { const tileKey = `${tileX},${tileY}`; const virtualTile = virtualTiles.current.get(tileKey); // Get tile position from pre-calculated edges const tileIndexX = tileX - leftTile; const tileIndexY = tileY - topTile; const screenX = tileEdgesX[tileIndexX]; const screenY = tileEdgesY[tileIndexY]; const screenWidth = tileEdgesX[tileIndexX + 1] - screenX; const screenHeight = tileEdgesY[tileIndexY + 1] - screenY; // Calculate clipping bounds to ensure we don't draw outside canvas const clippedX = Math.max(0, screenX); const clippedY = Math.max(0, screenY); const clippedWidth = Math.min(screenWidth, width - clippedX); const clippedHeight = Math.min(screenHeight, height - clippedY); // Skip if tile is completely outside canvas if (clippedWidth <= 0 || clippedHeight <= 0) { continue; } if (virtualTile) { // Tile is loaded, draw it with clipping ctx.imageSmoothingEnabled = false; // Round source coordinates to prevent subpixel sampling const rawSourceX = clippedX > screenX ? (clippedX - screenX) / scale : 0; const rawSourceY = clippedY > screenY ? (clippedY - screenY) / scale : 0; const rawSourceWidth = clippedWidth / scale; const rawSourceHeight = clippedHeight / scale; // Use clipped coordinates directly since screen coordinates are already rounded const destX = clippedX; const destY = clippedY; const destWidth = clippedWidth; const destHeight = clippedHeight; ctx.drawImage( virtualTile, rawSourceX, rawSourceY, rawSourceWidth, rawSourceHeight, destX, destY, destWidth, destHeight ); } else { // Tile not loaded yet, draw black ctx.fillStyle = '#000000'; ctx.fillRect(clippedX, clippedY, clippedWidth, clippedHeight); // Start loading the tile in the background (but don't wait for it) // Only attempt to load if we have all required parameters if (currentState.selectedInstance && currentState.selectedSurface && currentState.selectedForce) { getVirtualTile(tileX, tileY).then(() => { // When tile loads, trigger a re-render // But only if we're still looking at the same area const latestState = currentStateRef.current; if (latestState.selectedInstance && latestState.selectedSurface && latestState.selectedForce) { // Use a small delay to batch multiple tile loads setTimeout(() => { if (animationFrameRef.current) { // Render will happen on next animation frame anyway } }, 16); } }).catch(err => { console.error(`Failed to load tile ${tileX},${tileY}:`, err); }); } } } } // Render chart tags if enabled if (currentState.showChartTags) { const visibleTags = getVisibleChartTags(); ctx.save(); ctx.textAlign = 'center'; ctx.textBaseline = 'middle'; ctx.font = `${Math.max(10, 12 / scale)}px Arial`; for (const tag of visibleTags) { // Convert world coordinates to screen coordinates const screenX = Math.round((tag.position[0] - worldLeft) * scale); const screenY = Math.round((tag.position[1] - worldTop) * scale); // Skip if tag is outside visible area if (screenX < -50 || screenX > width + 50 || screenY < -50 || screenY > height + 50) { continue; } // Constant tag size regardless of zoom level const tagSize = 16; const halfSize = tagSize / 2; // Draw tag background ctx.fillStyle = tag.icon ? '#4CAF50' : '#2196F3'; ctx.fillRect(screenX - halfSize, screenY - halfSize, tagSize, tagSize); // Draw tag border ctx.strokeStyle = '#FFFFFF'; ctx.lineWidth = 2; ctx.strokeRect(screenX - halfSize, screenY - halfSize, tagSize, tagSize); // Draw tag text if zoom level is high enough if (scale > 0.5 && tag.text) { const fontSize = 12; ctx.font = `${fontSize}px Arial`; // Position text to the right of the square const textX = screenX + halfSize + 4; // 4px padding from square edge const textY = screenY; // Vertically centered with square // Draw text background const textMetrics = ctx.measureText(tag.text); const textWidth = textMetrics.width; const textHeight = fontSize; const textPadding = 2; ctx.fillStyle = 'rgba(0, 0, 0, 0.7)'; ctx.fillRect( textX - textPadding, textY - textHeight / 2 - textPadding, textWidth + textPadding * 2, textHeight + textPadding * 2 ); // Draw text ctx.fillStyle = '#FFFFFF'; ctx.textAlign = 'left'; // Align text to start from the left edge ctx.fillText(tag.text, textX, textY); ctx.textAlign = 'center'; // Reset for next iteration } } ctx.restore(); } }; // Handle canvas resize (one-time setup) useEffect(() => { const handleResize = () => { const canvas = canvasRef.current; const container = containerRef.current; if (!canvas || !container) return; // Use ResizeObserver for more accurate container size tracking const rect = container.getBoundingClientRect(); // Set canvas size to match container (simple 1:1 ratio) canvas.width = rect.width; canvas.height = rect.height; }; // Defer initial resize to ensure layout is complete const timeoutId = setTimeout(handleResize, 0); // Set up ResizeObserver for container size changes const container = containerRef.current; if (container && 'ResizeObserver' in window) { const resizeObserver = new ResizeObserver(handleResize); resizeObserver.observe(container); // Also listen to window resize as fallback window.addEventListener('resize', handleResize); return () => { clearTimeout(timeoutId); resizeObserver.disconnect(); window.removeEventListener('resize', handleResize); }; } else { // Fallback for browsers without ResizeObserver window.addEventListener('resize', handleResize); return () => { clearTimeout(timeoutId); window.removeEventListener('resize', handleResize); }; } }, []); // Ensure proper canvas sizing when instance selection changes useEffect(() => { if (selectedInstance) { // Force a resize check when instance becomes available const canvas = canvasRef.current; const container = containerRef.current; if (canvas && container) { const rect = container.getBoundingClientRect(); canvas.width = rect.width; canvas.height = rect.height; } } }, [selectedInstance]); // Reset view when instance changes and snap to pixel-perfect zoom useEffect(() => { if (selectedInstance) { // Reset to center view with default zoom when switching instances updateViewState({ centerX: 0, centerY: 0, zoomLevel: getClosestZoomLevel(1), // Snap to nearest pixel-perfect zoom }); // Clear caches when switching instances virtualTiles.current.clear(); tileStateCache.current.clear(); chunkCache.current.clear(); loadingTiles.current.clear(); } }, [selectedInstance]); // Reload ticks when instance, surface, force changes or timelapse mode toggles useEffect(() => { if (isTimelapseMode && selectedInstance && selectedSurface && selectedForce) { // Debounce the reload to avoid too many requests during navigation const timeoutId = setTimeout(async () => { // Ensure chart tags are loaded before getting available ticks await loadExistingChartTags(); await loadAvailableTicks(); }, 500); return () => clearTimeout(timeoutId); } }, [selectedInstance, selectedSurface, selectedForce, isTimelapseMode]); // Load existing chart tags when instance/surface/force selection changes useEffect(() => { if (selectedInstance && selectedSurface && selectedForce) { loadExistingChartTags(); } else { // Clear chart tags if no valid selection setRawChartTags([]); } }, [selectedInstance, selectedSurface, selectedForce]); // Snap current zoom level to nearest pixel-perfect level on mount useEffect(() => { updateViewState({ zoomLevel: getClosestZoomLevel(viewStateRef.current.zoomLevel) }); // Cleanup throttled zoom update on unmount return () => { if (throttledZoomUpdate.current) { clearTimeout(throttledZoomUpdate.current); } }; }, []); // Get visible chart tags based on current state const getVisibleChartTags = useCallback(() => { // Use the same ref state that the render function uses for consistency const currentState = currentStateRef.current; if (!currentState.selectedInstance || !currentState.showChartTags) { return []; } return currentState.mergedChartTags.filter((tag: MergedChartTag) => { // Filter by instance, surface, and force if (tag.instance_id !== currentState.selectedInstance || tag.surface !== currentState.selectedSurface || tag.force !== currentState.selectedForce) { return false; } // Filter by tick range (both in timelapse and live mode) if (currentState.isTimelapseMode && currentState.currentTick !== null) { // In timelapse mode, filter by current tick // Tag is visible if it started before or at current tick and hasn't ended yet if (tag.start_tick !== undefined && tag.start_tick > currentState.currentTick) { return false; } if (tag.end_tick !== undefined && tag.end_tick <= currentState.currentTick) { return false; } } else { // In live mode, only hide tags that have been deleted (have an end_tick) if (tag.end_tick !== undefined) { return false; } } return true; }); }, []); // Set up live chunk update listener (only in live mode) useEffect(() => { const plugin = control.plugins.get("minimap") as import("./index").WebPlugin; if (!plugin) { console.error("Minimap plugin not found"); return; } const handleChunkUpdate = (event: TileDataEvent) => { const currentState = currentStateRef.current; // Only process updates for the currently selected instance/surface/force if (event.instance_id === currentState.selectedInstance && event.surface === currentState.selectedSurface && event.force === currentState.selectedForce && !currentState.isTimelapseMode) { try { // Calculate chunk coordinates from world coordinates const chunkX = Math.floor(event.x / 32); const chunkY = Math.floor(event.y / 32); // Convert raw chart data to ImageData chartDataToImageData(event.chunk.chart_data).then(imageData => { // Update the chunk in our cache updateChunk(chunkX, chunkY, imageData); }).catch(err => { console.error("Failed to convert chart data to ImageData:", err); }); } catch (err) { console.error("Failed to process live chunk update:", err); } } }; const handleChartTagUpdate = (event: ChartTagDataEvent) => { const currentState = currentStateRef.current; // Only process updates for the currently selected instance/surface/force if (event.instance_id === currentState.selectedInstance && event.tag_data.surface === currentState.selectedSurface && event.tag_data.force === currentState.selectedForce) { // Add the new chart tag data to our collection const newTagData: ChartTagDataWithInstance = { ...event.tag_data, instance_id: event.instance_id, }; setRawChartTags(prevTags => { // Check if we already have this tag (by tag_number and instance) const existingIndex = prevTags.findIndex(tag => tag.tag_number === newTagData.tag_number && tag.instance_id === newTagData.instance_id && tag.surface === newTagData.surface && tag.force === newTagData.force ); if (existingIndex >= 0) { // Update existing tag const newTags = [...prevTags]; newTags[existingIndex] = newTagData; return newTags; } else { // Add new tag return [...prevTags, newTagData]; } }); } }; // Subscribe to update events through the plugin plugin.onTileUpdate(handleChunkUpdate); plugin.onChartTagUpdate(handleChartTagUpdate); return () => { plugin.offTileUpdate(handleChunkUpdate); plugin.offChartTagUpdate(handleChartTagUpdate); }; }, [updateChunk, control]); return (
{surfaceForceData.surfaces.map(surface => ( {surface} ))} Timelapse: {isTimelapseMode && ( {availableTicks.length} snapshots )} Chart Tags: {showChartTags && ( {getVisibleChartTags().length} visible )} } > {selectedInstance ? (
{isTimelapseMode && availableTicks.length > 0 && (
Speed:
Timeline: {currentTick ? formatTickTime(currentTick) : "No data"}
{availableTicks.length} total timestamps
tick === currentTick)} onChange={async (value) => await stepToTick(value)} style={{ marginTop: "8px" }} tooltip={{ formatter: (value) => { if (value !== undefined && availableTicks[value]) { return formatTickTime(availableTicks[value]); } return ""; } }} />
)}
Use WASD to move, click and drag to pan, +/- or scroll wheel to zoom. Current zoom: {displayZoom}x {isTimelapseMode && ( 📹 Timelapse Mode {currentTick ? `- ${formatTickTime(currentTick)}` : ""} (F/G to step through timeline) )}
) : (

No Instance Selected

Select a running instance to view its minimap

)}
); }