diff --git a/packages/controller/src/routes.ts b/packages/controller/src/routes.ts index 10d75533..a47ceb2d 100644 --- a/packages/controller/src/routes.ts +++ b/packages/controller/src/routes.ts @@ -240,9 +240,9 @@ async function uploadExport(req: Request, res: Response) { let exportFiles = [ "export/settings.json", "export/prototypes.json", - "export/item-spritesheet.png", - "export/item-metadata.json", "export/locale.json", + "export/spritesheet.png", + "export/metadata.json", ]; let assets: any = {}; @@ -263,7 +263,7 @@ async function uploadExport(req: Request, res: Response) { await lib.safeOutputFile(path.join("static", `${name}.${hash}${ext}`), await file.async("nodebuffer")); } - modPack.exportManifest = new lib.ExportManifest(assets); + modPack.exportManifest = new lib.ExportManifest(assets, new Date().toISOString()); modPack.fillDefaultSettings(settingPrototypes, logger); res.app.locals.controller.modPacks.set(modPack); @@ -701,5 +701,6 @@ export const webRoutes = [ "/roles/:id/view", "/plugins", "/plugins/:name/view", + "/icon-reference", "/error", ]; diff --git a/packages/host/src/export.ts b/packages/host/src/export.ts index f4fe3846..4368c7e4 100644 --- a/packages/host/src/export.ts +++ b/packages/host/src/export.ts @@ -98,7 +98,8 @@ async function loadZip(server: FactorioServer, modVersions: Map, async function loadFile(server: FactorioServer, modVersions: Map, modPath: string) { let match = /^__([^\/]+)__\/(.*)$/.exec(modPath); if (!match) { - throw new Error(`Bad mod path ${match}`); + server._logger.warn(`Skipping icon with bad mod path: ${JSON.stringify(modPath)}`); + return null; } let [, mod, filePath] = match; @@ -151,7 +152,6 @@ async function loadIcon( iconCache.set(iconPath, icon); } else { icon = null; - server._logger.warn(`${iconPath} not found`); } iconCache.set(iconPath, icon); } @@ -258,6 +258,14 @@ function fixIcons(item: ItemPrototype) { return item; } +/** Get the primary icon path from a prototype (first layer for layered, .icon for simple). */ +function getPrimaryIconPath(item: ItemPrototype): string | undefined { + if (item.icons) { + return (item as LayeredIconSpecification).icons[0]?.icon; + } + return (item as SimpleIconSpecification).icon; +} + const itemTypes = new Set([ "item", "ammo", @@ -280,87 +288,153 @@ const itemTypes = new Set([ "armor", "mining-tool", "repair-tool", - // XXX Bad hack to get icons for fluids. These should be treated as a // separate namespace from items as they may be named the same as items. "fluid", - // TODO consider adding virtual signals and recipes ]); -function filterItems(prototypes: Prototypes): ItemPrototype[] { +const recipeTypes = new Set(["recipe"]); +const signalTypes = new Set(["virtual-signal"]); +const technologyTypes = new Set(["technology"]); +const planetTypes = new Set(["planet", "space-location"]); +const qualityTypes = new Set(["quality"]); + +// Entity types to export. Entities whose name matches an already-exported +const entityTypes = new Set([ + "assembling-machine", "furnace", "inserter", "transport-belt", "underground-belt", + "splitter", "loader", "loader-1x1", "mining-drill", "container", "logistic-container", + "electric-pole", "pipe", "pipe-to-ground", "pump", "storage-tank", "boiler", + "generator", "solar-panel", "accumulator", "reactor", "heat-pipe", "lab", "beacon", + "roboport", "lamp", "radar", "wall", "gate", "land-mine", "turret", "ammo-turret", + "electric-turret", "fluid-turret", "artillery-turret", "rocket-silo", "car", + "spider-vehicle", "locomotive", "cargo-wagon", "fluid-wagon", "artillery-wagon", + "train-stop", "rail-signal", "rail-chain-signal", "straight-rail", "curved-rail-a", + "curved-rail-b", "half-diagonal-rail", "elevated-straight-rail", "elevated-curved-rail-a", + "elevated-curved-rail-b", "elevated-half-diagonal-rail", "rail-ramp", "rail-support", + "space-platform-hub", "cargo-bay", "asteroid-collector", "thruster", "cargo-pod", + "cargo-landing-pad", "asteroid", + "construction-robot", "logistic-robot", "combat-robot", "capture-robot", + "unit", "unit-spawner", "spider-unit", "segmented-unit", + "tree", "plant", "fish", "resource", "cliff", "simple-entity", + "simple-entity-with-owner", "simple-entity-with-force", + "arithmetic-combinator", "decider-combinator", "constant-combinator", + "selector-combinator", "programmable-speaker", "power-switch", "display-panel", + "character", + "offshore-pump", "valve", "lightning-attractor", + "fusion-generator", "fusion-reactor", "burner-generator", + "agricultural-tower", "market", "lane-splitter", +]); + +function filterPrototypes(prototypes: Prototypes, allowedTypes: Set): ItemPrototype[] { return Object.entries(prototypes) - .filter(([type, _]) => itemTypes.has(type)) + .filter(([type]) => allowedTypes.has(type)) .flatMap(([_, typePrototypes]) => Object.values(typePrototypes) as ItemPrototype[]) - .map(fixIcons) - ; + .map(fixIcons); +} + +/** Shared state for building a unified spritesheet across all categories. */ +interface SheetState { + sheet: Jimp; + metadata: Map; + iconCache: IconCache; + simpleIcons: Map; + pos: number; +} + +const SHEET_ICON_SIZE = 32; +const SHEET_WIDTH = 1024; + +async function createSheetState(): Promise { + return { + sheet: await Jimp.create(SHEET_WIDTH, SHEET_ICON_SIZE), + metadata: new Map(), + iconCache: new Map(), + simpleIcons: new Map(), + pos: 0, + }; +} + +/** Grow the spritesheet vertically if needed to fit another row. */ +async function growSheet(state: SheetState) { + const row = Math.floor(state.pos / (SHEET_WIDTH / SHEET_ICON_SIZE)); + const neededHeight = (row + 1) * SHEET_ICON_SIZE; + if (neededHeight > state.sheet.bitmap.height) { + const extended = await Jimp.create(SHEET_WIDTH, neededHeight); + extended.composite(state.sheet, 0, 0); + (state.sheet as any).bitmap = (extended as any).bitmap; + } } /** - * Export item icons and data + * Export item icons for a single category onto the shared spritesheet. * - * Assembles and packs the icons for the item prototypes given into a single - * spritesheet and json file with meta data. - * - * @param server - - * The server to generate the export mod for. - * @param modVersions - - * Mapping of mod name to versions to get icons from. - * @param items - Array of item prototypes. - * @return Item spritesheet and metadata. + * @param server - The server to load icons from. + * @param modVersions - Mapping of mod name to version. + * @param items - Array of item prototypes to export. + * @param category - Category name for metadata. + * @param state - Shared spritesheet state (mutated in place). + * @returns Number of icons exported for this category. * @internal */ -async function exportItems(server: FactorioServer, modVersions: Map, items: ItemPrototype[]) { - - // Size to render icons at - let size = 32; - - // Width of spritesheet - let width = 1024; - - let rows = Math.ceil(items.length / (width / size)); - let iconSheet = await Jimp.create(width, rows * size); - let itemData = new Map(); - let pos = 0; - - let iconCache: IconCache = new Map(); - let simpleIcons = new Map(); +async function exportItems( + server: FactorioServer, + modVersions: Map, + items: ItemPrototype[], + category: string, + state: SheetState, +) { + let count = 0; for (let item of items) { + // Skip prototypes with no icon data at all + if (!item.icons && !item.icon) { + continue; + } + let icon: Jimp | null = null; let iconPos: number | undefined; if (item.icons) { - icon = await loadLayeredIcon(server, modVersions, item as LayeredIconSpecification, size, iconCache); - iconPos = pos; + icon = await loadLayeredIcon( + server, modVersions, item as LayeredIconSpecification, SHEET_ICON_SIZE, state.iconCache, + ); + iconPos = state.pos; } else { - iconPos = simpleIcons.get(item.icon); + iconPos = state.simpleIcons.get(item.icon as string); if (iconPos === undefined) { - icon = await loadSimpleIcon(server, modVersions, item as SimpleIconSpecification, size, iconCache); + icon = await loadSimpleIcon( + server, modVersions, item as SimpleIconSpecification, SHEET_ICON_SIZE, state.iconCache, + ); if (icon) { - iconPos = pos; - simpleIcons.set(item.icon, pos); + iconPos = state.pos; + state.simpleIcons.set(item.icon as string, state.pos); } } } if (iconPos !== undefined) { - itemData.set(item.name, { - x: iconPos * size % width, - y: Math.floor(iconPos / (width / size)) * size, - size, - localised_name: item.localised_name, - localised_description: item.localised_description, + const iconPath = getPrimaryIconPath(item); + state.metadata.set(`${category}.${item.name}`, { + x: iconPos * SHEET_ICON_SIZE % SHEET_WIDTH, + y: Math.floor(iconPos / (SHEET_WIDTH / SHEET_ICON_SIZE)) * SHEET_ICON_SIZE, + size: SHEET_ICON_SIZE, + category, + ...(iconPath ? { path: iconPath } : {}), }); } if (icon) { - iconSheet.composite(icon, pos * size % width, Math.floor(pos / (width / size)) * size); - pos += 1; + await growSheet(state); + state.sheet.composite( + icon, + state.pos * SHEET_ICON_SIZE % SHEET_WIDTH, + Math.floor(state.pos / (SHEET_WIDTH / SHEET_ICON_SIZE)) * SHEET_ICON_SIZE, + ); + state.pos += 1; + count += 1; } } - iconSheet.crop(0, 0, width, Math.ceil(pos / (width / size)) * size); - - return { iconSheet, itemData }; + return count; } /** @@ -505,7 +579,16 @@ export async function exportData(server: FactorioServer) { } } - let { iconSheet, itemData } = await exportItems(server, modVersions, filterItems(prototypes)); + const categories: { name: string, types: Set }[] = [ + { name: "item", types: itemTypes }, + { name: "recipe", types: recipeTypes }, + { name: "signal", types: signalTypes }, + { name: "technology", types: technologyTypes }, + { name: "planet", types: planetTypes }, + { name: "quality", types: qualityTypes }, + { name: "entity", types: entityTypes }, + ]; + let locale = await exportLocale(server, modVersions, modOrder, "en"); // Free up the memory used by zip files loaded during the export. @@ -514,9 +597,28 @@ export async function exportData(server: FactorioServer) { let zip = new JSZip(); zip.file("export/settings.json", JSON.stringify(settings)); zip.file("export/prototypes.json", JSON.stringify(prototypes)); - zip.file("export/item-spritesheet.png", await iconSheet.getBufferAsync(Jimp.MIME_PNG)); - zip.file("export/item-metadata.json", JSON.stringify([...itemData.entries()])); zip.file("export/locale.json", JSON.stringify([...locale.entries()])); + + // Build a single unified spritesheet across all prototype categories. + const state = await createSheetState(); + for (const category of categories) { + const categoryItems = filterPrototypes(prototypes, category.types); + + if (categoryItems.length === 0) { + continue; + } + const count = await exportItems(server, modVersions, categoryItems, category.name, state); + server._logger.info(`Exported ${count} ${category.name} icons`); + } + + // Crop sheet to actual used height and write single spritesheet + metadata. + const usedRows = Math.ceil(state.pos / (SHEET_WIDTH / SHEET_ICON_SIZE)); + state.sheet.crop(0, 0, SHEET_WIDTH, Math.max(usedRows * SHEET_ICON_SIZE, 1)); + zip.file("export/spritesheet.png", await state.sheet.getBufferAsync(Jimp.MIME_PNG)); + zip.file("export/metadata.json", JSON.stringify([...state.metadata.entries()])); + + server._logger.info(`Export complete: ${state.metadata.size} icons on ${usedRows} row(s)`); + return zip; } diff --git a/packages/lib/src/data/ExportManifest.ts b/packages/lib/src/data/ExportManifest.ts index f3edfe06..00e2eb6b 100644 --- a/packages/lib/src/data/ExportManifest.ts +++ b/packages/lib/src/data/ExportManifest.ts @@ -11,21 +11,26 @@ export default class ExportManifest { /** * Mapping between known assets and their file names. * - * Currently exported assets are + * Currently exported assets are: * - settings: JSON of mod settings prototypes. * - prototypes: JSON of all game prototypes except settings. - * - item-spritesheet: PNG containing icons from the game. - * - item-metadata: JSON of Map entries describing icons in item-spritesheet * - locale: JSON of flattened Map entries of en locale strings from the game. + * - spritesheet: Single PNG spritesheet containing all icon categories. + * - metadata: JSON array of [name, {x, y, size, category, path?}] entries + * describing sprite coordinates and category membership. Categories: + * item, recipe, signal, technology, planet, quality, entity, static. */ - public assets: Record + public assets: Record, + /** ISO 8601 timestamp of when the export was uploaded. */ + public exportedAt?: string, ) { } static jsonSchema = Type.Object({ "assets": Type.Record(Type.String(), Type.String()), + "exportedAt": Type.Optional(Type.String()), }); static fromJSON(json: Static) { - return new this(json.assets); + return new this(json.assets, json.exportedAt); } } diff --git a/packages/web_ui/src/components/IconReferencePage.tsx b/packages/web_ui/src/components/IconReferencePage.tsx new file mode 100644 index 00000000..bfb896bf --- /dev/null +++ b/packages/web_ui/src/components/IconReferencePage.tsx @@ -0,0 +1,248 @@ +import React, { useMemo, useState } from "react"; +import { Card, Input, Space, Table, Tag, Typography } from "antd"; + +import { + useItemMetadata, + useRecipeMetadata, + useSignalMetadata, + useTechnologyMetadata, + usePlanetMetadata, + useQualityMetadata, + useEntityMetadata, +} from "../model/item_metadata"; +import { useExportManifest } from "../model/export_manifest"; +import PageHeader from "./PageHeader"; +import PageLayout from "./PageLayout"; + +const { Text } = Typography; + +type IconEntry = { + key: string; + category: string; + name: string; + cssClass: string; + size: number; + path?: string; +}; + +const CATEGORIES = [ + "item", "recipe", "signal", "technology", "planet", "quality", "entity", +] as const; + +type Category = typeof CATEGORIES[number]; + +const CATEGORY_LABELS: Record = { + item: "Item", + recipe: "Recipe", + signal: "Signal", + technology: "Technology", + planet: "Planet", + quality: "Quality", + entity: "Entity", +}; + +function useAllIconEntries() { + const item = useItemMetadata(); + const recipe = useRecipeMetadata(); + const signal = useSignalMetadata(); + const technology = useTechnologyMetadata(); + const planet = usePlanetMetadata(); + const quality = useQualityMetadata(); + const entity = useEntityMetadata(); + + const byCategory: Record> = { + item, recipe, signal, technology, planet, quality, entity, + }; + + return useMemo(() => { + const entries: IconEntry[] = []; + + for (const category of CATEGORIES) { + const names = [...byCategory[category].keys()].sort(); + for (const name of names) { + const meta = byCategory[category].get(name)!; + entries.push({ + key: `${category}:${name}`, + category, + name, + cssClass: `${category}-${CSS.escape(name)}`, + size: meta.size, + path: meta.path, + }); + } + } + + return entries; + }, [item, recipe, signal, technology, planet, quality, entity]); +} + +export default function IconReferencePage() { + const [filter, setFilter] = useState(""); + const [expandedGroups, setExpandedGroups] = useState>(new Set()); + const allEntries = useAllIconEntries(); + + const filtered = useMemo(() => { + const q = filter.trim().toLowerCase(); + if (!q) { + return allEntries; + } + return allEntries.filter(e => e.name.toLowerCase().includes(q) || e.cssClass.toLowerCase().includes(q) + ); + }, [allEntries, filter]); + + const groups = useMemo(() => { + const map = new Map(); + for (const cat of CATEGORIES) { + map.set(cat, []); + } + for (const entry of filtered) { + map.get(entry.category)!.push(entry); + } + return CATEGORIES.map(cat => ({ category: cat, entries: map.get(cat)! })) + .filter(g => g.entries.length > 0); + }, [filtered]); + + const visibleCount = filtered.length; + const totalCount = allEntries.length; + const autoExpand = visibleCount <= 20; + + const isExpanded = (category: string) => autoExpand || expandedGroups.has(category); + + const toggleGroup = (category: string) => { + setExpandedGroups(prev => { + const next = new Set(prev); + if (next.has(category)) { + next.delete(category); + } else { + next.add(category); + } + return next; + }); + }; + + const columns = [ + { + title: "Icon", + dataIndex: "cssClass", + key: "icon", + width: 48, + render: (_: string, record: IconEntry) => ( +
+ ), + }, + { + title: "Name", + dataIndex: "name", + key: "name", + render: (name: string) => ( + {name} + ), + }, + { + title: "Usage", + dataIndex: "cssClass", + key: "usage", + render: (cssClass: string) => ( + + {`
`} + + ), + }, + { + title: "Path", + dataIndex: "path", + key: "path", + render: (p: string | undefined) => (p + ? {p} + : null), + }, + ]; + + const manifest = useExportManifest(); + + return ( + + +
+ {!manifest && ( + + + No export data available. Run export-data on an instance to generate icons. + + + )} + {manifest && manifest.exportedAt && ( +
+ {manifest.exportedAt && ( +
+ Exported: + {new Date(manifest.exportedAt).toLocaleString()} +
+ )} +
+ Icons: + {totalCount} +
+
+ )} + + + setFilter(e.target.value)} + allowClear + style={{ width: 320 }} + /> + + {visibleCount === totalCount + ? `${totalCount} icons` + : `${visibleCount} / ${totalCount} icons`} + + + {groups.map(({ category, entries }) => { + const label = CATEGORY_LABELS[category as Category] ?? category; + const expanded = isExpanded(category); + return ( +
+
toggleGroup(category)} + style={{ + display: "flex", + alignItems: "center", + gap: 8, + padding: "6px 12px", + background: "#1d1d1d", + border: "1px solid #333", + borderRadius: expanded ? "4px 4px 0 0" : 4, + cursor: "pointer", + userSelect: "none", + }} + > + + {expanded ? "▾" : "►"} + + {label} + + {entries.length} + +
+ {expanded && ( + + columns={columns} + dataSource={entries} + rowKey="key" + size="small" + showHeader={false} + pagination={false} + style={{ borderTop: "none" }} + /> + )} +
+ ); + })} +
+
+
+ ); +} diff --git a/packages/web_ui/src/model/export_manifest.ts b/packages/web_ui/src/model/export_manifest.ts index da5d6967..5ec39b28 100644 --- a/packages/web_ui/src/model/export_manifest.ts +++ b/packages/web_ui/src/model/export_manifest.ts @@ -4,10 +4,10 @@ import * as lib from "@clusterio/lib"; import ControlContext from "../components/ControlContext"; let exportManifestCache: lib.ExportManifest|null = null; -let emptyCache = { assets: {} }; +let loaded = false; export function useExportManifest(): lib.ExportManifest|null { const control = useContext(ControlContext); - let [exportManifest, setExportManifest] = useState(exportManifestCache || emptyCache); + let [exportManifest, setExportManifest] = useState(exportManifestCache); useEffect(() => { async function load() { let modPack = await control.send(new lib.ModPackGetDefaultRequest()); @@ -15,9 +15,10 @@ export function useExportManifest(): lib.ExportManifest|null { exportManifestCache = modPack.exportManifest; setExportManifest(exportManifestCache); } + loaded = true; } - if (!exportManifestCache) { + if (!loaded) { load(); } }, []); diff --git a/packages/web_ui/src/model/item_metadata.ts b/packages/web_ui/src/model/item_metadata.ts index 0b1658ed..a170566e 100644 --- a/packages/web_ui/src/model/item_metadata.ts +++ b/packages/web_ui/src/model/item_metadata.ts @@ -7,31 +7,51 @@ type Metadata = { x: number; y: number; size: number; + category: string; localised_name?: any[]; + path?: string; }; -let itemMetadataCache: Map | null = null; -export function useItemMetadata() { - let exportManifest = useExportManifest(); - let [itemMetadata, setItemMetadata] = useState>(itemMetadataCache || new Map()); + +const metadataCaches = new Map>(); +let cssInjected = false; + +/** + * Load the unified spritesheet metadata and inject CSS rules for every icon. + * CSS class name: `.{category}-{CSS.escape(name)}` + * e.g. `.item-iron-plate`, `.recipe-iron-plate`, `.signal-signal-red`, `.planet-nauvis` + */ +function useSpriteMetadata(category: string): Map { + const exportManifest = useExportManifest(); + const [metadata, setMetadata] = useState>( + metadataCaches.get(category) ?? new Map() + ); + useEffect(() => { async function load() { if ( !exportManifest - || !exportManifest.assets["item-metadata"] - || !exportManifest.assets["item-spritesheet"] + || !exportManifest.assets["metadata"] + || !exportManifest.assets["spritesheet"] ) { return; } - let response = await fetch(`${staticRoot}static/${exportManifest.assets["item-metadata"]}`); - if (response.ok) { - let data = await response.json(); - itemMetadataCache = new Map(data); - let style = document.createElement("style"); + + const response = await fetch(`${staticRoot}static/${exportManifest.assets["metadata"]}`); + if (!response.ok) { + return; + } + + const data: [string, Metadata][] = await response.json(); + + if (!cssInjected) { + const sheetUrl = `${staticRoot}static/${exportManifest.assets["spritesheet"]}`; + const style = document.createElement("style"); document.head.appendChild(style); - for (let [name, meta] of itemMetadataCache) { + for (const [key, meta] of data) { + const name = key.includes(".") ? key.slice(key.indexOf(".") + 1) : key; style.sheet!.insertRule(`\ -.item-${CSS.escape(name)} { - background-image: url("${staticRoot}static/${exportManifest.assets["item-spritesheet"]}"); +.${meta.category}-${CSS.escape(name)} { + background-image: url("${sheetUrl}"); background-repeat: no-repeat; background-position: -${meta.x}px -${meta.y}px; height: ${meta.size}px; @@ -39,14 +59,32 @@ export function useItemMetadata() { }` ); } - setItemMetadata(itemMetadataCache); + cssInjected = true; } + + const cache = new Map(); + for (const [key, meta] of data) { + if (meta.category === category) { + const name = key.includes(".") ? key.slice(key.indexOf(".") + 1) : key; + cache.set(name, meta); + } + } + metadataCaches.set(category, cache); + setMetadata(cache); } - if (!itemMetadataCache) { + if (!metadataCaches.has(category)) { load(); } }, [exportManifest]); - return itemMetadata; + return metadata; } + +export function useItemMetadata() { return useSpriteMetadata("item"); } +export function useRecipeMetadata() { return useSpriteMetadata("recipe"); } +export function useSignalMetadata() { return useSpriteMetadata("signal"); } +export function useTechnologyMetadata() { return useSpriteMetadata("technology"); } +export function usePlanetMetadata() { return useSpriteMetadata("planet"); } +export function useQualityMetadata() { return useSpriteMetadata("quality"); } +export function useEntityMetadata() { return useSpriteMetadata("entity"); } diff --git a/packages/web_ui/src/pages.tsx b/packages/web_ui/src/pages.tsx index 5235fd51..f3f36a35 100644 --- a/packages/web_ui/src/pages.tsx +++ b/packages/web_ui/src/pages.tsx @@ -16,6 +16,7 @@ import RoleViewPage from "./components/RoleViewPage"; import PluginsPage from "./components/PluginsPage"; import PluginViewPage from "./components/PluginViewPage"; import ErrorPage from "./components/ErrorPage"; +import IconReferencePage from "./components/IconReferencePage"; export const pages: PluginPage[] = [ { @@ -88,6 +89,10 @@ export const pages: PluginPage[] = [ sidebarPath: "/plugins", content: , }, + { + path: "/icon-reference", + content: , + }, { path: "/error", content: , diff --git a/test/integration/clusterio.js b/test/integration/clusterio.js index d874b7d3..57f5eec5 100644 --- a/test/integration/clusterio.js +++ b/test/integration/clusterio.js @@ -654,7 +654,7 @@ describe("Integration of Clusterio", function() { let modPack = await getControl().send(new lib.ModPackGetDefaultRequest()); let assets = modPack.exportManifest.assets; assert(Object.keys(assets).length > 1, "Export assets is empty"); - for (let key of ["settings", "prototypes", "item-metadata", "item-spritesheet", "locale"]) { + for (let key of ["settings", "prototypes", "metadata", "spritesheet", "locale"]) { assert(assets[key], `Missing ${key} from assets`); assert( await fs.exists(path.join(exportPath, assets[key])),