#![cfg(target_arch = "wasm32")]
use wasm_bindgen::prelude::*;
use crate::{Extractor, Rom, SymbolTable};
fn to_js<E: std::fmt::Display>(err: E) -> JsError {
JsError::new(&err.to_string())
}
const USED_SYMBOL_NAMES: &[&str] = &[
"Start",
"gMapLayouts",
"gMonBackPicCoords",
"gMonBackPicTable",
"gMonFootprintTable",
"gMonFrontPicCoords",
"gMonFrontPicTable",
"gMonPaletteTable",
"gMonShinyPaletteTable",
"gSpeciesNames",
"gSpeciesToNationalPokedexNum",
"sSpeciesToNationalPokedexNum",
"SpeciesToNationalPokedexNum",
];
const USED_SYMBOL_PREFIXES: &[&str] = &[
"gMetatiles_",
"gMonBackPic_",
"gMonFootprint_",
"gMonFrontPic_",
"gMonPalette_",
"gMonShinyPalette_",
"gTilesetPalettes_",
"gTilesetTiles_",
"gTileset_",
];
#[wasm_bindgen]
#[derive(Debug)]
pub struct HypercutterExtractor {
rom: Rom,
symbols: SymbolTable,
}
#[wasm_bindgen]
impl HypercutterExtractor {
#[wasm_bindgen(constructor)]
pub fn new(rom_bytes: Vec<u8>, sym_text: &str) -> std::result::Result<Self, JsError> {
let rom = Rom::from_bytes(rom_bytes).map_err(to_js)?;
let symbols = SymbolTable::from_toml(sym_text)
.or_else(|_| SymbolTable::from_text(sym_text))
.map_err(to_js)?;
Ok(Self { rom, symbols })
}
#[wasm_bindgen]
pub fn with_bundled(rom_bytes: Vec<u8>) -> std::result::Result<Self, JsError> {
let rom = Rom::from_bytes(rom_bytes).map_err(to_js)?;
let symbols = SymbolTable::resolve_for_rom(&rom).map_err(to_js)?;
Ok(Self { rom, symbols })
}
#[wasm_bindgen(getter)]
pub fn game(&self) -> String {
self.rom.game().short_name().to_owned()
}
#[wasm_bindgen]
pub fn national_dex_map(&self) -> std::result::Result<Vec<u16>, JsError> {
let extractor = Extractor::new(&self.rom, &self.symbols);
extractor.national_dex_map().map_err(to_js)
}
#[wasm_bindgen]
pub fn metatile_names(&self) -> std::result::Result<Vec<JsValue>, JsError> {
let extractor = Extractor::new(&self.rom, &self.symbols);
let metatiles = extractor.metatiles().map_err(to_js)?;
Ok(metatiles.names().map(JsValue::from).collect())
}
#[wasm_bindgen]
pub fn render_tileset(&self, name: &str) -> std::result::Result<Vec<u8>, JsError> {
use crate::TilesetRenderer;
let extractor = Extractor::new(&self.rom, &self.symbols);
let metatiles = extractor.metatiles().map_err(to_js)?;
let Some(entry) = metatiles.get(name) else {
return Err(JsError::new(&format!("unknown tileset: {name}")));
};
let primary_tile_count = self.rom.game().primary_tile_count();
let renderer = match entry.secondary.as_ref() {
Some(secondary) => TilesetRenderer::new(&entry.primary)
.with_secondary(secondary)
.with_primary_tile_count(primary_tile_count),
None => {
TilesetRenderer::new(&entry.primary).with_primary_tile_count(primary_tile_count)
}
};
let mut png_bytes: Vec<u8> = Vec::new();
let img = renderer.render();
img.write_png(&mut png_bytes).map_err(to_js)?;
Ok(png_bytes)
}
#[wasm_bindgen]
pub fn render_sprite(&self, species_id: u16) -> std::result::Result<Vec<u8>, JsError> {
use crate::SpriteRenderer;
let extractor = Extractor::new(&self.rom, &self.symbols);
let sprites = extractor.sprites().map_err(to_js)?;
let Some(sprite) = sprites
.iter()
.find(|s| u32::from(s.id.0) == u32::from(species_id))
else {
return Err(JsError::new(&format!("unknown species: {species_id}")));
};
let Some(sheet) = sprite.front.as_ref() else {
return Err(JsError::new("species has no front sprite"));
};
let Some(palette) = sprite.palette.get(0) else {
return Err(JsError::new("species has no palette"));
};
let renderer = SpriteRenderer::new(sheet, palette);
let mut png_bytes: Vec<u8> = Vec::new();
renderer.render().write_png(&mut png_bytes).map_err(to_js)?;
Ok(png_bytes)
}
#[wasm_bindgen]
pub fn render_sprite_back(&self, species_id: u16) -> std::result::Result<Vec<u8>, JsError> {
use crate::SpriteRenderer;
let extractor = Extractor::new(&self.rom, &self.symbols);
let sprites = extractor.sprites().map_err(to_js)?;
let Some(sprite) = sprites
.iter()
.find(|s| u32::from(s.id.0) == u32::from(species_id))
else {
return Err(JsError::new(&format!("unknown species: {species_id}")));
};
let Some(sheet) = sprite.back.as_ref() else {
return Err(JsError::new("species has no back sprite"));
};
let Some(palette) = sprite.palette.get(0) else {
return Err(JsError::new("species has no palette"));
};
let renderer = SpriteRenderer::new(sheet, palette);
let mut png_bytes: Vec<u8> = Vec::new();
renderer.render().write_png(&mut png_bytes).map_err(to_js)?;
Ok(png_bytes)
}
#[wasm_bindgen]
pub fn render_footprint(&self, species_id: u16) -> std::result::Result<Vec<u8>, JsError> {
let extractor = Extractor::new(&self.rom, &self.symbols);
let sprites = extractor.sprites().map_err(to_js)?;
let Some(sprite) = sprites
.iter()
.find(|s| u32::from(s.id.0) == u32::from(species_id))
else {
return Err(JsError::new(&format!("unknown species: {species_id}")));
};
let Some(ref fp) = sprite.footprint else {
return Err(JsError::new("species has no footprint"));
};
let img = crate::render::render_footprint(fp);
let mut png_bytes: Vec<u8> = Vec::new();
img.write_png(&mut png_bytes).map_err(to_js)?;
Ok(png_bytes)
}
#[wasm_bindgen]
pub fn species_names(&self) -> std::result::Result<Vec<JsValue>, JsError> {
let extractor = Extractor::new(&self.rom, &self.symbols);
let names = extractor.species_names().map_err(to_js)?;
Ok(names.into_iter().map(JsValue::from).collect())
}
#[wasm_bindgen]
pub fn forms(&self) -> std::result::Result<Vec<JsValue>, JsError> {
let extractor = Extractor::new(&self.rom, &self.symbols);
let forms = extractor.forms().map_err(to_js)?;
Ok(forms
.into_iter()
.map(|f| {
let obj = js_sys::Object::new();
js_sys::Reflect::set(&obj, &JsValue::from("base"), &JsValue::from(f.base.0))
.expect("Reflect::set should not fail on a fresh object");
js_sys::Reflect::set(
&obj,
&JsValue::from("form"),
&JsValue::from(f.form.as_str()),
)
.expect("Reflect::set should not fail on a fresh object");
JsValue::from(obj)
})
.collect())
}
#[wasm_bindgen]
pub fn render_form_sprite(
&self,
base_species_id: u16,
form: &str,
) -> std::result::Result<Vec<u8>, JsError> {
use crate::render::SpriteRenderer;
use crate::sprite::MonCoords;
use crate::tileset::TileData;
let extractor = Extractor::new(&self.rom, &self.symbols);
let forms = extractor.forms().map_err(to_js)?;
let form_sprite = forms
.iter()
.find(|f| u32::from(f.base.0) == u32::from(base_species_id) && f.form == form)
.ok_or_else(|| JsError::new(&format!("unknown form: {base_species_id}/{form}")))?;
let tiles = form_sprite
.front_tiles
.as_ref()
.ok_or_else(|| JsError::new("form has no front sprite"))?;
let palette = form_sprite
.palette
.as_ref()
.ok_or_else(|| JsError::new("form has no palette"))?;
let pal_entry = palette
.get(0)
.ok_or_else(|| JsError::new("form palette is empty"))?;
let sheet = crate::SpriteSheet {
tiles: TileData::from_bytes(tiles.clone()),
coords: MonCoords {
width_tiles: 8,
height_tiles: 8,
y_offset: 0,
},
};
let renderer = SpriteRenderer::new(&sheet, pal_entry);
let mut png_bytes: Vec<u8> = Vec::new();
renderer.render().write_png(&mut png_bytes).map_err(to_js)?;
Ok(png_bytes)
}
#[wasm_bindgen]
pub fn symbol_names(&self) -> Vec<JsValue> {
self.symbols
.iter()
.filter(|s| {
USED_SYMBOL_NAMES.contains(&s.name.as_str())
|| USED_SYMBOL_PREFIXES.iter().any(|p| s.name.starts_with(p))
})
.map(|s| JsValue::from(s.name.as_str()))
.collect()
}
}
#[wasm_bindgen]
#[allow(dead_code, unreachable_pub)] pub fn count_sym(text: &str) -> std::result::Result<usize, JsError> {
let table = SymbolTable::from_toml(text)
.or_else(|_| SymbolTable::from_text(text))
.map_err(to_js)?;
Ok(table.len())
}
#[wasm_bindgen]
#[allow(dead_code, unreachable_pub)] pub fn identify_game(rom_bytes: Vec<u8>) -> std::result::Result<String, JsError> {
let rom = Rom::from_bytes(rom_bytes).map_err(to_js)?;
Ok(rom.game().short_name().to_owned())
}