silphscope 1.1.5 → 1.2.0

package/README.md

@@ -20,10 +20,11 @@ const rom = fs.readFileSync("pokefirered.gba"); // replace with path to your own
 await renderAllGraphics(rom, {
     outputMonDir: "./Assets/monImages", // must I explain?
     outputIconDir: "./Assets/Icons", // same thing here :p
+    outputTrainerDir: "./Assets/Trainers", // ...
 });
 ```
 
-Of course though the above is for extracting all graphics (which is kinda a lie... In reality it only extracts mon images and item icons... but like I said this is a WIP :p so wait a bit please!).
+Of course though the above is for extracting all graphics (which is kinda a lie... In reality it only extracts mon images, item icons, and trainer images... but like I said this is a WIP :p so wait a bit please!).
 
 But if you want say just the mon images or item icons refer below:
 
@@ -49,4 +50,15 @@ const rom = fs.readFileSync("pokefirered.gba")// find your own rom and so on :l
 await renderAllIcons(rom, {
     outputDir: "./Assets/Icons" // no comment (wait... that was a comment :p)
 });
+```
+
+trainer image extraction:
+```JavaScript
+import fs from "fs";
+import { renderAllTrainers } from "silphscope" // :O
+
+const rom = fs.readFileSync("pokefirered.gba") // stuff stuff stuff
+await renderAllTrainers(rom, {
+    outputDir: "./Assets/trainers" // more stuff
+})
 ```

package/package.json

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

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

@@ -6,6 +6,7 @@ import path from "path";
 import { fileURLToPath } from "url";
 import { renderMon } from "./render-mons.js";
 import { renderIcon } from "./icons/render-icons.js";
+import { renderTrainer } from "./trainers/render-trainers.js";
 
 const currentDir = path.dirname(fileURLToPath(import.meta.url));
 
@@ -17,6 +18,7 @@ function loadDefaultJson(relativePath) {
 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");
 
 export async function renderAllMons(rom, options = {}) {
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
@@ -85,6 +87,25 @@ export async function renderAllIcons(rom, options = {}) {
     }
 }
 
+export async function renderAllTrainers(rom, options = {}) {
+    if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
+        throw new TypeError("renderAllTrainers(rom, options) requires rom Buffer/Uint8Array as first argument");
+    }
+    
+    const {
+        assets: providedAssets = assets,
+        trainers: providedTrainers = trainers,
+        outputDir = "./out",
+    } = options;
+
+    fs.mkdirSync(outputDir, { recursive: true });
+
+    for (const trainerName of Object.keys(providedTrainers)) {
+        await renderTrainer(trainerName, providedTrainers, providedAssets, rom, { outputDir });
+        console.log(`Done: ${trainerName}`);
+    }
+}
+
 export async function renderAllGraphics(rom, options = {}) { // eventually I will speed this up instead of doing it sequentially :p but for now its fine I guess
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderAllGraphics(rom, options) requires rom Buffer/Uint8Array as first argument");
@@ -93,6 +114,7 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
     const {
         outputMonDir = "./out/mons",
         outputIconDir = "./out/icons",
+        outputTrainerDir = "./out/trainers",
     } = options;
 
     await renderAllMons(rom, {
@@ -104,6 +126,10 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
     await renderAllIcons(rom, {
         outputDir: outputIconDir,
     });
+
+    await renderTrainer(rom, {
+        outputDir: outputTrainerDir,
+    });
 }
 
 export function loadDefaultRom() {

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

@@ -37,8 +37,8 @@ export async function renderIcon(itemName, items, assets, rom, options = {}) {
     const height = 24;
 
     const image = render4bppImage({
-        tileData: iconImageData, 
-        paletteData: rawIconPalData, 
+        tileData: iconImageData.data, 
+        paletteData: rawIconPalData.data, 
         width, 
         height
     });

package/src/graphics/render-mons.js

@@ -57,8 +57,8 @@ export async function renderMon(monName, mons, assets, rom, options = {}) {
     const height = 64;
 
     const image = render4bppImage({
-        tileData: monImageData, 
-        paletteData: rawMonPalData, 
+        tileData: monImageData.data, 
+        paletteData: rawMonPalData.data, 
         width, 
         height, 
     });

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

@@ -0,0 +1,58 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+import { extract } from "../extract.js";
+import { render4bppImage } from "../render-4bpp-image.js";
+import { PNG } from "pngjs";
+import fs from "fs";
+
+const streamToBuffer = (stream) => new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", chunk => chunks.push(chunk));
+    stream.on("end", () => resolve(Buffer.concat(chunks)));
+    stream.on("error", reject);
+});
+
+export async function renderTrainer(trainerName, trainers, assets, rom, options = {}) {
+    const { outputDir = null } = options;
+    if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
+        throw new TypeError("renderTrainer(..., rom) requires a ROM Buffer/Uint8Array");
+    }
+
+    const trainer = trainers[trainerName];
+    if (!trainer) {
+        throw new Error(`Missing Trainer: ${trainerName}`);
+    }
+
+    const trainerPal = assets.find(a => a.name === trainer.Palette);
+    const trainerPic = assets.find(a => a.name === trainer.Pic);
+
+    if (!trainerPal || !trainerPic) {
+        throw new Error(`Missing assets for: ${trainerName}`);
+    }
+
+    const trainerImageData = extract(trainerPic, rom);
+    const rawTrainerPalData = extract(trainerPal, rom);
+    const width = 64;
+    const height = 64;
+
+    const image = render4bppImage({
+        tileData: trainerImageData.data,
+        paletteData: rawTrainerPalData.data,
+        width,
+        height
+    });
+
+    const png = new PNG({ width, height });
+    png.data = image;
+    const pngBuffer = await streamToBuffer(png.pack());
+
+    if (outputDir) {
+        const dir = `${outputDir}/${trainerName}`;
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        const fileName = `${dir}/trainer_front.png`;
+        fs.writeFileSync(fileName, pngBuffer);
+    }
+
+    return pngBuffer;
+}

package/src/trainer-data-parser.js

@@ -0,0 +1,24 @@
+import fs from "fs";
+import path from "path";
+
+const trainerFrontPicMap = path.resolve("../trainer_graphics/front_pic_tables.h");
+const frontPicLines = fs.readFileSync(trainerFrontPicMap, "utf-8").split("\n");
+
+const trainerData = {};
+
+for (let i = 0; i < frontPicLines.length; i++) {
+    const match = frontPicLines[i].match(/TRAINER_(SPRITE|PAL)\(\s*([A-Z0-9_]+)\s*,\s*(gTrainer(?:FrontPic|Palette)_[A-Za-z0-9_]+)/);
+    if (match) {
+        let trainerName = match[2];
+        if (!trainerData[trainerName]) {
+            trainerData[trainerName] = {};
+        }
+        if (match[1] === "SPRITE") {
+            trainerData[trainerName]["Pic"] = match[3];
+        } else {
+            trainerData[trainerName]["Palette"] = match[3];
+        }
+    }
+}
+
+fs.writeFileSync("../trainer-data/trainerData.json", JSON.stringify(trainerData, null, 2));