mirror of
https://github.com/clusterio/clusterio.git
synced 2026-11-12 15:04:52 +09:00
333 lines
10 KiB
TypeScript
333 lines
10 KiB
TypeScript
import * as lib from "@clusterio/lib";
|
|
import { BaseControllerPlugin } from "@clusterio/controller";
|
|
import {
|
|
TileDataEvent,
|
|
GetInstanceBoundsRequest,
|
|
ChartData,
|
|
ChunkUpdateEvent,
|
|
} from "./messages";
|
|
import * as fs from "fs-extra";
|
|
import * as path from "path";
|
|
import * as zlib from "zlib";
|
|
import { promisify } from "util";
|
|
import sharp from "sharp";
|
|
|
|
const CHUNK_SIZE = 32;
|
|
const inflateAsync = promisify(zlib.inflate);
|
|
|
|
|
|
export class ControllerPlugin extends BaseControllerPlugin {
|
|
private tilesPath: string = "";
|
|
// Set to true if colors appear inverted - this will try big-endian byte order
|
|
private useBigEndian: boolean = false;
|
|
|
|
async init() {
|
|
this.tilesPath = path.resolve(
|
|
this.controller.config.get("controller.database_directory"),
|
|
"minimap_chunks"
|
|
);
|
|
await fs.ensureDir(this.tilesPath);
|
|
|
|
this.controller.handle(TileDataEvent, this.handleTileDataEvent.bind(this));
|
|
|
|
this.controller.handle(GetInstanceBoundsRequest, this.handleGetInstanceBoundsRequest.bind(this));
|
|
|
|
// Set up HTTP routes for serving tiles
|
|
this.setupTileRoutes();
|
|
}
|
|
|
|
// Convert RGB565 to RGB888 values using Factorio's exact method
|
|
private rgb565ToRgb888(rgb565Value: number): [number, number, number] {
|
|
// This matches ByteColor(uint16_t rgb5) constructor in Factorio source
|
|
const r = ((rgb565Value >> 11) & 0x1F) << 3; // 5 bits -> 8 bits
|
|
const g = ((rgb565Value >> 5) & 0x3F) << 2; // 6 bits -> 8 bits
|
|
const b = (rgb565Value & 0x1F) << 3; // 5 bits -> 8 bits
|
|
return [r, g, b];
|
|
}
|
|
|
|
private setupTileRoutes() {
|
|
const app = this.controller.app;
|
|
|
|
// Create black placeholder image for 512x512 tiles
|
|
const createBlackTile = async () => {
|
|
return await sharp({
|
|
create: {
|
|
width: 512,
|
|
height: 512,
|
|
channels: 4,
|
|
background: { r: 0, g: 0, b: 0, alpha: 0 },
|
|
},
|
|
}).png().toBuffer();
|
|
};
|
|
|
|
// Serve chart tiles with surface and force support - now serving 512x512 tiles
|
|
app.get("/api/minimap/chart/:instanceId/:surface/:force/:z/:x/:y.png", async (req, res) => {
|
|
try {
|
|
const { instanceId, surface, force, z, x, y } = req.params;
|
|
const tileX = parseInt(x);
|
|
const tileY = parseInt(y);
|
|
|
|
// Each 512x512 tile contains 16x16 chunks of 32x32 pixels
|
|
const chunksPerTile = 16;
|
|
const tileSize = 512;
|
|
|
|
// Calculate the range of chunk coordinates that make up this 512x512 tile
|
|
const startChunkX = tileX * chunksPerTile;
|
|
const startChunkY = tileY * chunksPerTile;
|
|
const endChunkX = startChunkX + chunksPerTile;
|
|
const endChunkY = startChunkY + chunksPerTile;
|
|
|
|
// Create a 512x512 canvas
|
|
const canvas = sharp({
|
|
create: {
|
|
width: tileSize,
|
|
height: tileSize,
|
|
channels: 4,
|
|
background: { r: 0, g: 0, b: 0, alpha: 0 },
|
|
},
|
|
});
|
|
|
|
// Load all the 32x32 chunks and composite them
|
|
const compositeImages = [];
|
|
let chunksFound = 0;
|
|
|
|
for (let chunkY = startChunkY; chunkY < endChunkY; chunkY++) {
|
|
for (let chunkX = startChunkX; chunkX < endChunkX; chunkX++) {
|
|
const filename = `${instanceId}/${surface}/${force}/${chunkX}_${chunkY}.png`;
|
|
const filePath = path.resolve(this.tilesPath, filename);
|
|
|
|
if (await fs.pathExists(filePath)) {
|
|
const relativeX = (chunkX - startChunkX) * CHUNK_SIZE;
|
|
const relativeY = (chunkY - startChunkY) * CHUNK_SIZE;
|
|
|
|
compositeImages.push({
|
|
input: filePath,
|
|
left: relativeX,
|
|
top: relativeY,
|
|
});
|
|
chunksFound++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(chunksFound > 0) {
|
|
this.logger.info(`Tile ${tileX},${tileY}: Found ${chunksFound} chunks, chunk range: ${startChunkX}-${endChunkX-1}, ${startChunkY}-${endChunkY-1}`);
|
|
}
|
|
|
|
// If we have any chunks to composite, create the merged image
|
|
if (compositeImages.length > 0) {
|
|
const mergedImage = await canvas.composite(compositeImages).png().toBuffer();
|
|
res.setHeader("Content-Type", "image/png");
|
|
res.send(mergedImage);
|
|
} else {
|
|
// No chunks found, return black tile
|
|
res.setHeader("Content-Type", "image/png");
|
|
res.send(await createBlackTile());
|
|
}
|
|
} catch (err) {
|
|
this.logger.error(`Error serving chart tile: ${err}`);
|
|
|
|
// Return black tile on error
|
|
res.setHeader("Content-Type", "image/png");
|
|
res.send(await createBlackTile());
|
|
}
|
|
});
|
|
|
|
// List available surfaces and forces
|
|
app.get("/api/minimap/surfaces", async (req, res) => {
|
|
try {
|
|
const instances = new Set<string>();
|
|
const surfaces = new Set<string>();
|
|
const forces = new Set<string>();
|
|
|
|
// Traverse the hierarchical directory structure: instanceId/surface/force/
|
|
const instanceDirs = await fs.readdir(this.tilesPath, { withFileTypes: true });
|
|
|
|
for (const instanceDir of instanceDirs) {
|
|
if (instanceDir.isDirectory()) {
|
|
instances.add(instanceDir.name);
|
|
|
|
const instancePath = path.join(this.tilesPath, instanceDir.name);
|
|
const surfaceDirs = await fs.readdir(instancePath, { withFileTypes: true });
|
|
|
|
for (const surfaceDir of surfaceDirs) {
|
|
if (surfaceDir.isDirectory()) {
|
|
surfaces.add(surfaceDir.name);
|
|
|
|
const surfacePath = path.join(instancePath, surfaceDir.name);
|
|
const forceDirs = await fs.readdir(surfacePath, { withFileTypes: true });
|
|
|
|
for (const forceDir of forceDirs) {
|
|
if (forceDir.isDirectory()) {
|
|
forces.add(forceDir.name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
res.json({
|
|
instances: Array.from(instances),
|
|
surfaces: Array.from(surfaces),
|
|
forces: Array.from(forces),
|
|
});
|
|
} catch (err) {
|
|
this.logger.error(`Error listing surfaces: ${err}`);
|
|
res.status(500).json({ error: "Failed to list surfaces" });
|
|
}
|
|
});
|
|
}
|
|
|
|
async handleTileDataEvent(event: TileDataEvent) {
|
|
try {
|
|
const { type, data, position, instanceId } = event;
|
|
|
|
if (type === "chart") {
|
|
await this.processChartData(data as ChartData[], position, instanceId);
|
|
}
|
|
} catch (err) {
|
|
this.logger.error(`Error processing tile data: ${err}`);
|
|
}
|
|
}
|
|
|
|
private async processChartData(chartData: ChartData[], position: [number, number], instanceId: number) {
|
|
if (!position || !instanceId) {
|
|
this.logger.error("Chart data requires position and instanceId");
|
|
return;
|
|
}
|
|
|
|
const [worldX, worldY] = position;
|
|
|
|
// Convert world coordinates to chunk coordinates
|
|
const chunkX = Math.floor(worldX / 32);
|
|
const chunkY = Math.floor(worldY / 32);
|
|
|
|
// Process each surface/force combination
|
|
for (const chart of chartData) {
|
|
const { surface, force, chart_data } = chart;
|
|
|
|
// Create filename using chunk coordinates
|
|
const filename = `${instanceId}/${surface}/${force}/${chunkX}_${chunkY}.png`;
|
|
|
|
// Process the 32x32 chunk directly and get the processed image data
|
|
const imageDataBase64 = await this.saveChunkImage(filename, chart_data);
|
|
|
|
// Send live update to connected web clients
|
|
if (imageDataBase64) {
|
|
const updateEvent = new ChunkUpdateEvent(
|
|
instanceId,
|
|
surface,
|
|
force,
|
|
chunkX,
|
|
chunkY,
|
|
imageDataBase64
|
|
);
|
|
|
|
// Broadcast to all connected control clients
|
|
this.controller.sendEvent(updateEvent, new lib.Address(lib.Address.broadcast, lib.Address.control));
|
|
}
|
|
}
|
|
}
|
|
|
|
private async saveChunkImage(filename: string, chartData: string): Promise<string | null> {
|
|
const imagePath = path.resolve(this.tilesPath, filename);
|
|
|
|
// Ensure the directory structure exists
|
|
await fs.ensureDir(path.dirname(imagePath));
|
|
|
|
// Create raw image buffer for 32x32 RGBA
|
|
const raw = Buffer.alloc(CHUNK_SIZE * CHUNK_SIZE * 4);
|
|
|
|
try {
|
|
// Decode base64 to get the deflate-compressed data
|
|
const compressedBuffer = Buffer.from(chartData, 'base64');
|
|
|
|
// Decompress the deflate data to get the original binary chart data
|
|
const binaryBuffer = await inflateAsync(compressedBuffer);
|
|
const dataLength = Math.min(binaryBuffer.length, CHUNK_SIZE * CHUNK_SIZE * 2);
|
|
|
|
for (let i = 0; i < dataLength; i += 2) {
|
|
// Read bytes properly from binary buffer
|
|
const byte1 = binaryBuffer[i];
|
|
const byte2 = binaryBuffer[i + 1];
|
|
|
|
if (byte1 === undefined || byte2 === undefined) {
|
|
continue;
|
|
}
|
|
|
|
// Choose endianness based on flag
|
|
const rgb565Value = this.useBigEndian ?
|
|
(byte1 << 8) + byte2 : // Big-endian: byte1 is high byte
|
|
byte1 + (byte2 << 8); // Little-endian: byte1 is low byte
|
|
|
|
const [r, g, b] = this.rgb565ToRgb888(rgb565Value);
|
|
|
|
// Calculate pixel position within the chunk
|
|
const pixelIndex = i / 2;
|
|
const x = pixelIndex % CHUNK_SIZE;
|
|
const y = Math.floor(pixelIndex / CHUNK_SIZE);
|
|
|
|
// Set pixel in raw buffer (RGBA order - Sharp expects this)
|
|
const bufferIndex = pixelIndex * 4;
|
|
if (bufferIndex >= 0 && bufferIndex < raw.length - 3) {
|
|
raw[bufferIndex] = r; // R
|
|
raw[bufferIndex + 1] = g; // G
|
|
raw[bufferIndex + 2] = b; // B
|
|
raw[bufferIndex + 3] = 255; // A (full alpha)
|
|
}
|
|
}
|
|
|
|
// Create the PNG buffer for both saving and live updates
|
|
const pngBuffer = await sharp(raw, {
|
|
raw: {
|
|
width: CHUNK_SIZE,
|
|
height: CHUNK_SIZE,
|
|
channels: 4,
|
|
},
|
|
}).png().toBuffer();
|
|
|
|
// Save the chunk image to disk
|
|
await fs.writeFile(imagePath, pngBuffer);
|
|
|
|
// Convert ImageData to base64 for live updates
|
|
// Create ImageData-like structure that can be sent over WebSocket
|
|
const imageDataArray = new Uint8ClampedArray(raw);
|
|
const imageDataJson = {
|
|
data: Array.from(imageDataArray),
|
|
width: CHUNK_SIZE,
|
|
height: CHUNK_SIZE,
|
|
};
|
|
|
|
// Get the final PNG file size for comparison
|
|
const stats = await fs.stat(imagePath);
|
|
const pngSize = stats.size;
|
|
this.logger.info(`Chunk ${filename}: raw ${raw.length}, decompressed ${binaryBuffer.length}, compressed ${compressedBuffer.length}, PNG ${pngSize} bytes`);
|
|
|
|
// Return base64 encoded ImageData for live updates
|
|
return Buffer.from(JSON.stringify(imageDataJson)).toString('base64');
|
|
|
|
} catch (err) {
|
|
this.logger.error(`Error processing chunk image ${filename}: ${err}`);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
async handleGetInstanceBoundsRequest(request: GetInstanceBoundsRequest) {
|
|
const instances = Array.from(this.controller.instances.values())
|
|
.filter(instance => instance.status === "running")
|
|
.map(instance => ({
|
|
instanceId: instance.config.get("instance.id"),
|
|
name: instance.config.get("instance.name"),
|
|
bounds: {
|
|
x1: -512, // Default bounds, could be made configurable
|
|
y1: -512,
|
|
x2: 512,
|
|
y2: 512,
|
|
},
|
|
}));
|
|
|
|
return { instances };
|
|
}
|
|
}
|