normalize-strip.mjs

#!/usr/bin/env node
import sharp from 'sharp';
import { parseArgs } from 'node:util';
import { mkdirSync } from 'node:fs';
import { join } from 'node:path';

const { values } = parseArgs({
    options: {
        input:      { type: 'string' },
        outdir:     { type: 'string' },
        frames:     { type: 'string', default: '4' },
        framesize:  { type: 'string', default: '128' },
        anchor:     { type: 'string' },
        lockframe1: { type: 'boolean', default: false },
        name:       { type: 'string', default: 'frame' },
    },
});

if (!values.input || !values.outdir) {
    console.error(
        'Usage: node scripts/normalize-strip.mjs \\\n' +
        '  --input sprites/raw/walk-strip.png \\\n' +
        '  --outdir sprites/final \\\n' +
        '  [--frames 4] [--framesize 128] \\\n' +
        '  [--anchor sprites/final/companion-front.png] \\\n' +
        '  [--lockframe1] [--name walk]'
    );
    process.exit(1);
}

const numFrames = Number(values.frames);
const frameSize = Number(values.framesize);
mkdirSync(values.outdir, { recursive: true });

// Load the full strip
const stripMeta = await sharp(values.input).metadata();
const slotW = Math.floor(stripMeta.width / numFrames);
const slotH = stripMeta.height;

console.log(`Strip: ${stripMeta.width}x${stripMeta.height}, ${numFrames} slots of ${slotW}x${slotH}`);

// Find the bounding box of non-transparent (and non-magenta) pixels
async function findBounds(buffer, w, h) {
    const { data } = await sharp(buffer)
    .raw()
    .toBuffer({ resolveWithObject: true });

    let minX = w, minY = h, maxX = 0, maxY = 0;
    let found = false;

    for (let y = 0; y < h; y++) {
        for (let x = 0; x < w; x++) {
            const i = (y * w + x) * 4;
            const r = data[i], g = data[i + 1], b = data[i + 2], a = data[i + 3];

            // Skip transparent pixels
            if (a < 10) continue;

            // Skip magenta background pixels
            if (r > 230 && g < 30 && b > 230) continue;

            minX = Math.min(minX, x);
            minY = Math.min(minY, y);
            maxX = Math.max(maxX, x);
            maxY = Math.max(maxY, y);
            found = true;
        }
    }

    if (!found) return null;
    return { x: minX, y: minY, w: maxX - minX + 1, h: maxY - minY + 1 };
}

// Extract each slot from the strip
const slotBuffers = [];
for (let i = 0; i < numFrames; i++) {
    const buf = await sharp(values.input)
    .extract({ left: i * slotW, top: 0, width: slotW, height: slotH })
    .ensureAlpha()
    .png()
    .toBuffer();
    slotBuffers.push(buf);
}

// Find bounds for each frame
const allBounds = [];
for (let i = 0; i < numFrames; i++) {
    const bounds = await findBounds(slotBuffers[i], slotW, slotH);
    if (bounds) {
        allBounds.push({ index: i, ...bounds });
        console.log(`Frame ${i + 1}: character at ${bounds.x},${bounds.y} size ${bounds.w}x${bounds.h}`);
    } else {
        allBounds.push({ index: i, x: 0, y: 0, w: slotW, h: slotH });
        console.log(`Frame ${i + 1}: no character found, using full slot`);
    }
}

// Find the tallest and widest character across all frames
const maxCharW = Math.max(...allBounds.map(b => b.w));
const maxCharH = Math.max(...allBounds.map(b => b.h));

// Calculate uniform scale to fit in frameSize with padding
const padding = Math.floor(frameSize * 0.05);
const availableSize = frameSize - padding * 2;
const scale = Math.min(availableSize / maxCharW, availableSize / maxCharH);

console.log(`\nMax character size: ${maxCharW}x${maxCharH}`);
console.log(`Scale factor: ${scale.toFixed(3)} → fits in ${frameSize}x${frameSize}`);

// Process each frame
for (let i = 0; i < numFrames; i++) {
    const b = allBounds[i];

    // Crop to character bounds
    let frame = sharp(slotBuffers[i])
    .extract({ left: b.x, top: b.y, width: b.w, height: b.h });

    // Scale uniformly
    const scaledW = Math.round(b.w * scale);
    const scaledH = Math.round(b.h * scale);

    frame = frame.resize(scaledW, scaledH, {
        kernel: sharp.kernel.nearest,
    });

    // Place on final canvas, anchored at bottom-center
    const offsetX = Math.floor((frameSize - scaledW) / 2);
    const offsetY = frameSize - scaledH - padding; // bottom-aligned

    const finalFrame = await sharp({
        create: {
            width: frameSize,
            height: frameSize,
            channels: 4,
            background: { r: 0, g: 0, b: 0, alpha: 0 },
        },
    })
    .composite([{
        input: await frame.png().toBuffer(),
               left: offsetX,
               top: offsetY,
    }])
    .png()
    .toBuffer();

    const outPath = join(values.outdir, `${values.name}-${String(i + 1).padStart(2, '0')}.png`);
    await sharp(finalFrame).toFile(outPath);
    console.log(`Saved: ${outPath} (${scaledW}x${scaledH} placed at ${offsetX},${offsetY})`);
}

// Lock frame 1 to the original anchor/seed if requested
if (values.lockframe1 && values.anchor) {
    const frame1Path = join(values.outdir, `${values.name}-01.png`);
    await sharp(values.anchor)
    .resize(frameSize, frameSize, {
        fit: 'contain',
        background: { r: 0, g: 0, b: 0, alpha: 0 },
        kernel: sharp.kernel.nearest,
    })
    .png()
    .toFile(frame1Path);
    console.log(`\nFrame 01 locked to anchor: ${values.anchor}`);
}

console.log(`\nDone. ${numFrames} normalized frames in ${values.outdir}`);