silphscope 1.4.5 → 1.4.7

package/README.md

@@ -28,6 +28,7 @@ import { renderAllGraphics } from "silphscope"; // this is cool...
 
 const rom = fs.readFileSync("pokefirered.gba"); // replace with path to your own firered rom
 await renderAllGraphics(rom, {
+    concurrency: 4, // handles how many concurrent promises are run. Set to 1 to run sequentially and conversly increase to run more promises at once (don't set too high though if your CPU / I/O can't handle it then it might actually be slower...)
     outputMonDir: "./Assets/monImages", // must I explain?
     outputIconDir: "./Assets/Icons", // same thing here :p
     outputTrainerDir: "./Assets/Trainers", // ...
@@ -48,6 +49,7 @@ import { renderAllMons } from "silphscope"; // never gets old :p
 
 const rom = fs.readFileSync("pokefirered.gba")// once again replace with the path to your own firered rom
 await renderAllMons(rom, {
+    concurrency: 4, // handles how many concurrent promises are run. Set to 1 to run sequentially and conversly increase to run more promises at once (don't set too high though if your CPU / I/O can't handle it then it might actually be slower...)
     outputDir: "./Assets/monImages", // do I actually have to explain?
     icon: true, // set to false if you don't want icons I guess...
     footprint: true, // same as the above...
@@ -61,6 +63,7 @@ import { renderAllIcons } from "silphscope" // :D
 
 const rom = fs.readFileSync("pokefirered.gba")// find your own rom and so on :l
 await renderAllIcons(rom, {
+    concurrency: 4, // handles how many concurrent promises are run. Set to 1 to run sequentially and conversly increase to run more promises at once (don't set too high though if your CPU / I/O can't handle it then it might actually be slower...)
     outputDir: "./Assets/Icons" // no comment (wait... that was a comment :p)
 });
 ```
@@ -72,6 +75,7 @@ import { renderAllTrainers } from "silphscope" // :O
 
 const rom = fs.readFileSync("pokefirered.gba") // stuff stuff stuff
 await renderAllTrainers(rom, {
+    concurrency: 4, // handles how many concurrent promises are run. Set to 1 to run sequentially and conversly increase to run more promises at once (don't set too high though if your CPU / I/O can't handle it then it might actually be slower...)
     outputDir: "./Assets/trainers", // more stuff
     trainerBackPics: true, // renders the like 8 trainer back pics
 })
@@ -84,6 +88,7 @@ import { renderAllMoves } from "silphscope" // :O
 
 const rom = fs.readFileSync("pokefirered.gba") // stuff stuff stuff (more stuff!)
 await renderAllMoves(rom, {
+    concurrency: 4, // handles how many concurrent promises are run. Set to 1 to run sequentially and conversly increase to run more promises at once (don't set too high though if your CPU / I/O can't handle it then it might actually be slower...)
     outputDir: "./Assets/trainers", // (incredibly) more stuff
     renderMasterImage: true, // kinda forgot about this... basically it renders a uncut image of the move anim if you like
     sortUnused: true, // sorts unused moves into a sub-directory
@@ -97,6 +102,9 @@ import { renderAllBalls } from "silphscope" // o-O
 
 const rom = fs.readFileSync("./path/to/your/rom.gba") // the file path explains :/
 await renderAllBalls(rom, {
+    concurrency: 4, // handles how many concurrent promises are run. Set to 1 to run sequentially and conversly increase to run more promises at once (don't set too high though if your CPU / I/O can't handle it then it might actually be slower...)
     outputDir: "./Assets/Balls",
     ballParticles: true, // set to false if you don't want the ball particles :p
+    renderMasterBallImage: true, // set to false if you don't want the uncut image
+    renderMasterBallParticleImage: true, // set to false if you also don't want the uncut particle image :p
 })

package/package.json

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

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

@@ -79,9 +79,9 @@ export async function renderBall(ballName, balls, reader, rom, options = {}) {
 
     if (outputDir) {
         const dir = `${outputDir}/${ballName}`;
-        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        await fs.promises.mkdir(dir, { recursive: true });
         if (renderMasterBallImage) {
-            fs.writeFileSync(`${dir}/master-image.png`, pngBuffer)
+            await fs.promises.writeFile(`${dir}/master-image.png`, pngBuffer)
         }
         for (let i = 0; i < ball.frames.length; i++) {
             const frame = ball.frames[i];
@@ -92,7 +92,7 @@ export async function renderBall(ballName, balls, reader, rom, options = {}) {
             const pngFrameBuffer = await streamToBuffer(png.pack());
 
             const fileName = `${dir}/frame-${i}.png`;
-            fs.writeFileSync(fileName, pngFrameBuffer);
+            await fs.promises.writeFile(fileName, pngFrameBuffer);
         }
     }
 

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

@@ -35,6 +35,7 @@ export async function renderAllMons(rom, options = {}) {
     const {
         mons: providedMons = mons,
         outputDir = "./out",
+        concurrency = 4,
         icon = true,
         footprint = true,
     } = options;
@@ -44,27 +45,29 @@ 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,
+    if (concurrency > 1) {
+        await mapLimit(Object.keys(providedMons), concurrency, async (monName) => { // so in theory we should be running the function 4 times concurrently now...
+            await renderMon(monName, providedMons, reader, rom, {
+                side: ["front", "back"],
+                variant: ["normal", "shiny"],
+                icon,
+                footprint,
+                outputDir,
+            });
+            console.log(`Done: ${monName}`);
         });
-        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"],
-            variant: ["normal", "shiny"],
-            icon,
-            footprint,
-            outputDir,
-        });
-        console.log(`Done: ${monName}`);
+    } else {
+        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"],
+                variant: ["normal", "shiny"],
+                icon,
+                footprint,
+                outputDir,
+            });
+            console.log(`Done: ${monName}`);
+        }
     }
-*/
 }
 
 export async function renderAllIcons(rom, options = {}) {
@@ -74,6 +77,7 @@ export async function renderAllIcons(rom, options = {}) {
 
     const {
         icons: providedIcons = icons,
+        concurrency = 4,
         outputDir = "./out",
     } = options;
 
@@ -82,9 +86,16 @@ export async function renderAllIcons(rom, options = {}) {
     const config = getRomConfig(rom);
     const reader = new RomReader(rom, config);
 
-    for (const itemName of Object.keys(providedIcons)) {
-        await renderIcon(itemName, providedIcons, reader, rom, { outputDir });
-        console.log(`Done: ${itemName}`);
+    if (concurrency > 1) {
+        await mapLimit(Object.keys(providedIcons), concurrency, async (itemName) => {
+            await renderIcon(itemName, providedIcons, reader, rom, { outputDir });
+            console.log(`Done: ${itemName}`);
+        });
+    } else {
+        for (const itemName of Object.keys(providedIcons)) {
+            await renderIcon(itemName, providedIcons, reader, rom, { outputDir });
+            console.log(`Done: ${itemName}`);
+        }
     }
 }
 
@@ -92,11 +103,12 @@ 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 {
         trainers: providedTrainers = trainers,
         trainersBack: providedBackTrainers = trainersBack,
         trainerBackPics = true,
+        concurrency = 4,
         outputDir = "./out",
     } = options;
 
@@ -105,18 +117,29 @@ export async function renderAllTrainers(rom, options = {}) {
     const config = getRomConfig(rom);
     const reader = new RomReader(rom, config);
 
-    for (const trainerName of Object.keys(providedTrainers)) {
-        await renderTrainer(trainerName, providedTrainers, providedBackTrainers, reader, rom, {
-            trainerBackPics, 
-            outputDir 
+    if (concurrency > 1) {
+        await mapLimit(Object.keys(providedTrainers), concurrency, async (trainerName) => {
+            await renderTrainer(trainerName, providedTrainers, providedBackTrainers, reader, rom, {
+                trainerBackPics,
+                outputDir
+            });
         });
         console.log(`Done: ${trainerName}`);
+    } else {
+        for (const trainerName of Object.keys(providedTrainers)) {
+            await renderTrainer(trainerName, providedTrainers, providedBackTrainers, reader, rom, {
+                trainerBackPics,
+                outputDir
+            });
+            console.log(`Done: ${trainerName}`);
+        }
     }
 }
 
 export async function renderAllMoves(rom, options = {}) {
     const {
         moves: providedMoves = moves,
+        concurrency = 4,
         outputDir = "./out",
         renderMasterImage = true,
         sortUnused = true,
@@ -127,19 +150,31 @@ export async function renderAllMoves(rom, options = {}) {
     const config = getRomConfig(rom);
     const reader = new RomReader(rom, config);
 
-    for (const moveName of Object.keys(providedMoves)) {
-        await renderMove(moveName, providedMoves, reader, rom, { 
-            outputDir,
-            renderMasterImage,
-            sortUnused,
+    if (concurrency > 1) {
+        await mapLimit(Object.keys(providedMoves), concurrency, async (moveName) => {
+            await renderMove(moveName, providedMoves, reader, rom, {
+                outputDir,
+                renderMasterImage,
+                sortUnused,
+            });
+            console.log(`Done: ${moveName}`);
         });
-        console.log(`Done: ${moveName}`);
+    } else {
+        for (const moveName of Object.keys(providedMoves)) {
+            await renderMove(moveName, providedMoves, reader, rom, {
+                outputDir,
+                renderMasterImage,
+                sortUnused,
+            });
+            console.log(`Done: ${moveName}`);
+        }
     }
 }
 
-export async function renderAllBalls(rom, options= {}) {
+export async function renderAllBalls(rom, options = {}) {
     const {
         balls: providedBalls = balls,
+        concurrency = 4,
         outputDir = "./out",
         ballParticles = true,
         renderMasterBallImage = true,
@@ -151,14 +186,26 @@ export async function renderAllBalls(rom, options= {}) {
     const config = getRomConfig(rom);
     const reader = new RomReader(rom, config);
 
-    for (const ballName of Object.keys(providedBalls)) {
-        await renderBall(ballName, providedBalls, reader, rom, { 
-            outputDir,
-            ballParticles, 
-            renderMasterBallImage,
-            renderMasterBallParticleImage,
-        });
-        console.log(`Done: ${ballName}`);
+    if (concurrency > 1) {
+        await mapLimit(Object.keys(providedBalls), concurrency, async (ballName) => {
+            await renderBall(ballName, providedBalls, reader, rom, {
+                outputDir,
+                ballParticles,
+                renderMasterBallImage,
+                renderMasterBallParticleImage,
+            });
+            console.log(`Done: ${ballName}`);
+        })
+    } else {
+        for (const ballName of Object.keys(providedBalls)) {
+            await renderBall(ballName, providedBalls, reader, rom, {
+                outputDir,
+                ballParticles,
+                renderMasterBallImage,
+                renderMasterBallParticleImage,
+            });
+            console.log(`Done: ${ballName}`);
+        }
     }
 }
 
@@ -168,6 +215,7 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
     }
 
     const {
+        concurrency = 4,
         outputMonDir = "./out/mons",
         outputIconDir = "./out/icons",
         outputTrainerDir = "./out/trainers",
@@ -177,27 +225,32 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
     } = options;
 
     await renderAllMons(rom, {
+        concurrency,
         outputDir: outputMonDir,
         icon: true,
         footprint: true,
     });
-    
+
     await renderAllIcons(rom, {
+        concurrency,
         outputDir: outputIconDir,
     });
 
     await renderAllTrainers(rom, {
+        concurrency,
         outputDir: outputTrainerDir,
         trainerBackPics: true,
     });
 
     await renderAllMoves(rom, {
+        concurrency,
         outputDir: outputMoveDir,
         renderMasterImage: true,
         sortUnused: sortUnusedMoves,
     });
 
     await renderAllBalls(rom, {
+        concurrency,
         outputDir: outputBallDir,
         ballParticles: true,
         renderMasterBallImage: true,

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

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

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

@@ -75,12 +75,12 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
     if (outputDir) { // I will update this later but in theory it should also work... eventually though it will need a split inside to handle full image generation :p
         const rootDir = (sortUnused && move?.unused === true)? `${outputDir}/unused` : `${outputDir}`
         const dir = `${rootDir}/${moveName}`;
-        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        await fs.promises.mkdir(dir, { recursive: true });
         if (renderMasterImage) {
             const png = new PNG({ width, height });
             png.data = image;
             const pngBuffer = await streamToBuffer(png.pack());
-            fs.writeFileSync(`${dir}/master.png`, pngBuffer);
+            await fs.promises.writeFile(`${dir}/master.png`, pngBuffer);
         }
         for (let i = 0; i < move.frames.length; i++) {
             const frame = move.frames[i];
@@ -91,7 +91,7 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
             const pngBuffer = await streamToBuffer(png.pack());
 
             const fileName = `${dir}/frame-${i}.png`;
-            fs.writeFileSync(fileName, pngBuffer);
+            await fs.promises.writeFile(fileName, pngBuffer);
         }
     }
 

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

@@ -75,11 +75,11 @@ export async function renderTrainerBackPic(trainerName, trainers, reader, rom, o
 
     if (outputDir) {
         const dir = `${outputDir}/${trainerName}`;
-        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(`${dir}/trainer_back_frame_1.png`, buffer1);
-        fs.writeFileSync(`${dir}/trainer_back_frame_2.png`, buffer2);
-        fs.writeFileSync(`${dir}/trainer_back_frame_3.png`, buffer3);
-        fs.writeFileSync(`${dir}/trainer_back_frame_4.png`, buffer4);
+        await fs.promises.mkdir(dir, { recursive: true });
+        await fs.promises.writeFile(`${dir}/trainer_back_frame_1.png`, buffer1);
+        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);
         if (frame5) {
             const pngFrame5 = new PNG({ width, height: frameHeight });
             pngFrame5.data = frame5;

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

@@ -66,9 +66,9 @@ export async function renderTrainer(trainerName, trainers, backTrainers, reader,
 
     if (outputDir) {
         const dir = `${outputDir}/${trainerName}`;
-        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        await fs.promises.mkdir(dir, { recursive: true });
         const fileName = `${dir}/trainer_front.png`;
-        fs.writeFileSync(fileName, pngBuffer);
+        await fs.promises.writeFile(fileName, pngBuffer);
     }
 
     return pngBuffer;