fix entity lump extraction

Author: wyozi

src/bin/bsp.rs

@@ -67,6 +67,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             println!("map version = {}", bsp_reader.header().version);
             println!("map revision = {}", bsp_reader.header().map_revision);
 
+            println!("===");
+
+            for (i, lump) in bsp_reader.header().lumps.iter().enumerate() {
+                println!(
+                    "lump #{i}: off={} len={} ident={:?}",
+                    lump.off, lump.len, lump.ident
+                );
+            }
+
             Ok(())
         }
         SubCommand::ListPackedFiles(t) => {
@@ -106,8 +115,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                     .to_owned()
             });
 
-            // generate lump file
+            // create a new slice where worldspawn (i.e. entity number one) is kept in the entity lump
+            let mut slice = bsp.lump_slice(LumpIndex::LUMP_ENTITIES);
+            let brace_pos = slice.iter().position(|b| *b == b'}');
+            let new_slice = match brace_pos {
+                Some(p) => slice[0..p + 1].to_owned(),
+                None => Vec::new(),
+            };
 
+            // generate extracted lump file
             let lump_header = &bsp.header.lumps[LumpIndex::LUMP_ENTITIES as usize];
             let lump_file = File::create(lump_output)?;
             let mut lump_writer = BufWriter::new(lump_file);
@@ -118,13 +134,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             lump_writer.write_u32::<LittleEndian>(lump_header.len)?; // lumpLength
             lump_writer.write_u32::<LittleEndian>(bsp.header.map_revision)?; // mapRevision
 
-            io::copy(
-                &mut bsp.lump_slice(LumpIndex::LUMP_ENTITIES),
-                &mut lump_writer,
-            )?;
+            io::copy(&mut slice, &mut lump_writer)?;
 
-            // remove entity lump from input bsp
-            bsp.replace_lump(LumpIndex::LUMP_ENTITIES, &[]);
+            // replace bsp entity lump with a stripped one
+            bsp.replace_lump(LumpIndex::LUMP_ENTITIES, &new_slice);
 
             let lump_file = File::create(t.output)?;
             let mut lump_writer = BufWriter::new(lump_file);

src/bsp/buffered_bsp.rs

@@ -2,7 +2,7 @@ use std::io::Write;
 
 use byteorder::{LittleEndian, WriteBytesExt};
 
-use super::{lump_indices::LumpIndex, BSPHeader, BSP_LUMP_COUNT};
+use super::{lump_indices::LumpIndex, BSPHeader, BSP_HEADER_LEN, BSP_LUMP_COUNT};
 
 pub struct BufferedBSP {
     pub header: BSPHeader,
@@ -13,7 +13,8 @@ impl BufferedBSP {
     pub fn lump_slice(&self, lump_index: LumpIndex) -> &[u8] {
         let lump = &self.header.lumps[lump_index as usize];
 
-        &self.data_without_header[lump.off as usize..(lump.off + lump.len) as usize]
+        &self.data_without_header
+            [(lump.off - BSP_HEADER_LEN) as usize..(lump.off + lump.len - BSP_HEADER_LEN) as usize]
     }
 
     pub fn replace_lump(&mut self, lump_index: LumpIndex, new_lump: &[u8]) {
@@ -24,14 +25,15 @@ impl BufferedBSP {
         );
 
         // zero old slice
-        let old_slice =
-            &mut self.data_without_header[lump.off as usize..(lump.off + lump.len) as usize];
+        let old_slice = &mut self.data_without_header
+            [(lump.off - BSP_HEADER_LEN) as usize..(lump.off + lump.len - BSP_HEADER_LEN) as usize];
         for i in old_slice {
             *i = 0;
         }
 
         // set new slice
-        self.data_without_header[lump.off as usize..(lump.off) as usize + new_lump.len()]
+        self.data_without_header[(lump.off - BSP_HEADER_LEN) as usize
+            ..(lump.off - BSP_HEADER_LEN) as usize + new_lump.len()]
             .copy_from_slice(new_lump);
 
         // set length in header
@@ -46,7 +48,7 @@ impl BufferedBSP {
             writer.write_u32::<LittleEndian>(self.header.lumps[i].off)?;
             writer.write_u32::<LittleEndian>(self.header.lumps[i].len)?;
             writer.write_u32::<LittleEndian>(self.header.lumps[i].version)?;
-            writer.write_u32::<LittleEndian>(self.header.lumps[i].ident)?;
+            writer.write_all(&self.header.lumps[i].ident)?;
         }
 
         writer.write_u32::<LittleEndian>(self.header.map_revision)?;

src/bsp/mod.rs

@@ -17,7 +17,7 @@ pub struct Lump {
     pub off: u32,
     pub len: u32,
     pub version: u32,
-    pub ident: u32,
+    pub ident: [u8; 4],
 }
 
 pub struct BSPHeader {
@@ -52,13 +52,15 @@ impl<R: Read> BSPReader<R> {
             let off = reader.read_u32::<LittleEndian>()?;
             let len = reader.read_u32::<LittleEndian>()?;
             let vers = reader.read_u32::<LittleEndian>()?;
-            let ident = reader.read_u32::<LittleEndian>()?;
+
+            let mut ident_buf = [0; 4];
+            reader.read_exact(&mut ident_buf)?;
 
             lumps[i] = Lump {
                 off: off,
                 len: len,
                 version: vers,
-                ident: ident,
+                ident: ident_buf,
             };
         }
         let map_revision = reader.read_u32::<LittleEndian>()?;