silphscope 1.2.30 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silphscope",
-  "version": "1.2.30",
+  "version": "1.3.0",
   "description": "A firered/leafgreen ROM asset extractor for use in web applications",
   "main": "main.js",
   "exports": {
@@ -17,7 +17,8 @@
     "rom-maps/",
     "item-data/",
     "trainer-data",
-    "rom-configs/"
+    "rom-configs/",
+    "move-data/"
   ],
   "keywords": [],
   "author": "chickenPoo",

package/rom-configs/firered.js

@@ -19,5 +19,7 @@ export const firered = {
         trainerBackPicTable: 0x239FA4,
         trainerBackPicPaletteTable: 0x239FD4,
         itemIconTable: 0x3D4294, // newer update: (so turns out this old value was the pointer to the table lol however this new one is the actual table... for real this time!) rest of the old message: so this was very hard to find since it isn't labeled in the .map of ROMs... luckily Ghidra and the ROM decomps exist so that helped a ton... issue is I believe this contains both the palette and gfx in each listing (should probably double check pokefirered to confirm...) so it will be interesting to extract assets I suppose...
+        moveAnimPicTable: 0x3ACC08,
+        moveAnimPaletteTable: 0x3AD510,
     } // if this works out... well hehe... :D
 }

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

@@ -9,6 +9,7 @@ import { renderIcon } from "./icons/render-icons.js";
 import { renderTrainer } from "./trainers/render-trainers.js";
 import { RomReader } from "../rom-reader.js";
 import { getRomConfig } from "../get-rom-config.js";
+import { renderMove } from "./moves/render-moves.js";
 
 const currentDir = path.dirname(fileURLToPath(import.meta.url));
 
@@ -17,11 +18,11 @@ function loadDefaultJson(relativePath) {
     return JSON.parse(fs.readFileSync(absolutePath, "utf-8"));
 }
 
-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");
 const trainersBack = loadDefaultJson("../trainer-data/trainerBackData.json");
+const moves = loadDefaultJson("../move-data/moveData.json");
 
 export async function renderAllMons(rom, options = {}) {
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
@@ -58,7 +59,6 @@ export async function renderAllIcons(rom, options = {}) {
     }
 
     const {
-        assets: providedAssets = assets,
         icons: providedIcons = icons,
         outputDir = "./out",
     } = options;
@@ -69,7 +69,7 @@ export async function renderAllIcons(rom, options = {}) {
     const reader = new RomReader(rom, config);
 
     for (const itemName of Object.keys(providedIcons)) {
-        await renderIcon(itemName, providedIcons, providedAssets, reader, rom, { outputDir });
+        await renderIcon(itemName, providedIcons, reader, rom, { outputDir });
         console.log(`Done: ${itemName}`);
     }
 }
@@ -100,6 +100,23 @@ export async function renderAllTrainers(rom, options = {}) {
     }
 }
 
+export async function renderAllMoves(rom, options = {}) {
+    const {
+        moves: providedMoves = moves,
+        outputDir = "./out",
+    } = options;
+
+    fs.mkdirSync(outputDir, { recursive: true });
+
+    const config = getRomConfig(rom);
+    const reader = new RomReader(rom, config);
+
+    for (const moveName of Object.keys(providedMoves)) {
+        await renderMove(moveName, providedMoves, reader, rom, { outputDir });
+        console.log(`Done: ${moveName}`);
+    }
+}
+
 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");
@@ -109,6 +126,7 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
         outputMonDir = "./out/mons",
         outputIconDir = "./out/icons",
         outputTrainerDir = "./out/trainers",
+        outputMoveDir = "./out/moves"
     } = options;
 
     await renderAllMons(rom, {
@@ -125,6 +143,10 @@ export async function renderAllGraphics(rom, options = {}) { // eventually I wil
         outputDir: outputTrainerDir,
         trainerBackPics: true,
     });
+
+    await renderAllMoves(rom, {
+        outputDir: outputMoveDir,
+    })
 }
 
 export function loadDefaultRom() {

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

@@ -14,7 +14,7 @@ const streamToBuffer = (stream) => new Promise((resolve, reject) => {
     stream.on("error", reject);
 });
 
-export async function renderIcon(itemName, items, assets, reader, rom, options = {}) {
+export async function renderIcon(itemName, items, reader, rom, options = {}) {
     const { outputDir = null } = options;
 
     if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {

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

@@ -0,0 +1,85 @@
+// 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 { resolveMovePic } from "./resolvers/move-pic-resolver.js";
+import { resolveMovePal } from "./resolvers/move-pal-resolver.js";
+import fs from "fs";
+import { PNG } from "pngjs";
+
+// let's see if I remember how to throw one of these together...
+
+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);
+});
+
+const extractFrameFromImage = (imageData, fullWidth, frameData) => { // in theory should work...
+    const { x, y, width, height } = frameData;
+    const frameImage = new Uint8ClampedArray(width * height * 4);
+
+    for (let row = 0; row < height; row++) {
+        for (let col = 0; col < width; col++) {
+            const srcIndex = ((y + row) * fullWidth + (x + col)) * 4;
+            const dstIndex = (row * width + col) * 4;
+            frameImage[dstIndex] = imageData[srcIndex];
+            frameImage[dstIndex + 1] = imageData[srcIndex + 1];
+            frameImage[dstIndex + 2] = imageData[srcIndex + 2];
+            frameImage[dstIndex + 3] = imageData[srcIndex + 3];
+        }
+    }
+
+    return frameImage;
+};
+
+export async function renderMove(moveName, moves, reader, rom, options = {}) {
+    const {
+        outputDir = null
+    } = options;
+    if (!rom || !(rom instanceof Uint8Array || Buffer.isBuffer(rom))) {
+        throw new TypeError("renderMove(..., rom) requires a ROM Buffer/Uint8Array");
+    }
+
+    const move = moves[moveName];
+    if (!move) {
+        throw new Error(`Missing move: ${moveName}`)
+    }
+
+    const movePic = resolveMovePic(move, reader, moveName);
+    const movePal = resolveMovePal(move, reader, moveName);
+    if (!movePal || !movePic) {
+        throw new Error(`Missing assets for: ${moveName}`);
+    }
+
+    const moveImageData = extract(movePic, rom);
+    const rawMovePalData = extract(movePal, rom);
+    const width = move.imageWidth;
+    const height = move.imageHeight;
+
+    const image = render4bppImage({
+        tileData: moveImageData.data,
+        paletteData: rawMovePalData.data,
+        width,
+        height,
+    });
+
+    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 dir = `${outputDir}/${moveName}`;
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+        for (let i = 0; i < move.frames.length; i++) {
+            const frame = move.frames[i];
+            const frameImageData = extractFrameFromImage(image, width, frame);
+
+            const png = new PNG({ width: frame.width, height: frame.height });
+            png.data = frameImageData;
+            const pngBuffer = await streamToBuffer(png.pack());
+
+            const fileName = `${dir}/frame-${i}.png`;
+            fs.writeFileSync(fileName, pngBuffer);
+        }
+    }
+}

package/src/graphics/moves/resolvers/move-pal-resolver.js

@@ -0,0 +1,10 @@
+export function resolveMovePal(move, reader, moveName) {
+    const table = reader.getTable("moveAnimPaletteTable");
+    const entryOffset = table + move.index * 8;
+    const ptr = reader.readOffset(entryOffset);
+    return {
+        name: `move_${moveName}_pal`,
+        offset: ptr,
+        size: 40 // maybe this will continue working? perhaps? please?
+    }
+}

package/src/graphics/moves/resolvers/move-pic-resolver.js

@@ -0,0 +1,10 @@
+export function resolveMovePic(move, reader, moveName) {
+    const table = reader.getTable("moveAnimPicTable");
+    const entryOffset = table + move.index * 8;
+    const ptr = reader.readOffset(entryOffset);
+    return {
+        name: `move_${moveName}_pic`,
+        offset: ptr
+        // I don't think this needs a size... since I think most of these are all lz77 compressed... if not more JSON time :/
+    }
+}

package/src/graphics/trainers/resolvers/trainer-back-pic-resolver.js

@@ -2,8 +2,15 @@ export function resolveTrainerBackPic(trainer, reader, trainerName) {
     const table = reader.getTable("trainerBackPicTable");
     const entryOffset = table + trainer.index * 8;
     const ptr = reader.readPointer(entryOffset);
+    let size;
+    if (trainerName === "RED" || trainerName === "LEAF") {
+        size = 10240;
+    } else {
+        size = 8192;
+    }
     return {
         name: `trainer_${trainerName}_back_pic`,
         offset: ptr,
+        size,
     }
 }

package/src/move-data-parser.js

@@ -0,0 +1,169 @@
+import fs from "fs";
+import path from "path";
+
+// === CONFIG ===
+const USE_PREBUILT_TEMPLATES = true; // Set to true to load from moveStructData.json instead of parsing .c files
+// ===
+
+// Paths
+const movePicMap = path.resolve("../move_graphics/gBattleAnimPicTable.h");
+const moveDataPath = "../move-data/moveData.json";
+const unusedTagData = JSON.parse(fs.readFileSync(path.resolve("../move-data/unusedTags.json"), "utf-8"));
+
+// Read animation pic table to get move animation tags
+const movePicLines = fs.readFileSync(movePicMap, "utf-8").split("\n");
+
+const moveData = {};
+let moveIndex = 0;
+
+// Tags that are defined but never assigned a SpriteTemplate
+const unusedTags = new Set(Object.keys(unusedTagData));
+
+// Parse gBattleAnimPicTable.h for animation tags
+for (const line of movePicLines) {
+    const match = line.match(/\{\s*(gBattleAnimSpriteGfx_[A-Za-z0-9_]+)\s*,\s*(0x[0-9A-Fa-f]+)\s*,\s*(ANIM_TAG_[A-Za-z0-9_]+)\s*\},/);
+    if (match) {
+        const moveName = match[3].replace("ANIM_TAG_", "");
+        const moveTag = match[3];
+
+        if (!moveData[moveName]) {
+            moveData[moveName] = { index: moveIndex++ };
+        }
+        moveData[moveName].animTag = moveTag;
+
+        if (unusedTagData[moveTag]) {
+            Object.assign(moveData[moveName], unusedTagData[moveTag]);
+            moveData[moveName].unused = true;
+          }
+    }
+}
+
+// Parse SpriteTemplate structs from battle_anim_*.c files (or load prebuilt)
+let templates = {};
+
+if (USE_PREBUILT_TEMPLATES) {
+    // Load from prebuilt JSON
+    const prebuiltPath = "../move-data/moveStructData.json";
+    templates = JSON.parse(fs.readFileSync(prebuiltPath, "utf-8"));
+    console.log(`Loaded ${Object.keys(templates).length} templates from prebuilt file.`);
+} else {
+    // Parse from source files
+    const animFiles = [
+        "../move_graphics/battle_anim_bug.c", "../move_graphics/battle_anim_dark.c",
+        "../move_graphics/battle_anim_dragon.c", "../move_graphics/battle_anim_effects_1.c",
+        "../move_graphics/battle_anim_effects_2.c", "../move_graphics/battle_anim_effects_3.c",
+        "../move_graphics/battle_anim_electric.c", "../move_graphics/battle_anim_fight.c",
+        "../move_graphics/battle_anim_fire.c", "../move_graphics/battle_anim_flying.c",
+        "../move_graphics/battle_anim_ghost.c", "../move_graphics/battle_anim_ground.c",
+        "../move_graphics/battle_anim_ice.c", "../move_graphics/battle_anim_normal.c",
+        "../move_graphics/battle_anim_poison.c", "../move_graphics/battle_anim_psychic.c",
+        "../move_graphics/battle_anim_rock.c", "../move_graphics/battle_anim_water.c",
+        "../move_graphics/battle_anim_status_effects.c",
+    ];
+
+    for (const file of animFiles) {
+        const lines = fs.readFileSync(file, "utf-8").split("\n");
+        Object.assign(templates, parseStructs(lines));
+    }
+    console.log(`Parsed ${Object.keys(templates).length} templates from source files.`);
+}
+
+// Build template lookup by tileTag
+const templateByTag = Object.fromEntries(
+    Object.values(templates).map(t => [t.tileTag, t])
+);
+
+// Check for missing animTags
+const animTagsInPicTable = Object.values(moveData).map(item => item.animTag);
+const tileTagsInTemplates = Object.values(templates).map(t => t.tileTag);
+const missingTags = animTagsInPicTable.filter(tag => !tileTagsInTemplates.includes(tag));
+
+if (missingTags.length > 0) {
+    console.log("Missing animTags from templates:");
+    missingTags.forEach(tag => {
+        if (!unusedTags.has(tag)) console.log(tag);
+    });
+} else {
+    console.log("No missing animTags.");
+}
+
+// Extract OAM size info for each move
+for (const key in moveData) {
+    const item = moveData[key];
+    const template = templateByTag[item.animTag];
+
+    if (template?.oam) {
+        const size = extractOamSize(template.oam);
+        if (size) {
+            item.possibleFrameSize = size.raw;
+            item.possibleFrameWidth = size.width;
+            item.possibleFrameHeight = size.height;
+        }
+    }
+}
+
+// Write final output
+fs.writeFileSync(moveDataPath, JSON.stringify(moveData, null, 2));
+console.log(`Wrote ${Object.keys(moveData).length} moves to ${moveDataPath}`);
+
+// --- Helper Functions ---
+
+function parseStructs(fileLines) {
+    const results = {};
+    let current = null;
+    let braceDepth = 0;
+    let inStruct = false;
+
+    for (const line of fileLines) {
+        const trimmed = line.trim();
+        const startMatch = trimmed.match(/^(static\s+)?const\s+struct\s+SpriteTemplate\s+(\w+)/);
+
+        if (startMatch) {
+            current = { name: startMatch[2] };
+            inStruct = true;
+            braceDepth = trimmed.includes("{") ? 1 : 0;
+            continue;
+        }
+
+        if (!inStruct) continue;
+
+        // Track brace depth
+        for (const char of trimmed) {
+            if (char === "{") braceDepth++;
+            if (char === "}") braceDepth--;
+        }
+
+        // Parse struct fields
+        if (trimmed.startsWith(".")) {
+            const eqIndex = trimmed.indexOf("=");
+            if (eqIndex === -1) continue;
+
+            const key = trimmed.slice(1, eqIndex).trim();
+            let value = trimmed.slice(eqIndex + 1).replace(",", "").trim();
+            if (value === "NULL") value = null;
+            else if (value.startsWith("&")) value = value.slice(1);
+
+            current[key] = value;
+        }
+
+        // End of struct
+        if (inStruct && braceDepth === 0) {
+            results[current.name] = current;
+            current = null;
+            inStruct = false;
+        }
+    }
+
+    return results;
+}
+
+function extractOamSize(oam) {
+    const match = oam?.match(/(\d+)x(\d+)$/);
+    if (!match) return null;
+
+    return {
+        width: parseInt(match[1], 10),
+        height: parseInt(match[2], 10),
+        raw: match[0]
+    };
+}