oaf-boost/tools/cheat-builder/build.js

const { readFile, writeFile } = require("fs/promises");
const transform = require("./worker");

const loadlist = async () => {
    const datfile = await readFile("./serial.json");
    const datas = JSON.parse(datfile.toString());
    return Object.entries(datas).filter(n => n[1] != "????");
}

const format = valid => {
    valid.sort((a, b) => a.serial.localeCompare(b.serial));
    console.info(`valid rom has ${valid.length}`);

    const enc = new TextEncoder();
    const size = Symbol("length");
    const concatUnit = 10240;
    const align = (n, base) => base * Math.floor((n + base - 1) / base);
    const concat = (a, b) => {
        let len = (a[size] || 0) + b.length;
        if (len > a.length) {
            let n = new (Object.getPrototypeOf(a).constructor)(align(len, concatUnit) * 2);
            n.set(a, 0);
            n.set(b, a[size]);
            n[size] = len;
            return n;
        }
        else {
            a.set(b, a[size]);
            a[size] = len;
            return a;
        }
    }
    const getnametable = list => list.reduce((r, { serial, cheat }, idx, arr) => {
        const val = serial.slice(0, -1);
        if (val != r[4]) {
            if (r[1][size] > 0 && r[2] - r[1].at(r[1][size] - 1) > r[3])
                r[3] = r[2] - r[1].at(r[1][size] - 1);
            r[0] = concat(r[0], enc.encode(val))
            r[1] = concat(r[1], [r[2]]);
            r[4] = val;
        }
        r[2] = r[2] + cheat.length;
        if (idx + 1 == arr.length) {
            if (r[2] - r[1].at(r[1][size] - 1) > r[3])
                r[3] = r[2] - r[1].at(r[1][size] - 1);
            r[1] = concat(r[1], [r[2]]);
        }
        return r;
    }, [concat(new Uint8Array(concatUnit), []), concat(new Uint16Array(concatUnit), []), 0, 0, ""]);

    const expandcheat = (list, base) => list.reduce((r, { cheat, serial }) => {
        const val = serial.charCodeAt(3);
        return cheat.reduce((r, { id, bin }) => {
            const off = r[2] + r[1][size];
            r[0] = concat(r[0], [val | (off << 3), id])
            r[1] = concat(r[1], bin);
            return r;
        }, r);
    }, [concat(new Uint32Array(concatUnit), []), concat(new Uint8Array(concatUnit), []), align(base, 32)]);

    const linkbuffer = (arr, ...l) => {
        for (let i of l) {
            const arrBa = arr[i];
            arr[i] = arrBa.slice(0, arrBa[size]);
        }
        return arr;
    }

    const [sers, offs, chtc, maxl] = linkbuffer(getnametable(valid), 0, 1);
    const [cheats, expanded] = linkbuffer(expandcheat(valid, 8 + sers.length + offs.length * 2 + chtc * 8), 0, 1);
    console.info(`name: ${sers.length} cheats: ${chtc} maxl: ${maxl}`);

    const serialbase = 8;
    const offsetbase = serialbase + sers.length;
    const cheatbase = offsetbase + offs.length * 2;
    const expandbase = align(cheatbase + cheats.length * 4, 32);
    const total = expandbase + expanded.length;

    const output = new ArrayBuffer(total);
    // header: magic number: ACL\1-serial length(u32)
    const writter = new DataView(output);
    writter.setUint8(0, "A".charCodeAt());
    writter.setUint8(1, "C".charCodeAt());
    writter.setUint8(2, "L".charCodeAt());
    writter.setUint8(3, 1);

    const slen = sers.length / 3;
    writter.setUint16(4, slen, true);
    writter.setUint16(6, maxl, true);

    let ret = new Uint8Array(output);
    ret.set(sers, serialbase);
    ret.set(new Uint8Array(offs.buffer), offsetbase);
    ret.set(new Uint8Array(cheats.buffer), cheatbase);
    ret.set(expanded, expandbase);

    return ret;
}

const start = async () => {
    let begin = Date.now();
    let list = await loadlist();
    let roms = await transform(list);
    console.log(`all rom has ${roms.length} and time ${Date.now() - begin}`);
    roms = Object.entries(roms.reduce((r, data) => {
        if (!data) return r;

        const { serial, cheat } = data;
        if (!cheat || cheat.length == 0) return r;
        if (serial in r) r[serial] = [...r[serial], ...cheat];
        else r[serial] = cheat;
        return r;
    }, {})).map(([serial, cheat]) => ({ serial, cheat }));

    const content = await format( roms );
    await writeFile( "gba.acl", content );
}

start()