some progress in decoding. need to decode all worlds

src/main.rs

@@ -12,5 +12,7 @@ fn main() {
     };*/
     
     let save = Save::load(Path::new(save_path)).expect("load save");
-    dbg!(save);
+    for w in save.worlds {
+        println!("World {:x} size {}", w.offset, w.size);
+    }
 }

src/save.rs

@@ -7,17 +7,18 @@ use inflate::inflate_bytes_zlib;
 
 #[derive(Debug)]
 pub struct World {
-    offset: usize,
+    pub offset: usize,
-    size: usize,
+    pub size: usize,
-    data: Vec<u8>
+    pub data: Vec<u8>
 }
 
 impl World {
     const DATA_OFFSET: usize = 0x13;
 
     fn decode(raw: &[u8], offset: usize, size: usize) -> Result<Self> {
-        let data_offset = offset + World::DATA_OFFSET;
+        let data_start = offset + World::DATA_OFFSET;
-        let data = inflate_bytes_zlib(&raw[data_offset..data_offset+size])
+        let data_end = offset + size;
+        let data = inflate_bytes_zlib(&raw[data_start..data_end])
             .map_err(|e| anyhow!(e))?;
 
         Ok(Self { offset, size, data })
@@ -30,22 +31,26 @@ impl World {
 
 #[derive(Debug)]
 pub struct Save {
-    raw: Vec<u8>,
+    pub raw: Vec<u8>,
-    worlds: Vec<World>
+    pub worlds: Vec<World>
+    //world: World
 }
 
 impl Save {
+    const WORLD_HDR: &str = "<world>";
+    const WORLD_HDR_LEN: usize = Self::WORLD_HDR.len();
+
     pub fn load(path: &Path) -> Result<Self> {
         let raw = fs::read(path)?;
-        let file_end = raw.len() - 1;
+        let file_end = raw.len();
         let mut offsets: Vec<usize> = Vec::new();
-        for i in 0..raw.len()-7 {
+        for i in 0..raw.len()-Self::WORLD_HDR_LEN {
-            let keyword = match str::from_utf8(&raw[i..i+7]) {
+            let keyword = match str::from_utf8(&raw[i..i+Self::WORLD_HDR_LEN]) {
                 Ok(keyword) => keyword,
                 Err(_) => continue
             };
 
-            if keyword == "<world>" {
+            if keyword == Self::WORLD_HDR {
                 offsets.push(i);
             }
         }
@@ -53,13 +58,22 @@ impl Save {
         let mut worlds: Vec<World> = Vec::new();
         for i in offsets.chunks(2) {
             let offset = i[0];
-            let size = i.get(1).unwrap_or(&file_end);
+            let end = i.get(1).unwrap_or(&file_end);
-            match World::decode(&raw, offset, *size) {
+            match World::decode(&raw, offset, *end - offset) {
                 Ok(world) => worlds.push(world),
                 Err(e) => println!("world 0x{:x} decode error {}", offset, e)
             };
         }
 
         Ok(Self { raw, worlds })
+
+        /*let offset = match offsets.last() {
+            Some(offset) => *offset,
+            None => return Err(anyhow!("no world offset found"))
+        };
+        let size = raw.len() - offset;
+        let world = World::decode(&raw, offset, size)?;
+
+        Ok(Self { raw, world })*/
     }
 }