src/lumps/lump.rs

@@ -11,4 +11,5 @@ pub enum LumpType {
     Unknown,
     Vertex,
     Linedef,
+    Sidedef,
 }

src/lumps/mod.rs

@@ -1,8 +1,9 @@
 mod linedef;
 mod lump;
+mod sidedef;
 mod vertex;
 
 pub use linedef::LinedefLump;
-pub use lump::Lump;
+pub use lump::{Lump, LumpType};
-pub use lump::LumpType;
+pub use sidedef::SidedefLump;
 pub use vertex::VertexLump;

src/lumps/sidedef.rs

@@ -0,0 +1,19 @@
+use crate::types::Sidedef;
+
+pub struct SidedefLump {
+    pub sidedefs: Vec<Sidedef>,
+}
+
+impl SidedefLump {
+    pub fn get_num_sidedefs(&self) -> usize {
+        self.sidedefs.len()
+    }
+
+    pub fn get_all_sidedefs(&self) -> Vec<Sidedef> {
+        self.sidedefs.to_vec()
+    }
+
+    pub fn get_sidedef(&self, pos: usize) -> Sidedef {
+        self.sidedefs[pos].to_owned()
+    }
+}

src/tests/wad.rs

@@ -147,3 +147,49 @@ pub fn get_num_linedefs() {
 
     assert_eq!(linedef_lump.get_num_linedefs(), 475);
 }
+
+#[test]
+pub fn read_first_sidedef() {
+    use crate::types::Sidedef;
+
+    let wad_file = get_wad();
+
+    let sidedef_lump = wad_file.get_sidedef_lump(&wad_file.directory[9]);
+
+    let correct_sidedef = Sidedef {
+        x_offset: 0,
+        y_offset: 0,
+        upper_texture: String::from("-"),
+        lower_texture: String::from("-"),
+        middle_texture: String::from("DOOR3"),
+        sector: 40,
+    };
+
+    assert_eq!(sidedef_lump.get_sidedef(0), correct_sidedef);
+}
+
+#[test]
+pub fn get_num_sidedef_lumps() {
+    use crate::lumps::{Lump, LumpType};
+
+    let mut sidedef_lumps: Vec<Lump> = Vec::new();
+
+    let wad_file = get_wad();
+
+    for entry in 0..wad_file.num_lumps as usize {
+        if let LumpType::Sidedef = wad_file.directory[entry].lump_type {
+            sidedef_lumps.push(wad_file.directory[entry].to_owned());
+        }
+    }
+
+    assert_eq!(sidedef_lumps.len(), 9);
+}
+
+#[test]
+pub fn get_num_sidedefs() {
+    let wad_file = get_wad();
+
+    let sidedef_lump = wad_file.get_sidedef_lump(&wad_file.directory[9]);
+
+    assert_eq!(sidedef_lump.get_num_sidedefs(), 648);
+}

src/types/mod.rs

@@ -1,5 +1,7 @@
 mod linedef;
+mod sidedef;
 mod vertex;
 
 pub use linedef::Linedef;
+pub use sidedef::Sidedef;
 pub use vertex::Vertex;

src/types/sidedef.rs

@@ -0,0 +1,9 @@
+#[derive(Clone, Debug, PartialEq)]
+pub struct Sidedef {
+    pub x_offset: i16,
+    pub y_offset: i16,
+    pub upper_texture: String,
+    pub lower_texture: String,
+    pub middle_texture: String,
+    pub sector: i16,
+}

src/wad/wadfile.rs

@@ -44,6 +44,7 @@ impl WADFile {
             let lump_type = match name.as_str() {
                 "VERTEXES" => LumpType::Vertex,
                 "LINEDEFS" => LumpType::Linedef,
+                "SIDEDEFS" => LumpType::Sidedef,
                 _ => LumpType::Unknown,
             };
             lump_dir.push(Lump {

src/wad/wadfile/readers.rs

@@ -1,5 +1,6 @@
-use crate::lumps::{LinedefLump, Lump, VertexLump};
+use crate::lumps::{LinedefLump, Lump, SidedefLump, VertexLump};
-use crate::types::{Linedef, Vertex};
+use crate::types::{Linedef, Sidedef, Vertex};
+use crate::utils::read_ascii;
 use crate::wad::WADFile;
 use crate::wad::wadfile::read_i16_le;
 
@@ -55,4 +56,33 @@ impl WADFile {
 
         LinedefLump { linedefs }
     }
+
+    pub fn get_sidedef_lump(&self, lump: &Lump) -> SidedefLump {
+        let lump_offset = lump.offset as usize;
+        let lump_size = lump.size as usize;
+        let lump_data = &self.data[lump_offset..lump_offset + lump_size];
+        let lump_entires = lump_size / 30;
+        let mut sidedefs: Vec<Sidedef> = Vec::with_capacity(lump_entires);
+
+        for entry in 0..lump_entires {
+            let startpos = entry * 30;
+            let x_offset = read_i16_le(&lump_data[startpos..startpos + 2]);
+            let y_offset = read_i16_le(&lump_data[startpos + 2..startpos + 4]);
+            let upper_texture = read_ascii(&lump_data[startpos + 4..startpos + 12]);
+            let lower_texture = read_ascii(&lump_data[startpos + 12..startpos + 20]);
+            let middle_texture = read_ascii(&lump_data[startpos + 20..startpos + 28]);
+            let sector = read_i16_le(&lump_data[startpos + 28..startpos + 30]);
+
+            sidedefs.push(Sidedef {
+                x_offset,
+                y_offset,
+                upper_texture,
+                lower_texture,
+                middle_texture,
+                sector,
+            });
+        }
+
+        SidedefLump { sidedefs }
+    }
 }