1.4.3

blf_cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "blf_cli"
-version = "1.4.2"
+version = "1.4.3"
 edition = "2021"
 
 [dependencies]

blf_lib-derivable/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "blf_lib-derivable"
 description = "Shared traits used by blf_lib and blf_lib-derive"
-version = "1.4.2"
+version = "1.4.3"
 edition = "2021"
 
 [dependencies]

blf_lib-derive/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "blf_lib-derive"
 description = "Derive macros for blf_lib"
-version = "1.4.2"
+version = "1.4.3"
 edition = "2021"
 
 [lib]

blf_lib-derive/src/macros/blf_chunk.rs

@@ -32,7 +32,7 @@ pub fn blf_chunk_macro(input: TokenStream) -> TokenStream {
     let bytes = signature_string.as_bytes();
     assert_eq!(bytes.len(), 4, "Signature provided with invalid byte length! {signature_string}");
 
-    // let test_size_tokens: TokenStream2 = if size_attribute.is_some() { test_size_macro(tokens.clone()).into() } else { quote! {} };
+    let test_size_tokens: TokenStream2 = if size_attribute.is_some() { test_size_macro(tokens.clone()).into() } else { quote! {} };
 
     match input.data {
         Data::Struct(_s) => {
@@ -61,4 +61,4 @@ pub fn blf_chunk_macro(input: TokenStream) -> TokenStream {
         }
         _ => { panic!("#[derive(BlfChunk)] is only defined for structs!")}
     }.into()
-}
+}

blf_lib-derive/src/macros/test_size.rs

@@ -21,7 +21,15 @@ pub fn test_size_macro(input: TokenStream) -> TokenStream {
 
             let size_literal = parsed_ints.first().unwrap();
 
-            expected_size = size_literal.base10_parse().expect("Size value is invalid");
+            if size_literal.to_string().starts_with("0x") {
+
+                expected_size = usize::from_str_radix(&size_literal.to_string()[2..], 16).unwrap();
+
+                // panic!("HEX {} EXPECTED {}", size_literal.to_string(), expected_size);
+
+            } else {
+                expected_size = size_literal.base10_parse().expect("Size value is invalid");
+            }
         }
         _ => {
             panic!("Unsupported attribute type for Size. Please use the #[Size(0x44)] syntax.");
@@ -35,18 +43,14 @@ pub fn test_size_macro(input: TokenStream) -> TokenStream {
                 mod derive_test_size {
                     use super::*;
 
-                    const fn size_of_raw<T>(_: *const T) -> usize {
-                        core::mem::size_of::<T>()
-                    }
-
                     #[test]
                     fn #test_name() {
-                        let m = core::mem::MaybeUninit::<#name>::uninit();
+                        let m: #name = Default::default();
 
                         let mut total_size: usize = 0;
 
                         let mut writer = std::io::Cursor::new(Vec::new());
-                        writer.write_ne(&self).unwrap();
+                        <std::io::Cursor<std::vec::Vec<u8>> as binrw::BinWriterExt>::write_ne(&mut writer, &m).unwrap();
                         let written = writer.get_ref().clone();
                         let total_size = written.len();
 

blf_lib/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "blf_lib"
-version = "1.4.2"
+version = "1.4.3"
 edition = "2021"
 
 [dependencies]

blf_lib/src/blam/halo_3/release/game/game_engine_variant.rs

@@ -35,7 +35,7 @@ pub enum e_game_engine {
 
 #[derive(Default, PartialEq, Debug, Clone, Serialize, Deserialize)]
 pub struct c_game_variant {
-    pub m_game_engine_index: e_game_engine,
+    pub m_game_engine: e_game_engine,
     pub m_base_variant: c_game_engine_base_variant,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub m_ctf_variant: Option<c_game_engine_ctf_variant>,
@@ -63,10 +63,10 @@ impl BinWrite for c_game_variant {
     type Args<'a> = ();
 
     fn write_options<W: Write + Seek>(&self, writer: &mut W, endian: Endian, args: Self::Args<'_>) -> BinResult<()> {
-        writer.write_ne(&self.m_game_engine_index)?;
+        writer.write_ne(&self.m_game_engine)?;
         writer.write_ne(&self.m_base_variant)?;
 
-        match self.m_game_engine_index {
+        match self.m_game_engine {
             e_game_engine::none => { Ok(()) }
             e_game_engine::ctf => { writer.write_ne(&self.m_ctf_variant.as_ref().unwrap()) }
             e_game_engine::slayer => { writer.write_ne(&self.m_slayer_variant.as_ref().unwrap()) }
@@ -90,7 +90,7 @@ impl BinRead for c_game_variant {
         let base_game_engine: c_game_engine_base_variant = reader.read_ne()?;
 
         let mut game_variant = c_game_variant {
-            m_game_engine_index: game_engine_index,
+            m_game_engine: game_engine_index,
             m_base_variant: base_game_engine,
             m_ctf_variant: None,
             m_slayer_variant: None,
@@ -104,7 +104,7 @@ impl BinRead for c_game_variant {
             m_infection_variant: None,
         };
 
-        match game_variant.m_game_engine_index {
+        match game_variant.m_game_engine {
             e_game_engine::none => {}
             e_game_engine::ctf => { game_variant.m_ctf_variant = reader.read_ne()?; }
             e_game_engine::slayer => { game_variant.m_slayer_variant = reader.read_ne()?; }
@@ -125,11 +125,11 @@ impl BinRead for c_game_variant {
 
 impl c_game_variant {
     pub fn encode(&self, bitstream: &mut c_bitstream_writer) {
-        bitstream.write_raw(&self.m_game_engine_index, 4);
+        bitstream.write_raw(&self.m_game_engine, 4);
 
         self.m_base_variant.encode(bitstream);
 
-        match self.m_game_engine_index {
+        match self.m_game_engine {
             e_game_engine::none => { }
             e_game_engine::ctf => { self.m_ctf_variant.as_ref().unwrap().encode(bitstream); }
             e_game_engine::slayer => { self.m_slayer_variant.as_ref().unwrap().encode(bitstream); }
@@ -146,10 +146,10 @@ impl c_game_variant {
     }
 
     pub fn decode(&mut self, bitstream: &mut c_bitstream_reader) {
-        self.m_game_engine_index = bitstream.read_enum(4);
+        self.m_game_engine = bitstream.read_enum(4);
         self.m_base_variant.decode(bitstream);
 
-        match self.m_game_engine_index {
+        match self.m_game_engine {
             e_game_engine::none => { }
             e_game_engine::ctf => {
                 self.m_ctf_variant = Some(c_game_engine_ctf_variant::default());

blf_lib/src/blf/chunks/halo3/v12070_08_09_05_2031_halo3_ship/s_blf_chunk_hopper_configuration_table.rs

@@ -34,6 +34,7 @@ pub struct s_game_hopper_custom_category {
 #[derive(Clone, Default, PartialEq, Debug, Serialize, Deserialize)]
 pub struct c_hopper_configuration {
     pub hopper_name: StaticString<15>,
+    #[serde(skip_serializing,skip_deserializing)]
     pub game_set_hash: s_network_http_request_hash,
     pub hopper_identifier: u16,
     pub hopper_category: u16,

blf_lib/src/blf/chunks/halo3/v12070_08_09_05_2031_halo3_ship/s_blf_chunk_network_configuration.rs

@@ -13,6 +13,7 @@ use blf_lib_derive::BlfChunk;
 #[binrw]
 #[derive(BlfChunk,Default,PartialEq,Debug,Clone,Serialize,Deserialize)]
 #[Header("netc", 135.1)]
+#[Size(8300)]
 #[brw(big)]
 pub struct s_blf_chunk_network_configuration
 {