silphscope 1.4.3 → 1.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silphscope",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "description": "A firered/leafgreen ROM asset extractor for use in web applications",
   "main": "main.js",
   "exports": {
@@ -26,7 +26,8 @@
     "!src/rom-map-parser.js",
     "!rom-maps/",
     "!graphics-maps/",
-    "ball-data/"
+    "ball-data/",
+    "!src/object-event-data-parser.js"
   ],
   "keywords": [
     "gba",

package/rom-configs/fireredRev0.js

@@ -26,5 +26,7 @@ export const fireredRev0 = {
         ballParticlePalTable: 0x40BFA8,
         ballAnimPicTable: 0x26056C,
         ballAnimPalTable: 0x2605CC, // any idea what I am doing next?
+        objectEventPicTable: 0x39FDB0,
+        objectEventPalTable: 0x3A5158, // so these tables... technically aren't tables (except for the palette one kinda...) they are actually pointers to objects which then contain children who actually contain another object which finally contains a pointer to the actual graphics... this will be fun... (anyway will work on this eventually...)
     } // if this works out... well hehe... :D
 }

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

@@ -4,6 +4,7 @@
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
+import { mapLimit } from "../map-limit.js";
 import { renderMon } from "./mons/render-mons.js";
 import { renderIcon } from "./icons/render-icons.js";
 import { renderTrainer } from "./trainers/render-trainers.js";
@@ -43,6 +44,16 @@ export async function renderAllMons(rom, options = {}) {
     const config = getRomConfig(rom);
     const reader = new RomReader(rom, config);
 
+    await mapLimit(Object.keys(providedMons), 4, async (monName) => { // so in theory we should be running the function 4 times concurrently now...
+        await renderMon(monName, providedMons, reader, rom, {
+            variant: ["normal", "shiny"],
+            icon,
+            footprint,
+            outputDir,
+        });
+        console.log(`Done: ${monName}`);
+    });
+/* just going to leave this here for now in case I decide to make it so that you can toggle between concurrent usage and I suppose synchronous would be the correct term for this down here...
     for (const monName of Object.keys(providedMons)) {
         await renderMon(monName, providedMons, reader, rom, { // hopefully this is faster since we are no longer calling the function 4 times lol
             side: ["front", "back"],
@@ -53,6 +64,7 @@ export async function renderAllMons(rom, options = {}) {
         });
         console.log(`Done: ${monName}`);
     }
+*/
 }
 
 export async function renderAllIcons(rom, options = {}) {

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

@@ -74,9 +74,9 @@ export async function renderMonFoot(monName, mons, reader, rom, options = {}) {
 
     if (outputDir) {
         const dir = `${outputDir}/${monName}`;
-        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        await fs.promises.mkdir(dir, { recursive: true });
         const fileName = `${dir}/footprint.png`;
-        fs.writeFileSync(fileName, pngBuffer);
+        await fs.promises.writeFile(fileName, pngBuffer);
     }
 
     return pngBuffer;

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

@@ -56,9 +56,9 @@ export async function renderMonIcon(monName, mons, reader, rom, options = {}) {
 
     if (outputDir) {
         const dir = `${outputDir}/${monName}`;
-        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(`${dir}/icon_frame1.png`, buffer1);
-        fs.writeFileSync(`${dir}/icon_frame2.png`, buffer2);
+        await fs.promises.mkdir(dir, { recursive: true });
+        await fs.promises.writeFile(`${dir}/icon_frame1.png`, buffer1);
+        await fs.promises.writeFile(`${dir}/icon_frame2.png`, buffer2);
     }
 
     return {

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

@@ -61,6 +61,9 @@ export async function renderMon(monName, mons, reader, rom, options = {}) {
     const results = [];
     const width = 64;
     const height = 64;
+    if (outputDir) {
+        await fs.promises.mkdir(dir, { recursive: true }); // why was I using existsSync... eh well "fixed?" now I guess... also I moved this out of the loop as you can see so it only has to run... 440 times now... instead of 4x that number :p
+    }
     for (const side of sides) {
         for (const variant of variants) {
             const image = render4bppImage({
@@ -76,9 +79,8 @@ export async function renderMon(monName, mons, reader, rom, options = {}) {
 
             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);
+                await fs.promises.writeFile(fileName, pngBuffer);
             }
 
             results.push(pngBuffer);

package/src/map-limit.js

@@ -0,0 +1,25 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+export async function mapLimit(items, limit, mapper) { // I hope this works... in theory it should and it seems quite simple... it's just that I am garbage at async thingies...
+    const results = new Array(items.length);
+    let index = 0;
+
+    async function worker() {
+        while (true) {
+            const current = index++;
+
+            if (index >= items.length) return;
+
+            results[current] = await mapper(items[current], current);
+        }
+    }
+    await Promise.all(
+        Array.from(
+            { length: Math.min(limit, items.length) },
+            worker
+        )
+    );
+
+    return results;
+}