import { afterEach, describe, expect, test } from 'bun:test'
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import path from 'node:path'
import { inheritStyles, resolve, type Style, type StyleDump } from '../src/core/gameStyle'
import { composeLayer, precomposePixel, ensurePieces, gameTint, piecesCurrent, writePieces, type PiecesIndex } from '../tools/pieces'
import { decodePng, encodePng, type Image } from '../tools/bench/png'
const dirs: string[] = []
const temp = () => {
const dir = mkdtempSync(path.join(tmpdir(), 'factorio-pieces-'))
dirs.push(dir)
return dir
}
afterEach(() => { for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true }) })
const atlas: Image = { width: 17, height: 17, data: new Uint8Array(17 * 17 * 4) }
for (let y = 0; y < atlas.height; y++) {
for (let x = 0; x < atlas.width; x++) atlas.data.set([x * 10, y * 10, 100, 255], (y * atlas.width + x) * 4)
}
const layer = (set: Style) => resolve({ raw: { box: { graphical_set: set } } }, 'box').layers[0]!
describe('atlas piece composition', () => {
test('precomposes additive tint against its declared opaque backdrop', () => {
const source = [255, 255, 255, 173] as [number, number, number, number]
const tint = [135, 216, 139, 128] as [number, number, number, number]
const backdrop = [49, 48, 49, 255] as [number, number, number, number]
const actual = precomposePixel(source, tint, 1, backdrop)
for (let c = 0; c < 3; c++) expect(Math.abs(actual[c]! - (tint[c]! * 173 / 255 + backdrop[c]! * (1 - 173 / 255 * 128 / 255)))).toBeLessThanOrEqual(1)
expect(actual[3]).toBe(255)
const dump = fixture()
dump.raw.green_button = { graphical_set: { base: { position: [0, 0], corner_size: 8 }, glow: { position: [0, 0], corner_size: 8, tint, draw_type: 'outer' } } }
const out = temp()
const index = writePieces(dump, 1, out, () => atlas)
expect(index.format).toBe(4)
const p = index.pieces['green_button-hovered-precomposed']!
expect(p.backdrop?.name).toBe('subheader')
expect(p.backdrop?.color).toEqual([36, 35, 36, 255])
const pixel = decodePng(readFileSync(path.join(out, '1', p.file))).data.slice(0, 4)
// This corner lies outside the face: the synthetic atlas averages to
// (5,5,100,255), and its glow is applied directly over the declared backdrop.
for (let c = 0; c < 3; c++) {
const expected = [5, 5, 100][c]! * tint[c]! / 255 + p.backdrop!.color[c]! * (1 - 128 / 255)
expect(Math.abs(pixel[c]! - expected)).toBeLessThanOrEqual(1)
}
expect(pixel[3]).toBe(255)
})
test('uses truncation when composing an exact 2:1 atlas sprite', () => {
const image: Image = { width: 2, height: 2, data: new Uint8Array([
10, 20, 30, 255, 11, 21, 31, 255,
11, 21, 31, 255, 11, 21, 31, 255,
]) }
const piece = composeLayer(layer({ position: [0, 0], size: 2 }), 1, () => image)
expect([...piece.image.data]).toEqual([10, 20, 30, 255])
})
test('aligns unequal tab-glow corners and straight bands at the outer edge', () => {
const piece = composeLayer(layer({
draw_type: 'outer',
left_top: { position: [0, 0], size: 8 }, right_top: { position: [9, 0], size: 8 },
top: { position: [8, 0], size: [1, 4] },
left: { position: [0, 8], size: [4, 1] }, right: { position: [13, 8], size: [4, 1] },
}), 1, () => atlas)
expect([...piece.image.data.slice(4 * 4, 4 * 4 + 4)]).toEqual([80, 5, 100, 255])
const side = 4 * piece.image.width * 4
expect([...piece.image.data.slice(side, side + 4)]).toEqual([5, 80, 100, 255])
})
test('cuts regions and joins corners, edges and an overridden center in Slint order', () => {
const result = composeLayer(layer({ position: [0, 0], corner_size: 8, center: { position: [16, 16], size: 1 } }), 1, () => atlas)
expect(result.image.width).toBe(9)
expect(result.image.height).toBe(9)
expect([...result.image.data.slice(0, 4)]).toEqual([5, 5, 100, 255])
expect([...result.image.data.slice((4 * 9 + 4) * 4, (4 * 9 + 4) * 4 + 4)]).toEqual([160, 160, 100, 255])
expect(result.metadata.nineSlice).toEqual([4, 4, 4, 4])
expect(result.metadata.source.center!.rect).toEqual([16, 16, 1, 1])
expect(decodePng(encodePng(result.image))).toEqual(result.image)
})
test('uses exact 2:1 and 1.6:1 area weights at the requested scale', () => {
const sprite = layer({ position: [0, 0], size: [8, 8] })
const one = composeLayer(sprite, 1, () => atlas)
const fractional = composeLayer(sprite, 1.25, () => atlas)
expect(one.metadata.screenSize).toEqual([4, 4])
expect([...one.image.data.slice(0, 4)]).toEqual([5, 5, 100, 255])
expect(fractional.metadata.screenSize).toEqual([5, 5])
// First footprint [0,1.6): weights 1 and .6; next [1.6,3.2): .4,1,.2.
expect([...fractional.image.data.slice(0, 8)]).toEqual([4, 4, 100, 255, 19, 4, 100, 255])
expect(composeLayer(layer({ position: [0, 0], corner_size: 8 }), 1.25, () => atlas).metadata.nineSlice).toEqual([5, 5, 5, 5])
})
test('filters premultiplied alpha before applying the game tint', () => {
const image: Image = { width: 2, height: 2, data: new Uint8Array([200, 100, 50, 255, 0, 0, 255, 0, 200, 100, 50, 255, 0, 0, 255, 0]) }
const piece = composeLayer(layer({ position: [0, 0], size: 2, tint: [32, 16, 8, 128], opacity: 0.5 }), 1, () => image)
expect([...piece.image.data]).toEqual([50, 12, 3, 32])
expect([...gameTint(image, [0, 0, 0, 0], 1).data]).toEqual(new Array(16).fill(0))
expect(image.data[0]).toBe(200)
})
test('keeps fractional fixed-sprite screen dimensions separate from the integer PNG', () => {
const piece = composeLayer(layer({ position: [0, 0], size: 12 }), 1.25, () => atlas)
expect(piece.metadata.screenSize).toEqual([7.5, 7.5])
expect(piece.metadata.rasterSize).toEqual([8, 8])
expect(piece.metadata.nineSlice).toEqual([0, 0, 0, 0])
})
test('filters odd scrollbar caps together instead of rounding each cap independently', () => {
const piece = composeLayer(layer({ top: { position: [0, 0], size: [8, 7] }, center: { position: [8, 0], size: [8, 8] }, bottom: { position: [0, 8], size: [8, 7] }, center_tiling_vertical: true }), 1, () => atlas)
expect(piece.metadata.screenSize).toEqual([4, 11])
expect(piece.metadata.rasterSize).toEqual([4, 11])
expect([...piece.image.data.slice(3 * 4 * 4, 3 * 4 * 4 + 4)]).toEqual([45, 30, 100, 255])
})
test('scales outer extents, retaining shifts separately from nine-slice corners', () => {
const piece = composeLayer(layer({ position: [0, 0], corner_size: 8, draw_type: 'outer', left_outer_border_shift: 2, bottom_outer_border_shift: -1 }), 1.25, () => atlas)
expect(piece.metadata.outerExtent).toEqual({ top: 5, right: 5, bottom: 3.75, left: 2.5 })
expect(piece.metadata.nineSlice).toEqual([5, 5, 5, 5])
})
test('assembles a full-height tip and the opposite straight side without stretching the tip vertically', () => {
const set = layer({ left: { position: [0, 0], size: [8, 16] }, center: { position: [8, 0], size: [1, 16] }, right_top: { position: [9, 0], size: 2 }, right: { position: [9, 2], size: [2, 1] }, right_bottom: { position: [9, 3], size: 2 } })
const piece = composeLayer(set, 1, () => atlas)
expect(piece.metadata.screenSize).toEqual([6, 8])
expect(piece.metadata.nineSlice).toEqual([0, 1, 0, 4])
expect(piece.metadata.fixedHeight).toBe(8)
expect([...piece.image.data.slice(0, 4)]).toEqual([5, 5, 100, 255])
})
test('rejects invalid geometry and out-of-atlas cuts', () => {
expect(() => composeLayer(layer({ position: [16, 16], size: 4 }), 1, () => atlas)).toThrow('outside')
expect(() => composeLayer(layer({ position: [0, 0], size: 4, scale: 0 }), 1, () => atlas)).toThrow('Invalid sprite geometry')
})
})
function fixture(): StyleDump {
const raw: Record<string, Style> = {}
const set = { position: [0, 0], corner_size: 8 }
const names = ['frame', 'inside_shallow_frame', 'inside_deep_frame', 'mod_thumbnail_image', 'mod_explore_thumbnail_image', 'mods_scroll_pane', 'scroll_pane', 'subheader_frame', 'negative_message_frame', 'tabbed_pane_frame', 'button', 'green_button', 'red_button', 'back_button', 'confirm_button', 'dropdown_button', 'tool_button', 'tool_button_red', 'tab', 'table_with_selection', 'mods_explore_results_table', 'list_box_item', 'checkbox', 'black_checkbox']
for (const name of names) raw[name] = { graphical_set: set }
for (const name of ['draggable_space', 'draggable_space_header']) raw[name] = { graphical_set: { top: { position: [0, 0], size: [8, 7] }, center: { position: [8, 0], size: [8, 8] }, bottom: { position: [0, 8], size: [8, 8] }, center_tiling_horizontal: true } }
for (const name of ['textbox', 'search_popup_textfield']) raw[name] = { default_background: set, active_background: set, disabled_background: set }
for (const state of ['default', 'hover', 'press', 'disabled', 'selected']) raw.tab![`${state}_badge_graphical_set`] = set
for (const name of ['vertical_scrollbar', 'horizontal_scrollbar']) raw[name] = { graphical_set: set, thumb_button_style: { default_graphical_set: set, hovered_graphical_set: set, clicked_graphical_set: set } }
for (const name of ['line', 'bordered_table']) raw[name] = { border: { left_end: { position: [0, 0], size: 8 }, horizontal_line: { position: [8, 0], size: [1, 8] }, right_end: { position: [9, 0], size: 8 } } }
raw.checkbox = { type: 'checkbox_style', default_graphical_set: set, selected_graphical_set: set, disabled_graphical_set: set, checkmark: { position: [0, 0], size: 8 }, disabled_checkmark: { position: [8, 8], size: 8 } }
return { gameVersion: '2.0.test', raw, resolved: inheritStyles(raw), constants: {}, fonts: {} }
}
describe('piece index and startup cache in temporary directories', () => {
test('writes PNGs, source metadata, ordered checkmarks, and phase-correct rib tiles', () => {
const out = temp()
const index = writePieces(fixture(), 1, out, () => atlas, 'fixture')
expect(index.gameVersion).toBe('2.0.test')
expect(index.entries['checkbox:disabled-checked']).toEqual(['checkbox-disabled-checked-base', 'checkbox-disabled-checked-checkmark'])
expect(index.pieces['checkbox-disabled-checked-checkmark']!.source.center!.rect).toEqual([8, 8, 8, 8])
const ribs = decodePng(readFileSync(path.join(out, '1/draggable_space-24-base.png')))
expect([ribs.width, ribs.height]).toEqual([4, 24])
// Output row 3 averages source top row 6 with the first centre row, not two capped rows.
expect([...ribs.data.slice(3 * 4 * 4, 3 * 4 * 4 + 4)]).toEqual([45, 30, 100, 255])
expect(piecesCurrent(index, '2.0.test', 1, 'fixture', path.join(out, '1'))).toBe(true)
expect(piecesCurrent(index, '2.1', 1, 'fixture', path.join(out, '1'))).toBe(false)
expect(piecesCurrent(index, '2.0.test', 1.25, 'fixture', path.join(out, '1'))).toBe(false)
expect(piecesCurrent(index, '2.0.test', 1, 'changed', path.join(out, '1'))).toBe(false)
expect(piecesCurrent({ ...index, format: 0 }, '2.0.test', 1, 'fixture', path.join(out, '1'))).toBe(false)
rmSync(path.join(out, '1/checkbox-disabled-checked-checkmark.png'))
expect(piecesCurrent(index, '2.0.test', 1, 'fixture', path.join(out, '1'))).toBe(false)
})
test('ensurePieces reuses a current cache and repairs corrupt, missing, or stale indexes', async () => {
const dir = temp()
const install = path.join(dir, 'install')
const styles = path.join(dir, 'styles.json')
const out = path.join(dir, 'pieces')
const files: Record<string, string | Uint8Array> = {
'data/base/info.json': JSON.stringify({ version: '2.0.test' }),
'data/core/prototypes/style.lua': '', 'data/core/prototypes/fonts.lua': '', 'data/core/locale/en/info.json': '{}',
'data/core/graphics/gui-new.png': encodePng(atlas),
}
for (const [file, data] of Object.entries(files)) {
mkdirSync(path.dirname(path.join(install, file)), { recursive: true })
writeFileSync(path.join(install, file), data)
}
writeFileSync(styles, JSON.stringify(fixture()))
const options = { install, styles, out }
const first = await ensurePieces(1, options)
const indexPath = path.join(out, '1/index.json')
const time = statSync(indexPath).mtimeMs
expect(await ensurePieces(1, options)).toEqual(first)
expect(statSync(indexPath).mtimeMs).toBe(time)
writeFileSync(indexPath, '{broken')
expect(await ensurePieces(1, options)).toEqual(first)
const png = path.join(out, '1/button-default-base.png')
rmSync(png)
await ensurePieces(1, options)
expect(existsSync(png)).toBe(true)
const changed = fixture()
changed.raw.button!.graphical_set = { position: [0, 0], size: 8 }
writeFileSync(styles, JSON.stringify(changed))
const next = await ensurePieces(1, options)
expect(next.fingerprint).not.toBe(first.fingerprint)
expect(next.pieces['button-default-base']!.screenSize).toEqual([4, 4])
const stale = JSON.parse(readFileSync(indexPath, 'utf8')) as PiecesIndex
stale.gameVersion = 'old'
writeFileSync(indexPath, JSON.stringify(stale))
expect((await ensurePieces(1, options)).gameVersion).toBe('2.0.test')
await expect(ensurePieces(2 as 1, options)).rejects.toThrow('Scale must be 1 or 1.25')
})
})