use std::path::Path;
use anyhow::{Context, Result};
use console::style;
use indicatif::{ProgressBar, ProgressStyle};
use rayon::prelude::*;
use crate::{render_footprint, Extractor, SpriteRenderer, TilesetRenderer};
use super::{Cli, Summary};
pub(crate) fn run(
cli: &Cli,
extractor: &Extractor<'_>,
dump_sprites: bool,
dump_tilesets: bool,
dump_overworld: bool,
) -> Result<Summary> {
let q = cli.quiet;
let mut summary = Summary {
tilesets: 0,
sprites: 0,
forms: 0,
overworld: 0,
};
if dump_tilesets {
let metatiles = extractor
.metatiles()
.with_context(|| "extracting metatiles")?;
let tilesets_dir = cli.export.join("tilesets");
if !q {
println!(
" {} Extracting tilesets...",
style("\u{2192}").cyan().bold(),
);
}
let count =
output::write_tileset_pngs(&metatiles, &tilesets_dir, extractor.rom().game(), cli)?;
summary.tilesets = count;
if !q {
println!(
" {} Tilesets written to {}",
style("\u{2713}").green().bold(),
style(tilesets_dir.display()).bold(),
);
}
}
if dump_sprites {
let sprites = extractor.sprites().with_context(|| "extracting sprites")?;
let species_names = extractor
.species_names()
.with_context(|| "loading species names")?;
let national_map = extractor
.national_dex_map()
.with_context(|| "loading national dex map")?;
let sprites_dir = cli.export.join("sprites/pokemon");
if !q {
println!(
" {} Extracting sprites...",
style("\u{2192}").cyan().bold(),
);
}
let count = output::write_sprites(&sprites, &national_map, &sprites_dir, cli)?;
summary.sprites = count;
if !q {
println!(
" {} Extracted {} sprites to {}",
style("\u{2713}").green().bold(),
style(count).bold(),
style(sprites_dir.display()).bold(),
);
}
let forms = extractor.forms().with_context(|| "extracting forms")?;
if !forms.is_empty() {
if !q {
println!(
" {} Extracting alternate forms...",
style("\u{2192}").cyan().bold(),
);
}
let form_count =
output::write_forms(&forms, &species_names, &national_map, &sprites_dir, cli)?;
summary.forms = form_count;
if !q {
println!(
" {} Extracted {} form sprites",
style("\u{2713}").green().bold(),
style(form_count).bold(),
);
}
}
}
if dump_overworld {
let overworld = extractor
.overworld_sprites()
.with_context(|| "extracting overworld sprites")?;
let overworld_dir = cli.export.join("sprites/overworld");
if !q {
println!(
" {} Extracting overworld sprites...",
style("\u{2192}").cyan().bold(),
);
}
let count =
output::write_overworld_sprites(&overworld, &overworld_dir, cli)?;
summary.overworld = count;
if !q {
println!(
" {} Extracted {} overworld sprites to {}",
style("\u{2713}").green().bold(),
style(count).bold(),
style(overworld_dir.display()).bold(),
);
}
}
Ok(summary)
}
pub(crate) mod output {
use super::*;
use crate::{Metatiles, OverworldSprite, Sprite, SpriteSheet};
fn progress_bar(len: u64, quiet: bool) -> ProgressBar {
if quiet {
return ProgressBar::hidden();
}
let pb = ProgressBar::new(len);
pb.set_style(
ProgressStyle::with_template(" {spinner:.dim} [{bar:30}] {pos}/{len} {msg}")
.unwrap()
.progress_chars("#>-"),
);
pb
}
pub(super) fn write_tileset_pngs(
metatiles: &Metatiles,
export_dir: &Path,
game: crate::Game,
cli: &Cli,
) -> Result<usize> {
std::fs::create_dir_all(export_dir)
.with_context(|| format!("creating {}", export_dir.display()))?;
let primary_tile_count = game.primary_tile_count();
let exclude = super::super::game_exclude(game);
let filter = cli
.tileset_filter
.as_deref()
.map(glob::Pattern::new)
.transpose()
.with_context(|| "invalid tileset filter pattern")?;
let entries: Vec<_> = metatiles
.iter()
.filter(|(name, _)| !exclude.contains(name))
.filter(|(name, _)| {
if let Some(ref pat) = filter {
pat.matches(name)
} else {
true
}
})
.collect();
let pb = progress_bar(entries.len() as u64, cli.quiet);
let count = entries.len();
entries.par_iter().try_for_each(|(name, entry)| {
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 img = renderer.render();
let path = export_dir.join(format!("{name}.png"));
img.save_png(&path)
.with_context(|| format!("saving {}", path.display()))?;
pb.inc(1);
Ok::<(), anyhow::Error>(())
})?;
pb.finish_and_clear();
Ok(count)
}
pub(super) fn write_sprites(
sprites: &[Sprite],
national_map: &[u16],
out_dir: &Path,
cli: &Cli,
) -> Result<usize> {
if cli.spritesheet {
write_spritesheet(sprites, out_dir, cli.spritesheet_columns)?;
return Ok(sprites.len());
}
write_individual(sprites, national_map, out_dir, cli)
}
fn write_spritesheet(sprites: &[Sprite], out_dir: &Path, columns: usize) -> Result<()> {
std::fs::create_dir_all(out_dir)
.with_context(|| format!("creating {}", out_dir.display()))?;
let mut front_imgs = Vec::new();
let mut back_imgs = Vec::new();
let mut species_list = Vec::new();
for sprite in sprites {
if let Some(img) = render_sprite(sprite, true) {
front_imgs.push(img);
species_list.push(sprite.name.clone());
}
if let Some(img) = render_sprite(sprite, false) {
back_imgs.push(img);
}
}
if !front_imgs.is_empty() {
let sheet = compose_spritesheet(&front_imgs, columns);
sheet
.save_png(out_dir.join("front_spritesheet.png"))
.with_context(|| "saving front spritesheet")?;
}
if !back_imgs.is_empty() {
let sheet = compose_spritesheet(&back_imgs, columns);
sheet
.save_png(out_dir.join("back_spritesheet.png"))
.with_context(|| "saving back spritesheet")?;
}
let list = species_list
.into_iter()
.enumerate()
.map(|(i, name)| format!("{}: {}", i + 1, name))
.collect::<Vec<_>>()
.join("\n");
std::fs::write(out_dir.join("species_list.txt"), list)
.with_context(|| "writing species_list.txt")?;
Ok(())
}
fn write_individual(
sprites: &[Sprite],
national_map: &[u16],
out_dir: &Path,
cli: &Cli,
) -> Result<usize> {
std::fs::create_dir_all(out_dir)
.with_context(|| format!("creating {}", out_dir.display()))?;
let filter = cli
.sprite_filter
.as_deref()
.map(glob::Pattern::new)
.transpose()
.with_context(|| "invalid sprite filter pattern")?;
let filtered: Vec<_> = sprites
.iter()
.filter(|s| {
if let Some(ref pat) = filter {
pat.matches(&s.name)
} else {
true
}
})
.collect();
let pb = progress_bar(filtered.len() as u64 * 5, cli.quiet);
let count = filtered.len();
filtered.par_iter().try_for_each(|sprite| {
let display_name = if sprite.name == "?" || sprite.name.is_empty() {
"egg"
} else {
&sprite.name
};
let dex_num = national_map
.get(sprite.id.0 as usize)
.copied()
.filter(|&n| n != 0)
.unwrap_or(sprite.id.0);
let species_dir = if display_name == "egg" {
out_dir.join("egg")
} else {
out_dir.join(format!("{:03}_{}", dex_num, display_name))
};
std::fs::create_dir_all(&species_dir)
.with_context(|| format!("creating {}", species_dir.display()))?;
for (is_front, label) in [(true, "front"), (false, "back")] {
for (is_shiny, suffix) in [(false, ""), (true, "_shiny")] {
if let Some(img) = render_sprite_variant(sprite, is_front, is_shiny) {
let path = species_dir.join(format!("{label}{suffix}.png"));
img.save_png(&path)
.with_context(|| format!("saving {}", path.display()))?;
}
pb.inc(1);
}
}
if let Some(ref fp) = sprite.footprint {
let img = render_footprint(fp);
let path = species_dir.join("footprint.png");
img.save_png(&path)
.with_context(|| format!("saving {}", path.display()))?;
}
Ok::<(), anyhow::Error>(())
})?;
pb.finish_and_clear();
Ok(count)
}
fn render_sprite(sprite: &Sprite, is_front: bool) -> Option<crate::RgbaImage> {
render_sprite_variant(sprite, is_front, false)
}
fn render_sprite_variant(
sprite: &Sprite,
is_front: bool,
is_shiny: bool,
) -> Option<crate::RgbaImage> {
let sheet: &SpriteSheet = if is_front {
sprite.front.as_ref()?
} else {
sprite.back.as_ref()?
};
let palette_data = if is_shiny {
&sprite.shiny_palette
} else {
&sprite.palette
};
let palette = palette_data.get(0)?;
Some(SpriteRenderer::new(sheet, palette).render())
}
pub(super) fn write_forms(
forms: &[crate::FormSprite],
species_names: &[String],
national_map: &[u16],
sprites_dir: &Path,
cli: &Cli,
) -> Result<usize> {
use crate::sprite::MonCoords;
use crate::tileset::TileData;
use crate::{FormSprite, SpriteRenderer, SpriteSheet};
use std::collections::BTreeMap;
let mut by_species: BTreeMap<u16, Vec<&FormSprite>> = BTreeMap::new();
for form in forms {
by_species.entry(form.base.0).or_default().push(form);
}
let filter = cli
.sprite_filter
.as_deref()
.map(glob::Pattern::new)
.transpose()
.with_context(|| "invalid sprite filter pattern")?;
let mut work: Vec<(&FormSprite, std::path::PathBuf)> = Vec::new();
for (base_id, form_list) in &by_species {
let base_name = species_names
.get(*base_id as usize)
.cloned()
.unwrap_or_default();
if base_name.is_empty() || base_name == "?" {
continue;
}
if let Some(ref pat) = filter {
if !pat.matches(&base_name) {
continue;
}
}
let dex_num = national_map
.get(*base_id as usize)
.copied()
.filter(|&n| n != 0)
.unwrap_or(*base_id);
let species_dir = sprites_dir.join(format!("{:03}_{}", dex_num, base_name));
let forms_dir = species_dir.join("forms");
for form in form_list {
let form_dir = forms_dir.join(&form.form);
work.push((form, form_dir));
}
}
let total = work.len() as u64 * 4;
let pb = progress_bar(total, cli.quiet);
let count = work.len();
work.par_iter().try_for_each(|(form, form_dir)| {
std::fs::create_dir_all(form_dir)
.with_context(|| format!("creating {}", form_dir.display()))?;
for (_is_front, label, tiles_data) in [
(true, "front", form.front_tiles.as_ref()),
(false, "back", form.back_tiles.as_ref()),
] {
let Some(tiles) = tiles_data else {
continue;
};
let sheet = SpriteSheet {
tiles: TileData::from_bytes(tiles.clone()),
coords: MonCoords::default(),
};
for (_is_shiny, suffix, palette_opt) in [
(false, "", form.palette.as_ref()),
(true, "_shiny", form.shiny_palette.as_ref()),
] {
let Some(pal) = palette_opt else {
continue;
};
let Some(palette_data) = pal.get(0) else {
continue;
};
let img = SpriteRenderer::new(&sheet, palette_data).render();
let path = form_dir.join(format!("{label}{suffix}.png"));
img.save_png(&path)
.with_context(|| format!("saving {}", path.display()))?;
pb.inc(1);
}
}
Ok::<(), anyhow::Error>(())
})?;
pb.finish_and_clear();
Ok(count)
}
fn compose_spritesheet(images: &[crate::RgbaImage], columns: usize) -> crate::RgbaImage {
let max_w = images.iter().map(|i| i.width()).max().unwrap_or(64);
let max_h = images.iter().map(|i| i.height()).max().unwrap_or(64);
let rows = images.len().div_ceil(columns);
let pad = 1u32;
let sheet_w = columns as u32 * (max_w + pad) - pad;
let sheet_h = rows as u32 * (max_h + pad) - pad;
let mut sheet = crate::RgbaImage::new(sheet_w, sheet_h);
for (idx, img) in images.iter().enumerate() {
let col = idx % columns;
let row = idx / columns;
let x = col as u32 * (max_w + pad);
let y = row as u32 * (max_h + pad);
sheet.alpha_blit(img, (x, y));
}
sheet
}
pub(super) fn write_overworld_sprites(
sprites: &[OverworldSprite],
out_dir: &Path,
cli: &Cli,
) -> Result<usize> {
if cli.overworld_spritesheet {
return write_overworld_spritesheet(sprites, out_dir, cli);
}
write_overworld_individual(sprites, out_dir, cli)
}
fn write_overworld_individual(
sprites: &[OverworldSprite],
out_dir: &Path,
cli: &Cli,
) -> Result<usize> {
std::fs::create_dir_all(out_dir)
.with_context(|| format!("creating {}", out_dir.display()))?;
let filter = cli
.overworld_filter
.as_deref()
.map(glob::Pattern::new)
.transpose()
.with_context(|| "invalid overworld filter pattern")?;
let filtered: Vec<_> = sprites
.iter()
.filter(|s| {
if let Some(ref pat) = filter {
pat.matches(&s.name)
} else {
true
}
})
.collect();
let total_frames: u64 = filtered.iter().map(|s| {
let base = s.frames.len() as u64;
if cli.overworld_shiny && s.shiny_palette.is_some() {
base * 2
} else {
base
}
}).sum();
let pb = progress_bar(total_frames, cli.quiet);
let count = filtered.len();
filtered.par_iter().try_for_each(|sprite| {
let sprite_dir = out_dir.join(format!("{:03}_{}", sprite.id, sprite.name));
std::fs::create_dir_all(&sprite_dir)
.with_context(|| format!("creating {}", sprite_dir.display()))?;
let palette_data = sprite.palette.get(0);
for frame in &sprite.frames {
if let Some(pal) = palette_data {
use crate::OverworldSpriteRenderer;
let renderer = OverworldSpriteRenderer::new(
&frame.tiles,
sprite.width_tiles,
sprite.height_tiles,
pal,
);
let img = renderer.render();
let path = sprite_dir.join(format!("frame_{}.png", frame.index));
img.save_png(&path)
.with_context(|| format!("saving {}", path.display()))?;
}
pb.inc(1);
}
if cli.overworld_shiny {
if let Some(shiny_pal_data) = sprite.shiny_palette.as_ref() {
if let Some(shiny_pal) = shiny_pal_data.get(0) {
use crate::OverworldSpriteRenderer;
for frame in &sprite.frames {
let renderer = OverworldSpriteRenderer::new(
&frame.tiles,
sprite.width_tiles,
sprite.height_tiles,
shiny_pal,
);
let img = renderer.render();
let path = sprite_dir.join(format!("frame_{}_shiny.png", frame.index));
img.save_png(&path)
.with_context(|| format!("saving {}", path.display()))?;
pb.inc(1);
}
}
}
}
Ok::<(), anyhow::Error>(())
})?;
pb.finish_and_clear();
let mut list_lines: Vec<String> = Vec::new();
for sprite in &filtered {
list_lines.push(format!("{}: {}", sprite.id, sprite.name));
}
std::fs::write(out_dir.join("sprite_list.txt"), list_lines.join("\n"))
.with_context(|| "writing sprite_list.txt")?;
Ok(count)
}
fn write_overworld_spritesheet(
sprites: &[OverworldSprite],
out_dir: &Path,
cli: &Cli,
) -> Result<usize> {
std::fs::create_dir_all(out_dir)
.with_context(|| format!("creating {}", out_dir.display()))?;
let filter = cli
.overworld_filter
.as_deref()
.map(glob::Pattern::new)
.transpose()
.with_context(|| "invalid overworld filter pattern")?;
let filtered: Vec<_> = sprites
.iter()
.filter(|s| {
if let Some(ref pat) = filter {
pat.matches(&s.name)
} else {
true
}
})
.collect();
let mut normal_imgs = Vec::new();
let mut shiny_imgs = Vec::new();
let mut sprite_list = Vec::new();
for sprite in &filtered {
if let Some(pal) = sprite.palette.get(0) {
if let Some(frame) = sprite.frames.first() {
use crate::OverworldSpriteRenderer;
let renderer = OverworldSpriteRenderer::new(
&frame.tiles,
sprite.width_tiles,
sprite.height_tiles,
pal,
);
normal_imgs.push(renderer.render());
sprite_list.push(sprite.name.clone());
}
}
if cli.overworld_shiny {
if let Some(shiny_pal) = sprite.shiny_palette.as_ref().and_then(|p| p.get(0)) {
if let Some(frame) = sprite.frames.first() {
use crate::OverworldSpriteRenderer;
let renderer = OverworldSpriteRenderer::new(
&frame.tiles,
sprite.width_tiles,
sprite.height_tiles,
shiny_pal,
);
shiny_imgs.push(renderer.render());
}
}
}
}
let columns = cli.overworld_columns;
if !normal_imgs.is_empty() {
let sheet = compose_spritesheet(&normal_imgs, columns);
sheet
.save_png(out_dir.join("overworld_spritesheet.png"))
.with_context(|| "saving overworld spritesheet")?;
}
if !shiny_imgs.is_empty() {
let sheet = compose_spritesheet(&shiny_imgs, columns);
sheet
.save_png(out_dir.join("overworld_spritesheet_shiny.png"))
.with_context(|| "saving overworld shiny spritesheet")?;
}
let list = sprite_list
.into_iter()
.enumerate()
.map(|(i, name)| format!("{}: {}", i, name))
.collect::<Vec<_>>()
.join("\n");
std::fs::write(out_dir.join("sprite_list.txt"), list)
.with_context(|| "writing sprite_list.txt")?;
Ok(filtered.len())
}
}