src/lumps/lump.rs

@@ -13,4 +13,5 @@ pub enum LumpType {
     Linedef,
     Sidedef,
     Thing,
+    Seg,
 }

src/lumps/mod.rs

@@ -1,11 +1,13 @@
 mod linedef;
 mod lump;
+mod seg;
 mod sidedef;
 mod thing;
 mod vertex;
 
 pub use linedef::LinedefLump;
 pub use lump::{Lump, LumpType};
+pub use seg::SegLump;
 pub use sidedef::SidedefLump;
 pub use thing::ThingLump;
 pub use vertex::VertexLump;

src/lumps/seg.rs

@@ -0,0 +1,19 @@
+use crate::types::Seg;
+
+pub struct SegLump {
+    pub segs: Vec<Seg>,
+}
+
+impl SegLump {
+    pub fn get_num_segs(&self) -> usize {
+        self.segs.len()
+    }
+
+    pub fn get_all_segs(&self) -> Vec<Seg> {
+        self.segs.to_vec()
+    }
+
+    pub fn get_seg(&self, pos: usize) -> Seg {
+        self.segs[pos].to_owned()
+    }
+}

src/tests/wad.rs

@@ -238,3 +238,49 @@ pub fn get_num_things() {
 
     assert_eq!(thing_lump.get_num_things(), 138);
 }
+
+#[test]
+pub fn read_first_seg() {
+    use crate::types::Seg;
+
+    let wad_file = get_wad();
+
+    let seg_lump = wad_file.get_seg_lump(&wad_file.directory[11]);
+
+    let correct_seg = Seg {
+        start_vertex: 123,
+        end_vertex: 124,
+        angle: 16384,
+        linedef: 152,
+        direction: 0,
+        offset: 0,
+    };
+
+    assert_eq!(seg_lump.get_seg(0), correct_seg);
+}
+
+#[test]
+pub fn get_num_seg_lumps() {
+    use crate::lumps::{Lump, LumpType};
+
+    let mut seg_lumps: Vec<Lump> = Vec::new();
+
+    let wad_file = get_wad();
+
+    for entry in 0..wad_file.num_lumps as usize {
+        if let LumpType::Seg = wad_file.directory[entry].lump_type {
+            seg_lumps.push(wad_file.directory[entry].to_owned());
+        }
+    }
+
+    assert_eq!(seg_lumps.len(), 9);
+}
+
+#[test]
+pub fn get_num_segs() {
+    let wad_file = get_wad();
+
+    let thing_lump = wad_file.get_seg_lump(&wad_file.directory[11]);
+
+    assert_eq!(thing_lump.get_num_segs(), 732);
+}

src/types/mod.rs

@@ -1,9 +1,11 @@
 mod linedef;
+mod seg;
 mod sidedef;
 mod thing;
 mod vertex;
 
 pub use linedef::Linedef;
+pub use seg::Seg;
 pub use sidedef::Sidedef;
 pub use thing::Thing;
 pub use vertex::Vertex;

src/types/seg.rs

@@ -0,0 +1,9 @@
+#[derive(Clone, Debug, PartialEq)]
+pub struct Seg {
+    pub start_vertex: i16,
+    pub end_vertex: i16,
+    pub angle: i16,
+    pub linedef: i16,
+    pub direction: i16,
+    pub offset: i16,
+}

src/wad/wadfile.rs

@@ -46,6 +46,7 @@ impl WADFile {
                 "LINEDEFS" => LumpType::Linedef,
                 "SIDEDEFS" => LumpType::Sidedef,
                 "THINGS" => LumpType::Thing,
+                "SEGS" => LumpType::Seg,
                 _ => LumpType::Unknown,
             };
             lump_dir.push(Lump {

src/wad/wadfile/readers.rs

@@ -1,5 +1,5 @@
-use crate::lumps::{LinedefLump, Lump, SidedefLump, ThingLump, VertexLump};
+use crate::lumps::{LinedefLump, Lump, SegLump, SidedefLump, ThingLump, VertexLump};
-use crate::types::{Linedef, Sidedef, Thing, Vertex};
+use crate::types::{Linedef, Seg, Sidedef, Thing, Vertex};
 use crate::utils::read_ascii;
 use crate::wad::WADFile;
 use crate::wad::wadfile::read_i16_le;
@@ -112,4 +112,32 @@ impl WADFile {
 
         ThingLump { things }
     }
+
+    pub fn get_seg_lump(&self, lump: &Lump) -> SegLump {
+        let lump_offset = lump.offset as usize;
+        let lump_size = lump.size as usize;
+        let lump_entries = lump_size / 12;
+        let mut segs: Vec<Seg> = Vec::with_capacity(lump_entries);
+
+        for entry in 0..lump_entries {
+            let startpos = (entry * 12) + lump_offset;
+            let start_vertex = read_i16_le(&self.data[startpos..startpos + 2]);
+            let end_vertex = read_i16_le(&self.data[startpos + 2..startpos + 4]);
+            let angle = read_i16_le(&self.data[startpos + 4..startpos + 6]);
+            let linedef = read_i16_le(&self.data[startpos + 6..startpos + 8]);
+            let direction = read_i16_le(&self.data[startpos + 8..startpos + 10]);
+            let offset = read_i16_le(&self.data[startpos + 10..startpos + 12]);
+
+            segs.push(Seg {
+                start_vertex,
+                end_vertex,
+                angle,
+                linedef,
+                direction,
+                offset,
+            });
+        }
+
+        SegLump { segs }
+    }
 }