silphscope 1.4.10 → 1.4.11

package/README.md

@@ -1,5 +1,30 @@
 still a WIP however hopefully with some more work I can get this into a workable state...
 
+(Small But New Update!) Update:
+
+so you can now set stuff such as the pngFilterType and pngCompressionLevel allow me to explain how they work:
+
+pngFilterType:
+
+This takes a integer between -1 and 4 with each integer corresponding like so:
+
+-1: auto
+0: none
+1: sub
+2: up
+3: average
+4: paeth
+
+now as to what each of these mean... I don't know exactly lol (I'm not some png genius D:) but from what I understand none of these actually change the look of the image instead they are basically compression some will work better with different images depending on content... that said though it is still somewhat important to point out that paeth is the most computationally expensive but usually results in a smaller file size (most of the time... for an example one image might get marginal file size decreases with a paeth filter meanwhile it would get a larger decrease using average or something) if you do not want to deal with trying to figure out which filter is best it is recommended to set the value to 0 as that will apply no filter onto the image or if you wish for the best filter for each image type to be applied use -1 as this will make it so that each image is tested for which filter is best for it and which is best is applied be aware though this is pretty expensive resource wise (can add on to like 2 seconds to the renderAllGraphics() function... so not crazy but if you need upmost speed perhaps that is an issue for you :p) you can also however pass an array like so:
+
+[1, 3, 4]
+
+this will make it so that the only png filters allowed to be used are 1, 3, and 4 (sub, average, and paeth) so each image will be tested for each of these filters and the best is chosen out of however many filters you put in the array (not sure why you would want to do this but it's there I guess...)
+
+pngCompressionLevel:
+
+This one is much simpler it essentially takes a integer between 0-9 with 0 being no compression added at all and 9 being the maximum compression added of course though this also uses more resources so it could cause the render time to be slower (like by 1-2 seconds... once again not crazy but sometimes you need speed I guess... wait I should mention that is measured via the renderAllGraphics() function not 1-2 seconds per asset lol) but it will result in a smaller file meanwhile 0 will be the fastest you can do (since you aren't computing anything...) but it will result in a much larger file
+
 (Amazingly Newer!) Update:
 
 so now ball extraction works! still need to cut the images up but that should be simple
@@ -29,6 +54,8 @@ 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...)
+    pngFilterType: 0, // view the explanation for this above
+    pngCompression: 4, // same thing :p explanation above
     outputMonDir: "./Assets/monImages", // must I explain?
     outputIconDir: "./Assets/Icons", // same thing here :p
     outputTrainerDir: "./Assets/Trainers", // ...
@@ -50,6 +77,8 @@ 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...)
+    pngFilterType: 0, // explanation above
+    pngCompression: 4, // explanation above
     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...
@@ -64,6 +93,8 @@ 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...)
+    pngFilterType: 0, // explanation above
+    pngCompression: 4, // explanation above
     outputDir: "./Assets/Icons" // no comment (wait... that was a comment :p)
 });
 ```
@@ -76,6 +107,8 @@ 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...)
+    pngFilterType: 0, // explanation above
+    pngCompression: 4, // explanation above
     outputDir: "./Assets/trainers", // more stuff
     trainerBackPics: true, // renders the like 8 trainer back pics
 })
@@ -89,6 +122,8 @@ 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...)
+    pngFilterType: 0, // explanation above
+    pngCompression: 4, // explanation above
     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
@@ -103,6 +138,8 @@ 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...)
+    pngFilterType: 0, // explanation above
+    pngCompression: 4, // explanation above
     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

package/package.json

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

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

@@ -35,6 +35,8 @@ const extractFrameFromImage = (imageData, fullWidth, frameData) => {
 
 export async function renderBallParticle(ballName, balls, reader, rom, options = {}) {
     const {
+        pngFilterType = null,
+        pngCompressionLevel = null,
         outputDir = null,
         renderMasterBallParticleImage = false,
     } = options;
@@ -67,7 +69,10 @@ export async function renderBallParticle(ballName, balls, reader, rom, options =
 
     const png = new PNG({ width, height });
     png.data = image;
-    const pngBuffer = PNG.sync.write(png, { filterType: 0 });
+    const pngBuffer = PNG.sync.write(png, { 
+        filterType: pngFilterType,
+        deflateLevel: pngCompressionLevel, 
+    });
 
     if (outputDir) {
         const dir = `${outputDir}/${ballName}`;
@@ -81,7 +86,10 @@ export async function renderBallParticle(ballName, balls, reader, rom, options =
 
             const png = new PNG({ width: frame.width, height: frame.height });
             png.data = frameImageData;
-            const pngFrameBuffer = PNG.sync.write(png, { filterType: 0 });
+            const pngFrameBuffer = PNG.sync.write(png, { 
+                filterType: pngFilterType,
+                deflateLevel: pngCompressionLevel,
+            });
 
             const fileName = `${dir}/particle-${i}.png`;
             fs.writeFileSync(fileName, pngFrameBuffer);

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

@@ -36,6 +36,8 @@ const extractFrameFromImage = (imageData, fullWidth, frameData) => {
 
 export async function renderBall(ballName, balls, reader, rom, options = {}) {
     const {
+        pngFilterType = null,
+        pngCompressionLevel = null,
         outputDir = null,
         ballParticles = false,
         renderMasterBallImage = false,
@@ -51,6 +53,8 @@ export async function renderBall(ballName, balls, reader, rom, options = {}) {
     }
     if (ballParticles) {
         renderBallParticle(ballName, balls, reader, rom, {
+            pngFilterType,
+            pngCompressionLevel,
             outputDir,
             renderMasterBallParticleImage, 
         });
@@ -75,7 +79,10 @@ export async function renderBall(ballName, balls, reader, rom, options = {}) {
 
     const png = new PNG({ width, height });
     png.data = image;
-    const pngBuffer = PNG.sync.write(png, { filterType: 0 });
+    const pngBuffer = PNG.sync.write(png, { 
+        filterType: pngFilterType,
+        deflateLevel: pngCompressionLevel, 
+    });
 
     if (outputDir) {
         const dir = `${outputDir}/${ballName}`;
@@ -89,7 +96,10 @@ export async function renderBall(ballName, balls, reader, rom, options = {}) {
 
             const png = new PNG({ width: frame.width, height: frame.height });
             png.data = frameImageData;
-            const pngFrameBuffer = PNG.sync.write(png, { filterType: 0 });
+            const pngFrameBuffer = PNG.sync.write(png, { 
+                filterType: pngFilterType,
+                deflateLevel: pngCompressionLevel, 
+            });
 
             const fileName = `${dir}/frame-${i}.png`;
             await fs.promises.writeFile(fileName, pngFrameBuffer);

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

@@ -27,6 +27,19 @@ const trainersBack = loadDefaultJson("../trainer-data/trainerBackData.json");
 const moves = loadDefaultJson("../move-data/moveData.json");
 const balls = loadDefaultJson("../ball-data/ballData.json");
 
+function isValidFilterType(filterTypeValue) {
+    if (Number.isInteger(filterTypeValue)) {
+        return filterTypeValue >= -1 && filterTypeValue <= 4;
+    }
+    if (Array.isArray(filterTypeValue)) {
+        return filterTypeValue.length > 0 && filterTypeValue.every(entry => 
+            Number.isInteger(entry) && entry >= 0 && entry <= 4
+        );
+    }
+
+    return false;
+}
+
 export async function renderAllMons(rom, options = {}) {
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderAllMons(rom, options) requires rom Buffer/Uint8Array as first argument");
@@ -36,10 +49,22 @@ export async function renderAllMons(rom, options = {}) {
         mons: providedMons = mons,
         outputDir = "./out",
         concurrency = 4,
+        pngFilterType = 0,
+        pngCompressionLevel = 4,
         icon = true,
         footprint = true,
     } = options;
 
+    if (!Number.isInteger(concurrency) || concurrency < 1) {
+        throw new TypeError(`renderAllMons(rom, options = { concurrency, ... }) requires concurrency to be a integer greater than 0 (recieved ${concurrency})`);
+    }
+    if (isValidFilterType(pngFilterType)) {
+        throw new TypeError(`renderAllMons(rom, options = { pngFilterType, ... }) requires pngFilterType to be a integer between -1 and 4 (received ${pngFilterType})`)
+    }
+    if (!Number.isInteger(pngCompressionLevel) || pngCompressionLevel < 0 || pngCompressionLevel > 9) {
+        throw new TypeError(`renderAllMons(rom, options = { pngCompressionLevel, ... }) requires pngCompressionLevel to be a integer between 0 and 9 (received ${pngCompressionLevel})`)
+    }
+
     fs.mkdirSync(outputDir, { recursive: true });
 
     const config = getRomConfig(rom);
@@ -52,6 +77,8 @@ export async function renderAllMons(rom, options = {}) {
                 variant: ["normal", "shiny"],
                 icon,
                 footprint,
+                pngFilterType,
+                pngCompressionLevel,
                 outputDir,
             });
             console.log(`Done: ${monName}`);
@@ -59,9 +86,12 @@ export async function renderAllMons(rom, options = {}) {
     } else {
         for (const monName of Object.keys(providedMons)) {
             await renderMon(monName, providedMons, reader, rom, {
+                side: ["front", "back"],
                 variant: ["normal", "shiny"],
                 icon,
                 footprint,
+                pngFilterType,
+                pngCompressionLevel,
                 outputDir,
             });
             console.log(`Done: ${monName}`);
@@ -77,9 +107,21 @@ export async function renderAllIcons(rom, options = {}) {
     const {
         icons: providedIcons = icons,
         concurrency = 4,
+        pngFilterType = 0,
+        pngCompressionLevel = 4,
         outputDir = "./out",
     } = options;
 
+    if (!Number.isInteger(concurrency) || concurrency < 1) {
+        throw new TypeError(`renderAllIcons(rom, options = { concurrency, ... }) requires concurrency to be a integer greater than 0 (recieved ${concurrency})`);
+    }
+    if (isValidFilterType(pngFilterType)) {
+        throw new TypeError(`renderAllIcons(rom, options = { pngFilterType, ... }) requires pngFilterType to be a integer between -1 and 4 (received ${pngFilterType})`)
+    }
+    if (!Number.isInteger(pngCompressionLevel) || pngCompressionLevel < 0 || pngCompressionLevel > 9) {
+        throw new TypeError(`renderAllIcons(rom, options = { pngCompressionLevel, ... }) requires pngCompressionLevel to be a integer between 0 and 9 (received ${pngCompressionLevel})`)
+    }
+
     fs.mkdirSync(outputDir, { recursive: true });
 
     const config = getRomConfig(rom);
@@ -87,12 +129,20 @@ export async function renderAllIcons(rom, options = {}) {
 
     if (concurrency > 1) {
         await mapLimit(Object.keys(providedIcons), concurrency, async (itemName) => {
-            await renderIcon(itemName, providedIcons, reader, rom, { outputDir });
+            await renderIcon(itemName, providedIcons, reader, rom, { 
+                pngFilterType,
+                pngCompressionLevel,
+                outputDir,
+            });
             console.log(`Done: ${itemName}`);
         });
     } else {
         for (const itemName of Object.keys(providedIcons)) {
-            await renderIcon(itemName, providedIcons, reader, rom, { outputDir });
+            await renderIcon(itemName, providedIcons, reader, rom, { 
+                pngFilterType,
+                pngCompressionLevel,
+                outputDir,
+            });
             console.log(`Done: ${itemName}`);
         }
     }
@@ -108,9 +158,21 @@ export async function renderAllTrainers(rom, options = {}) {
         trainersBack: providedBackTrainers = trainersBack,
         trainerBackPics = true,
         concurrency = 4,
+        pngFilterType = 0,
+        pngCompressionLevel = 4,
         outputDir = "./out",
     } = options;
 
+    if (!Number.isInteger(concurrency) || concurrency < 1) {
+        throw new TypeError(`renderAllTrainers(rom, options = { concurrency, ... }) requires concurrency to be a integer greater than 0 (recieved ${concurrency})`);
+    }
+    if (isValidFilterType(pngFilterType)) {
+        throw new TypeError(`renderAllTrainers(rom, options = { pngFilterType, ... }) requires pngFilterType to be a integer between -1 and 4 (received ${pngFilterType})`)
+    }
+    if (!Number.isInteger(pngCompressionLevel) || pngCompressionLevel < 0 || pngCompressionLevel > 9) {
+        throw new TypeError(`renderAllTrainers(rom, options = { pngCompressionLevel, ... }) requires pngCompressionLevel to be a integer between 0 and 9 (received ${pngCompressionLevel})`)
+    }
+
     fs.mkdirSync(outputDir, { recursive: true });
 
     const config = getRomConfig(rom);
@@ -120,6 +182,8 @@ export async function renderAllTrainers(rom, options = {}) {
         await mapLimit(Object.keys(providedTrainers), concurrency, async (trainerName) => {
             await renderTrainer(trainerName, providedTrainers, providedBackTrainers, reader, rom, {
                 trainerBackPics,
+                pngFilterType,
+                pngCompressionLevel,
                 outputDir
             });
             console.log(`Done: ${trainerName}`);
@@ -128,6 +192,8 @@ export async function renderAllTrainers(rom, options = {}) {
         for (const trainerName of Object.keys(providedTrainers)) {
             await renderTrainer(trainerName, providedTrainers, providedBackTrainers, reader, rom, {
                 trainerBackPics,
+                pngFilterType,
+                pngCompressionLevel,
                 outputDir
             });
             console.log(`Done: ${trainerName}`);
@@ -136,14 +202,30 @@ export async function renderAllTrainers(rom, options = {}) {
 }
 
 export async function renderAllMoves(rom, options = {}) {
+    if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
+        throw new TypeError("renderAllMoves(rom, options) requires rom Buffer/Uint8Array as first argument");
+    }
+
     const {
         moves: providedMoves = moves,
         concurrency = 4,
+        pngFilterType = 0,
+        pngCompressionLevel = 4,
         outputDir = "./out",
         renderMasterImage = true,
         sortUnused = true,
     } = options;
 
+    if (!Number.isInteger(concurrency) || concurrency < 1) {
+        throw new TypeError(`renderAllMoves(rom, options = { concurrency, ... }) requires concurrency to be a integer greater than 0 (recieved ${concurrency})`);
+    }
+    if (isValidFilterType(pngFilterType)) {
+        throw new TypeError(`renderAllMoves(rom, options = { pngFilterType, ... }) requires pngFilterType to be a integer between -1 and 4 (received ${pngFilterType})`)
+    }
+    if (!Number.isInteger(pngCompressionLevel) || pngCompressionLevel < 0 || pngCompressionLevel > 9) {
+        throw new TypeError(`renderAllMoves(rom, options = { pngCompressionLevel, ... }) requires pngCompressionLevel to be a integer between 0 and 9 (received ${pngCompressionLevel})`)
+    }
+
     fs.mkdirSync(outputDir, { recursive: true });
 
     const config = getRomConfig(rom);
@@ -152,6 +234,8 @@ export async function renderAllMoves(rom, options = {}) {
     if (concurrency > 1) {
         await mapLimit(Object.keys(providedMoves), concurrency, async (moveName) => {
             await renderMove(moveName, providedMoves, reader, rom, {
+                pngFilterType,
+                pngCompressionLevel,
                 outputDir,
                 renderMasterImage,
                 sortUnused,
@@ -161,6 +245,8 @@ export async function renderAllMoves(rom, options = {}) {
     } else {
         for (const moveName of Object.keys(providedMoves)) {
             await renderMove(moveName, providedMoves, reader, rom, {
+                pngFilterType,
+                pngCompressionLevel,
                 outputDir,
                 renderMasterImage,
                 sortUnused,
@@ -171,15 +257,31 @@ export async function renderAllMoves(rom, options = {}) {
 }
 
 export async function renderAllBalls(rom, options = {}) {
+    if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
+        throw new TypeError("renderAllBalls(rom, options) requires rom Buffer/Uint8Array as first argument");
+    }
+
     const {
         balls: providedBalls = balls,
         concurrency = 4,
+        pngFilterType = 0,
+        pngCompressionLevel = 4,
         outputDir = "./out",
         ballParticles = true,
         renderMasterBallImage = true,
         renderMasterBallParticleImage = true,
     } = options;
 
+    if (!Number.isInteger(concurrency) || concurrency < 1) {
+        throw new TypeError(`renderAllBalls(rom, options = { concurrency, ... }) requires concurrency to be a integer greater than 0 (recieved ${concurrency})`);
+    }
+    if (isValidFilterType(pngFilterType)) {
+        throw new TypeError(`renderAllBalls(rom, options = { pngFilterType, ... }) requires pngFilterType to be a integer between -1 and 4 (received ${pngFilterType})`)
+    }
+    if (!Number.isInteger(pngCompressionLevel) || pngCompressionLevel < 0 || pngCompressionLevel > 9) {
+        throw new TypeError(`renderAllBalls(rom, options = { pngCompressionLevel, ... }) requires pngCompressionLevel to be a integer between 0 and 9 (received ${pngCompressionLevel})`)
+    }
+
     fs.mkdirSync(outputDir, { recursive: true });
 
     const config = getRomConfig(rom);
@@ -188,6 +290,8 @@ export async function renderAllBalls(rom, options = {}) {
     if (concurrency > 1) {
         await mapLimit(Object.keys(providedBalls), concurrency, async (ballName) => {
             await renderBall(ballName, providedBalls, reader, rom, {
+                pngFilterType,
+                pngCompressionLevel,
                 outputDir,
                 ballParticles,
                 renderMasterBallImage,
@@ -198,6 +302,8 @@ export async function renderAllBalls(rom, options = {}) {
     } else {
         for (const ballName of Object.keys(providedBalls)) {
             await renderBall(ballName, providedBalls, reader, rom, {
+                pngFilterType,
+                pngCompressionLevel,
                 outputDir,
                 ballParticles,
                 renderMasterBallImage,
@@ -215,6 +321,8 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
 
     const {
         concurrency = 4,
+        pngFilterType = 0,
+        pngCompressionLevel = 4,
         outputMonDir = "./out/mons",
         outputIconDir = "./out/icons",
         outputTrainerDir = "./out/trainers",
@@ -223,8 +331,20 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
         outputBallDir = "./out/balls",
     } = options;
 
+    if (!Number.isInteger(concurrency) || concurrency < 1) {
+        throw new TypeError(`renderAllGraphics(rom, options = { concurrency, ... }) requires concurrency to be a integer greater than 0 (recieved ${concurrency})`);
+    }
+    if (isValidFilterType(pngFilterType)) {
+        throw new Error(`renderAllGraphics(rom, options = { pngFilterType, ... }) requires pngFilterType to be a integer between -1 and 4 (received ${pngFilterType})`)
+    }
+    if (!Number.isInteger(pngCompressionLevel) || pngCompressionLevel < 0 || pngCompressionLevel > 9) {
+        throw new Error(`renderAllGraphics(rom, options = { pngCompressionLevel, ... }) requires pngCompressionLevel to be a integer between 0 and 9 (received ${pngCompressionLevel})`)
+    }
+
     await renderAllMons(rom, {
         concurrency,
+        pngFilterType,
+        pngCompressionLevel,
         outputDir: outputMonDir,
         icon: true,
         footprint: true,
@@ -232,17 +352,23 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
 
     await renderAllIcons(rom, {
         concurrency,
+        pngFilterType,
+        pngCompressionLevel,
         outputDir: outputIconDir,
     });
 
     await renderAllTrainers(rom, {
         concurrency,
+        pngFilterType,
+        pngCompressionLevel,
         outputDir: outputTrainerDir,
         trainerBackPics: true,
     });
 
     await renderAllMoves(rom, {
         concurrency,
+        pngFilterType,
+        pngCompressionLevel,
         outputDir: outputMoveDir,
         renderMasterImage: true,
         sortUnused: sortUnusedMoves,
@@ -250,6 +376,8 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
 
     await renderAllBalls(rom, {
         concurrency,
+        pngFilterType,
+        pngCompressionLevel,
         outputDir: outputBallDir,
         ballParticles: true,
         renderMasterBallImage: true,

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

@@ -15,7 +15,11 @@ const streamToBuffer = (stream) => new Promise((resolve, reject) => {
 });
 
 export async function renderIcon(itemName, items, reader, rom, options = {}) {
-    const { outputDir = null } = options;
+    const {
+        pngFilterType = null,
+        pngCompressionType = null, 
+        outputDir = null 
+    } = options;
 
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderIcon(..., rom) requires a ROM Buffer/Uint8Array");
@@ -46,7 +50,10 @@ export async function renderIcon(itemName, items, reader, rom, options = {}) {
 
     const png = new PNG({ width, height });
     png.data = image;
-    const pngBuffer = PNG.sync.write(png, { filterType: 0 });
+    const pngBuffer = PNG.sync.write(png, { 
+        filterType: pngFilterType,
+        deflateLevel: pngCompressionType, 
+    });
 
     if (outputDir) {
         const dir = `${outputDir}/${itemName}`;

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

@@ -15,7 +15,11 @@ const streamToBuffer = (stream) => new Promise((resolve, reject) => {
 });
 
 export async function renderMonFoot(monName, mons, reader, rom, options = {}) {
-    const { outputDir = null } = options;
+    const { 
+        pngFilterType = null,
+        pngCompressionType = null,
+        outputDir = null,
+    } = options;
 
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderMonFoot(..., rom) requires a ROM Buffer/Uint8Array");
@@ -70,7 +74,10 @@ export async function renderMonFoot(monName, mons, reader, rom, options = {}) {
 
     const png = new PNG({ width, height });
     png.data = image;
-    const pngBuffer = PNG.sync.write(png, { filterType: 0 });
+    const pngBuffer = PNG.sync.write(png, { 
+        filterType: pngFilterType,
+        deflateLevel: pngCompressionType,
+    });
 
     if (outputDir) {
         const dir = `${outputDir}/${monName}`;

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

@@ -16,7 +16,11 @@ const streamToBuffer = (stream) => new Promise((resolve, reject) => {
 });
 
 export async function renderMonIcon(monName, mons, reader, rom, options = {}) {
-    const { outputDir = null } = options;
+    const { 
+        pngFilterType = null,
+        pngCompressionLevel = null,
+        outputDir = null 
+    } = options;
 
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderMonIcon(..., rom) requires a ROM Buffer/Uint8Array");
@@ -51,8 +55,14 @@ export async function renderMonIcon(monName, mons, reader, rom, options = {}) {
     pngFrame1.data = frame1;
     const pngFrame2 = new PNG({ width, height: frameHeight });
     pngFrame2.data = frame2;
-    const buffer1 = PNG.sync.write(pngFrame1, { filterType: 0 });
-    const buffer2 = PNG.sync.write(pngFrame2, { filterType: 0 });
+    const buffer1 = PNG.sync.write(pngFrame1, { 
+        filterType: pngFilterType,
+        deflateLevel: pngCompressionLevel, 
+    });
+    const buffer2 = PNG.sync.write(pngFrame2, { 
+        filterType: pngFilterType,
+        deflateLevel: pngCompressionLevel, 
+    });
 
     if (outputDir) {
         const dir = `${outputDir}/${monName}`;

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

@@ -23,6 +23,8 @@ export async function renderMon(monName, mons, reader, rom, options = {}) {
         variant = "normal",
         icon = false,
         footprint = false,
+        pngFilterType = null,
+        pngCompressionLevel = null,
         outputDir = null,
     } = options;
 
@@ -34,10 +36,18 @@ export async function renderMon(monName, mons, reader, rom, options = {}) {
     const variants = Array.isArray(variant) ? variant : [variant];
 
     if (icon === true) {
-        await renderMonIcon(monName, mons, reader, rom, { outputDir });
+        await renderMonIcon(monName, mons, reader, rom, { 
+            pngFilterType,
+            pngCompressionLevel,
+            outputDir,
+        });
     }
     if (footprint === true) {
-        await renderMonFoot(monName, mons, reader, rom, { outputDir });
+        await renderMonFoot(monName, mons, reader, rom, { 
+            pngFilterType,
+            pngCompressionLevel,
+            outputDir, 
+        });
     }
 
     const mon = mons[monName];
@@ -76,7 +86,10 @@ export async function renderMon(monName, mons, reader, rom, options = {}) {
 
             const png = new PNG({ width, height });
             png.data = image;
-            const pngBuffer = PNG.sync.write(png, { filterType: 0 });
+            const pngBuffer = PNG.sync.write(png, { 
+                filterType: pngFilterType,
+                deflateLevel: pngCompressionLevel, 
+            });
 
             if (outputDir) {
                 const dir = `${outputDir}/${monName}`;

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

@@ -37,6 +37,8 @@ const extractFrameFromImage = (imageData, fullWidth, frameData) => { // in theor
 
 export async function renderMove(moveName, moves, reader, rom, options = {}) {
     const {
+        pngFilterType = null,
+        pngCompressionLevel = null,
         outputDir = null,
         renderMasterImage = false,
         sortUnused = false,
@@ -70,7 +72,10 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
 
     const png = new PNG({ width, height });
     png.data = image;
-    const pngBuffer = PNG.sync.write(png, { filterType: 0 });
+    const pngBuffer = PNG.sync.write(png, { 
+        filterType: pngFilterType,
+        deflateLevel: pngCompressionLevel, 
+    });
 
     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}`
@@ -79,7 +84,10 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
         if (renderMasterImage) {
             const png = new PNG({ width, height });
             png.data = image;
-            const pngBuffer = PNG.sync.write(png, { filterType: 0 });
+            const pngBuffer = PNG.sync.write(png, { 
+                filterType: pngFilterType,
+                deflateLevel: pngCompressionLevel,
+            });
             await fs.promises.writeFile(`${dir}/master.png`, pngBuffer);
         }
         for (let i = 0; i < move.frames.length; i++) {
@@ -88,7 +96,10 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
 
             const png = new PNG({ width: frame.width, height: frame.height });
             png.data = frameImageData;
-            const pngBuffer = PNG.sync.write(png, { filterType: 0 });
+            const pngBuffer = PNG.sync.write(png, { 
+                filterType: pngFilterType,
+                deflateLevel: pngCompressionLevel, 
+            });
 
             const fileName = `${dir}/frame-${i}.png`;
             await fs.promises.writeFile(fileName, pngBuffer);

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

@@ -16,7 +16,11 @@ const streamToBuffer = (stream) => new Promise((resolve, reject) => {
 });
 
 export async function renderTrainerBackPic(trainerName, trainers, reader, rom, options = {}) {
-    const { outputDir = null } = options;
+    const { 
+        pngFilterType = null,
+        pngCompressionLevel = null,
+        outputDir = null 
+    } = options;
 
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
         throw new TypeError("renderTrainerBackPic(..., rom) requires a ROM Buffer/Uint8Array");
@@ -67,10 +71,22 @@ export async function renderTrainerBackPic(trainerName, trainers, reader, rom, o
     pngFrame3.data = frame3;
     const pngFrame4 = new PNG({ width, height: frameHeight });
     pngFrame4.data = frame4;
-    const buffer1 = PNG.sync.write(pngFrame1, { filterType: 0 });
-    const buffer2 = PNG.sync.write(pngFrame2, { filterType: 0 });
-    const buffer3 = PNG.sync.write(pngFrame3, { filterType: 0 });
-    const buffer4 = PNG.sync.write(pngFrame4, { filterType: 0 });
+    const buffer1 = PNG.sync.write(pngFrame1, { 
+        filterType: pngFilterType,
+        deflateLevel: pngCompressionLevel,
+    });
+    const buffer2 = PNG.sync.write(pngFrame2, { 
+        filterType: pngFilterType,
+        deflateLevel: pngCompressionLevel,
+    });
+    const buffer3 = PNG.sync.write(pngFrame3, { 
+        filterType: pngFilterType,
+        deflateLevel: pngCompressionLevel,
+    });
+    const buffer4 = PNG.sync.write(pngFrame4, { 
+        filterType: pngFilterType,
+        deflateLevel: pngCompressionLevel,
+    });
     let buffer5
 
     if (outputDir) {
@@ -83,7 +99,10 @@ export async function renderTrainerBackPic(trainerName, trainers, reader, rom, o
         if (frame5) {
             const pngFrame5 = new PNG({ width, height: frameHeight });
             pngFrame5.data = frame5;
-            buffer5 = PNG.sync.write(pngFrame5, { filterType: 0 });
+            buffer5 = PNG.sync.write(pngFrame5, { 
+                filterType: pngFilterType,
+                deflateLevel: pngCompressionLevel,
+            });
             fs.writeFileSync(`${dir}/trainer_back_frame_5.png`, buffer5);
         }
     }

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

@@ -19,6 +19,8 @@ const streamToBuffer = (stream) => new Promise((resolve, reject) => {
 export async function renderTrainer(trainerName, trainers, backTrainers, reader, rom, options = {}) {
     const {
         trainerBackPics = false,
+        pngFilterType = null,
+        pngCompressionLevel = null,
         outputDir = null,
     } = options;
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
@@ -34,11 +36,23 @@ export async function renderTrainer(trainerName, trainers, backTrainers, reader,
             ? trainerName
             : false;
         if (backTrainerName) {
-            await renderTrainerBackPic(backTrainerName, backTrainers, reader, rom, { outputDir }); // that could have been bad lol I forgot to add await :p
+            await renderTrainerBackPic(backTrainerName, backTrainers, reader, rom, {
+                pngFilterType,
+                pngCompressionLevel,
+                outputDir,
+            }); // that could have been bad lol I forgot to add await :p
         }
         else if (backTrainerName === false && trainerName === "PAINTER") {
-            await renderTrainerBackPic("OLDMAN", backTrainers, reader, rom, { outputDir });
-            await renderTrainerBackPic("POKEDUDE", backTrainers, reader, rom, { outputDir });
+            await renderTrainerBackPic("OLDMAN", backTrainers, reader, rom, { 
+                pngFilterType,
+                pngCompressionLevel,
+                outputDir,
+            });
+            await renderTrainerBackPic("POKEDUDE", backTrainers, reader, rom, { 
+                pngFilterType,
+                pngCompressionLevel,
+                outputDir,
+            });
         }
     }
     const trainerPal = resolveTrainerFrontPicPal(trainer, reader, trainerName);
@@ -62,7 +76,10 @@ export async function renderTrainer(trainerName, trainers, backTrainers, reader,
 
     const png = new PNG({ width, height });
     png.data = image;
-    const pngBuffer = PNG.sync.write(png, { filterType: 0 });
+    const pngBuffer = PNG.sync.write(png, { 
+        filterType: pngFilterType,
+        deflateLevel: pngCompressionLevel, 
+    });
 
     if (outputDir) {
         const dir = `${outputDir}/${trainerName}`;