dotzuki-renderer 0.1.0

use super::*;

// ─── Base coordinate data ────────────────────────────────────────────
// 177 (Y, X) pairs in pixels.

pub static BASE_COORDS: [(u8, u8); NUM_BASECOORDS] = [
    (0x10, 0x68), // 00
    (0x10, 0x70), // 01
    (0x10, 0x78), // 02
    (0x10, 0x80), // 03
    (0x10, 0x88), // 04
    (0x10, 0x90), // 05
    (0x10, 0x98), // 06
    (0x18, 0x68), // 07
    (0x18, 0x70), // 08
    (0x18, 0x78), // 09
    (0x34, 0x28), // 0A
    (0x18, 0x80), // 0B
    (0x18, 0x88), // 0C
    (0x18, 0x98), // 0D
    (0x20, 0x68), // 0E
    (0x20, 0x70), // 0F
    (0x20, 0x78), // 10
    (0x20, 0x80), // 11
    (0x20, 0x88), // 12
    (0x20, 0x90), // 13
    (0x20, 0x98), // 14
    (0x28, 0x68), // 15
    (0x28, 0x70), // 16
    (0x28, 0x78), // 17
    (0x28, 0x80), // 18
    (0x28, 0x88), // 19
    (0x30, 0x68), // 1A
    (0x30, 0x70), // 1B
    (0x30, 0x78), // 1C
    (0x30, 0x80), // 1D
    (0x30, 0x90), // 1E
    (0x30, 0x98), // 1F
    (0x38, 0x68), // 20
    (0x38, 0x78), // 21
    (0x38, 0x80), // 22
    (0x38, 0x88), // 23
    (0x40, 0x68), // 24
    (0x40, 0x70), // 25
    (0x40, 0x78), // 26
    (0x40, 0x80), // 27
    (0x40, 0x88), // 28
    (0x40, 0x98), // 29
    (0x10, 0x60), // 2A
    (0x18, 0x60), // 2B
    (0x20, 0x60), // 2C
    (0x28, 0x60), // 2D
    (0x30, 0x60), // 2E
    (0x40, 0x60), // 2F
    (0x58, 0x28), // 30
    (0x43, 0x38), // 31
    (0x33, 0x48), // 32
    (0x20, 0x58), // 33
    (0x32, 0x78), // 34
    (0x58, 0x58), // 35
    (0x2C, 0x6C), // 36
    (0x34, 0x80), // 37
    (0x48, 0x70), // 38
    (0x42, 0x36), // 39
    (0x38, 0x44), // 3A
    (0x40, 0x52), // 3B
    (0x48, 0x60), // 3C
    (0x3E, 0x6E), // 3D
    (0x28, 0x7C), // 3E
    (0x28, 0x8A), // 3F
    (0x50, 0x3C), // 40
    (0x48, 0x50), // 41
    (0x40, 0x64), // 42
    (0x38, 0x38), // 43
    (0x50, 0x30), // 44
    (0x50, 0x38), // 45
    (0x50, 0x40), // 46
    (0x50, 0x48), // 47
    (0x50, 0x50), // 48
    (0x48, 0x58), // 49
    (0x50, 0x44), // 4A
    (0x48, 0x48), // 4B
    (0x48, 0x4C), // 4C
    (0x40, 0x50), // 4D
    (0x40, 0x54), // 4E
    (0x38, 0x58), // 4F
    (0x38, 0x5C), // 50
    (0x30, 0x64), // 51
    (0x48, 0x40), // 52
    (0x48, 0x39), // 53
    (0x24, 0x88), // 54
    (0x24, 0x70), // 55
    (0x1C, 0x70), // 56
    (0x1C, 0x88), // 57
    (0x34, 0x68), // 58
    (0x34, 0x88), // 59
    (0x68, 0x50), // 5A
    (0x60, 0x50), // 5B
    (0x68, 0x60), // 5C
    (0x58, 0x50), // 5D
    (0x60, 0x60), // 5E
    (0x68, 0x40), // 5F
    (0x40, 0x40), // 60
    (0x38, 0x40), // 61
    (0x0B, 0x60), // 62
    (0x44, 0x48), // 63
    (0x40, 0x14), // 64
    (0x48, 0x1C), // 65
    (0x50, 0x24), // 66
    (0x4C, 0x24), // 67
    (0x10, 0x62), // 68
    (0x12, 0x62), // 69
    (0x12, 0x60), // 6A
    (0x20, 0x72), // 6B
    (0x22, 0x72), // 6C
    (0x22, 0x70), // 6D
    (0x28, 0x62), // 6E
    (0x50, 0x0A), // 6F
    (0x52, 0x0A), // 70
    (0x38, 0x30), // 71
    (0x40, 0x48), // 72
    (0x30, 0x48), // 73
    (0x40, 0x30), // 74
    (0x30, 0x40), // 75
    (0x38, 0x48), // 76
    (0x40, 0x4A), // 77
    (0x48, 0x4B), // 78
    (0x50, 0x4C), // 79
    (0x58, 0x4D), // 7A
    (0x60, 0x4D), // 7B
    (0x68, 0x4D), // 7C
    (0x38, 0x10), // 7D
    (0x50, 0x10), // 7E
    (0x38, 0x28), // 7F
    (0x48, 0x18), // 80
    (0x40, 0x20), // 81
    (0x48, 0x20), // 82
    (0x40, 0x3C), // 83
    (0x38, 0x50), // 84
    (0x28, 0x64), // 85
    (0x1C, 0x90), // 86
    (0x24, 0x80), // 87
    (0x2C, 0x70), // 88
    (0x30, 0x38), // 89
    (0x10, 0x50), // 8A
    (0x3C, 0x40), // 8B
    (0x40, 0x58), // 8C
    (0x30, 0x58), // 8D
    (0x58, 0x48), // 8E
    (0x50, 0x58), // 8F
    (0x48, 0x68), // 90
    (0x40, 0x18), // 91
    (0x28, 0x58), // 92
    (0x40, 0x38), // 93
    (0x48, 0x38), // 94
    (0x08, 0x70), // 95
    (0x44, 0x1C), // 96
    (0x3C, 0x58), // 97
    (0x38, 0x60), // 98
    (0x08, 0x60), // 99
    (0x38, 0x70), // 9A
    (0x38, 0x6C), // 9B
    (0x38, 0x64), // 9C
    (0x1C, 0x74), // 9D
    (0x2E, 0x74), // 9E
    (0x34, 0x50), // 9F
    (0x2F, 0x60), // A0
    (0x31, 0x70), // A1
    (0x4C, 0x30), // A2
    (0x3B, 0x40), // A3
    (0x2D, 0x50), // A4
    (0x26, 0x60), // A5
    (0x2D, 0x70), // A6
    (0x28, 0x50), // A7
    (0x1E, 0x60), // A8
    (0x29, 0x70), // A9
    (0x16, 0x60), // AA
    (0x14, 0x58), // AB
    (0x12, 0x54), // AC
    (0x14, 0x50), // AD
    (0x18, 0x4C), // AE
    (0x1C, 0x48), // AF
    (0x48, 0x28), // B0
];

// ─── Frame block data ────────────────────────────────────────────────

/// Frame block data.
/// Each entry is a slice of (x_px, y_px, tile_id, flags) where the offsets
/// are pixel bytes: Y = y_tile*8 + y_px, X = x_tile*8 + x_px.
pub fn get_frame_block(id: usize) -> FrameBlock {
    if id >= NUM_FRAMEBLOCKS {
        return FrameBlock::empty();
    }
    let data: &[(u8, u8, u8, u8)] = FRAME_BLOCK_DATA[id];
    FrameBlock {
        tiles: data
            .iter()
            .map(|&(x, y, t, f)| FrameBlockTile {
                x_px: x,
                y_px: y,
                tile_id: t,
                flags: f,
            })
            .collect(),
    }
}

pub static FRAME_BLOCK_DATA: [&[(u8, u8, u8, u8)]; 122] = [
    &[], // 00 FrameBlock00
    &[
        (0, 0, 0x2C, 0x00),
        (8, 0, 0x2D, 0x00),
        (16, 0, 0x2C, 0x20),
        (0, 8, 0x3C, 0x00),
        (8, 8, 0x3D, 0x00),
        (16, 8, 0x3C, 0x20),
        (0, 16, 0x2C, 0x40),
        (8, 16, 0x2D, 0x40),
        (16, 16, 0x2C, 0x60),
    ], // 01 FrameBlock01
    &[
        (0, 0, 0x20, 0x00),
        (8, 0, 0x21, 0x00),
        (16, 0, 0x21, 0x20),
        (24, 0, 0x20, 0x20),
        (0, 8, 0x30, 0x00),
        (8, 8, 0x31, 0x00),
        (16, 8, 0x31, 0x20),
        (24, 8, 0x30, 0x20),
        (0, 16, 0x30, 0x40),
        (8, 16, 0x31, 0x40),
        (16, 16, 0x31, 0x60),
        (24, 16, 0x30, 0x60),
        (0, 24, 0x20, 0x40),
        (8, 24, 0x21, 0x40),
        (16, 24, 0x21, 0x60),
        (24, 24, 0x20, 0x60),
    ], // 02 FrameBlock02
    &[
        (0, 0, 0x02, 0x00),
        (8, 0, 0x02, 0x20),
        (0, 8, 0x12, 0x00),
        (8, 8, 0x12, 0x20),
    ], // 03 FrameBlock03
    &[
        (0, 0, 0x06, 0x00),
        (8, 0, 0x07, 0x00),
        (0, 8, 0x16, 0x00),
        (8, 8, 0x17, 0x00),
    ], // 04 FrameBlock04
    &[
        (0, 0, 0x07, 0x20),
        (8, 0, 0x06, 0x20),
        (0, 8, 0x17, 0x20),
        (8, 8, 0x16, 0x20),
    ], // 05 FrameBlock05
    &[
        (8, 0, 0x23, 0x00),
        (0, 8, 0x32, 0x00),
        (8, 8, 0x33, 0x00),
        (16, 0, 0x23, 0x20),
        (16, 8, 0x33, 0x20),
        (24, 8, 0x32, 0x20),
        (0, 16, 0x32, 0x40),
        (8, 16, 0x33, 0x40),
        (8, 24, 0x23, 0x40),
        (16, 16, 0x33, 0x60),
        (24, 16, 0x32, 0x60),
        (16, 24, 0x23, 0x60),
    ], // 06 FrameBlock06
    &[
        (0, 0, 0x20, 0x00),
        (8, 0, 0x21, 0x00),
        (0, 8, 0x30, 0x00),
        (8, 8, 0x31, 0x00),
        (16, 0, 0x21, 0x20),
        (24, 0, 0x20, 0x20),
        (16, 8, 0x31, 0x20),
        (24, 8, 0x30, 0x20),
        (0, 16, 0x30, 0x40),
        (8, 16, 0x31, 0x40),
        (0, 24, 0x20, 0x40),
        (8, 24, 0x21, 0x40),
        (16, 16, 0x31, 0x60),
        (24, 16, 0x30, 0x60),
        (16, 24, 0x21, 0x60),
        (24, 24, 0x20, 0x60),
    ], // 07 FrameBlock07
    &[
        (0, 0, 0x20, 0x00),
        (8, 0, 0x21, 0x00),
        (0, 8, 0x30, 0x00),
        (8, 8, 0x31, 0x00),
        (24, 0, 0x21, 0x20),
        (32, 0, 0x20, 0x20),
        (24, 8, 0x31, 0x20),
        (32, 8, 0x30, 0x20),
        (0, 24, 0x30, 0x40),
        (8, 24, 0x31, 0x40),
        (0, 32, 0x20, 0x40),
        (8, 32, 0x21, 0x40),
        (24, 24, 0x31, 0x60),
        (32, 24, 0x30, 0x60),
        (24, 32, 0x21, 0x60),
        (32, 32, 0x20, 0x60),
    ], // 08 FrameBlock08
    &[
        (0, 0, 0x24, 0x00),
        (8, 0, 0x25, 0x00),
        (0, 8, 0x34, 0x00),
        (24, 0, 0x25, 0x20),
        (32, 0, 0x24, 0x20),
        (32, 8, 0x34, 0x20),
        (0, 24, 0x34, 0x40),
        (0, 32, 0x24, 0x40),
        (8, 32, 0x25, 0x40),
        (32, 24, 0x34, 0x60),
        (24, 32, 0x25, 0x60),
        (32, 32, 0x24, 0x60),
    ], // 09 FrameBlock09
    &[
        (0, 0, 0x24, 0x00),
        (8, 0, 0x25, 0x00),
        (0, 8, 0x34, 0x00),
        (32, 0, 0x25, 0x20),
        (40, 0, 0x24, 0x20),
        (40, 8, 0x34, 0x20),
        (0, 32, 0x34, 0x40),
        (0, 40, 0x24, 0x40),
        (8, 40, 0x25, 0x40),
        (40, 32, 0x34, 0x60),
        (32, 40, 0x25, 0x60),
        (40, 40, 0x24, 0x60),
    ], // 0A FrameBlock0a
    &[
        (0, 0, 0x05, 0x00),
        (8, 0, 0x05, 0x20),
        (0, 8, 0x15, 0x00),
        (8, 8, 0x15, 0x20),
    ], // 0B FrameBlock0b
    &[
        (0, 0, 0x04, 0x00),
        (8, 0, 0x04, 0x20),
        (0, 8, 0x14, 0x00),
        (8, 8, 0x14, 0x20),
    ], // 0C FrameBlock0c
    &[
        (0, 0, 0x0C, 0x00),
        (8, 0, 0x0D, 0x00),
        (0, 8, 0x1C, 0x00),
        (8, 8, 0x1D, 0x00),
        (0, 16, 0x1D, 0x60),
        (8, 16, 0x1C, 0x60),
        (0, 24, 0x0D, 0x60),
        (8, 24, 0x0C, 0x60),
    ], // 0D FrameBlock0d
    &[
        (0, 32, 0x0C, 0x00),
        (8, 32, 0x0D, 0x00),
        (0, 40, 0x1C, 0x00),
        (8, 40, 0x1D, 0x00),
    ], // 0E FrameBlock0e
    &[
        (0, 48, 0x1D, 0x60),
        (8, 48, 0x1C, 0x60),
        (0, 56, 0x0D, 0x60),
        (8, 56, 0x0C, 0x60),
    ], // 0F FrameBlock0f
    &[
        (0, 0, 0x0E, 0x00),
        (8, 0, 0x0F, 0x00),
        (0, 8, 0x1E, 0x00),
        (8, 8, 0x1F, 0x00),
        (16, 0, 0x0F, 0x20),
        (24, 0, 0x0E, 0x20),
        (16, 8, 0x1F, 0x20),
        (24, 8, 0x1E, 0x20),
    ], // 10 FrameBlock10
    &[
        (0, 0, 0x0E, 0x00),
        (8, 0, 0x0F, 0x00),
        (0, 8, 0x1E, 0x00),
        (8, 8, 0x1F, 0x00),
        (32, 0, 0x0F, 0x20),
        (40, 0, 0x0E, 0x20),
        (32, 8, 0x1F, 0x20),
        (40, 8, 0x1E, 0x20),
    ], // 11 FrameBlock11
    &[
        (0, 0, 0x37, 0x00),
        (16, 8, 0x37, 0x00),
        (32, 0, 0x37, 0x00),
    ], // 12 FrameBlock12
    &[
        (0, 0, 0x36, 0x00),
        (8, 0, 0x36, 0x20),
        (0, 8, 0x36, 0x40),
        (8, 8, 0x36, 0x60),
    ], // 13 FrameBlock13
    &[
        (16, 0, 0x28, 0x00),
        (24, 0, 0x28, 0x20),
        (16, 8, 0x38, 0x00),
        (24, 8, 0x38, 0x20),
        (32, 0, 0x36, 0x00),
        (40, 0, 0x36, 0x20),
        (32, 8, 0x36, 0x40),
        (40, 8, 0x36, 0x60),
    ], // 14 FrameBlock14
    &[
        (0, 0, 0x28, 0x00),
        (8, 0, 0x28, 0x20),
        (0, 8, 0x38, 0x00),
        (8, 8, 0x38, 0x20),
        (16, 0, 0x29, 0x00),
        (24, 0, 0x29, 0x20),
        (16, 8, 0x39, 0x00),
        (24, 8, 0x39, 0x20),
        (32, 0, 0x28, 0x00),
        (40, 0, 0x28, 0x20),
        (32, 8, 0x38, 0x00),
        (40, 8, 0x38, 0x20),
    ], // 15 FrameBlock15
    &[
        (0, 0, 0x29, 0x00),
        (8, 0, 0x29, 0x20),
        (0, 8, 0x39, 0x00),
        (8, 8, 0x39, 0x20),
        (32, 0, 0x29, 0x00),
        (40, 0, 0x29, 0x20),
        (32, 8, 0x39, 0x00),
        (40, 8, 0x39, 0x20),
    ], // 16 FrameBlock16
    &[
        (0, 0, 0x08, 0x00),
        (8, 0, 0x09, 0x00),
        (0, 8, 0x18, 0x00),
        (8, 8, 0x19, 0x00),
    ], // 17 FrameBlock17
    &[
        (0, 24, 0x45, 0x60),
    ], // 18 FrameBlock18
    &[
        (8, 24, 0x45, 0x00),
        (8, 16, 0x46, 0x60),
    ], // 19 FrameBlock19
    &[
        (16, 16, 0x45, 0x60),
        (16, 24, 0x46, 0x00),
    ], // 1A FrameBlock1a
    &[
        (24, 16, 0x45, 0x00),
        (24, 8, 0x46, 0x60),
    ], // 1B FrameBlock1b
    &[
        (32, 8, 0x45, 0x60),
        (32, 16, 0x46, 0x00),
    ], // 1C FrameBlock1c
    &[
        (40, 8, 0x45, 0x00),
        (40, 0, 0x46, 0x60),
    ], // 1D FrameBlock1d
    &[
        (48, 0, 0x45, 0x60),
        (48, 8, 0x46, 0x00),
    ], // 1E FrameBlock1e
    &[
        (0, 0, 0x03, 0x00),
        (48, 0, 0x03, 0x20),
    ], // 1F FrameBlock1f
    &[
        (0, 0, 0x03, 0x00),
        (48, 0, 0x03, 0x20),
        (8, 8, 0x03, 0x00),
        (40, 8, 0x03, 0x20),
        (0, 8, 0x13, 0x00),
        (48, 8, 0x13, 0x20),
    ], // 20 FrameBlock20
    &[
        (0, 0, 0x03, 0x00),
        (48, 0, 0x03, 0x20),
        (8, 8, 0x03, 0x00),
        (40, 8, 0x03, 0x20),
        (0, 8, 0x13, 0x00),
        (48, 8, 0x13, 0x20),
        (16, 16, 0x03, 0x00),
        (32, 16, 0x03, 0x20),
        (8, 16, 0x13, 0x00),
        (40, 16, 0x13, 0x20),
        (0, 16, 0x03, 0x00),
        (48, 16, 0x03, 0x20),
    ], // 21 FrameBlock21
    &[
        (0, 0, 0x03, 0x00),
        (0, 8, 0x13, 0x00),
        (0, 16, 0x03, 0x00),
        (0, 24, 0x13, 0x00),
        (8, 8, 0x03, 0x00),
        (8, 16, 0x13, 0x00),
        (8, 24, 0x03, 0x00),
        (16, 16, 0x03, 0x00),
        (16, 24, 0x13, 0x00),
        (24, 24, 0x03, 0x00),
        (32, 16, 0x03, 0x20),
        (32, 24, 0x13, 0x20),
        (40, 8, 0x03, 0x20),
        (40, 16, 0x13, 0x20),
        (40, 24, 0x03, 0x20),
        (48, 0, 0x03, 0x20),
        (48, 8, 0x13, 0x20),
        (48, 16, 0x03, 0x20),
        (48, 24, 0x13, 0x20),
    ], // 22 FrameBlock22
    &[
        (0, 0, 0x0A, 0x00),
        (8, 0, 0x0B, 0x00),
        (0, 8, 0x1A, 0x00),
        (8, 8, 0x1B, 0x00),
    ], // 23 FrameBlock23
    &[
        (0, 8, 0x0A, 0x00),
        (8, 8, 0x0B, 0x00),
    ], // 24 FrameBlock24
    &[
        (0, 16, 0x0A, 0x00),
        (8, 16, 0x0B, 0x00),
        (0, 24, 0x1A, 0x00),
        (8, 24, 0x1B, 0x00),
        (16, 0, 0x0A, 0x00),
        (24, 0, 0x0B, 0x00),
        (16, 8, 0x1A, 0x00),
        (24, 8, 0x1B, 0x00),
        (32, 8, 0x0A, 0x00),
        (40, 8, 0x0B, 0x00),
        (32, 16, 0x1A, 0x00),
        (40, 16, 0x1B, 0x00),
    ], // 25 FrameBlock25
    &[
        (16, 0, 0x44, 0x00),
        (24, 0, 0x44, 0x20),
        (16, 8, 0x44, 0x40),
        (24, 8, 0x44, 0x60),
    ], // 26 FrameBlock26
    &[
        (8, 8, 0x44, 0x00),
        (16, 8, 0x44, 0x20),
        (8, 16, 0x44, 0x40),
        (16, 16, 0x44, 0x60),
        (24, 0, 0x47, 0x00),
    ], // 27 FrameBlock27
    &[
        (0, 16, 0x44, 0x00),
        (8, 16, 0x44, 0x20),
        (0, 24, 0x44, 0x40),
        (8, 24, 0x44, 0x60),
        (16, 8, 0x47, 0x00),
        (22, 2, 0x47, 0x00),
    ], // 28 FrameBlock28
    &[
        (0, 24, 0x47, 0x00),
        (6, 18, 0x47, 0x00),
        (12, 12, 0x47, 0x00),
        (18, 6, 0x47, 0x00),
    ], // 29 FrameBlock29
    &[
        (0, 0, 0x44, 0x00),
        (8, 0, 0x44, 0x20),
        (0, 8, 0x44, 0x40),
        (8, 8, 0x44, 0x60),
    ], // 2A FrameBlock2a
    &[
        (2, 6, 0x47, 0x00),
        (8, 0, 0x47, 0x00),
    ], // 2B FrameBlock2b
    &[
        (0, 160, 0x4D, 0x00),
    ], // 2C FrameBlock2c
    &[
        (0, 0, 0x26, 0x00),
        (8, 0, 0x27, 0x00),
        (0, 8, 0x36, 0x00),
        (8, 8, 0x37, 0x00),
        (0, 16, 0x28, 0x00),
        (8, 16, 0x29, 0x00),
        (0, 24, 0x38, 0x00),
        (8, 24, 0x39, 0x00),
    ], // 2D FrameBlock2d
    &[
        (0, 0, 0x27, 0x20),
        (8, 0, 0x26, 0x20),
        (0, 8, 0x37, 0x20),
        (8, 8, 0x36, 0x20),
        (0, 16, 0x29, 0x20),
        (8, 16, 0x28, 0x20),
        (0, 24, 0x39, 0x20),
        (8, 24, 0x38, 0x20),
    ], // 2E FrameBlock2e
    &[
        (0, 0, 0x0C, 0x00),
        (8, 0, 0x0D, 0x00),
        (0, 8, 0x0C, 0x40),
        (8, 8, 0x0D, 0x40),
    ], // 2F FrameBlock2f
    &[
        (0, 0, 0x44, 0x00),
        (8, 0, 0x44, 0x20),
        (0, 8, 0x44, 0x40),
        (8, 8, 0x44, 0x60),
    ], // 30 FrameBlock30
    &[
        (0, 0, 0x45, 0x00),
    ], // 31 FrameBlock31
    &[
        (0, 0, 0x4D, 0x00),
        (8, 0, 0x2F, 0x00),
        (16, 0, 0x4D, 0x20),
        (0, 8, 0x4E, 0x00),
        (8, 8, 0x07, 0x00),
        (16, 8, 0x4E, 0x20),
        (8, 16, 0x3F, 0x00),
    ], // 32 FrameBlock32
    &[
        (8, 0, 0x3F, 0x40),
        (0, 8, 0x4E, 0x40),
        (8, 8, 0x07, 0x40),
        (16, 8, 0x4E, 0x60),
        (0, 16, 0x4D, 0x40),
        (8, 16, 0x2F, 0x40),
        (16, 16, 0x4D, 0x60),
    ], // 33 FrameBlock33
    &[
        (0, 160, 0x00, 0x10),
    ], // 34 FrameBlock34
    &[
        (0, 0, 0x2A, 0x00),
        (8, 0, 0x2B, 0x00),
        (0, 8, 0x3A, 0x00),
        (0, 16, 0x3A, 0x40),
        (0, 24, 0x2A, 0x40),
        (8, 24, 0x2B, 0x40),
    ], // 35 FrameBlock35
    &[
        (0, 0, 0x00, 0x00),
        (8, 0, 0x01, 0x00),
        (0, 8, 0x10, 0x00),
        (8, 8, 0x11, 0x00),
    ], // 36 FrameBlock36
    &[
        (0, 0, 0x01, 0xA0),
        (8, 0, 0x00, 0xA0),
        (0, 8, 0x11, 0xA0),
        (8, 8, 0x10, 0xA0),
    ], // 37 FrameBlock37
    &[
        (0, 0, 0x0A, 0x00),
        (8, 0, 0x0B, 0x00),
        (0, 8, 0x1A, 0x00),
        (8, 8, 0x1B, 0x00),
    ], // 38 FrameBlock38
    &[
        (0, 0, 0x0B, 0x20),
        (8, 0, 0x0A, 0x20),
        (0, 8, 0x1B, 0x20),
        (8, 8, 0x1A, 0x20),
    ], // 39 FrameBlock39
    &[
        (0, 32, 0x05, 0x00),
        (8, 32, 0x05, 0x20),
        (0, 40, 0x15, 0x00),
        (8, 40, 0x15, 0x20),
    ], // 3A FrameBlock3a
    &[
        (0, 24, 0x04, 0x00),
        (8, 24, 0x04, 0x20),
        (0, 32, 0x14, 0x00),
        (8, 32, 0x14, 0x20),
        (4, 40, 0x41, 0x00),
    ], // 3B FrameBlock3b
    &[
        (0, 16, 0x05, 0x00),
        (8, 16, 0x05, 0x20),
        (0, 24, 0x15, 0x00),
        (8, 24, 0x15, 0x20),
        (4, 32, 0x42, 0x00),
        (4, 40, 0x42, 0x00),
    ], // 3C FrameBlock3c
    &[
        (0, 8, 0x04, 0x00),
        (8, 8, 0x04, 0x20),
        (0, 16, 0x14, 0x00),
        (8, 16, 0x14, 0x20),
        (4, 24, 0x41, 0x00),
        (4, 32, 0x41, 0x00),
        (4, 40, 0x41, 0x00),
    ], // 3D FrameBlock3d
    &[
        (0, 0, 0x05, 0x00),
        (8, 0, 0x05, 0x20),
        (0, 8, 0x15, 0x00),
        (8, 8, 0x15, 0x20),
        (4, 16, 0x42, 0x00),
        (4, 24, 0x42, 0x00),
        (4, 32, 0x42, 0x00),
        (4, 40, 0x42, 0x00),
    ], // 3E FrameBlock3e
    &[
        (0, 0, 0x04, 0x00),
        (8, 0, 0x04, 0x20),
        (0, 8, 0x14, 0x00),
        (8, 8, 0x14, 0x20),
        (4, 16, 0x41, 0x00),
        (4, 24, 0x41, 0x00),
        (4, 32, 0x41, 0x00),
        (4, 40, 0x41, 0x00),
    ], // 3F FrameBlock3f
    &[
        (0, 0, 0x3D, 0x00),
        (8, 0, 0x3D, 0x00),
        (8, 8, 0x3D, 0x00),
    ], // 40 FrameBlock40
    &[
        (0, 0, 0x06, 0x00),
        (8, 0, 0x06, 0x20),
        (0, 8, 0x16, 0x00),
        (8, 8, 0x17, 0x00),
    ], // 41 FrameBlock41
    &[
        (16, 0, 0x42, 0x00),
        (0, 8, 0x42, 0x00),
        (8, 8, 0x42, 0x00),
        (16, 8, 0x42, 0x00),
        (24, 8, 0x42, 0x00),
        (32, 8, 0x42, 0x00),
        (16, 16, 0x42, 0x00),
        (8, 24, 0x42, 0x00),
        (24, 24, 0x42, 0x00),
        (0, 32, 0x42, 0x00),
        (32, 32, 0x42, 0x00),
    ], // 42 FrameBlock42
    &[
        (16, 0, 0x41, 0x00),
        (0, 8, 0x41, 0x00),
        (8, 8, 0x41, 0x00),
        (16, 8, 0x41, 0x00),
        (24, 8, 0x41, 0x00),
        (32, 8, 0x41, 0x00),
        (16, 16, 0x41, 0x00),
        (8, 24, 0x41, 0x00),
        (24, 24, 0x41, 0x00),
        (0, 32, 0x41, 0x00),
        (32, 32, 0x41, 0x00),
    ], // 43 FrameBlock43
    &[
        (0, 0, 0x49, 0x00),
        (40, 0, 0x49, 0x00),
        (0, 40, 0x49, 0x00),
        (40, 40, 0x49, 0x00),
    ], // 44 FrameBlock44
    &[
        (0, 0, 0x49, 0x00),
        (24, 0, 0x49, 0x00),
        (0, 24, 0x49, 0x00),
        (24, 24, 0x49, 0x00),
    ], // 45 FrameBlock45
    &[
        (0, 0, 0x49, 0x00),
        (8, 0, 0x49, 0x00),
        (0, 8, 0x49, 0x00),
        (8, 8, 0x49, 0x00),
    ], // 46 FrameBlock46
    &[
        (0, 0, 0x43, 0x00),
        (8, 0, 0x43, 0x20),
        (0, 8, 0x43, 0x40),
        (8, 8, 0x43, 0x60),
    ], // 47 FrameBlock47
    &[
        (8, 8, 0x33, 0x00),
        (16, 8, 0x33, 0x20),
        (8, 16, 0x33, 0x40),
        (16, 16, 0x33, 0x60),
    ], // 48 SmallBlackCircleFrameBlock
    &[
        (0, 0, 0x22, 0x00),
        (8, 0, 0x23, 0x00),
        (16, 0, 0x23, 0x20),
        (24, 0, 0x22, 0x20),
        (0, 8, 0x32, 0x00),
        (8, 8, 0x43, 0x00),
        (16, 8, 0x43, 0x20),
        (24, 8, 0x32, 0x20),
        (0, 16, 0x32, 0x40),
        (8, 16, 0x43, 0x40),
        (16, 16, 0x43, 0x60),
        (24, 16, 0x32, 0x60),
        (0, 24, 0x22, 0x40),
        (8, 24, 0x23, 0x40),
        (16, 24, 0x23, 0x60),
        (24, 24, 0x22, 0x60),
    ], // 49 LargeBlackCircleFrameBlock
    &[
        (24, 8, 0x4C, 0x20),
        (8, 32, 0x4B, 0x00),
        (32, 48, 0x4C, 0x00),
        (48, 24, 0x4B, 0x40),
    ], // 4A FrameBlock4a
    &[
        (24, 0, 0x4C, 0x00),
        (0, 32, 0x4B, 0x40),
        (32, 56, 0x4C, 0x20),
        (56, 24, 0x4B, 0x00),
    ], // 4B FrameBlock4b
    &[
        (8, 16, 0x4A, 0x40),
        (16, 48, 0x4A, 0x00),
        (48, 40, 0x4A, 0x20),
        (40, 8, 0x4A, 0x60),
    ], // 4C FrameBlock4c
    &[
        (0, 8, 0x4A, 0x20),
        (8, 56, 0x4A, 0x60),
        (56, 48, 0x4A, 0x40),
        (48, 0, 0x4A, 0x00),
    ], // 4D FrameBlock4d
    &[
        (48, 0, 0x44, 0x00),
        (56, 0, 0x44, 0x20),
        (48, 8, 0x44, 0x40),
        (56, 8, 0x44, 0x60),
        (10, 38, 0x44, 0x00),
        (18, 38, 0x44, 0x20),
        (10, 46, 0x44, 0x40),
        (18, 46, 0x44, 0x60),
    ], // 4E FrameBlock4e
    &[
        (34, 14, 0x44, 0x00),
        (42, 14, 0x44, 0x20),
        (34, 22, 0x44, 0x40),
        (42, 22, 0x44, 0x60),
        (50, 6, 0x47, 0x00),
        (56, 0, 0x47, 0x00),
        (22, 26, 0x44, 0x00),
        (30, 26, 0x44, 0x20),
        (22, 34, 0x44, 0x40),
        (30, 34, 0x44, 0x60),
        (8, 48, 0x47, 0x00),
        (14, 42, 0x47, 0x00),
    ], // 4F FrameBlock4f
    &[
        (50, 6, 0x47, 0x00),
        (56, 0, 0x47, 0x00),
        (38, 18, 0x47, 0x00),
        (44, 12, 0x47, 0x00),
        (26, 30, 0x47, 0x00),
        (32, 24, 0x47, 0x00),
        (14, 42, 0x47, 0x00),
        (20, 36, 0x47, 0x00),
    ], // 50 FrameBlock50
    &[
        (0, 0, 0x35, 0x20),
        (0, 8, 0x35, 0x40),
        (0, 16, 0x35, 0x00),
        (0, 24, 0x35, 0x60),
        (64, 0, 0x35, 0x00),
        (64, 8, 0x35, 0x60),
        (64, 16, 0x35, 0x20),
        (64, 24, 0x35, 0x40),
    ], // 51 FrameBlock51
    &[
        (0, 0, 0x2A, 0x00),
        (8, 0, 0x2B, 0x00),
        (0, 8, 0x3A, 0x00),
        (8, 8, 0x3B, 0x00),
    ], // 52 FrameBlock52
    &[
        (0, 0, 0x3F, 0x00),
        (8, 0, 0x3F, 0x00),
        (6, 8, 0x3F, 0x00),
    ], // 53 FrameBlock53
    &[
        (0, 0, 0x0E, 0x00),
        (8, 0, 0x0E, 0x20),
        (0, 8, 0x0F, 0x00),
        (8, 8, 0x0F, 0x20),
    ], // 54 FrameBlock54
    &[
        (0, 16, 0x2C, 0x00),
        (8, 16, 0x3C, 0x00),
        (16, 16, 0x2D, 0x00),
    ], // 55 FrameBlock55
    &[
        (16, 16, 0x31, 0x00),
        (24, 16, 0x31, 0x00),
        (16, 8, 0x2C, 0x00),
        (24, 8, 0x3C, 0x00),
        (32, 8, 0x2D, 0x00),
        (32, 16, 0x2D, 0x00),
    ], // 56 FrameBlock56
    &[
        (32, 8, 0x31, 0x00),
        (32, 16, 0x31, 0x00),
        (40, 8, 0x31, 0x00),
        (40, 16, 0x31, 0x00),
        (32, 0, 0x2C, 0x00),
        (40, 0, 0x3C, 0x00),
        (48, 0, 0x2D, 0x00),
        (48, 8, 0x2D, 0x00),
        (48, 16, 0x2D, 0x00),
    ], // 57 FrameBlock57
    &[
        (0, 0, 0x46, 0x00),
        (2, 8, 0x47, 0x00),
        (3, 16, 0x48, 0x00),
        (4, 24, 0x48, 0x00),
        (5, 32, 0x48, 0x00),
        (5, 40, 0x48, 0x00),
        (5, 48, 0x48, 0x00),
    ], // 58 FrameBlock58
    &[
        (0, 0, 0x42, 0x00),
    ], // 59 FrameBlock59
    &[
        (0, 0, 0x24, 0x00),
        (8, 0, 0x25, 0x00),
        (0, 8, 0x34, 0x00),
        (16, 0, 0x25, 0x20),
        (24, 0, 0x24, 0x20),
        (24, 8, 0x34, 0x20),
        (0, 16, 0x34, 0x40),
        (0, 24, 0x24, 0x40),
        (8, 24, 0x25, 0x40),
        (24, 16, 0x34, 0x60),
        (16, 24, 0x25, 0x60),
        (24, 24, 0x24, 0x60),
    ], // 5A FrameBlock5a
    &[
        (0, 0, 0x43, 0x00),
        (8, 0, 0x43, 0x20),
        (0, 8, 0x43, 0x40),
        (8, 8, 0x43, 0x60),
    ], // 5B FrameBlock5b
    &[
        (0, 0, 0x49, 0x00),
        (8, 2, 0x49, 0x00),
        (0, 24, 0x49, 0x00),
        (16, 16, 0x49, 0x00),
        (0, 8, 0x43, 0x00),
        (8, 8, 0x43, 0x20),
        (0, 16, 0x43, 0x40),
        (8, 16, 0x43, 0x60),
    ], // 5C FrameBlock5c
    &[
        (0, 0, 0x49, 0x00),
        (2, 24, 0x49, 0x00),
        (16, 20, 0x49, 0x00),
        (0, 8, 0x43, 0x00),
        (8, 0, 0x43, 0x20),
        (0, 16, 0x43, 0x40),
        (8, 16, 0x43, 0x60),
        (8, 4, 0x43, 0x00),
        (16, 4, 0x43, 0x20),
        (8, 12, 0x43, 0x40),
        (16, 12, 0x43, 0x60),
    ], // 5D FrameBlock5d
    &[
        (8, 0, 0x49, 0x00),
        (16, 8, 0x49, 0x00),
        (0, 32, 0x49, 0x00),
        (0, 8, 0x43, 0x00),
        (8, 8, 0x43, 0x20),
        (0, 16, 0x43, 0x40),
        (8, 16, 0x43, 0x60),
        (16, 16, 0x43, 0x00),
        (24, 16, 0x43, 0x20),
        (16, 24, 0x43, 0x40),
        (24, 24, 0x43, 0x60),
        (8, 32, 0x43, 0x00),
        (16, 32, 0x43, 0x20),
        (8, 40, 0x43, 0x40),
        (16, 40, 0x43, 0x60),
    ], // 5E FrameBlock5e
    &[
        (0, 0, 0x49, 0x00),
        (16, 0, 0x49, 0x00),
        (32, 0, 0x49, 0x00),
        (48, 0, 0x49, 0x00),
    ], // 5F FrameBlock5f
    &[
        (0, 0, 0x49, 0x00),
        (16, 0, 0x49, 0x00),
        (32, 0, 0x49, 0x00),
        (48, 0, 0x49, 0x00),
        (8, 8, 0x49, 0x00),
        (24, 8, 0x49, 0x00),
        (40, 8, 0x49, 0x00),
        (56, 8, 0x49, 0x00),
    ], // 60 FrameBlock60
    &[
        (0, 0, 0x49, 0x00),
        (16, 0, 0x49, 0x00),
        (32, 0, 0x49, 0x00),
        (48, 0, 0x49, 0x00),
        (8, 8, 0x49, 0x00),
        (24, 8, 0x49, 0x00),
        (40, 8, 0x49, 0x00),
        (56, 8, 0x49, 0x00),
        (0, 16, 0x49, 0x00),
        (16, 16, 0x49, 0x00),
        (32, 16, 0x49, 0x00),
        (48, 16, 0x49, 0x00),
    ], // 61 FrameBlock61
    &[
        (0, 0, 0x49, 0x00),
        (16, 0, 0x49, 0x00),
        (32, 0, 0x49, 0x00),
        (48, 0, 0x49, 0x00),
        (8, 8, 0x49, 0x00),
        (24, 8, 0x49, 0x00),
        (40, 8, 0x49, 0x00),
        (56, 8, 0x49, 0x00),
        (0, 16, 0x49, 0x00),
        (16, 16, 0x49, 0x00),
        (32, 16, 0x49, 0x00),
        (48, 16, 0x49, 0x00),
        (8, 24, 0x49, 0x00),
        (24, 24, 0x49, 0x00),
        (40, 24, 0x49, 0x00),
    ], // 62 FrameBlock62
    &[
        (0, 16, 0x26, 0x00),
        (8, 16, 0x27, 0x00),
        (16, 8, 0x26, 0x00),
        (24, 8, 0x27, 0x00),
        (32, 0, 0x26, 0x00),
        (40, 0, 0x27, 0x00),
    ], // 63 FrameBlock63
    &[
        (0, 24, 0x27, 0x00),
        (8, 16, 0x26, 0x00),
        (16, 16, 0x27, 0x00),
        (24, 8, 0x26, 0x00),
        (32, 8, 0x27, 0x00),
        (40, 0, 0x26, 0x00),
    ], // 64 FrameBlock64
    &[
        (0, 0, 0x1C, 0x00),
        (8, 0, 0x1D, 0x00),
        (0, 16, 0x1C, 0x00),
        (8, 16, 0x1D, 0x00),
        (0, 32, 0x1C, 0x00),
        (8, 32, 0x1D, 0x00),
    ], // 65 FrameBlock65
    &[
        (0, 0, 0x03, 0x00),
        (0, 8, 0x13, 0x00),
    ], // 66 FrameBlock66
    &[
        (0, 0, 0x03, 0x00),
    ], // 67 FrameBlock67
    &[
        (0, 0, 0x03, 0x00),
        (8, 0, 0x03, 0x20),
        (0, 8, 0x13, 0x00),
        (8, 8, 0x13, 0x20),
    ], // 68 FrameBlock68
    &[
        (0, 0, 0x06, 0x00),
    ], // 69 FrameBlock69
    &[
        (0, 0, 0x2E, 0x00),
        (48, 0, 0x2E, 0x20),
        (0, 48, 0x2E, 0x40),
        (48, 48, 0x2E, 0x60),
        (24, 0, 0x2F, 0x00),
        (24, 48, 0x2F, 0x40),
        (0, 24, 0x3E, 0x00),
        (48, 24, 0x3E, 0x20),
    ], // 6A FrameBlock6a
    &[
        (0, 0, 0x2E, 0x00),
        (32, 0, 0x2E, 0x20),
        (0, 32, 0x2E, 0x40),
        (32, 32, 0x2E, 0x60),
        (16, 0, 0x2F, 0x00),
        (16, 32, 0x2F, 0x40),
        (0, 16, 0x3E, 0x00),
        (32, 16, 0x3E, 0x20),
    ], // 6B FrameBlock6b
    &[
        (0, 0, 0x2E, 0x00),
        (16, 0, 0x2E, 0x20),
        (0, 16, 0x2E, 0x40),
        (16, 16, 0x2E, 0x60),
        (8, 0, 0x2F, 0x00),
        (8, 16, 0x2F, 0x40),
        (0, 8, 0x3E, 0x00),
        (16, 8, 0x3E, 0x20),
    ], // 6C FrameBlock6c
    &[
        (0, 0, 0x1E, 0x00),
        (8, 0, 0x1F, 0x00),
    ], // 6D FrameBlock6d
    &[
        (0, 0, 0x48, 0x00),
        (8, 0, 0x48, 0x20),
        (0, 8, 0x12, 0x00),
        (8, 8, 0x12, 0x20),
    ], // 6E FrameBlock6e
    &[
        (0, 0, 0x4A, 0x00),
        (8, 0, 0x07, 0x00),
        (0, 8, 0x16, 0x00),
        (8, 8, 0x17, 0x00),
    ], // 6F FrameBlock6f
    &[
        (0, 0, 0x07, 0x20),
        (8, 0, 0x4A, 0x20),
        (0, 8, 0x17, 0x20),
        (8, 8, 0x16, 0x20),
    ], // 70 FrameBlock70
    &[
        (0, 0, 0x22, 0x00),
        (8, 0, 0x3B, 0x00),
        (16, 0, 0x23, 0x20),
        (24, 0, 0x22, 0x20),
        (0, 8, 0x32, 0x00),
        (8, 8, 0x43, 0x00),
        (16, 8, 0x43, 0x20),
        (24, 8, 0x32, 0x20),
        (0, 16, 0x32, 0x40),
        (8, 16, 0x43, 0x40),
        (16, 16, 0x43, 0x60),
        (24, 16, 0x32, 0x60),
        (0, 24, 0x22, 0x40),
        (8, 24, 0x23, 0x40),
        (16, 24, 0x23, 0x60),
        (24, 24, 0x22, 0x60),
    ], // 71 FrameBlock71
    &[
        (0, 0, 0x32, 0x00),
        (8, 0, 0x43, 0x00),
        (16, 0, 0x43, 0x20),
        (24, 0, 0x32, 0x20),
        (0, 8, 0x32, 0x40),
        (8, 8, 0x43, 0x40),
        (16, 8, 0x43, 0x60),
        (24, 8, 0x32, 0x60),
        (0, 16, 0x22, 0x40),
        (8, 16, 0x23, 0x40),
        (16, 16, 0x23, 0x60),
        (24, 16, 0x22, 0x60),
    ], // 72 FrameBlock72
    &[
        (0, 0, 0x32, 0x40),
        (8, 0, 0x43, 0x40),
        (16, 0, 0x43, 0x60),
        (24, 0, 0x32, 0x60),
        (0, 8, 0x22, 0x40),
        (8, 8, 0x23, 0x40),
        (16, 8, 0x23, 0x60),
        (24, 8, 0x22, 0x60),
    ], // 73 FrameBlock73
    &[
        (0, 0, 0x22, 0x40),
        (8, 0, 0x23, 0x40),
        (16, 0, 0x23, 0x60),
        (24, 0, 0x22, 0x60),
    ], // 74 FrameBlock74
    &[
        (0, 0, 0x43, 0x00),
        (8, 0, 0x43, 0x20),
        (0, 8, 0x22, 0x00),
        (8, 8, 0x43, 0x60),
    ], // 75 FrameBlock75
    &[
        (16, 0, 0x2F, 0x00),
        (8, 1, 0x2F, 0x00),
        (24, 1, 0x2F, 0x00),
        (0, 2, 0x2E, 0x00),
        (32, 2, 0x2E, 0x20),
        (0, 10, 0x3E, 0x00),
        (32, 10, 0x3E, 0x20),
    ], // 76 FrameBlock76
    &[
        (2, 0, 0x4B, 0x00),
        (10, 0, 0x4C, 0x00),
        (0, 8, 0x4C, 0x60),
        (8, 8, 0x4B, 0x60),
    ], // 77 FrameBlock77
    &[
        (0, 0, 0x4D, 0x00),
    ], // 78 FrameBlock78
    &[
        (0, 0, 0x4E, 0x00),
    ], // 79 FrameBlock79
];

// ─── Subanimation data ───────────────────────────────────────────────

pub fn get_subanimation(id: usize) -> SubAnimation {
    if id >= NUM_SUBANIMS {
        return SubAnimation {
            transform: SubAnimTransform::Normal,
            frames: Vec::new(),
        };
    }
    let (transform, data) = SUBANIM_DATA[id];
    SubAnimation {
        transform: SubAnimTransform::from_u8(transform),
        frames: data
            .iter()
            .map(|&(fb, bc, m)| SubAnimFrame {
                frame_block_id: fb,
                base_coord_id: bc,
                mode: FrameBlockMode::from_u8(m),
            })
            .collect(),
    }
}

pub static SUBANIM_DATA: [(u8, &[(u8, u8, u8)]); 86] = [
    (2, &[(1, 23, 0)]),                                     // 00 Subanim_0Star
    (2, &[(1, 15, 0), (1, 29, 0)]),                         // 01 Subanim_0StarTwice
    (2, &[(1, 18, 0), (1, 21, 0), (1, 28, 0)]),             // 02 Subanim_0StarThrice
    (2, &[(1, 11, 0), (1, 17, 0), (1, 24, 0), (1, 29, 0)]), // 03 Subanim_0StarDescending
    (2, &[(2, 26, 0), (2, 16, 0), (2, 3, 0)]),              // 04 Subanim_1StarBigMoving
    (2, &[(2, 16, 0)]),                                     // 05 Subanim_1StarBig
    (
        0,
        &[
            (3, 48, 0),
            (3, 162, 0),
            (3, 147, 0),
            (3, 97, 0),
            (3, 115, 0),
            (3, 167, 0),
            (3, 51, 0),
            (3, 168, 0),
            (3, 14, 0),
            (3, 169, 0),
            (3, 52, 0),
        ],
    ), // 06 Subanim_0BallTossHigh
    (
        0,
        &[
            (3, 48, 0),
            (3, 162, 0),
            (3, 49, 0),
            (3, 163, 0),
            (3, 50, 0),
            (3, 164, 0),
            (3, 146, 0),
            (3, 165, 0),
            (3, 21, 0),
            (3, 166, 0),
            (3, 52, 0),
        ],
    ), // 07 Subanim_0BallTossMiddle
    (
        0,
        &[
            (3, 48, 0),
            (3, 68, 0),
            (3, 148, 0),
            (3, 96, 0),
            (3, 118, 0),
            (3, 159, 0),
            (3, 141, 0),
            (3, 160, 0),
            (3, 26, 0),
            (3, 161, 0),
            (3, 52, 0),
        ],
    ), // 08 Subanim_0BallTossLow
    (0, &[(3, 33, 4), (4, 33, 4), (3, 33, 4), (5, 33, 4)]), // 09 Subanim_0BallShakeEnemy
    (
        2,
        &[
            (6, 27, 0),
            (7, 27, 0),
            (8, 54, 0),
            (9, 54, 0),
            (10, 21, 0),
            (10, 21, 0),
        ],
    ), // 0A Subanim_0BallPoofEnemy
    (0, &[(1, 45, 0), (3, 47, 0), (3, 53, 0), (3, 77, 0)]), // 0B Subanim_0BallBlock
    (2, &[(12, 32, 0), (12, 33, 0), (12, 35, 0)]),          // 0C Subanim_1FlameColumn1
    (
        2,
        &[
            (12, 32, 2),
            (12, 21, 0),
            (12, 33, 2),
            (12, 23, 0),
            (12, 35, 2),
            (12, 25, 0),
        ],
    ), // 0D Subanim_1FlameColumn2
    (
        2,
        &[
            (12, 32, 2),
            (12, 21, 2),
            (12, 7, 0),
            (12, 33, 2),
            (12, 23, 2),
            (12, 9, 0),
            (12, 35, 2),
            (12, 25, 2),
            (12, 12, 0),
        ],
    ), // 0E Subanim_1FlameColumn3
    (
        2,
        &[
            (38, 14, 2),
            (38, 22, 2),
            (38, 28, 0),
            (39, 14, 2),
            (39, 22, 2),
            (39, 28, 0),
            (40, 14, 2),
            (40, 22, 2),
            (40, 28, 0),
            (41, 14, 2),
            (41, 22, 2),
            (41, 28, 0),
        ],
    ), // 0F Subanim_0Scratches
    (
        4,
        &[
            (45, 68, 0),
            (46, 69, 0),
            (45, 70, 0),
            (46, 71, 0),
            (45, 72, 0),
            (46, 73, 0),
            (45, 47, 0),
            (46, 26, 0),
        ],
    ), // 10 Subanim_1Tornado
    (
        2,
        &[
            (11, 38, 0),
            (12, 38, 0),
            (11, 38, 0),
            (12, 38, 0),
            (11, 40, 0),
            (12, 40, 0),
            (11, 40, 0),
            (12, 40, 0),
            (11, 39, 0),
            (12, 39, 0),
            (11, 39, 0),
            (12, 39, 0),
        ],
    ), // 11 Subanim_1Flames
    (
        3,
        &[
            (23, 48, 0),
            (23, 57, 0),
            (23, 58, 0),
            (23, 59, 0),
            (23, 60, 0),
            (23, 61, 0),
            (23, 62, 0),
            (23, 63, 0),
            (23, 31, 0),
        ],
    ), // 12 Subanim_0Heart_1Music
    (
        4,
        &[
            (48, 49, 0),
            (48, 50, 0),
            (48, 146, 0),
            (48, 14, 0),
            (48, 15, 0),
            (48, 16, 0),
        ],
    ), // 13 Subanim_1BlobToss
    (
        2,
        &[
            (48, 16, 0),
            (48, 16, 3),
            (49, 28, 4),
            (49, 33, 4),
            (49, 38, 0),
            (48, 16, 2),
            (49, 29, 4),
            (49, 34, 4),
            (49, 39, 0),
        ],
    ), // 14 Subanim_1BlobDripEnemy
    (1, &[(53, 82, 0), (53, 83, 0)]),                       // 15 Subanim_1Shout
    (
        2,
        &[
            (42, 5, 0),
            (43, 5, 2),
            (43, 12, 2),
            (42, 17, 4),
            (43, 17, 2),
            (43, 23, 2),
            (42, 27, 4),
            (43, 27, 2),
            (43, 32, 2),
            (42, 47, 4),
            (44, 0, 2),
            (44, 0, 0),
        ],
    ), // 16 Subanim_0Slice
    (2, &[(54, 84, 0), (54, 85, 0), (55, 86, 0), (55, 87, 0)]), // 17 Subanim_0BirdiesCirclingEnemy
    (5, &[(54, 84, 0), (54, 85, 0), (55, 86, 0), (55, 87, 0)]), // 18 Subanim_1SwordsCircling
    (
        4,
        &[
            (56, 49, 0),
            (57, 49, 0),
            (56, 50, 0),
            (57, 50, 0),
            (56, 146, 0),
            (57, 146, 0),
            (56, 14, 0),
            (57, 14, 0),
            (56, 15, 0),
            (57, 15, 0),
            (56, 16, 0),
            (57, 16, 0),
        ],
    ), // 19 Subanim_1CloudToss
    (
        2,
        &[
            (58, 8, 0),
            (59, 8, 0),
            (60, 8, 0),
            (61, 8, 0),
            (62, 8, 0),
            (63, 8, 0),
            (62, 8, 0),
            (63, 8, 0),
            (58, 11, 0),
            (59, 11, 0),
            (60, 11, 0),
            (61, 11, 0),
            (62, 11, 0),
            (63, 11, 0),
            (62, 11, 0),
            (63, 11, 0),
        ],
    ), // 1A Subanim_0WaterColumns
    (4, &[(64, 49, 0), (64, 50, 0), (64, 146, 0), (64, 21, 0)]), // 1B Subanim_1SeedToss
    (2, &[(65, 88, 0), (65, 89, 0), (65, 33, 0)]),          // 1C Subanim_1SeedLand
    (
        5,
        &[
            (36, 154, 0),
            (35, 27, 2),
            (36, 34, 0),
            (35, 22, 2),
            (35, 29, 2),
            (36, 152, 0),
            (37, 44, 4),
            (37, 42, 4),
            (37, 153, 4),
            (37, 98, 4),
            (37, 153, 4),
            (37, 98, 4),
            (37, 153, 4),
            (37, 98, 4),
            (37, 153, 3),
        ],
    ), // 1D Subanim_0RocksLift
    (0, &[(37, 117, 0)]),                                   // 1E Subanim_0RocksToss
    (
        4,
        &[
            (12, 48, 3),
            (12, 64, 3),
            (12, 65, 3),
            (12, 66, 3),
            (12, 33, 0),
        ],
    ), // 1F Subanim_1FlameBeam
    (2, &[(66, 7, 0), (67, 7, 0)]),                         // 20 Subanim_1FlameStar
    (2, &[(68, 0, 0), (69, 8, 0), (70, 16, 2)]), // 21 Subanim_0Circles_1Squares_CenteringEnemy
    (
        4,
        &[
            (71, 16, 0),
            (71, 86, 0),
            (71, 7, 0),
            (71, 170, 0),
            (71, 171, 0),
            (71, 172, 0),
            (71, 173, 0),
            (71, 174, 0),
            (71, 175, 0),
            (71, 137, 0),
            (71, 176, 0),
        ],
    ), // 22 Subanim_0Circle_1Square_TossBack
    (2, &[(81, 45, 0), (81, 110, 0)]),           // 23 Subanim_0Bind
    (5, &[(81, 45, 0), (81, 110, 0)]),           // 24 Subanim_0StatusParalyzed
    (3, &[(82, 113, 0), (82, 114, 0)]),          // 25 Subanim_0StatusConfused
    (0, &[(82, 1, 0), (82, 44, 0)]),             // 26 Subanim_0StatusConfusedEnemy
    (5, &[(84, 1, 0), (84, 44, 0)]),             // 27 Subanim_0StatusPoisoned
    (1, &[(85, 115, 3), (86, 115, 3), (87, 115, 0)]), // 28 Subanim_1Sand
    (
        2,
        &[
            (72, 15, 0),
            (74, 104, 3),
            (75, 42, 3),
            (73, 15, 0),
            (74, 104, 3),
            (75, 42, 0),
            (76, 106, 3),
            (77, 105, 3),
            (73, 107, 0),
            (76, 106, 3),
            (77, 105, 0),
            (74, 104, 3),
            (75, 42, 3),
            (73, 108, 0),
            (74, 104, 3),
            (75, 42, 0),
            (76, 106, 3),
            (77, 105, 3),
            (73, 109, 0),
            (76, 106, 3),
            (77, 42, 0),
            (74, 104, 3),
            (75, 42, 3),
            (73, 15, 0),
            (74, 104, 3),
            (75, 42, 0),
            (76, 106, 3),
            (77, 42, 3),
            (73, 107, 0),
        ],
    ), // 29 Subanim_1LightningBall
    (2, &[(78, 43, 0), (79, 43, 0), (80, 43, 0), (80, 43, 0)]), // 2A Subanim_0SliceBothSides
    (
        2,
        &[
            (13, 3, 3),
            (14, 3, 3),
            (15, 3, 0),
            (13, 17, 0),
            (13, 17, 0),
            (13, 55, 0),
            (13, 55, 0),
            (16, 33, 0),
            (16, 33, 0),
            (17, 27, 0),
            (17, 27, 0),
        ],
    ), // 2B Subanim_1Lightning
    (
        2,
        &[
            (18, 1, 0),
            (18, 15, 0),
            (18, 27, 0),
            (18, 37, 0),
            (19, 56, 0),
            (19, 56, 2),
            (20, 56, 0),
            (20, 56, 2),
            (21, 56, 0),
            (21, 56, 0),
            (22, 56, 0),
            (22, 56, 0),
        ],
    ), // 2C Subanim_0WaterDroplets
    (
        3,
        &[
            (68, 100, 0),
            (69, 101, 0),
            (70, 102, 0),
            (71, 102, 0),
            (71, 102, 0),
            (71, 102, 0),
        ],
    ), // 2D Subanim_0CirclesCentering
    (
        1,
        &[
            (24, 67, 2),
            (117, 82, 4),
            (25, 67, 2),
            (117, 99, 4),
            (26, 67, 2),
            (117, 77, 4),
            (27, 67, 2),
            (117, 151, 4),
            (28, 67, 2),
            (117, 152, 4),
            (29, 67, 2),
            (117, 88, 4),
            (30, 67, 2),
            (117, 27, 0),
        ],
    ), // 2E Subanim_0Beam
    (2, &[(31, 36, 0), (32, 32, 0), (33, 26, 0), (34, 21, 0)]), // 2F Subanim_0IceRise
    (
        2,
        &[
            (35, 0, 2),
            (35, 2, 2),
            (35, 4, 0),
            (35, 7, 2),
            (35, 2, 2),
            (35, 4, 0),
            (35, 14, 2),
            (35, 2, 2),
            (35, 12, 0),
            (37, 7, 0),
            (37, 14, 0),
            (37, 21, 0),
            (36, 36, 2),
            (35, 28, 2),
            (35, 35, 0),
            (35, 33, 2),
            (36, 40, 0),
            (36, 40, 0),
        ],
    ), // 30 Subanim_0RocksFallEnemy
    (
        1,
        &[
            (47, 70, 0),
            (47, 74, 0),
            (47, 75, 0),
            (47, 76, 0),
            (47, 77, 0),
            (47, 78, 0),
            (47, 79, 0),
            (47, 80, 0),
            (47, 46, 0),
            (47, 81, 0),
        ],
    ), // 31 Subanim_0SoundWave
    (3, &[(71, 116, 0), (71, 67, 0), (71, 117, 0)]), // 32 Subanim_0Circle_1Square_HalfToss
    (
        1,
        &[
            (88, 118, 0),
            (52, 118, 0),
            (88, 118, 0),
            (52, 118, 0),
            (88, 118, 0),
            (52, 118, 0),
        ],
    ), // 33 Subanim_1Barrier
    (
        1,
        &[
            (72, 125, 0),
            (73, 125, 0),
            (90, 125, 0),
            (72, 48, 0),
            (73, 48, 0),
            (90, 48, 0),
            (72, 126, 0),
            (73, 126, 0),
            (90, 126, 0),
            (72, 127, 0),
            (73, 127, 0),
            (90, 127, 0),
            (72, 128, 0),
            (73, 128, 0),
            (90, 128, 0),
            (72, 129, 0),
            (73, 129, 0),
            (90, 129, 0),
            (72, 130, 0),
            (73, 130, 0),
            (90, 130, 0),
        ],
    ), // 34 Subanim_1Selfdestruct
    (1, &[(91, 131, 3), (92, 132, 3), (93, 133, 3), (94, 9, 0)]), // 35 Subanim_0WaterBubbles
    (
        2,
        &[
            (95, 42, 0),
            (95, 0, 0),
            (96, 42, 0),
            (96, 0, 0),
            (97, 42, 0),
            (97, 0, 0),
            (98, 42, 0),
            (98, 0, 0),
        ],
    ), // 36 Subanim_0CirclesFalling
    (
        1,
        &[
            (99, 137, 0),
            (100, 117, 0),
            (99, 118, 0),
            (101, 13, 0),
            (101, 134, 0),
            (101, 18, 0),
            (101, 135, 0),
            (101, 23, 0),
            (101, 136, 0),
            (101, 26, 0),
        ],
    ), // 37 Subanim_0StringShot
    (
        2,
        &[
            (102, 138, 0),
            (102, 51, 0),
            (102, 46, 0),
            (103, 36, 3),
            (102, 1, 4),
            (102, 16, 4),
            (102, 29, 4),
            (103, 40, 3),
            (102, 42, 4),
            (102, 14, 4),
            (102, 27, 4),
            (103, 38, 3),
            (102, 3, 4),
            (102, 18, 4),
            (102, 30, 4),
            (103, 41, 0),
        ],
    ), // 38 Subanim_0IceFall
    (3, &[(71, 103, 0)]),                        // 39 Subanim_0Circle_1Square_Appears
    (3, &[(83, 113, 0), (83, 127, 0), (83, 129, 0)]), // 3A Subanim_0StatusSleep
    (0, &[(83, 1, 0), (83, 21, 0), (83, 44, 0)]), // 3B Subanim_0StatusSleepEnemy
    (
        3,
        &[
            (89, 121, 3),
            (89, 123, 3),
            (89, 119, 3),
            (89, 122, 3),
            (89, 120, 3),
            (89, 124, 3),
            (89, 118, 0),
        ],
    ), // 3C Subanim_0Water_1Fire_Barrier
    (
        0,
        &[
            (58, 77, 0),
            (59, 77, 0),
            (60, 77, 0),
            (61, 77, 0),
            (62, 77, 0),
            (63, 77, 0),
            (62, 77, 0),
            (63, 77, 0),
        ],
    ), // 3D Subanim_0Water_1Fire_Geyser
    (
        4,
        &[
            (2, 49, 0),
            (52, 49, 0),
            (2, 49, 0),
            (2, 50, 0),
            (52, 50, 0),
            (2, 50, 0),
            (2, 146, 0),
            (52, 146, 0),
            (2, 146, 0),
            (2, 14, 0),
            (52, 14, 0),
            (2, 14, 0),
            (2, 15, 0),
            (52, 15, 0),
            (2, 15, 0),
            (2, 16, 0),
            (52, 16, 0),
            (2, 16, 0),
        ],
    ), // 3E Subanim_1StarBigToss
    (
        3,
        &[
            (104, 75, 0),
            (104, 140, 0),
            (104, 32, 0),
            (104, 28, 0),
            (104, 25, 0),
            (104, 20, 0),
            (104, 118, 0),
            (104, 141, 0),
            (104, 21, 0),
            (104, 16, 0),
            (104, 12, 0),
            (104, 6, 0),
            (104, 142, 0),
            (104, 143, 0),
            (104, 144, 0),
            (104, 38, 0),
            (104, 35, 0),
            (104, 31, 0),
        ],
    ), // 3F Subanim_1StarsSmallToss
    (
        2,
        &[
            (23, 84, 0),
            (23, 85, 0),
            (23, 14, 0),
            (23, 86, 0),
            (23, 87, 0),
            (23, 19, 0),
        ],
    ), // 40 Subanim_1MusicCirclingEnemy
    (
        4,
        &[(3, 49, 0), (3, 50, 0), (3, 146, 0), (3, 14, 0), (3, 16, 0)],
    ), // 41 Subanim_1CircleBlackToss
    (2, &[(72, 8, 0), (73, 8, 0), (90, 8, 0)]),  // 42 Subanim_1ExplosionSmallEnemy
    (5, &[(106, 7, 0), (107, 15, 0), (108, 23, 0)]), // 43 Subanim_0Circle_1Square_Closing
    (
        1,
        &[
            (105, 75, 0),
            (105, 140, 0),
            (105, 32, 0),
            (105, 28, 0),
            (105, 25, 0),
            (105, 20, 0),
            (105, 118, 0),
            (105, 141, 0),
            (105, 21, 0),
            (105, 16, 0),
            (105, 12, 0),
            (105, 6, 0),
        ],
    ), // 44 Subanim_1LeavesToss
    (
        1,
        &[(109, 139, 0), (109, 132, 0), (109, 99, 0), (109, 140, 0)],
    ), // 45 Subanim_0HornJabTwice
    (
        1,
        &[
            (109, 139, 0),
            (109, 132, 0),
            (109, 99, 0),
            (109, 140, 0),
            (109, 10, 0),
            (109, 137, 0),
        ],
    ), // 46 Subanim_0HornJabThrice
    (1, &[(6, 130, 0), (7, 130, 0), (8, 150, 0)]), // 47 Subanim_0BallPoof
    (
        0,
        &[
            (3, 65, 4),
            (3, 72, 4),
            (4, 72, 4),
            (3, 72, 4),
            (5, 72, 4),
            (3, 72, 3),
        ],
    ), // 48 Subanim_2TradeBallDrop
    (0, &[(4, 72, 4), (3, 72, 4), (5, 72, 4), (3, 72, 3)]), // 49 Subanim_2TradeBallShake
    (0, &[(4, 132, 3)]),                         // 4A Subanim_2TradeBallAppear
    (0, &[(6, 114, 0), (7, 114, 0), (8, 114, 0)]), // 4B Subanim_2TradeBallPoof
    (
        3,
        &[
            (111, 48, 0),
            (110, 48, 0),
            (112, 48, 0),
            (110, 48, 0),
            (111, 48, 0),
            (110, 48, 0),
            (112, 48, 0),
            (110, 48, 0),
        ],
    ), // 4C Subanim_0EggShaking
    (
        1,
        &[
            (50, 75, 0),
            (51, 79, 0),
            (50, 32, 0),
            (51, 22, 0),
            (50, 25, 0),
            (51, 13, 0),
        ],
    ), // 4D Subanim_1TriangleToss
    (2, &[(113, 15, 3)]),                        // 4E Subanim_1SphereBig
    (
        2,
        &[
            (113, 15, 0),
            (113, 8, 0),
            (113, 1, 0),
            (113, 149, 0),
            (114, 149, 0),
            (115, 149, 0),
            (116, 149, 0),
        ],
    ), // 4F Subanim_1SphereBigRise
    (
        2,
        &[
            (116, 149, 0),
            (115, 149, 0),
            (114, 149, 0),
            (113, 149, 0),
            (113, 1, 0),
            (113, 8, 0),
            (113, 15, 0),
            (113, 22, 0),
        ],
    ), // 50 Subanim_1SphereBigFall
    (
        5,
        &[
            (118, 27, 0),
            (52, 27, 0),
            (118, 27, 0),
            (52, 27, 0),
            (118, 27, 0),
            (52, 27, 0),
        ],
    ), // 51 Subanim_0Shell
    (
        2,
        &[
            (119, 37, 0),
            (119, 155, 0),
            (119, 26, 0),
            (119, 156, 0),
            (119, 47, 0),
            (119, 80, 0),
            (119, 140, 0),
        ],
    ), // 52 Subanim_0CoinBounce
    (
        0,
        &[
            (120, 48, 0),
            (120, 162, 0),
            (120, 147, 0),
            (120, 97, 0),
            (120, 115, 0),
            (120, 167, 0),
            (120, 51, 0),
            (120, 168, 0),
            (120, 14, 0),
            (120, 169, 0),
            (120, 52, 0),
            (1, 158, 0),
        ],
    ), // 53 Subanim_0SafariRock
    (
        0,
        &[
            (121, 48, 0),
            (121, 162, 0),
            (121, 147, 0),
            (121, 97, 0),
            (121, 115, 0),
            (121, 167, 0),
            (121, 51, 0),
            (121, 168, 0),
            (121, 14, 0),
            (121, 169, 0),
            (121, 52, 0),
        ],
    ), // 54 Subanim_0SafariBait
    (2, &[(1, 157, 0)]),                         // 55 Subanim_0StarHigh
];

// ─── Move animation data ─────────────────────────────────────────────

pub const NUM_MOVE_ANIMS: usize = 203;

pub fn get_move_animation(id: usize) -> MoveAnimation {
    if id >= NUM_MOVE_ANIMS {
        return MoveAnimation::empty();
    }
    let cmds = MOVE_ANIM_DATA[id];
    MoveAnimation {
        commands: cmds
            .iter()
            .map(|&(kind, a, b, c)| {
                if kind == 0 {
                    AnimCommand::SubAnim {
                        sound_id: a,
                        subanim_id: b,
                        tileset: c >> 6,
                        delay: c & 0x3F,
                    }
                } else {
                    AnimCommand::Effect {
                        sound_id: a,
                        effect: SpecialEffect::from_u8(b).unwrap_or(SpecialEffect::WavyScreen),
                    }
                }
            })
            .collect(),
    }
}

pub static MOVE_ANIM_DATA: [&[(u8, u8, u8, u8)]; 203] = [
    &[(0, 1, 1, 8)],                                                 // 00 Pound
    &[(0, 2, 3, 8)],                                                 // 01 KarateChop
    &[(0, 3, 1, 5), (0, 3, 1, 5)],                                   // 02 DoubleSlap
    &[(0, 4, 2, 4), (0, 4, 2, 4)],                                   // 03 CometPunch
    &[(0, 5, 4, 70)],                                                // 04 MegaPunch
    &[(0, 1, 1, 8), (0, 6, 82, 4)],                                  // 05 PayDay
    &[(0, 7, 2, 6), (0, 0, 17, 70)],                                 // 06 FirePunch
    &[(0, 8, 2, 6), (0, 0, 47, 16)],                                 // 07 IcePunch
    &[(0, 9, 2, 6), (1, 0, 253, 0), (0, 0, 43, 70), (1, 0, 252, 0)], // 08 ThunderPunch
    &[(0, 10, 15, 6)],                                               // 09 Scratch
    &[(0, 11, 42, 8)],                                               // 0A Vicegrip
    &[(0, 12, 42, 6)],                                               // 0B Guillotine
    &[(0, 13, 22, 4)],                                               // 0C RazorWind
    &[(0, 14, 24, 70), (0, 14, 24, 70), (0, 14, 24, 70)],            // 0D SwordsDance
    &[(1, 15, 254, 0), (0, 0, 22, 4)],                               // 0E Cut
    &[(0, 16, 16, 70), (0, 0, 2, 6)],                                // 0F Gust
    &[(0, 17, 4, 70)],                                               // 10 WingAttack
    &[(0, 18, 16, 70), (1, 0, 219, 0)],                              // 11 Whirlwind
    &[(0, 19, 4, 70), (1, 0, 221, 0)],                               // 12 Fly
    &[(0, 20, 35, 4), (0, 20, 35, 4)],                               // 13 Bind
    &[(0, 21, 2, 6)],                                                // 14 Slam
    &[(0, 22, 22, 1), (0, 0, 1, 8)],                                 // 15 VineWhip
    &[(0, 23, 5, 72)],                                               // 16 Stomp
    &[(0, 24, 1, 8), (0, 24, 1, 8)],                                 // 17 DoubleKick
    &[(0, 25, 4, 70)],                                               // 18 MegaKick
    &[(0, 26, 4, 70)],                                               // 19 JumpKick
    &[(1, 27, 254, 0), (0, 0, 4, 70)],                               // 1A RollingKick
    &[(0, 28, 40, 70)],                                              // 1B SandAttack
    &[(0, 29, 5, 70)],                                               // 1C Headbutt
    &[(0, 30, 69, 6), (0, 0, 5, 70)],                                // 1D HornAttack
    &[(0, 31, 70, 2), (0, 0, 70, 2)],                                // 1E FuryAttack
    &[
        (0, 32, 5, 66),
        (0, 0, 5, 66),
        (0, 0, 5, 66),
        (0, 0, 5, 66),
        (0, 0, 5, 66),
    ], // 1F HornDrill
    &[(1, 73, 242, 0), (1, 0, 241, 0)],                              // 20 Tackle
    &[
        (1, 73, 242, 0),
        (1, 0, 254, 0),
        (1, 0, 254, 0),
        (1, 0, 241, 0),
    ], // 21 BodySlam
    &[(0, 35, 35, 4), (0, 35, 35, 4), (0, 35, 35, 4)],               // 22 Wrap
    &[(1, 73, 242, 0), (1, 36, 254, 0), (1, 0, 241, 0)],             // 23 TakeDown
    &[(0, 37, 4, 70)],                                               // 24 Thrash
    &[
        (1, 73, 240, 0),
        (0, 0, 45, 6),
        (1, 0, 252, 0),
        (1, 0, 242, 0),
        (1, 38, 254, 0),
        (1, 0, 241, 0),
    ], // 25 DoubleEdge
    &[
        (1, 133, 242, 0),
        (1, 0, 225, 0),
        (1, 133, 241, 0),
        (1, 0, 225, 0),
        (1, 133, 242, 0),
        (1, 0, 225, 0),
        (1, 133, 241, 0),
    ], // 26 TailWhip
    &[(0, 40, 0, 6)],                                                // 27 PoisonSting
    &[(0, 41, 1, 5), (0, 41, 1, 5)],                                 // 28 Twineedle
    &[(0, 42, 1, 3)],                                                // 29 PinMissile
    &[
        (1, 73, 253, 0),
        (1, 43, 254, 0),
        (1, 43, 254, 0),
        (1, 0, 252, 0),
    ], // 2A Leer
    &[(0, 44, 2, 8)],                                                // 2B Bite
    &[(0, 45, 18, 70)],                                              // 2C Growl
    &[(0, 46, 21, 70), (0, 46, 21, 70), (0, 46, 21, 70)],            // 2D Roar
    &[(0, 47, 18, 70), (0, 0, 64, 80), (0, 0, 64, 80)],              // 2E Sing
    &[(0, 48, 49, 6)],                                               // 2F Supersonic
    &[
        (0, 46, 21, 70),
        (0, 46, 21, 70),
        (0, 16, 16, 70),
        (0, 0, 5, 70),
    ], // 30 SonicBoom
    &[
        (1, 73, 253, 0),
        (1, 43, 254, 0),
        (1, 43, 254, 0),
        (1, 0, 252, 0),
    ], // 31 Disable
    &[(0, 51, 19, 70), (0, 51, 20, 70)],                             // 32 Acid
    &[(0, 52, 17, 70)],                                              // 33 Ember
    &[(0, 53, 31, 70), (0, 53, 12, 70), (0, 53, 13, 70)],            // 34 Flamethrower
    &[(1, 0, 240, 0), (1, 57, 250, 0), (1, 0, 252, 0)],              // 35 Mist
    &[(0, 55, 44, 6)],                                               // 36 WaterGun
    &[(0, 56, 26, 6), (0, 56, 26, 6)],                               // 37 HydroPump
    &[(1, 57, 250, 0), (0, 56, 26, 6)],                              // 38 Surf
    &[(0, 58, 46, 3), (0, 0, 47, 16)],                               // 39 IceBeam
    &[(0, 59, 56, 4), (0, 56, 56, 4)],                               // 3A Blizzard
    &[(0, 60, 46, 3), (1, 0, 248, 0)],                               // 3B PsyBeam
    &[(0, 61, 53, 18)],                                              // 3C BubbleBeam
    &[(0, 62, 46, 3), (1, 0, 225, 0), (1, 0, 225, 0)],               // 3D AuroraBeam
    &[
        (1, 73, 253, 0),
        (1, 0, 226, 0),
        (0, 63, 46, 2),
        (1, 0, 254, 0),
        (1, 0, 254, 0),
        (0, 5, 4, 70),
        (1, 0, 252, 0),
    ], // 3E HyperBeam
    &[(0, 64, 1, 8)],                                                // 3F Peck
    &[(0, 65, 4, 70)],                                               // 40 DrillPeck
    &[(1, 66, 244, 0), (0, 0, 1, 6), (1, 0, 221, 0)],                // 41 Submission
    &[(1, 67, 244, 0), (0, 0, 4, 70), (1, 0, 221, 0)],               // 42 LowKick
    &[(1, 68, 244, 0), (0, 0, 4, 70), (1, 0, 221, 0)],               // 43 Counter
    &[
        (1, 0, 222, 0),
        (0, 140, 78, 65),
        (1, 0, 223, 0),
        (1, 0, 244, 0),
        (0, 69, 79, 66),
        (1, 0, 225, 0),
        (1, 0, 225, 0),
        (1, 0, 221, 0),
        (0, 69, 80, 65),
        (1, 0, 220, 0),
        (1, 0, 251, 0),
    ], // 44 SeismicToss
    &[(1, 73, 242, 0), (1, 0, 241, 0), (0, 7, 4, 70)],               // 45 Strength
    &[
        (1, 71, 240, 0),
        (0, 0, 33, 6),
        (0, 0, 34, 6),
        (1, 0, 252, 0),
    ], // 46 Absorb
    &[
        (1, 72, 240, 0),
        (1, 0, 254, 0),
        (0, 0, 33, 6),
        (0, 0, 34, 6),
        (1, 0, 254, 0),
        (1, 0, 252, 0),
    ], // 47 MegaDrain
    &[(0, 73, 27, 70), (0, 78, 28, 85)],                             // 48 LeechSeed
    &[(1, 74, 240, 0), (1, 0, 226, 0), (1, 0, 252, 0)],              // 49 Growth
    &[(1, 75, 231, 0), (0, 129, 68, 65), (0, 13, 22, 1)],            // 4A RazorLeaf
    &[(0, 76, 46, 6), (0, 0, 1, 6)],                                 // 4B SolarBeam
    &[(0, 77, 54, 6)],                                               // 4C PoisonPowder
    &[(0, 78, 54, 6)],                                               // 4D StunSpore
    &[(0, 79, 54, 6)],                                               // 4E SleepPowder
    &[(1, 80, 240, 0), (1, 0, 230, 0), (1, 0, 252, 0)],              // 4F PetalDance
    &[(0, 81, 55, 8)],                                               // 50 StringShot
    &[
        (0, 82, 31, 70),
        (0, 0, 12, 70),
        (0, 0, 13, 70),
        (0, 0, 14, 70),
    ], // 51 DragonRage
    &[(0, 83, 12, 70), (0, 0, 13, 70), (0, 0, 14, 70)],              // 52 FireSpin
    &[(0, 84, 41, 66)],                                              // 53 ThunderShock
    &[(0, 85, 41, 65), (0, 85, 41, 65)],                             // 54 ThunderBolt
    &[(0, 86, 41, 66), (0, 0, 35, 2), (0, 0, 35, 4)],                // 55 ThunderWave
    &[
        (1, 87, 253, 0),
        (1, 0, 254, 0),
        (0, 0, 43, 70),
        (1, 0, 254, 0),
        (0, 85, 41, 66),
        (1, 0, 252, 0),
    ], // 56 Thunder
    &[(0, 88, 48, 4)],                                               // 57 RockThrow
    &[(1, 89, 251, 0), (1, 89, 251, 0)],                             // 58 Earthquake
    &[
        (1, 90, 254, 0),
        (1, 0, 251, 0),
        (1, 90, 254, 0),
        (1, 0, 251, 0),
    ], // 59 Fissure
    &[(0, 91, 4, 70), (1, 0, 247, 0)],                               // 5A Dig
    &[(1, 57, 250, 0), (0, 92, 20, 70)],                             // 5B Toxic
    &[(1, 93, 248, 0)],                                              // 5C Confusion
    &[(1, 94, 248, 0), (1, 0, 216, 0)],                              // 5D Psychic
    &[(1, 95, 248, 0)],                                              // 5E Hypnosis
    &[
        (1, 96, 240, 0),
        (0, 0, 67, 70),
        (1, 0, 254, 0),
        (1, 0, 252, 0),
    ], // 5F Meditate
    &[(1, 97, 240, 0), (1, 0, 252, 0)],                              // 60 Agility
    &[(1, 98, 244, 0), (0, 0, 4, 70), (1, 0, 221, 0)],               // 61 QuickAttack
    &[(0, 99, 1, 6)],                                                // 62 Rage
    &[(1, 100, 238, 0), (1, 0, 237, 0)],                             // 63 Teleport
    &[(1, 93, 248, 0), (1, 0, 216, 0)],                              // 64 NightShade
    &[(0, 102, 33, 70), (0, 102, 34, 70)],                           // 65 Mimic
    &[(0, 103, 18, 70)],                                             // 66 Screech
    &[
        (1, 0, 253, 0),
        (1, 0, 225, 0),
        (1, 0, 225, 0),
        (1, 0, 254, 0),
        (1, 0, 254, 0),
        (1, 0, 252, 0),
        (1, 104, 218, 0),
        (1, 0, 221, 0),
        (0, 112, 51, 70),
    ], // 67 DoubleTeam
    &[
        (1, 105, 243, 0),
        (1, 0, 240, 0),
        (1, 0, 226, 0),
        (1, 0, 252, 0),
    ], // 68 Recover
    &[
        (1, 106, 240, 0),
        (0, 0, 67, 70),
        (1, 0, 254, 0),
        (1, 0, 252, 0),
    ], // 69 Harden
    &[
        (1, 107, 240, 0),
        (1, 0, 226, 0),
        (1, 0, 234, 0),
        (1, 0, 252, 0),
    ], // 6A Minimize
    &[
        (0, 108, 40, 70),
        (0, 0, 10, 4),
        (1, 0, 249, 0),
        (1, 0, 225, 0),
        (1, 0, 225, 0),
        (1, 0, 253, 0),
        (1, 0, 225, 0),
        (1, 0, 225, 0),
        (1, 0, 225, 0),
        (1, 0, 225, 0),
        (1, 0, 225, 0),
        (1, 0, 225, 0),
        (1, 0, 249, 0),
        (1, 0, 225, 0),
        (1, 0, 252, 0),
    ], // 6B SmokeScreen
    &[(1, 109, 253, 0), (0, 0, 62, 70), (1, 0, 252, 0)],             // 6C ConfuseRay
    &[
        (1, 111, 240, 0),
        (1, 0, 246, 0),
        (0, 0, 81, 6),
        (1, 0, 252, 0),
        (1, 0, 221, 0),
    ], // 6D Withdraw
    &[
        (1, 111, 240, 0),
        (0, 0, 67, 6),
        (1, 0, 254, 0),
        (1, 0, 252, 0),
    ], // 6E DefenseCurl
    &[(0, 112, 51, 70), (0, 112, 51, 70)],                           // 6F Barrier
    &[
        (1, 0, 240, 0),
        (0, 113, 51, 70),
        (0, 113, 51, 70),
        (1, 0, 252, 0),
    ], // 70 LightScreen
    &[(1, 0, 249, 0), (1, 57, 250, 0), (1, 0, 252, 0)],              // 71 Haze
    &[
        (1, 0, 253, 0),
        (0, 115, 51, 70),
        (0, 115, 51, 70),
        (1, 0, 252, 0),
    ], // 72 Reflect
    &[(1, 116, 226, 0)],                                             // 73 FocusEnergy
    &[(0, 117, 4, 70)],                                              // 74 Bide
    &[
        (1, 133, 242, 0),
        (1, 0, 225, 0),
        (1, 133, 241, 0),
        (1, 0, 225, 0),
        (1, 133, 242, 0),
        (1, 0, 225, 0),
        (1, 133, 241, 0),
    ], // 75 Metronome
    &[(0, 119, 1, 8)],                                               // 76 MirrorMove
    &[(0, 120, 52, 67)],                                             // 77 Selfdestruct
    &[(0, 121, 65, 68), (0, 121, 66, 68)],                           // 78 EggBomb
    &[(0, 124, 20, 70)],                                             // 79 Lick
    &[(1, 73, 249, 0), (0, 123, 25, 70), (1, 0, 252, 0)],            // 7A Smog
    &[(0, 124, 19, 70), (0, 124, 20, 70)],                           // 7B Sludge
    &[(0, 125, 2, 8)],                                               // 7C BoneClub
    &[
        (0, 126, 31, 70),
        (0, 0, 32, 70),
        (0, 0, 32, 70),
        (0, 0, 12, 70),
        (0, 0, 13, 70),
    ], // 7D FireBlast
    &[
        (1, 73, 246, 0),
        (0, 56, 26, 6),
        (0, 0, 2, 8),
        (1, 0, 247, 0),
    ], // 7E Waterfall
    &[(0, 128, 42, 8), (0, 132, 35, 6), (0, 132, 35, 6)],            // 7F Clamp
    &[(0, 129, 63, 67)],                                             // 80 Swift
    &[(0, 130, 5, 70)],                                              // 81 SkullBash
    &[(0, 131, 4, 68)],                                              // 82 SpikeCannon
    &[(0, 132, 35, 6), (0, 132, 35, 6), (0, 132, 35, 6)],            // 83 Constrict
    &[(0, 133, 37, 8), (0, 133, 37, 8)],                             // 84 Amnesia
    &[(0, 134, 1, 8)],                                               // 85 Kinesis
    &[
        (1, 73, 229, 0),
        (0, 135, 76, 8),
        (1, 0, 240, 0),
        (1, 0, 226, 0),
        (1, 0, 252, 0),
        (1, 0, 221, 0),
    ], // 86 Softboiled
    &[(0, 136, 4, 70)],                                              // 87 HiJumpKick
    &[
        (1, 73, 253, 0),
        (1, 137, 254, 0),
        (1, 0, 254, 0),
        (1, 0, 252, 0),
    ], // 88 Glare
    &[
        (1, 138, 248, 0),
        (1, 138, 253, 0),
        (0, 138, 2, 8),
        (1, 0, 252, 0),
    ], // 89 DreamEater
    &[(0, 139, 25, 70)],                                             // 8A PoisonGas
    &[(0, 140, 65, 67), (0, 0, 85, 5)],                              // 8B Barrage
    &[
        (0, 141, 2, 8),
        (1, 0, 254, 0),
        (0, 0, 33, 6),
        (0, 0, 34, 6),
        (1, 0, 254, 0),
    ], // 8C LeechLife
    &[(0, 142, 18, 6)],                                              // 8D LovelyKiss
    &[
        (1, 143, 238, 0),
        (1, 0, 237, 0),
        (0, 136, 4, 70),
        (1, 0, 221, 0),
    ], // 8E SkyAttack
    &[
        (0, 144, 33, 70),
        (0, 144, 34, 68),
        (0, 0, 71, 8),
        (1, 0, 232, 0),
    ], // 8F Transform
    &[(0, 145, 53, 22)],                                             // 90 Bubble
    &[
        (0, 146, 23, 6),
        (0, 146, 23, 6),
        (0, 146, 23, 6),
        (0, 3, 2, 6),
    ], // 91 DizzyPunch
    &[(0, 147, 54, 6)],                                              // 92 Spore
    &[
        (1, 73, 240, 0),
        (1, 137, 254, 0),
        (1, 0, 254, 0),
        (1, 0, 252, 0),
    ], // 93 Flash
    &[(0, 48, 49, 6), (1, 93, 216, 0)],                              // 94 Psywave
    &[(1, 150, 235, 0)],                                             // 95 Splash
    &[(1, 151, 233, 0)],                                             // 96 AcidArmor
    &[(0, 152, 5, 70), (0, 0, 42, 6)],                               // 97 CrabHammer
    &[(0, 153, 52, 67)],                                             // 98 Explosion
    &[(0, 154, 15, 4)],                                              // 99 FurySwipes
    &[(0, 155, 2, 6)],                                               // 9A Bonemerang
    &[(0, 156, 58, 16), (0, 156, 58, 16)],                           // 9B Rest
    &[(0, 157, 29, 4), (0, 157, 30, 3), (0, 158, 4, 70)],            // 9C RockSlide
    &[(0, 158, 2, 6)],                                               // 9D HyperFang
    &[
        (1, 159, 240, 0),
        (0, 0, 67, 70),
        (1, 0, 254, 0),
        (1, 0, 252, 0),
    ], // 9E Sharpen
    &[
        (1, 160, 254, 0),
        (0, 0, 33, 70),
        (0, 0, 34, 70),
        (1, 0, 254, 0),
    ], // 9F Conversion
    &[(1, 161, 254, 0), (0, 0, 77, 70), (1, 0, 254, 0)],             // A0 TriAttack
    &[(1, 73, 253, 0), (0, 162, 4, 70), (1, 0, 252, 0)],             // A1 SuperFang
    &[(0, 163, 15, 6)],                                              // A2 Slash
    &[(1, 164, 244, 0), (0, 0, 71, 8), (1, 0, 217, 0)],              // A3 Substitute
    &[(0, 1, 1, 8)],                                                 // A4 Struggle
    &[(1, 0, 220, 0)],                                               // A5 ShowPic
    &[(1, 0, 221, 0)],                                               // A6 EnemyFlash
    &[(1, 0, 245, 0)],                                               // A7 PlayerFlash
    &[(1, 0, 228, 0)],                                               // A8 EnemyHUDShake
    &[(0, 0, 72, 134)],                                              // A9 TradeBallDrop
    &[(0, 0, 73, 132)],                                              // AA TradeBallAppear1
    &[(0, 0, 74, 134)],                                              // AB TradeBallAppear2
    &[(0, 0, 75, 134)],                                              // AC TradeBallPoof
    &[(1, 0, 240, 0), (1, 0, 226, 0), (1, 0, 252, 0)],               // AD XStatItem
    &[(1, 0, 240, 0), (1, 0, 226, 0), (1, 0, 252, 0)],               // AE XStatItem
    &[(1, 0, 240, 0), (0, 0, 67, 70), (1, 0, 252, 0)],               // AF ShrinkingSquare
    &[(1, 0, 240, 0), (0, 0, 67, 70), (1, 0, 252, 0)],               // B0 ShrinkingSquare
    &[(1, 0, 249, 0), (1, 0, 226, 0), (1, 0, 252, 0)],               // B1 XStatItemBlack
    &[(1, 0, 249, 0), (1, 0, 226, 0), (1, 0, 252, 0)],               // B2 XStatItemBlack
    &[(1, 0, 249, 0), (0, 0, 67, 70), (1, 0, 252, 0)],               // B3 ShrinkingSquareBlack
    &[(1, 0, 249, 0), (0, 0, 67, 70), (1, 0, 252, 0)],               // B4 ShrinkingSquareBlack
    &[(1, 0, 240, 0), (1, 0, 236, 0), (1, 0, 252, 0)],               // B5 Unused
    &[(1, 0, 240, 0), (1, 0, 236, 0), (1, 0, 252, 0)],               // B6 Unused
    &[(0, 20, 36, 4), (0, 20, 36, 4)],                               // B7 Paralyze
    &[(0, 20, 36, 4), (0, 20, 36, 4)],                               // B8 Paralyze
    &[(0, 20, 39, 8), (0, 20, 39, 8)],                               // B9 Poison
    &[(0, 20, 39, 8), (0, 20, 39, 8)],                               // BA Poison
    &[(0, 156, 58, 16), (0, 156, 58, 16)],                           // BB SleepPlayer
    &[(0, 156, 59, 16), (0, 156, 59, 16)],                           // BC SleepEnemy
    &[(0, 133, 37, 8), (0, 133, 37, 8)],                             // BD ConfusedPlayer
    &[(0, 133, 38, 8), (0, 133, 38, 8)],                             // BE ConfusedEnemy
    &[(1, 91, 246, 0)],                                              // BF SlideDown
    &[(0, 0, 6, 3)],                                                 // C0 BallToss
    &[(0, 0, 9, 4)],                                                 // C1 BallShake
    &[(0, 0, 10, 4)],                                                // C2 BallPoof
    &[(0, 0, 11, 3)],                                                // C3 BallBlock
    &[(0, 0, 7, 3)],                                                 // C4 GreatToss
    &[(0, 0, 8, 2)],                                                 // C5 UltraToss
    &[(1, 0, 251, 0)],                                               // C6 ShakeScreen
    &[(1, 0, 223, 0)],                                               // C7 HidePic
    &[(0, 140, 83, 3)],                                              // C8 ThrowRock
    &[(0, 140, 84, 3)],                                              // C9 ThrowBait
    &[(1, 0, 216, 0)],                                               // CA ZigZagScreen
];

// ─── Per-animation-id frame hooks ────────────────────────────────────
// The hook runs after each drawn frame block, keyed by the animation id
// (1-based, i.e. MOVE_ANIM_DATA index + 1).

/// (animation id, hook) pairs — all 24 entries, in table order.
pub static ANIMATION_ID_HOOKS: [(u8, FrameHook); 24] = [
    (0x05, FrameHook::FlashScreen),           // MEGA_PUNCH
    (0x0C, FrameHook::FlashScreen),           // GUILLOTINE
    (0x19, FrameHook::FlashScreen),           // MEGA_KICK
    (0x1D, FrameHook::FlashScreen),           // HEADBUTT
    (0x27, FrameHook::TailWhipUnused),        // TAIL_WHIP
    (0x2D, FrameHook::Growl),                 // GROWL
    (0x32, FrameHook::FlashScreen),           // DISABLE
    (0x3B, FrameHook::BlizzardFlash),         // BLIZZARD
    (0x3D, FrameHook::FlashScreen),           // BUBBLEBEAM
    (0x3F, FrameHook::FlashScreenEveryFour),  // HYPER_BEAM
    (0x55, FrameHook::FlashScreenEveryEight), // THUNDERBOLT
    (0x73, FrameHook::FlashScreen),           // REFLECT
    (0x78, FrameHook::Explode),               // SELFDESTRUCT
    (0x93, FrameHook::FlashScreen),           // SPORE
    (0x99, FrameHook::Explode),               // EXPLOSION
    (0x9D, FrameHook::RockSlide),             // ROCK_SLIDE
    (0xAA, FrameHook::TradeHideMonster),      // TRADE_BALL_DROP_ANIM
    (0xAB, FrameHook::TradeShakeBall),        // TRADE_BALL_SHAKE_ANIM
    (0xAC, FrameHook::TradeJumpBall),         // TRADE_BALL_TILT_ANIM
    (0xC1, FrameHook::BallToss),              // TOSS_ANIM
    (0xC2, FrameHook::BallShake),             // SHAKE_ANIM
    (0xC3, FrameHook::BallPoof),              // POOF_ANIM
    (0xC5, FrameHook::BallToss),              // GREATTOSS_ANIM
    (0xC6, FrameHook::BallToss),              // ULTRATOSS_ANIM
];

/// Look up the per-frame hook for a 1-based animation id.
pub fn get_frame_hook(animation_id: u8) -> Option<FrameHook> {
    ANIMATION_ID_HOOKS
        .iter()
        .find(|&&(id, _)| id == animation_id)
        .map(|&(_, hook)| hook)
}

// ─── Tests ──────────────────────────────────────────────────────────

#[cfg(test)]
mod tests {
    use super::*;

    // === Data table size verification ===

    #[test]
    fn base_coords_count() {
        assert_eq!(BASE_COORDS.len(), NUM_BASECOORDS, "BASE_COORDS should have {} entries", NUM_BASECOORDS);
        assert_eq!(NUM_BASECOORDS, 177, "NUM_BASECOORDS should be 177");
    }

    #[test]
    fn frame_block_data_count() {
        assert_eq!(FRAME_BLOCK_DATA.len(), NUM_FRAMEBLOCKS, "FRAME_BLOCK_DATA should have {} entries", NUM_FRAMEBLOCKS);
        assert_eq!(NUM_FRAMEBLOCKS, 122, "NUM_FRAMEBLOCKS should be 122");
    }

    #[test]
    fn subanim_data_count() {
        assert_eq!(SUBANIM_DATA.len(), NUM_SUBANIMS, "SUBANIM_DATA should have {} entries", NUM_SUBANIMS);
        assert_eq!(NUM_SUBANIMS, 86, "NUM_SUBANIMS should be 86");
    }

    #[test]
    fn move_anim_data_count() {
        assert_eq!(MOVE_ANIM_DATA.len(), NUM_MOVE_ANIMS, "MOVE_ANIM_DATA should have {} entries", NUM_MOVE_ANIMS);
        assert_eq!(NUM_MOVE_ANIMS, 203, "NUM_MOVE_ANIMS should be 203");
    }

    // === BASE_COORDS spot checks ===

    #[test]
    fn base_coords_first_entries() {
        // BASECOORD_00: db $10, $68
        assert_eq!(BASE_COORDS[0], (0x10, 0x68));
        // BASECOORD_01: db $10, $70
        assert_eq!(BASE_COORDS[1], (0x10, 0x70));
        // BASECOORD_02: db $10, $78
        assert_eq!(BASE_COORDS[2], (0x10, 0x78));
    }

    #[test]
    fn base_coords_last_entries() {
        // BASECOORD_AF: db $1C, $48
        assert_eq!(BASE_COORDS[0xAF], (0x1C, 0x48));
        // BASECOORD_B0: db $48, $28
        assert_eq!(BASE_COORDS[0xB0], (0x48, 0x28));
    }

    #[test]
    fn base_coords_middle_entries() {
        // BASECOORD_30: db $58, $28
        assert_eq!(BASE_COORDS[0x30], (0x58, 0x28));
        // BASECOORD_50: db $38, $5C
        assert_eq!(BASE_COORDS[0x50], (0x38, 0x5C));
        // BASECOORD_80: db $48, $18
        assert_eq!(BASE_COORDS[0x80], (0x48, 0x18));
    }

    // === FRAME_BLOCK_DATA spot checks ===

    #[test]
    fn frame_block_00_is_empty() {
        assert_eq!(FRAME_BLOCK_DATA[0], &[], "FrameBlock00 should be empty");
    }

    #[test]
    fn frame_block_01_tiles() {
        // FrameBlock01: 3x3 star pattern
        let fb = FRAME_BLOCK_DATA[0x01];
        assert_eq!(fb.len(), 9, "FrameBlock01 should have 9 tiles");
        // First tile: (0, 0, 0x2C, 0x00)
        assert_eq!(fb[0], (0, 0, 0x2C, 0x00));
        // Last tile: (16, 16, 0x2C, 0x60) — offsets are pixel bytes
        assert_eq!(fb[8], (16, 16, 0x2C, 0x60));
    }

    #[test]
    fn frame_block_02_tiles() {
        // FrameBlock02: 4x4 big star
        let fb = FRAME_BLOCK_DATA[0x02];
        assert_eq!(fb.len(), 16, "FrameBlock02 should have 16 tiles");
        assert_eq!(fb[0], (0, 0, 0x20, 0x00));
    }

    #[test]
    fn frame_block_small_black_circle() {
        // FRAMEBLOCK_SMALL_BLACK_CIRCLE = 0x48
        let fb = FRAME_BLOCK_DATA[0x48];
        assert_eq!(fb.len(), 4, "SmallBlackCircle should have 4 tiles");
        assert_eq!(fb[0], (8, 8, 0x33, 0x00));
    }

    #[test]
    fn frame_block_large_black_circle() {
        // FRAMEBLOCK_LARGE_BLACK_CIRCLE = 0x49
        let fb = FRAME_BLOCK_DATA[0x49];
        assert_eq!(fb.len(), 16, "LargeBlackCircle should have 16 tiles");
    }

    // === SUBANIM_DATA spot checks ===

    #[test]
    fn subanim_0_star() {
        // Subanim_0Star: subanim SUBANIMTYPE_HFLIP, 1 / db FRAMEBLOCK_01, BASECOORD_17, FRAMEBLOCKMODE_00
        let (transform, frames) = SUBANIM_DATA[0];
        assert_eq!(transform, 2, "Subanim_0Star should be HFLIP (2)");
        assert_eq!(frames.len(), 1);
        assert_eq!(frames[0], (0x01, 0x17, 0), "Should be FRAMEBLOCK_01, BASECOORD_17, MODE_00");
    }

    #[test]
    fn subanim_0_star_twice() {
        // Subanim_0StarTwice: subanim SUBANIMTYPE_HFLIP, 2
        let (transform, frames) = SUBANIM_DATA[1];
        assert_eq!(transform, 2, "Subanim_0StarTwice should be HFLIP (2)");
        assert_eq!(frames.len(), 2);
        assert_eq!(frames[0], (0x01, 0x0F, 0), "First frame: FRAMEBLOCK_01, BASECOORD_0F, MODE_00");
        assert_eq!(frames[1], (0x01, 0x1D, 0), "Second frame: FRAMEBLOCK_01, BASECOORD_1D, MODE_00");
    }

    #[test]
    fn subanim_0_ball_toss_high() {
        // Subanim_0BallTossHigh: subanim SUBANIMTYPE_NORMAL, 11
        let (transform, frames) = SUBANIM_DATA[0x06];
        assert_eq!(transform, 0, "Subanim_0BallTossHigh should be NORMAL (0)");
        assert_eq!(frames.len(), 11);
        // First frame: FRAMEBLOCK_03, BASECOORD_30, MODE_00
        assert_eq!(frames[0], (0x03, 0x30, 0));
    }

    #[test]
    fn subanim_1_flame_beam() {
        // Subanim_1FlameBeam: subanim SUBANIMTYPE_REVERSE, 5
        let (transform, frames) = SUBANIM_DATA[0x1F];
        assert_eq!(transform, 4, "Subanim_1FlameBeam should be REVERSE (4)");
        assert_eq!(frames.len(), 5);
    }

    #[test]
    fn subanim_0_beam() {
        // Subanim_0Beam: subanim SUBANIMTYPE_HVFLIP, 14
        let (transform, frames) = SUBANIM_DATA[0x2E];
        assert_eq!(transform, 1, "Subanim_0Beam should be HVFLIP (1)");
        assert_eq!(frames.len(), 14);
    }

    // === MOVE_ANIM_DATA spot checks ===

    #[test]
    fn move_anim_pound() {
        // PoundAnim: battle_anim POUND, SUBANIM_0_STAR_TWICE, 0, 8
        let cmds = MOVE_ANIM_DATA[0x00];
        assert_eq!(cmds.len(), 1);
        // (kind=0, sound_id=POUND=1, subanim_id=SUBANIM_0_STAR_TWICE=1, packed=(0<<6)|8=8)
        assert_eq!(cmds[0], (0, 1, 1, 8));
    }

    #[test]
    fn move_anim_karate_chop() {
        // KarateChopAnim: battle_anim KARATE_CHOP, SUBANIM_0_STAR_DESCENDING, 0, 8
        let cmds = MOVE_ANIM_DATA[0x01];
        assert_eq!(cmds.len(), 1);
        // KARATE_CHOP=2, SUBANIM_0_STAR_DESCENDING=3, tileset=0, delay=8
        assert_eq!(cmds[0], (0, 2, 3, 8));
    }

    #[test]
    fn move_anim_double_slap() {
        // DoubleSlapAnim: two commands
        let cmds = MOVE_ANIM_DATA[0x02];
        assert_eq!(cmds.len(), 2);
        // Both: battle_anim DOUBLESLAP, SUBANIM_0_STAR_TWICE, 0, 5
        // DOUBLESLAP=3, SUBANIM_0_STAR_TWICE=1, tileset=0, delay=5
        assert_eq!(cmds[0], (0, 3, 1, 5));
        assert_eq!(cmds[1], (0, 3, 1, 5));
    }

    #[test]
    fn move_anim_thunder_punch() {
        // ThunderPunchAnim: 4 commands with special effects
        let cmds = MOVE_ANIM_DATA[0x08];
        assert_eq!(cmds.len(), 4);
        // battle_anim THUNDERPUNCH, SUBANIM_0_STAR_THRICE, 0, 6
        assert_eq!(cmds[0], (0, 9, 2, 6));
        // battle_anim NO_MOVE, SE_DARK_SCREEN_PALETTE
        assert_eq!(cmds[1], (1, 0, 0xFD, 0));
        // battle_anim NO_MOVE, SUBANIM_1_LIGHTNING, 1, 6
        assert_eq!(cmds[2], (0, 0, 43, 70));
        // battle_anim NO_MOVE, SE_RESET_SCREEN_PALETTE
        assert_eq!(cmds[3], (1, 0, 0xFC, 0));
    }

    #[test]
    fn move_anim_tackle() {
        // TackleAnim: battle_anim LEECH_SEED, SE_MOVE_MON_HORIZONTALLY / battle_anim NO_MOVE, SE_RESET_MON_POSITION
        let cmds = MOVE_ANIM_DATA[0x20];
        assert_eq!(cmds.len(), 2);
        // LEECH_SEED=73, SE_MOVE_MON_HORIZONTALLY=0xF2=242
        assert_eq!(cmds[0], (1, 73, 242, 0));
        // NO_MOVE=0, SE_RESET_MON_POSITION=0xF1=241
        assert_eq!(cmds[1], (1, 0, 241, 0));
    }

    #[test]
    fn move_anim_last_entry() {
        // ZigZagScreenAnim: battle_anim NO_MOVE, SE_WAVY_SCREEN
        let cmds = MOVE_ANIM_DATA[0xCA];
        assert_eq!(cmds.len(), 1);
        // NO_MOVE=0, SE_WAVY_SCREEN=0xD8=216
        assert_eq!(cmds[0], (1, 0, 216, 0));
    }

    // === Encoding/decoding verification ===

    #[test]
    fn subanim_command_encoding() {
        // Verify SubAnim command encoding: (kind=0, sound_id, subanim_id, packed)
        // packed = (tileset << 6) | delay
        let cmd = MOVE_ANIM_DATA[0x00][0]; // Pound
        let (kind, sound_id, subanim_id, packed) = cmd;
        assert_eq!(kind, 0, "Should be SubAnim command");
        assert_eq!(sound_id, 1, "POUND sound_id");
        assert_eq!(subanim_id, 1, "SUBANIM_0_STAR_TWICE");
        assert_eq!(packed >> 6, 0, "tileset should be 0");
        assert_eq!(packed & 0x3F, 8, "delay should be 8");
    }

    #[test]
    fn effect_command_encoding() {
        // Verify Effect command encoding: (kind=1, sound_id, effect_id, 0)
        let cmd = MOVE_ANIM_DATA[0x20][0]; // Tackle first command
        let (kind, sound_id, effect_id, extra) = cmd;
        assert_eq!(kind, 1, "Should be Effect command");
        assert_eq!(sound_id, 73, "LEech_SEED sound_id");
        assert_eq!(effect_id, 242, "SE_MOVE_MON_HORIZONTALLY");
        assert_eq!(extra, 0, "Extra byte should be 0");
    }

    #[test]
    fn tileset_delay_packing() {
        // Verify tileset/delay packing for MegaPunch: tileset=1, delay=6
        let cmd = MOVE_ANIM_DATA[0x04][0]; // MegaPunch
        let (_, _, _, packed) = cmd;
        assert_eq!(packed >> 6, 1, "tileset should be 1");
        assert_eq!(packed & 0x3F, 6, "delay should be 6");
        assert_eq!(packed, (1 << 6) | 6, "packed should be 70");
    }

    // === Subanimation transform type verification ===

    #[test]
    fn subanim_transform_types() {
        // Verify transform type values match SUBANIMTYPE_* constants
        assert_eq!(SUBANIM_DATA[0x06].0, 0, "BallTossHigh should be NORMAL (0)");
        assert_eq!(SUBANIM_DATA[0x0A].0, 2, "BallPoofEnemy should be HFLIP (2)");
        assert_eq!(SUBANIM_DATA[0x12].0, 3, "Heart_Music should be COORDFLIP (3)");
        assert_eq!(SUBANIM_DATA[0x10].0, 4, "Tornado should be REVERSE (4)");
        assert_eq!(SUBANIM_DATA[0x18].0, 5, "SwordsCircling should be ENEMY (5)");
    }

    // === Frame block mode verification ===

    #[test]
    fn frame_block_modes() {
        // Verify frame block modes in subanimations
        // Subanim_0BallShakeEnemy uses MODE_04
        let (_, frames) = SUBANIM_DATA[0x09];
        for &(_, _, mode) in frames {
            assert_eq!(mode, 4, "BallShakeEnemy frames should use MODE_04");
        }
    }

    // === Special effect ID verification ===

    #[test]
    fn special_effect_ids() {
        // Verify special effect IDs match SE_* constants
        // SE_WAVY_SCREEN = 0xD8 = 216
        assert_eq!(MOVE_ANIM_DATA[0xCA][0].2, 0xD8, "ZigZagScreen should use SE_WAVY_SCREEN");
        // SE_SHAKE_SCREEN = 0xFB = 251
        assert_eq!(MOVE_ANIM_DATA[0x58][0].2, 0xFB, "Earthquake should use SE_SHAKE_SCREEN");
        // SE_DARK_SCREEN_FLASH = 0xFE = 254
        assert_eq!(MOVE_ANIM_DATA[0x0E][0].2, 0xFE, "Cut should use SE_DARK_SCREEN_FLASH");
    }

    // === Comprehensive data integrity checks ===

    #[test]
    fn all_subanim_frames_valid() {
        // Verify all subanimation frames reference valid frame blocks and base coords
        for (i, &(transform, frames)) in SUBANIM_DATA.iter().enumerate() {
            assert!(transform <= 5, "Subanim {}: transform {} out of range", i, transform);
            for (j, &(fb_id, bc_id, mode)) in frames.iter().enumerate() {
                assert!((fb_id as usize) < NUM_FRAMEBLOCKS,
                    "Subanim {} frame {}: frame_block_id {} out of range", i, j, fb_id);
                assert!((bc_id as usize) < NUM_BASECOORDS,
                    "Subanim {} frame {}: base_coord_id {} out of range", i, j, bc_id);
                assert!(mode <= 4, "Subanim {} frame {}: mode {} out of range", i, j, mode);
            }
        }
    }

    #[test]
    fn all_move_anim_commands_valid() {
        // Verify all move animation commands have valid encoding
        for (i, cmds) in MOVE_ANIM_DATA.iter().enumerate() {
            for (j, &(kind, a, b, c)) in cmds.iter().enumerate() {
                assert!(kind <= 1, "Move {} cmd {}: kind {} out of range", i, j, kind);
                if kind == 0 {
                    // SubAnim: verify subanim_id is valid
                    assert!((b as usize) < NUM_SUBANIMS,
                        "Move {} cmd {}: subanim_id {} out of range", i, j, b);
                    // Verify tileset is 0, 1, or 2 (trade animations use tileset 2)
                    let tileset = c >> 6;
                    assert!(tileset <= 2, "Move {} cmd {}: tileset {} out of range", i, j, tileset);
                } else {
                    // Effect: verify effect_id is in SE range
                    assert!(b >= 0xD8, "Move {} cmd {}: effect_id {} below SE range", i, j, b);
                    assert!(b <= 0xFE, "Move {} cmd {}: effect_id {} above SE range", i, j, b);
                    assert_eq!(c, 0, "Move {} cmd {}: extra byte should be 0", i, j);
                }
            }
        }
    }
}