silphscope 1.4.13 → 1.4.15

package/package.json

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

package/src/graphics/balls/render-ball-particle.js

@@ -37,6 +37,7 @@ export async function renderBallParticle(ballName, balls, reader, rom, options =
     const {
         pngFilterType = null,
         pngCompressionLevel = null,
+        returnFileBuffer = false,
         outputDir = null,
         renderMasterBallParticleImage = false,
     } = options;
@@ -44,6 +45,8 @@ export async function renderBallParticle(ballName, balls, reader, rom, options =
         throw new TypeError("renderBallParticle(..., rom) requires a ROM Buffer/Uint8Array");
     }
 
+    let fileCount = 0;
+    const results = returnFileBuffer? [] : null;
     const ball = balls[ballName];
     if (!ball) {
         throw new Error(`Missing Ball: ${ballName}`);
@@ -79,6 +82,10 @@ export async function renderBallParticle(ballName, balls, reader, rom, options =
         if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
         if (renderMasterBallParticleImage) {
             fs.writeFileSync(`${dir}/master-particle.png`, pngBuffer);
+            fileCount += 1;
+            if (returnFileBuffer) {
+                results.push(pngBuffer);
+            }
         }
         for (let i = 0; i < ball.particleFrames.length; i++) {
             const frame = ball.particleFrames[i];
@@ -93,8 +100,15 @@ export async function renderBallParticle(ballName, balls, reader, rom, options =
 
             const fileName = `${dir}/particle-${i}.png`;
             fs.writeFileSync(fileName, pngFrameBuffer);
+            fileCount += 1;
+            if (returnFileBuffer) {
+                results.push(pngFrameBuffer);
+            }
         }
     }
 
-    return pngBuffer;
+    return {
+        ...(returnFileBuffer && { results }),
+        fileCount,
+    };
 }

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

@@ -38,6 +38,7 @@ export async function renderBall(ballName, balls, reader, rom, options = {}) {
     const {
         pngFilterType = null,
         pngCompressionLevel = null,
+        returnFileBuffer = false,
         outputDir = null,
         ballParticles = false,
         renderMasterBallImage = false,
@@ -47,17 +48,24 @@ export async function renderBall(ballName, balls, reader, rom, options = {}) {
         throw new TypeError("renderBall(..., rom) requires a ROM Buffer/Uint8Array");
     }
 
+    let fullFileCount = 0;
+    const results = returnFileBuffer? [] : null;
     const ball = balls[ballName];
     if (!ball) {
         throw new Error(`Missing Ball: ${ballName}`);
     }
     if (ballParticles) {
-        renderBallParticle(ballName, balls, reader, rom, {
+        const renderBallParticleData = await renderBallParticle(ballName, balls, reader, rom, {
             pngFilterType,
             pngCompressionLevel,
+            returnFileBuffer,
             outputDir,
             renderMasterBallParticleImage, 
         });
+        fullFileCount += renderBallParticleData.fileCount;
+        if (returnFileBuffer) {
+            results.push(...renderBallParticleData.results);
+        }
     }
     const ballPal = resolveBallSpritePal(ball, reader, ballName);
     const ballPic = resolveBallSpritePic(ball, reader, ballName);
@@ -89,6 +97,10 @@ export async function renderBall(ballName, balls, reader, rom, options = {}) {
         await fs.promises.mkdir(dir, { recursive: true });
         if (renderMasterBallImage) {
             await fs.promises.writeFile(`${dir}/master-image.png`, pngBuffer)
+            fullFileCount += 1;
+            if (returnFileBuffer) {
+                results.push(pngBuffer);
+            }
         }
         for (let i = 0; i < ball.frames.length; i++) {
             const frame = ball.frames[i];
@@ -103,8 +115,15 @@ export async function renderBall(ballName, balls, reader, rom, options = {}) {
 
             const fileName = `${dir}/frame-${i}.png`;
             await fs.promises.writeFile(fileName, pngFrameBuffer);
+            fullFileCount += 1;
+            if (returnFileBuffer) {
+                results.push(pngFrameBuffer);
+            }
         }
     }
 
-    return pngBuffer;
+    return {
+        ...(returnFileBuffer && { results }),
+        fullFileCount,
+    };
 }

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

@@ -92,7 +92,7 @@ export async function renderAllMons(rom, options = {}) {
                 console.log(`Done: ${monName}`);
             }
             totalFileCount += renderMonData.fullFileCount;
-            if (returnFileBuffer) {
+            if (returnFileBuffer && renderMonData?.results) {
                 finalResults.push(...renderMonData.results);
             }
         });
@@ -122,10 +122,10 @@ export async function renderAllMons(rom, options = {}) {
 
     if (showSummary) {
         console.log(`
-            renderAllMons() Output Summary:
-            Rendered ${Object.keys(providedMons).length} Mons amounting to:
-            ${totalFileCount} Files written
-            Done in ${elapsed}s with SilphScope`);
+renderAllMons() Output Summary:
+Rendered ${Object.keys(providedMons).length} Mons amounting to:
+${totalFileCount} Files written
+Done in ${elapsed}s with SilphScope`);
     }
 
     return {
@@ -135,6 +135,7 @@ export async function renderAllMons(rom, options = {}) {
 }
 
 export async function renderAllIcons(rom, options = {}) {
+    const start = performance.now();
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderAllIcons(rom, options) requires rom Buffer/Uint8Array as first argument");
     }
@@ -145,6 +146,8 @@ export async function renderAllIcons(rom, options = {}) {
         pngFilterType = 0,
         pngCompressionLevel = 4,
         verboseLogs = true,
+        showSummary = true,
+        returnFileBuffer = false,
         outputDir = "./out",
     } = options;
 
@@ -162,33 +165,61 @@ export async function renderAllIcons(rom, options = {}) {
 
     const config = getRomConfig(rom);
     const reader = new RomReader(rom, config);
+    let totalFileCount = 0;
+    const finalResults = returnFileBuffer? [] : null;
 
     if (concurrency > 1) {
         await mapLimit(Object.keys(providedIcons), concurrency, async (itemName) => {
-            await renderIcon(itemName, providedIcons, reader, rom, { 
+            const renderIconData = await renderIcon(itemName, providedIcons, reader, rom, { 
                 pngFilterType,
                 pngCompressionLevel,
+                returnFileBuffer,
                 outputDir,
             });
             if (verboseLogs) {
                 console.log(`Done: ${itemName}`);
             }
+            totalFileCount += renderIconData.fullFileCount;
+            if (returnFileBuffer && renderIconData?.pngBuffer) {
+                finalResults.push(renderIconData.pngBuffer);
+            }
         });
     } else {
         for (const itemName of Object.keys(providedIcons)) {
-            await renderIcon(itemName, providedIcons, reader, rom, { 
+            const renderIconData = await renderIcon(itemName, providedIcons, reader, rom, { 
                 pngFilterType,
                 pngCompressionLevel,
+                returnFileBuffer,
                 outputDir,
             });
             if (verboseLogs) {
                 console.log(`Done: ${itemName}`);
             }
+            totalFileCount += renderIconData.fullFileCount;
+            if (returnFileBuffer && renderIconData?.pngBuffer) {
+                finalResults.push(renderIconData.pngBuffer);
+            }
         }
     }
+
+    const elapsed = ((performance.now() - start) / 1000).toFixed(2);
+
+    if (showSummary) {
+        console.log(`
+renderAllIcons() Output Summary:
+Rendered ${Object.keys(providedIcons).length} Icons amounting to:
+${totalFileCount} Files written
+Done in ${elapsed}s with SilphScope`);
+    }
+
+    return {
+        totalFileCount,
+        ...(returnFileBuffer && { finalResults }),
+    };
 }
 
 export async function renderAllTrainers(rom, options = {}) {
+    const start = performance.now();
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderAllTrainers(rom, options) requires rom Buffer/Uint8Array as first argument");
     }
@@ -201,6 +232,8 @@ export async function renderAllTrainers(rom, options = {}) {
         pngFilterType = 0,
         pngCompressionLevel = 4,
         verboseLogs = true,
+        showSummary = true,
+        returnFileBuffer = false,
         outputDir = "./out",
     } = options;
 
@@ -218,35 +251,63 @@ export async function renderAllTrainers(rom, options = {}) {
 
     const config = getRomConfig(rom);
     const reader = new RomReader(rom, config);
+    let totalFileCount = 0;
+    const finalResults = returnFileBuffer? [] : null;
 
     if (concurrency > 1) {
         await mapLimit(Object.keys(providedTrainers), concurrency, async (trainerName) => {
-            await renderTrainer(trainerName, providedTrainers, providedBackTrainers, reader, rom, {
+            const renderTrainerData = await renderTrainer(trainerName, providedTrainers, providedBackTrainers, reader, rom, {
                 trainerBackPics,
                 pngFilterType,
                 pngCompressionLevel,
+                returnFileBuffer,
                 outputDir
             });
             if (verboseLogs) {
                 console.log(`Done: ${trainerName}`);
             }
+            totalFileCount += renderTrainerData.fullFileCount;
+            if (returnFileBuffer && renderTrainerData?.results) {
+                finalResults.push(...renderTrainerData.results);
+            }
         });
     } else {
         for (const trainerName of Object.keys(providedTrainers)) {
-            await renderTrainer(trainerName, providedTrainers, providedBackTrainers, reader, rom, {
+            const renderTrainerData = await renderTrainer(trainerName, providedTrainers, providedBackTrainers, reader, rom, {
                 trainerBackPics,
                 pngFilterType,
                 pngCompressionLevel,
+                returnFileBuffer,
                 outputDir
             });
             if (verboseLogs) {
                 console.log(`Done: ${trainerName}`);
             }
+            totalFileCount += renderTrainerData.fullFileCount;
+            if (returnFileBuffer && renderTrainerData?.results) {
+                finalResults.push(...renderTrainerData.results);
+            }
         }
     }
+
+    const elapsed = ((performance.now() - start) / 1000).toFixed(2);
+
+    if (showSummary) {
+        console.log(`
+renderAllTrainers() Output Summary:
+Rendered ${Object.keys(providedTrainers).length} Trainers amounting to:
+${totalFileCount} Files written
+Done in ${elapsed}s with SilphScope`);
+    }
+
+    return {
+        ...(returnFileBuffer && { finalResults }),
+        totalFileCount,
+    };
 }
 
 export async function renderAllMoves(rom, options = {}) {
+    const start = performance.now();
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderAllMoves(rom, options) requires rom Buffer/Uint8Array as first argument");
     }
@@ -257,6 +318,8 @@ export async function renderAllMoves(rom, options = {}) {
         pngFilterType = 0,
         pngCompressionLevel = 4,
         verboseLogs = true,
+        showSummary = true,
+        returnFileBuffer = false,
         outputDir = "./out",
         renderMasterImage = true,
         sortUnused = true,
@@ -276,12 +339,15 @@ export async function renderAllMoves(rom, options = {}) {
 
     const config = getRomConfig(rom);
     const reader = new RomReader(rom, config);
+    let totalFileCount = 0;
+    const finalResults = returnFileBuffer? [] : null;
 
     if (concurrency > 1) {
         await mapLimit(Object.keys(providedMoves), concurrency, async (moveName) => {
-            await renderMove(moveName, providedMoves, reader, rom, {
+            const renderMoveData = await renderMove(moveName, providedMoves, reader, rom, {
                 pngFilterType,
                 pngCompressionLevel,
+                returnFileBuffer,
                 outputDir,
                 renderMasterImage,
                 sortUnused,
@@ -289,12 +355,17 @@ export async function renderAllMoves(rom, options = {}) {
             if (verboseLogs) {
                 console.log(`Done: ${moveName}`);
             }
+            totalFileCount += renderMoveData.fullFileCount;
+            if (returnFileBuffer && renderMoveData?.results) {
+                finalResults.push(...renderMoveData.results);
+            }
         });
     } else {
         for (const moveName of Object.keys(providedMoves)) {
-            await renderMove(moveName, providedMoves, reader, rom, {
+            const renderMoveData = await renderMove(moveName, providedMoves, reader, rom, {
                 pngFilterType,
                 pngCompressionLevel,
+                returnFileBuffer,
                 outputDir,
                 renderMasterImage,
                 sortUnused,
@@ -302,11 +373,31 @@ export async function renderAllMoves(rom, options = {}) {
             if (verboseLogs) {
                 console.log(`Done: ${moveName}`);
             }
+            totalFileCount += renderMoveData.fullFileCount;
+            if (returnFileBuffer && renderMoveData?.results) {
+                finalResults.push(...renderMoveData.results);
+            }
         }
     }
+
+    const elapsed = ((performance.now() - start) / 1000).toFixed(2);
+
+    if (showSummary) {
+        console.log(`
+renderAllMoves() Output Summary:
+Rendered ${Object.keys(providedMoves).length} Moves amounting to:
+${totalFileCount} Files written
+Done in ${elapsed}s with SilphScope`);
+    }
+
+    return {
+        ...(returnFileBuffer && { finalResults }),
+        totalFileCount,
+    }
 }
 
 export async function renderAllBalls(rom, options = {}) {
+    const start = performance.now();
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderAllBalls(rom, options) requires rom Buffer/Uint8Array as first argument");
     }
@@ -317,6 +408,8 @@ export async function renderAllBalls(rom, options = {}) {
         pngFilterType = 0,
         pngCompressionLevel = 4,
         verboseLogs = true,
+        showSummary = true,
+        returnFileBuffer = false,
         outputDir = "./out",
         ballParticles = true,
         renderMasterBallImage = true,
@@ -337,12 +430,15 @@ export async function renderAllBalls(rom, options = {}) {
 
     const config = getRomConfig(rom);
     const reader = new RomReader(rom, config);
+    let totalFileCount = 0;
+    const finalResults = returnFileBuffer? [] : null;
 
     if (concurrency > 1) {
         await mapLimit(Object.keys(providedBalls), concurrency, async (ballName) => {
-            await renderBall(ballName, providedBalls, reader, rom, {
+            const renderBallData = await renderBall(ballName, providedBalls, reader, rom, {
                 pngFilterType,
                 pngCompressionLevel,
+                returnFileBuffer,
                 outputDir,
                 ballParticles,
                 renderMasterBallImage,
@@ -351,12 +447,17 @@ export async function renderAllBalls(rom, options = {}) {
             if (verboseLogs) {
                 console.log(`Done: ${ballName}`);
             }
+            totalFileCount += renderBallData.fullFileCount;
+            if (returnFileBuffer) {
+                finalResults.push(...renderBallData.results);
+            }
         })
     } else {
         for (const ballName of Object.keys(providedBalls)) {
-            await renderBall(ballName, providedBalls, reader, rom, {
+            const renderBallData = await renderBall(ballName, providedBalls, reader, rom, {
                 pngFilterType,
                 pngCompressionLevel,
+                returnFileBuffer,
                 outputDir,
                 ballParticles,
                 renderMasterBallImage,
@@ -365,8 +466,27 @@ export async function renderAllBalls(rom, options = {}) {
             if (verboseLogs) {
                 console.log(`Done: ${ballName}`);
             }
+            totalFileCount += renderBallData.fullFileCount;
+            if (returnFileBuffer) {
+                finalResults.push(...renderBallData.results);
+            }
         }
     }
+
+    const elapsed = ((performance.now() - start) / 1000).toFixed(2);
+
+    if (showSummary) {
+        console.log(`
+renderAllBalls() Output Summary:
+Rendered ${Object.keys(providedBalls).length} Balls amounting to:
+${totalFileCount} Files written
+Done in ${elapsed}s with SilphScope`);
+    }
+
+    return {
+        ...(returnFileBuffer && { finalResults }),
+        totalFileCount,
+    };
 }
 
 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
@@ -379,6 +499,8 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
         pngFilterType = 0,
         pngCompressionLevel = 4,
         verboseLogs = true,
+        showSummary = true,
+        returnFileBuffer = false,
         outputMonDir = "./out/mons",
         outputIconDir = "./out/icons",
         outputTrainerDir = "./out/trainers",
@@ -402,6 +524,8 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
         pngFilterType,
         pngCompressionLevel,
         verboseLogs,
+        showSummary,
+        returnFileBuffer,
         outputDir: outputMonDir,
         icon: true,
         footprint: true,
@@ -412,6 +536,8 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
         pngFilterType,
         pngCompressionLevel,
         verboseLogs,
+        showSummary,
+        returnFileBuffer,
         outputDir: outputIconDir,
     });
 
@@ -420,6 +546,8 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
         pngFilterType,
         pngCompressionLevel,
         verboseLogs,
+        showSummary,
+        returnFileBuffer,
         outputDir: outputTrainerDir,
         trainerBackPics: true,
     });
@@ -429,6 +557,8 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
         pngFilterType,
         pngCompressionLevel,
         verboseLogs,
+        showSummary,
+        returnFileBuffer,
         outputDir: outputMoveDir,
         renderMasterImage: true,
         sortUnused: sortUnusedMoves,
@@ -439,6 +569,8 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
         pngFilterType,
         pngCompressionLevel,
         verboseLogs,
+        showSummary,
+        returnFileBuffer,
         outputDir: outputBallDir,
         ballParticles: true,
         renderMasterBallImage: true,

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

@@ -18,6 +18,7 @@ export async function renderIcon(itemName, items, reader, rom, options = {}) {
     const {
         pngFilterType = null,
         pngCompressionType = null, 
+        returnFileBuffer = false,
         outputDir = null 
     } = options;
 
@@ -25,6 +26,7 @@ export async function renderIcon(itemName, items, reader, rom, options = {}) {
         throw new TypeError("renderIcon(..., rom) requires a ROM Buffer/Uint8Array");
     }
 
+    let fullFileCount = 0;
     const item = items[itemName];
     if (!item) {
         throw new Error(`Missing Item: ${itemName}`);
@@ -60,7 +62,11 @@ export async function renderIcon(itemName, items, reader, rom, options = {}) {
         await fs.promises.mkdir(dir, { recursive: true });
         const fileName = `${dir}/icon.png`;
         await fs.promises.writeFile(fileName, pngBuffer);
+        fullFileCount += 1;
     }
 
-    return pngBuffer;
+    return {
+        ...(returnFileBuffer && { pngBuffer }),
+        fullFileCount,
+    };
 }

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

@@ -17,7 +17,7 @@ const streamToBuffer = (stream) => new Promise((resolve, reject) => {
 export async function renderMonFoot(monName, mons, reader, rom, options = {}) {
     const { 
         pngFilterType = null,
-        pngCompressionType = null,
+        pngCompressionLevel = null,
         returnFileBuffer,
         outputDir = null,
     } = options;
@@ -32,7 +32,11 @@ export async function renderMonFoot(monName, mons, reader, rom, options = {}) {
         throw new Error(`Missing mon entry for ${monName}`);
     }
 
-    if (monName.includes("UNOWN")) return;
+    if (monName.includes("UNOWN")) {
+        return {
+            fileCount: 0,
+        }
+    }
 
     const footAsset = resolveMonFootprint(mon, reader, monName); // possibly the easiest change ive had to do if it works first try :o
     if (!footAsset) {
@@ -78,7 +82,7 @@ export async function renderMonFoot(monName, mons, reader, rom, options = {}) {
     png.data = image;
     const pngBuffer = PNG.sync.write(png, { 
         filterType: pngFilterType,
-        deflateLevel: pngCompressionType,
+        deflateLevel: pngCompressionLevel,
     });
 
     if (outputDir) {

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

@@ -39,6 +39,7 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
     const {
         pngFilterType = null,
         pngCompressionLevel = null,
+        returnFileBuffer = false,
         outputDir = null,
         renderMasterImage = false,
         sortUnused = false,
@@ -47,6 +48,8 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
         throw new TypeError("renderMove(..., rom) requires a ROM Buffer/Uint8Array");
     }
 
+    let fullFileCount = 0;
+    const results = returnFileBuffer? [] : null;
     const move = moves[moveName];
     if (!move) {
         throw new Error(`Missing move: ${moveName}`)
@@ -89,6 +92,10 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
                 deflateLevel: pngCompressionLevel,
             });
             await fs.promises.writeFile(`${dir}/master.png`, pngBuffer);
+            fullFileCount += 1;
+            if (returnFileBuffer) {
+                results.push(pngBuffer);
+            }
         }
         for (let i = 0; i < move.frames.length; i++) {
             const frame = move.frames[i];
@@ -103,8 +110,15 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
 
             const fileName = `${dir}/frame-${i}.png`;
             await fs.promises.writeFile(fileName, pngBuffer);
+            fullFileCount += 1;
+            if (returnFileBuffer) {
+                results.push(pngBuffer);
+            }
         }
     }
 
-    return pngBuffer;
+    return {
+        ...(returnFileBuffer && { results }),
+        fullFileCount,
+    };
 }

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

@@ -19,6 +19,7 @@ export async function renderTrainerBackPic(trainerName, trainers, reader, rom, o
     const { 
         pngFilterType = null,
         pngCompressionLevel = null,
+        returnFileBuffer = false,
         outputDir = null 
     } = options;
 
@@ -26,6 +27,7 @@ export async function renderTrainerBackPic(trainerName, trainers, reader, rom, o
         throw new TypeError("renderTrainerBackPic(..., rom) requires a ROM Buffer/Uint8Array");
     }
 
+    let fileCount = 0;
     const trainer = trainers[trainerName];
     if (!trainer) {
         throw new Error(`Missing trainer entry for ${trainerName}`);
@@ -87,7 +89,7 @@ export async function renderTrainerBackPic(trainerName, trainers, reader, rom, o
         filterType: pngFilterType,
         deflateLevel: pngCompressionLevel,
     });
-    let buffer5
+    let buffer5 = null;
 
     if (outputDir) {
         const dir = `${outputDir}/${trainerName}`;
@@ -96,6 +98,7 @@ export async function renderTrainerBackPic(trainerName, trainers, reader, rom, o
         await fs.promises.writeFile(`${dir}/trainer_back_frame_2.png`, buffer2);
         await fs.promises.writeFile(`${dir}/trainer_back_frame_3.png`, buffer3);
         await fs.promises.writeFile(`${dir}/trainer_back_frame_4.png`, buffer4);
+        fileCount += 4;
         if (frame5) {
             const pngFrame5 = new PNG({ width, height: frameHeight });
             pngFrame5.data = frame5;
@@ -104,14 +107,16 @@ export async function renderTrainerBackPic(trainerName, trainers, reader, rom, o
                 deflateLevel: pngCompressionLevel,
             });
             fs.writeFileSync(`${dir}/trainer_back_frame_5.png`, buffer5);
+            fileCount += 1;
         }
     }
 
     return {
-        frame1: buffer1,
-        frame2: buffer2,
-        frame3: buffer3,
-        frame4: buffer4,
-        frame5: buffer5,
+        ...(returnFileBuffer && { frame1: buffer1 }),
+        ...(returnFileBuffer && { frame2: buffer2 }),
+        ...(returnFileBuffer && { frame3: buffer3 }),
+        ...(returnFileBuffer && { frame4: buffer4 }),
+        ...(returnFileBuffer && { frame5: buffer5 }),
+        fileCount,
     };
 }

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

@@ -21,12 +21,15 @@ export async function renderTrainer(trainerName, trainers, backTrainers, reader,
         trainerBackPics = false,
         pngFilterType = null,
         pngCompressionLevel = null,
+        returnFileBuffer = false,
         outputDir = null,
     } = options;
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderTrainer(..., rom) requires a ROM Buffer/Uint8Array");
     }
 
+    let fullFileCount = 0;
+    let results = returnFileBuffer? [] : null;
     const trainer = trainers[trainerName];
     if (!trainer) {
         throw new Error(`Missing Trainer: ${trainerName}`);
@@ -36,23 +39,50 @@ export async function renderTrainer(trainerName, trainers, backTrainers, reader,
             ? trainerName
             : false;
         if (backTrainerName) {
-            await renderTrainerBackPic(backTrainerName, backTrainers, reader, rom, {
+            const trainerBackPicData = await renderTrainerBackPic(backTrainerName, backTrainers, reader, rom, {
                 pngFilterType,
                 pngCompressionLevel,
+                returnFileBuffer,
                 outputDir,
-            }); // that could have been bad lol I forgot to add await :p
+            });
+            fullFileCount += trainerBackPicData.fileCount;
+            if (returnFileBuffer) {
+                results.push(trainerBackPicData.frame1);
+                results.push(trainerBackPicData.frame2);
+                results.push(trainerBackPicData.frame3);
+                results.push(trainerBackPicData.frame4);
+                if (trainerBackPicData?.frame5) {
+                    results.push(trainerBackPicData.frame5);
+                }
+            }
         }
         else if (backTrainerName === false && trainerName === "PAINTER") {
-            await renderTrainerBackPic("OLDMAN", backTrainers, reader, rom, { 
+            const trainerBackPicData = await renderTrainerBackPic("OLDMAN", backTrainers, reader, rom, { 
                 pngFilterType,
                 pngCompressionLevel,
+                returnFileBuffer,
                 outputDir,
             });
-            await renderTrainerBackPic("POKEDUDE", backTrainers, reader, rom, { 
+            fullFileCount += trainerBackPicData.fileCount;
+            if (returnFileBuffer) {
+                results.push(trainerBackPicData.frame1);
+                results.push(trainerBackPicData.frame2);
+                results.push(trainerBackPicData.frame3);
+                results.push(trainerBackPicData.frame4);
+            }
+            const trainerBackPicData2 = await renderTrainerBackPic("POKEDUDE", backTrainers, reader, rom, { 
                 pngFilterType,
                 pngCompressionLevel,
+                returnFileBuffer,
                 outputDir,
             });
+            fullFileCount += trainerBackPicData2.fileCount;
+            if (returnFileBuffer) {
+                results.push(trainerBackPicData.frame1);
+                results.push(trainerBackPicData.frame2);
+                results.push(trainerBackPicData.frame3);
+                results.push(trainerBackPicData.frame4);
+            }
         }
     }
     const trainerPal = resolveTrainerFrontPicPal(trainer, reader, trainerName);
@@ -81,12 +111,20 @@ export async function renderTrainer(trainerName, trainers, backTrainers, reader,
         deflateLevel: pngCompressionLevel, 
     });
 
+    if (returnFileBuffer) {
+        results.push(pngBuffer);
+    }
+
     if (outputDir) {
         const dir = `${outputDir}/${trainerName}`;
         await fs.promises.mkdir(dir, { recursive: true });
         const fileName = `${dir}/trainer_front.png`;
         await fs.promises.writeFile(fileName, pngBuffer);
+        fullFileCount += 1;
     }
 
-    return pngBuffer;
+    return {
+        ...(returnFileBuffer && { results }),
+        fullFileCount,
+    };
 }