header should be there i think

.gitignore

···
 /target
 /LegallyObtainedRom.gb
+/OtherLegallyObtainedRom.gb
 .idea/

src/enums.rs

···
+pub enum CartridgeHeaderAddress {
+    // Whole Header
+    CartridgeHeaderStart = 0x0100,
+    CartridgeHeaderEnd = 0x014F,
+    // 0100-0103 — Entry point
+    EntryPointEnd = 0x0103,
+    // 0104-0133 — Nintendo logo
+    NintendoLogoStart = 0x0104,
+    NintendoLogoEnd = 0x00133,
+    // 0134-0143 — Title
+    TitleStart = 0x0134,
+    TitleEnd = 0x0143,
+    // 013F-0142 — Manufacturer code
+    ManufacturerCodeStart = 0x013F,
+    ManufacturerCodeEnd = 0x0142,
+    // 0144–0145 — New licensee code
+    NewLicenseStart = 0x0144,
+    NewLicenseEnd = 0x0145,
+    // 0146 — SGB flag
+    SgbFlag = 0x0146,
+    // 0147 — Cartridge type
+    CartType = 0x0147,
+    // 0148 — ROM size
+    RomSize = 0x0148,
+    // 0149 - RAM Size,
+    RamSize = 0x0149,
+    // 014A — Destination code
+    DestinationCode = 0x014A,
+    // 014B — Old licensee code
+    OldLicenseeCode = 0x014b,
+    // 014C — Mask ROM version number,
+    MaskRomVersion = 0x014C,
+    // 014D — Header checksum
+    HeaderChecksum = 0x014D,
+    // 014E-014F — Global checksum
+    GlobalChecksumStart = 0x014E,
+    //End is the end of cartheader
+}
+
+pub enum Error {
+    CartridgeReadError,
+    //Nintendo logos do not match
+    NotAValidRom,
+}
+
+pub enum DestinationCode {
+    Japan = 0x00,
+    NotJapan = 0x01,
+}
+
+impl DestinationCode {
+    pub fn from_byte(byte: u8) -> Self {
+        match byte {
+            0x00 => Self::Japan,
+            0x01 | _ => Self::NotJapan,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum RamSize {
+    NoRAM = 0x000,
+    Unused = 0x001,
+    Ram8KiB = 0x002,
+    Ram32KiB = 0x003,
+    Ram128KiB = 0x004,
+    Ram64KiB = 0x005,
+}
+
+impl RamSize {
+    pub fn from_byte(byte: u8) -> Self {
+        match byte {
+            0x001 => Self::Unused,
+            0x002 => Self::Ram8KiB,
+            0x003 => Self::Ram32KiB,
+            0x004 => Self::Ram128KiB,
+            0x005 => Self::Ram64KiB,
+            _ => Self::NoRAM,
+        }
+    }
+}
+#[derive(Debug)]
+pub enum CartridgeType {
+    RomOnly = 0x000,
+    MBC1 = 0x001,
+    Mbc1Ram = 0x002,
+    Mbc1RamBattery = 0x003,
+    MBC2 = 0x005,
+    Mbc2Battery = 0x006,
+    RomRam9 = 0x008,
+    RomRamBattery9 = 0x009,
+    MMM01 = 0x00B,
+    Mmm01Ram = 0x00C,
+    Mmm01RamBattery = 0x00D,
+    Mbc3TimerBattery = 0x00F,
+    Mbc3TimerRamBattery10 = 0x010,
+    MBC3 = 0x011,
+    Mbc3Ram10 = 0x012,
+    Mbc3RaBattery10 = 0x013,
+    MBC5 = 0x019,
+    Mbc5Ram = 0x01A,
+    Mbc5RamBattery = 0x01B,
+    Mbc5Rumble = 0x01C,
+    Mbc5RumbleRam = 0x01D,
+    Mbc5RumbleRamBattery = 0x01E,
+    MBC6 = 0x020,
+    Mbc7SensorRumbleRamBattery = 0x022,
+    PocketCamera = 0x0FC,
+    BandaiTama5 = 0x0FD,
+    HuC3 = 0x0FE,
+    HuC1RamBattery = 0x0FF,
+}
+
+impl CartridgeType {
+    pub fn from_byte(byte: u8) -> Self {
+        match byte {
+            0x001 => Self::MBC1,
+            0x002 => Self::Mbc1Ram,
+            0x003 => Self::Mbc1RamBattery,
+            0x005 => Self::MBC2,
+            0x006 => Self::Mbc2Battery,
+            0x008 => Self::RomRam9,
+            0x009 => Self::RomRamBattery9,
+            0x00B => Self::MMM01,
+            0x00C => Self::Mmm01Ram,
+            0x00D => Self::Mmm01RamBattery,
+            0x00F => Self::Mbc3TimerBattery,
+            0x010 => Self::Mbc3TimerRamBattery10,
+            0x011 => Self::MBC3,
+            0x012 => Self::Mbc3Ram10,
+            0x013 => Self::Mbc3RaBattery10,
+            0x019 => Self::MBC5,
+            0x01A => Self::Mbc5Ram,
+            0x01B => Self::Mbc5RamBattery,
+            0x01C => Self::Mbc5Rumble,
+            0x01D => Self::Mbc5RumbleRam,
+            0x01E => Self::Mbc5RumbleRamBattery,
+            0x020 => Self::MBC6,
+            0x022 => Self::Mbc7SensorRumbleRamBattery,
+            0x0FC => Self::PocketCamera,
+            0x0FD => Self::BandaiTama5,
+            0x0FE => Self::HuC3,
+            0x0FF => Self::HuC1RamBattery,
+            0x000 | _ => Self::RomOnly,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum RomSize {
+    Rom32KiB = 0x000,
+    Rom64KiB = 0x001,
+    Rom128KiB = 0x002,
+    Rom256KiB = 0x003,
+    Rom512KiB = 0x004,
+    Rom1MiB = 0x005,
+    Rom2MiB = 0x006,
+    Rom4MiB = 0x007,
+    Rom8MiB = 0x008,
+    Rom1_1MiB = 0x052,
+    Rom1_2MiB = 0x053,
+    Rom1_5MiB = 0x054,
+}
+
+impl RomSize {
+    pub fn from_byte(byte: u8) -> Self {
+        match byte {
+            0x001 => Self::Rom64KiB,
+            0x002 => Self::Rom128KiB,
+            0x003 => Self::Rom256KiB,
+            0x004 => Self::Rom512KiB,
+            0x005 => Self::Rom1MiB,
+            0x006 => Self::Rom2MiB,
+            0x007 => Self::Rom4MiB,
+            0x008 => Self::Rom8MiB,
+            0x052 => Self::Rom1_1MiB,
+            0x053 => Self::Rom1_2MiB,
+            0x054 => Self::Rom1_5MiB,
+            0x000 | _ => Self::Rom32KiB,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum CGBFlag {
+    SupportsColorBackwardCompatiable,
+    ColorOnly,
+    NotSet,
+}

src/main.rs

···
+mod enums;
+
+use crate::enums::CartridgeHeaderAddress::OldLicenseeCode;
+use crate::enums::{
+    CGBFlag, CartridgeHeaderAddress, CartridgeType, DestinationCode, Error, RamSize, RomSize,
+};
 use std::fs::File;
-use std::io::{Read, Seek, SeekFrom, Write};
+use std::io::Read;
 
+// https://github.com/ISSOtm/gb-bootroms/blob/2dce25910043ce2ad1d1d3691436f2c7aabbda00/src/dmg.asm#L259-L269
+// Each tile is encoded using 2 (!) bytes
+// The tiles are represented below
+// XX.. .XX. XX.. .... .... .... .... .... .... ...X X... ....
+// XXX. .XX. XX.. .... ..XX .... .... .... .... ...X X... ....
+// XXX. .XX. .... .... .XXX X... .... .... .... ...X X... ....
+// XX.X .XX. XX.X X.XX ..XX ..XX XX.. XX.X X... XXXX X..X XXX.
+// XX.X .XX. XX.X XX.X X.XX .XX. .XX. XXX. XX.X X..X X.XX ..XX
+// XX.. XXX. XX.X X..X X.XX .XXX XXX. XX.. XX.X X..X X.XX ..XX
+// XX.. XXX. XX.X X..X X.XX .XX. .... XX.. XX.X X..X X.XX ..XX
+// XX.. .XX. XX.X X..X X.XX ..XX XXX. XX.. XX.. XXXX X..X XXX.
+const NINTENDO_LOGO: [u8; 48] = [
+    0x0CE, 0x0ED, 0x066, 0x066, 0x0CC, 0x00D, 0x000, 0x00B, 0x003, 0x073, 0x000, 0x083, 0x000,
+    0x00C, 0x000, 0x00D, 0x000, 0x008, 0x011, 0x01F, 0x088, 0x089, 0x000, 0x00E, 0x0DC, 0x0CC,
+    0x06E, 0x0E6, 0x0DD, 0x0DD, 0x0D9, 0x099, 0x0BB, 0x0BB, 0x067, 0x063, 0x06E, 0x00E, 0x0EC,
+    0x0CC, 0x0DD, 0x0DC, 0x099, 0x09F, 0x0BB, 0x0B9, 0x033, 0x03E,
+];
 
+// const ROM_NAME: &str = "OtherLegallyObtainedRom.gb";
 const ROM_NAME: &str = "LegallyObtainedRom.gb";
-
-pub enum Error {
-    CartridgeReadError,
-}
 
 struct CartridgeHeader {
     //Should be 80 bytes (0x014F(335) - 0x0100(256)) + 1 to include the last address
     buffer: [u8; 80],
+    title: [char; 16],
+    manufacturer_code: [char; 4],
+    cgb_flag: CGBFlag,
+    // https://gbdev.io/pandocs/The_Cartridge_Header.html#01440145--new-licensee-code
+    license_code: [char; 2],
+    support_gb: bool,
+    cart_type: CartridgeType,
+    rom_size: RomSize,
+    ram_size: RamSize,
+    old_licensee_code: Option<u8>,
+    destination_code: DestinationCode,
+    version: u8,
+    header_checksum: u8,
+    global_checksum: u16,
 }
 
+impl CartridgeHeader {
+    fn bytes_to_chars<const N: usize>(bytes: &[u8], break_on_null: bool) -> [char; N] {
+        let mut chars = [0x000 as char; N];
+        for (i, byte) in bytes.iter().enumerate() {
+            if break_on_null && *byte == 0x00 {
+                break;
+            }
+            chars[i] = *byte as char;
+        }
+        chars
+    }
 
+    fn parse(rom_bytes: &[u8]) -> Result<Self, Error> {
+        let start = CartridgeHeaderAddress::CartridgeHeaderStart as usize;
+        let end = start + 80;
+        let header_buffer: &[u8] = rom_bytes[start..end]
+            .try_into()
+            .map_err(|_| Error::CartridgeReadError)?;
 
+        //Checks if the Nintendo logo matches the device's version. Early anti piracy feature. Neat to take note of
+        let nintendo_logo_from_rom = &rom_bytes[CartridgeHeaderAddress::NintendoLogoStart as usize
+            ..CartridgeHeaderAddress::NintendoLogoEnd as usize + 1];
+        for (i, true_logo_byte) in NINTENDO_LOGO.iter().enumerate() {
+            let rom_byte = nintendo_logo_from_rom[i];
+            if rom_byte != *true_logo_byte {
+                return Err(Error::CartridgeReadError);
+            }
+        }
 
+        let title = &rom_bytes[CartridgeHeaderAddress::TitleStart as usize
+            ..CartridgeHeaderAddress::TitleEnd as usize + 1];
+        let title_chars = Self::bytes_to_chars::<16>(title, true);
 
+        let manufacturer_code = &rom_bytes[CartridgeHeaderAddress::ManufacturerCodeStart as usize
+            ..CartridgeHeaderAddress::ManufacturerCodeEnd as usize + 1];
+        let man_code_chars = Self::bytes_to_chars::<4>(manufacturer_code, false);
 
-impl CartridgeHeader {
-    fn new(rom_bytes: &[u8] ) -> Result<Self, Error>  {
-        let start = CartridgeHeaderAddress::CartridgeHeaderStart as usize;
-        //We know the header is only 80 chars
-        let end = start + 80;
+        let cgb_flag_byte = rom_bytes[0x0143];
+        let cgb_flag = match cgb_flag_byte {
+            0x80 => CGBFlag::SupportsColorBackwardCompatiable,
+            0xC0 => CGBFlag::ColorOnly,
+            _ => CGBFlag::NotSet,
+        };
+
+        let license_code = &rom_bytes[CartridgeHeaderAddress::NewLicenseStart as usize
+            ..CartridgeHeaderAddress::NewLicenseEnd as usize + 1];
+        let license_code_chars = Self::bytes_to_chars::<2>(license_code, false);
+
+        // https://gbdev.io/pandocs/The_Cartridge_Header.html#0146--sgb-flag
+        let sgb_flag = rom_bytes[CartridgeHeaderAddress::SgbFlag as usize] == 0x03;
+
+        let cart_type =
+            CartridgeType::from_byte(rom_bytes[CartridgeHeaderAddress::CartType as usize]);
+
+        let rom_size = RomSize::from_byte(rom_bytes[CartridgeHeaderAddress::RomSize as usize]);
+        let ram_size = RamSize::from_byte(rom_bytes[CartridgeHeaderAddress::RamSize as usize]);
+
+        let mut old_licensee_code = None;
+        if !sgb_flag {
+            old_licensee_code = Some(rom_bytes[CartridgeHeaderAddress::OldLicenseeCode as usize])
+        }
+
+        let destination_code =
+            DestinationCode::from_byte(rom_bytes[CartridgeHeaderAddress::DestinationCode as usize]);
+
+        let version = rom_bytes[CartridgeHeaderAddress::MaskRomVersion as usize];
+        let header_checksum = rom_bytes[CartridgeHeaderAddress::HeaderChecksum as usize];
+        let global_checksum = u16::from_le_bytes([
+            rom_bytes[CartridgeHeaderAddress::GlobalChecksumStart as usize],
+            rom_bytes[CartridgeHeaderAddress::CartridgeHeaderEnd as usize],
+        ]);
 
         Ok(Self {
-            buffer: rom_bytes[start..end].try_into().map_err(|_| Error::CartridgeReadError)?
+            buffer: header_buffer
+                .try_into()
+                .map_err(|_| Error::CartridgeReadError)?,
+            title: title_chars,
+            manufacturer_code: man_code_chars,
+            cgb_flag,
+            license_code: license_code_chars,
+            support_gb: sgb_flag,
+            cart_type,
+            rom_size,
+            ram_size,
+            old_licensee_code,
+            destination_code,
+            version,
+            header_checksum,
+            global_checksum,
         })
     }
 
···
     }
 }
 
-
-pub enum CartridgeHeaderAddress {
-    CartridgeHeaderStart = 0x0100,
-    CartridgeHeaderEnd = 0x014F
-}
-
-
 fn main() -> std::io::Result<()> {
     let mut rom_file = File::open(ROM_NAME)?;
     let mut rom_buffer: Vec<u8> = Vec::new();
     rom_file.read_to_end(&mut rom_buffer)?;
-    let cart_header = CartridgeHeader::new(&*rom_buffer).map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, "Rom failed to parse"))?;
-    cart_header.print_test();
-    Ok(())
-}
+    let cart_header = match CartridgeHeader::parse(&*rom_buffer) {
+        Ok(header) => header,
+        Err(err) => {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                "Rom failed to parse",
+            ));
+        }
+    };
+    // cart_header.print_test();
 
+    let title: String = String::from_iter(cart_header.title);
+    println!("Title: {}", title);
+    let manufacturer_code = String::from_iter(cart_header.manufacturer_code);
+    println!("Manufacturer Code: {}", manufacturer_code);
 
-fn buffer_from_file(path: &str) -> Vec<u8> {
-    let mut file = std::fs::File::open(path).expect("File not there");
-    let mut buffer = Vec::new();
-    file.read_to_end(&mut buffer).expect("Could not read file");
-    buffer
-}
+    match cart_header.old_licensee_code {
+        Some(code) => println!("Uses Old Licensee Code: {:#X}", code),
+        None => println!(
+            "Uses New Licensee Code: {}",
+            String::from_iter(cart_header.license_code)
+        ),
+    }
+
+    println!("CGB Flag: {:?}", cart_header.cgb_flag);
+    println!("Supports SGB: {:?}", cart_header.support_gb);
+    println!("Cartridge Type: {:?}", cart_header.cart_type);
+    println!("ROM Size: {:?}", cart_header.rom_size);
+    println!("RAM Size: {:?}", cart_header.ram_size);
+    match cart_header.destination_code {
+        DestinationCode::Japan => println!("Destination Code: Japan"),
+        DestinationCode::NotJapan => println!("Destination Code: Not Japan"),
+    }
+    println!("Version: {:?}", cart_header.version);
+    println!("Header Checksum: {:#X}", cart_header.header_checksum);
+    println!("Global Checksum: {:#X}", cart_header.global_checksum);
+
+    Ok(())
+}