silphscope 1.2.28 → 1.2.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silphscope",
-  "version": "1.2.28",
+  "version": "1.2.29",
   "description": "A firered/leafgreen ROM asset extractor for use in web applications",
   "main": "main.js",
   "exports": {

package/rom-configs/firered.js

@@ -1,3 +1,6 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
 // I have an idea but it needs math D:
 
 export const firered = {

package/src/get-rom-config.js

@@ -1,3 +1,6 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
 import { firered } from "../rom-configs/firered.js";
 
 function detectRomCode(rom) {

package/src/graphics/graphics-extractor-main.js

@@ -21,6 +21,7 @@ const assets = loadDefaultJson("../graphics-maps/fr-graphic-map.json");
 const mons = loadDefaultJson("../mon-data/monData.json");
 const icons = loadDefaultJson("../item-data/itemData.json");
 const trainers = loadDefaultJson("../trainer-data/trainerData.json");
+const trainersBack = loadDefaultJson("../trainer-data/trainerBackData.json");
 
 export async function renderAllMons(rom, options = {}) {
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
@@ -40,34 +41,13 @@ export async function renderAllMons(rom, options = {}) {
     const reader = new RomReader(rom, config);
 
     for (const monName of Object.keys(providedMons)) {
-        await renderMon(monName, providedMons, reader, rom, {
-            side: "front",
-            variant: "normal",
+        await renderMon(monName, providedMons, reader, rom, { // hopefully this is faster since we are no longer calling the function 4 times lol
+            side: ["front", "back"],
+            variant: ["normal", "shiny"],
             icon,
             footprint,
             outputDir,
         });
-        await renderMon(monName, providedMons, reader, rom, {
-            side: "front",
-            variant: "shiny",
-            icon: false,
-            footprint: false,
-            outputDir,
-        });
-        await renderMon(monName, providedMons, reader, rom, {
-            side: "back",
-            variant: "normal",
-            icon: false,
-            footprint: false,
-            outputDir,
-        });
-        await renderMon(monName, providedMons, reader, rom, {
-            side: "back",
-            variant: "shiny",
-            icon: false,
-            footprint: false,
-            outputDir,
-        });
         console.log(`Done: ${monName}`);
     }
 }
@@ -100,16 +80,20 @@ export async function renderAllTrainers(rom, options = {}) {
     }
     
     const {
-        assets: providedAssets = assets,
         trainers: providedTrainers = trainers,
+        trainersBack: providedBackTrainers = trainersBack,
         trainerBackPics = true,
         outputDir = "./out",
     } = options;
 
     fs.mkdirSync(outputDir, { recursive: true });
+    const backTrainerName = Object.keys(providedBackTrainers);
+
+    const config = getRomConfig(rom);
+    const reader = new RomReader(rom, config);
 
     for (const trainerName of Object.keys(providedTrainers)) {
-        await renderTrainer(trainerName, providedTrainers, providedAssets, rom, {
+        await renderTrainer(trainerName, providedTrainers, backTrainerName, providedBackTrainers, reader, rom, {
             trainerBackPics, 
             outputDir 
         });

package/src/graphics/icons/resolvers/item-icons-resolver.js

@@ -1,3 +1,6 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
 export function resolveItemIconObject(item, reader, itemName, gfxOrPal) {
     const table = reader.getTable("itemIconTable");
     const entrySize = 8; // why did I make this variable... hmmm... I really can't remember... eh it doesn't do any harm other than being kinda useless since we could just pass 8 as is...

package/src/graphics/mons/render-mons.js

@@ -30,6 +30,9 @@ export async function renderMon(monName, mons, reader, rom, options = {}) {
         throw new TypeError("renderMon(..., rom) requires a ROM Buffer/Uint8Array");
     }
 
+    const sides = Array.isArray(side) ? side : [side];
+    const variants = Array.isArray(variant) ? variant : [variant];
+
     if (icon === true) {
         await renderMonIcon(monName, mons, reader, rom, { outputDir });
     }
@@ -42,35 +45,45 @@ export async function renderMon(monName, mons, reader, rom, options = {}) {
         throw new Error(`Missing mon: ${monName}`);
     }
 
-    const monPic = resolveMonSprite(mon, reader, monName, side); // I wonder if this will work :O
-    const monPal = resolveMonPalette(mon, reader, monName, variant);
-
-    if (!monPic || !monPal) {
-        throw new Error(`Missing assets for: ${monName}`);
+    const picCache = {};
+    const palCache = {};
+    for (const side of sides) {
+        const monPic = resolveMonSprite(mon, reader, monName, side);
+        if (!monPic) throw new Error(`Missing sprite data for: ${monName} ${side}`);
+        picCache[side] = extract(monPic, rom).data;
+    }
+    for (const variant of variants) {
+        const monPal = resolveMonPalette(mon, reader, monName, variant);
+        if (!monPal) throw new Error(`Missing palette data for: ${monName} ${variant}`);
+        palCache[variant] = extract(monPal, rom).data;
     }
 
-    const monImageData = extract(monPic, rom);
-    const rawMonPalData = extract(monPal, rom);
+    const results = [];
     const width = 64;
     const height = 64;
+    for (const side of sides) {
+        for (const variant of variants) {
+            const image = render4bppImage({
+                tileData: picCache[side], 
+                paletteData: palCache[variant], 
+                width, 
+                height, 
+            });
 
-    const image = render4bppImage({
-        tileData: monImageData.data, 
-        paletteData: rawMonPalData.data, 
-        width, 
-        height, 
-    });
+            const png = new PNG({ width, height });
+            png.data = image;
+            const pngBuffer = await streamToBuffer(png.pack());
 
-    const png = new PNG({ width, height });
-    png.data = image;
-    const pngBuffer = await streamToBuffer(png.pack());
+            if (outputDir) {
+                const dir = `${outputDir}/${monName}`;
+                if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true }); // I suppose it is better to have this out of the loop for performance but erm I would say its fine for now :p
+                const fileName = `${dir}/${side}${variant === "shiny" ? "_shiny" : ""}.png`;
+                fs.writeFileSync(fileName, pngBuffer);
+            }
 
-    if (outputDir) {
-        const dir = `${outputDir}/${monName}`;
-        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-        const fileName = `${dir}/${side}${variant === "shiny" ? "_shiny" : ""}.png`;
-        fs.writeFileSync(fileName, pngBuffer);
+            results.push(pngBuffer);
+        }
     }
 
-    return pngBuffer;
+    return results;
 }

package/src/graphics/mons/resolvers/mon-footprint-sprite-resolver.js

@@ -1,3 +1,6 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
 export function resolveMonFootprint(mon, reader, monName) {
     const table = reader.getTable("monFootprintTable");
     const entryOffset = table + mon.index * 4;

package/src/graphics/mons/resolvers/mon-icon-palette-resolver.js

@@ -1,3 +1,6 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
 export function resolveMonIconPalette(mon, reader, monName) { // I kinda think this might be wrong... but erm who knows :o maybe I got it right first try lol
     const indexTable = reader.getTable("monIconPaletteIndices");
     const paletteIndex = reader.readU8(indexTable + mon.index);

package/src/graphics/mons/resolvers/mon-icon-resolver.js

@@ -1,3 +1,6 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
 export function resolveMonIcon(mon, reader, monName) {
     const table = reader.getTable("monIconTable");
     const entryOffset = table + mon.index * 4;

package/src/graphics/mons/resolvers/mon-sprite-palette-resolver.js

@@ -1,3 +1,6 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
 export function resolveMonPalette(mon, romReader, monName, variant) {
     const tableName = variant === "shiny"
         ? "monShinyPalettes"

package/src/graphics/mons/resolvers/mon-sprite-resolver.js

@@ -1,3 +1,6 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
 // so the idea of "resolvers" is to essentially replace this line in the asset extraction:
 // const monPic = assets.find(a => a.name === picName);
 // of course though thats for the mon stuff specifically however!

package/src/graphics/trainers/render-trainer-back-pics.js

@@ -5,6 +5,8 @@ import { PNG } from "pngjs";
 import fs from "fs";
 import { extract } from "../extract.js";
 import { render4bppImage } from "../render-4bpp-image.js";
+import { resolveTrainerBackPic } from "./resolvers/trainer-back-pic-resolver.js";
+import { resolveTrainerBackPicPal } from "./resolvers/trainer-back-pic-pal-resolver.js"
 
 const streamToBuffer = (stream) => new Promise((resolve, reject) => {
     const chunks = [];
@@ -13,7 +15,7 @@ const streamToBuffer = (stream) => new Promise((resolve, reject) => {
     stream.on("error", reject);
 });
 
-export async function renderTrainerBackPic(trainerName, trainers, assets, rom, options = {}) {
+export async function renderTrainerBackPic(trainerName, trainers, reader, rom, options = {}) {
     const { outputDir = null } = options;
 
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
@@ -25,20 +27,8 @@ export async function renderTrainerBackPic(trainerName, trainers, assets, rom, o
         throw new Error(`Missing trainer entry for ${trainerName}`);
     }
 
-    if (trainerName !== "OLDMAN" &&
-        trainerName !== "POKEDUDE" &&
-        trainerName !== "RS_BRENDAN_1" &&
-        trainerName !== "RS_BRENDAN_2" &&
-        trainerName !== "RS_MAY_1" &&
-        trainerName !== "RS_MAY_2" && // I wonder if there is a more compact way to write this without using a array and `.includes` 
-        trainerName !== "RED" &&
-        trainerName !== "LEAF"
-    ) {
-        return;
-    }
-
-    const trainerBackPic = assets.find(a => a.name === trainer.BackPic);
-    const trainerBackPal = assets.find(a => a.name === trainer.BackPal);
+    const trainerBackPic = resolveTrainerBackPic(trainer, reader, trainerName);
+    const trainerBackPal = resolveTrainerBackPicPal(trainer, reader, trainerName);
     if (!trainerBackPic || !trainerBackPal) {
         throw new Error(`Missing assets for: ${trainerName}`);
     }

package/src/graphics/trainers/render-trainers.js

@@ -6,6 +6,8 @@ import { render4bppImage } from "../render-4bpp-image.js";
 import { PNG } from "pngjs";
 import fs from "fs";
 import { renderTrainerBackPic } from "./render-trainer-back-pics.js";
+import { resolveTrainerFrontPic } from "./resolvers/trainer-front-pic-resolver.js";
+import { resolveTrainerFrontPicPal } from "./resolvers/trainer-front-pic-pal-resolver.js";
 
 const streamToBuffer = (stream) => new Promise((resolve, reject) => {
     const chunks = [];
@@ -14,7 +16,7 @@ const streamToBuffer = (stream) => new Promise((resolve, reject) => {
     stream.on("error", reject);
 });
 
-export async function renderTrainer(trainerName, trainers, assets, rom, options = {}) {
+export async function renderTrainer(trainerName, trainers, backTrainerName, backTrainers, reader, rom, options = {}) {
     const {
         trainerBackPics = false,
         outputDir = null,
@@ -28,13 +30,10 @@ export async function renderTrainer(trainerName, trainers, assets, rom, options
         throw new Error(`Missing Trainer: ${trainerName}`);
     }
     if (trainerBackPics) {
-        renderTrainerBackPic(trainerName, trainers, assets, rom, { outputDir });
+        renderTrainerBackPic(backTrainerName, backTrainers, reader, rom, { outputDir });
     }
-    if (trainerName === "OLDMAN" || trainerName === "POKEDUDE") {
-        return;
-    }
-    const trainerPal = assets.find(a => a.name === trainer.Palette);
-    const trainerPic = assets.find(a => a.name === trainer.Pic);
+    const trainerPal = resolveTrainerFrontPicPal(trainer, reader, trainerName);
+    const trainerPic = resolveTrainerFrontPic(trainer, reader, trainerName);
 
     if (!trainerPal || !trainerPic) {
         throw new Error(`Missing assets for: ${trainerName}`);

package/src/graphics/trainers/resolvers/trainer-back-pic-pal-resolver.js

@@ -0,0 +1,10 @@
+export function resolveTrainerBackPicPal(trainer, reader, trainerName) { // I probably could generalize this stuff but erm... thats more work :p
+    const table = reader.getTable("trainerBackPicPaletteTable");
+    const entryOffset = table + trainer.index * 8;
+    const ptr = reader.readPointer(entryOffset);
+    return {
+        name: `trainer_${trainerName}_back_pic_pal`,
+        offset: ptr,
+        size: 40,
+    }
+}

package/src/graphics/trainers/resolvers/trainer-back-pic-resolver.js

@@ -0,0 +1,9 @@
+export function resolveTrainerBackPic(trainer, reader, trainerName) {
+    const table = reader.getTable("trainerBackPicTable");
+    const entryOffset = table + trainer.index * 8;
+    const ptr = reader.readPointer(entryOffset);
+    return {
+        name: `trainer_${trainerName}_back_pic`,
+        offset: ptr,
+    }
+}

package/src/graphics/trainers/resolvers/trainer-front-pic-pal-resolver.js

@@ -0,0 +1,10 @@
+export function resolveTrainerFrontPicPal(trainer, reader, trainerName) {
+    const table = reader.getTable("trainerFrontPicPaletteTable");
+    const entryOffset = table + trainer.index * 8;
+    const ptr = reader.readPointer(entryOffset);
+    return {
+        name: `trainer_${trainerName}_front_pic_pal`,
+        offset: ptr,
+        size: 40,
+    }
+}

package/src/graphics/trainers/resolvers/trainer-front-pic-resolver.js

@@ -0,0 +1,9 @@
+export function resolveTrainerFrontPic(trainer, reader, trainerName) {
+    const table = reader.getTable("trainerFrontPicTable");
+    const entryOffset = table + trainer.index * 8;
+    const ptr = reader.readPointer(entryOffset);
+    return {
+        name: `trainer_${trainerName}_front_pic`,
+        offset: ptr,
+    }
+}

package/src/rom-reader.js

@@ -1,3 +1,6 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
 export class RomReader {
     constructor(rom, mapConfig) {
         this.rom = rom;

package/src/trainer-data-parser.js

@@ -19,7 +19,7 @@ for (let i = 0; i < frontPicLines.length; i++) {
         } else {
             trainerData[trainerName]["Palette"] = match[3];
         }
-        if (!trainerData[trainerName]["index"]) {
+        if (trainerData[trainerName]["index"] === undefined) {
             trainerData[trainerName]["index"] = trainerIndex;
             trainerIndex++;
         }

package/trainer-data/trainerBackData.json

@@ -0,0 +1,26 @@
+{
+    "RED": {
+        "index": 0
+    },
+    "LEAF": {
+        "index": 1
+    },
+    "RS_BRENDAN_1": {
+        "index": 2
+    },
+    "RS_BRENDAN_2": {
+        "index": 2
+    },
+    "RS_MAY_1": {
+        "index": 3
+    },
+    "RS_MAY_2": {
+        "index": 3
+    },
+    "POKEDUDE": {
+        "index": 4
+    },
+    "OLDMAN": {
+        "index": 5
+    }
+}