use std::collections::BTreeMap;
use crate::graphics::Rgba;
use crate::tileset::{read_ptr_table, Palette, PALETTE_COLORS};
use crate::{Rom, SymbolTable};
const MAX_SCRIPT_OPS: usize = 32;
const SPRITE_PALETTE_SIZE: usize = 8;
const PALETTE_DATA_BYTES: usize = PALETTE_COLORS * 2;
const OP_LOADTILES: u8 = 0;
const OP_LOADFADEDPAL: u8 = 1;
const OP_LOADPAL: u8 = 2;
const OP_CALLNATIVE: u8 = 3;
const OP_END: u8 = 4;
const OP_LOADGFX_CALLNATIVE: u8 = 5;
const OP_LOADTILES_CALLNATIVE: u8 = 6;
const OP_LOADFADEDPAL_CALLNATIVE: u8 = 7;
pub fn build_palette_map(rom: &Rom, symbols: &SymbolTable) -> BTreeMap<u16, [Rgba; 16]> {
let mut palettes = parse_field_effect_palettes(rom, symbols);
for sym in symbols.iter() {
if !sym.name.starts_with("gSpritePalette_")
&& !sym.name.starts_with("gFieldEffectObjectPaletteInfo")
{
continue;
}
if let Some((tag, pal)) = read_sprite_palette(rom, sym.address) {
palettes.entry(tag).or_insert(pal);
}
}
palettes
}
fn parse_field_effect_palettes(rom: &Rom, symbols: &SymbolTable) -> BTreeMap<u16, [Rgba; 16]> {
let sym = match symbols.get("gFieldEffectScriptPointers") {
Some(s) => s,
None => return BTreeMap::new(),
};
let count = (sym.length / 4).min(256) as usize;
if count == 0 {
return BTreeMap::new();
}
let ptrs = match read_ptr_table(rom, sym.address, count) {
Ok(p) => p,
Err(_) => return BTreeMap::new(),
};
let mut palettes = BTreeMap::new();
for &script_ptr in &ptrs {
if let Some((tag, pal)) = parse_script_for_palette(rom, script_ptr) {
palettes.entry(tag).or_insert(pal);
}
}
palettes
}
fn parse_script_for_palette(rom: &Rom, script_ptr: u32) -> Option<(u16, [Rgba; 16])> {
let base = rom.offset_of(script_ptr).ok()?;
let bytes = rom.bytes();
let mut pos = base;
for _ in 0..MAX_SCRIPT_OPS {
if pos >= bytes.len() {
return None;
}
let op = bytes[pos];
pos += 1;
match op {
OP_LOADFADEDPAL | OP_LOADPAL => {
if pos + 4 > bytes.len() {
return None;
}
let pal_ptr = u32::from_le_bytes([
bytes[pos],
bytes[pos + 1],
bytes[pos + 2],
bytes[pos + 3],
]);
return read_sprite_palette(rom, pal_ptr);
}
OP_LOADFADEDPAL_CALLNATIVE => {
if pos + 8 > bytes.len() {
return None;
}
let pal_ptr = u32::from_le_bytes([
bytes[pos],
bytes[pos + 1],
bytes[pos + 2],
bytes[pos + 3],
]);
return read_sprite_palette(rom, pal_ptr);
}
OP_LOADGFX_CALLNATIVE => {
if pos + 12 > bytes.len() {
return None;
}
let pal_ptr = u32::from_le_bytes([
bytes[pos + 4],
bytes[pos + 5],
bytes[pos + 6],
bytes[pos + 7],
]);
if let Some(pal) = read_sprite_palette(rom, pal_ptr) {
return Some(pal);
}
pos += 12;
}
OP_LOADTILES => {
if pos + 4 > bytes.len() {
return None;
}
pos += 4;
}
OP_CALLNATIVE => {
if pos + 4 > bytes.len() {
return None;
}
pos += 4;
}
OP_LOADTILES_CALLNATIVE => {
if pos + 8 > bytes.len() {
return None;
}
pos += 8;
}
OP_END => return None,
_ => return None,
}
}
None
}
pub fn read_sprite_palette(rom: &Rom, pal_ptr: u32) -> Option<(u16, [Rgba; 16])> {
let offset = rom.offset_of(pal_ptr).ok()?;
let bytes = rom.bytes();
if offset + SPRITE_PALETTE_SIZE > bytes.len() {
return None;
}
let data_ptr = u32::from_le_bytes([
bytes[offset],
bytes[offset + 1],
bytes[offset + 2],
bytes[offset + 3],
]);
let tag = u16::from_le_bytes([bytes[offset + 4], bytes[offset + 5]]);
let pal_offset = rom.offset_of(data_ptr).ok()?;
if pal_offset + PALETTE_DATA_BYTES > bytes.len() {
return None;
}
let pal = Palette::from_bgr555(&bytes[pal_offset..pal_offset + PALETTE_DATA_BYTES]).ok()?;
Some((tag, *pal.as_array()))
}
pub fn read_template_palette_tag(rom: &Rom, template_addr: u32) -> Option<u16> {
let offset = rom.offset_of(template_addr).ok()?;
let bytes = rom.bytes();
if offset + 4 > bytes.len() {
return None;
}
Some(u16::from_le_bytes([bytes[offset + 2], bytes[offset + 3]]))
}