redstrate/ireko
1
Fork 0
Code Activity Actions
ireko/src/map_property.rs

274 lines
8.6 KiB
Rust
Raw Normal View History

Add writing support for ArrayProperty
2025-02-23 16:50:10 -05:00
use crate::common::{read_bool_from, read_string_with_length, write_string_with_length};
Add initial files
2025-02-19 19:34:13 -05:00
use crate::struct_property::Struct;
use crate::structs::PrimaryAssetNameProperty;
use binrw::helpers::until_exclusive;
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
use binrw::{BinRead, BinResult, binrw};
De-duplicate all the GUID structs, implement better debug display This replaces several of the duplicate GUID-like structs, and throws them into a struct that more closely resembles FGuid.
2025-02-23 16:14:44 -05:00
use crate::guid::Guid;
Add initial files
2025-02-19 19:34:13 -05:00
// A struct without a name
#[binrw]
#[derive(Debug)]
pub struct AnonymousStruct {
#[br(parse_with = until_exclusive(|entry: &PrimaryAssetNameProperty| entry.property_name == "None"))]
fields: Vec<PrimaryAssetNameProperty>,
}
#[binrw]
#[derive(Debug)]
pub struct MapSubStructProperty {
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
#[br(temp)]
#[bw(ignore)]
pub unk_name_length: u32,
pub r#struct: Struct,
}
#[binrw]
#[derive(Debug)]
pub struct StructMaybeKey {
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
#[br(parse_with = read_string_with_length)]
Add writing support for ArrayProperty
2025-02-23 16:50:10 -05:00
#[bw(write_with = write_string_with_length)]
Add initial files
2025-02-19 19:34:13 -05:00
pub unk_name: String,
Add writing support for ArrayProperty
2025-02-23 16:50:10 -05:00
#[brw(pad_after = 8)]
#[br(parse_with = read_string_with_length)]
#[bw(write_with = write_string_with_length)]
Add initial files
2025-02-19 19:34:13 -05:00
pub unk_type: String,
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
#[br(pad_before = 4)] // type length
Add initial files
2025-02-19 19:34:13 -05:00
pub r#struct: Struct,
}
#[binrw]
#[derive(Debug)]
pub struct MapSubFloatProperty {
pub value: f32,
}
#[binrw]
#[derive(Debug)]
pub struct MapSubNameProperty {
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
#[br(parse_with = read_string_with_length)]
Add writing support for ArrayProperty
2025-02-23 16:50:10 -05:00
#[bw(write_with = write_string_with_length)]
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
pub value: String,
Add initial files
2025-02-19 19:34:13 -05:00
}
#[binrw]
#[derive(Debug)]
pub struct MapSubStrProperty {
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
#[br(parse_with = read_string_with_length)]
Add writing support for ArrayProperty
2025-02-23 16:50:10 -05:00
#[bw(write_with = write_string_with_length)]
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
pub value: String,
Add initial files
2025-02-19 19:34:13 -05:00
}
#[binrw]
#[derive(Debug)]
pub struct MapSubBoolProperty {
#[br(map = read_bool_from::<u8>)]
#[bw(ignore)]
pub value: bool,
}
#[binrw]
#[derive(Debug)]
pub struct MapSubIntProperty {
pub value: u32,
}
#[binrw]
#[derive(Debug)]
pub struct MapSubEnumProperty {
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
#[br(parse_with = read_string_with_length)]
Add writing support for ArrayProperty
2025-02-23 16:50:10 -05:00
#[bw(write_with = write_string_with_length)]
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
pub value: String,
Add initial files
2025-02-19 19:34:13 -05:00
}
// Used in MapProperty exclusively, seems to be a shortened version of some Properties
#[binrw]
#[derive(Debug)]
Clean up code, imports, and other misc tasks
2025-02-23 14:43:10 -05:00
#[br(import { magic: &str })]
Add initial files
2025-02-19 19:34:13 -05:00
pub enum MabSubProperty {
#[br(pre_assert("NameProperty" == magic))]
Name(MapSubNameProperty),
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
#[br(pre_assert("StructProperty" == magic))]
Add initial files
2025-02-19 19:34:13 -05:00
Struct(MapSubStructProperty),
#[br(pre_assert("FloatProperty" == magic))]
Float(MapSubFloatProperty),
#[br(pre_assert("StrProperty" == magic))]
String(MapSubStrProperty),
#[br(pre_assert("BoolProperty" == magic))]
Bool(MapSubBoolProperty),
#[br(pre_assert("IntProperty" == magic))]
Int(MapSubIntProperty),
#[br(pre_assert("EnumProperty" == magic))]
Enum(MapSubEnumProperty),
}
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
#[binrw]
#[derive(Debug)]
pub struct StringMapKey {
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
#[br(parse_with = read_string_with_length)]
Add writing support for ArrayProperty
2025-02-23 16:50:10 -05:00
#[bw(write_with = write_string_with_length)]
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
pub value: String,
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
}
#[binrw]
#[derive(Debug)]
#[br(import { magic: &KeyType })]
pub enum MapKeyProperty {
#[br(pre_assert(*magic == KeyType::String))]
String(StringMapKey),
#[br(pre_assert(*magic == KeyType::StructMaybe))]
StructMaybe(StructMaybeKey),
#[br(pre_assert(*magic == KeyType::Enum))]
Enum(MapSubEnumProperty),
#[br(pre_assert(*magic == KeyType::EnumAgain))]
EnumAgain(MapSubEnumProperty),
#[br(pre_assert(*magic == KeyType::GUID))]
De-duplicate all the GUID structs, implement better debug display This replaces several of the duplicate GUID-like structs, and throws them into a struct that more closely resembles FGuid.
2025-02-23 16:14:44 -05:00
GUID(Guid),
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
#[br(pre_assert(*magic == KeyType::SomeID))]
De-duplicate all the GUID structs, implement better debug display This replaces several of the duplicate GUID-like structs, and throws them into a struct that more closely resembles FGuid.
2025-02-23 16:14:44 -05:00
SomeID(Guid),
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
#[br(pre_assert(*magic == KeyType::SomeID2))]
De-duplicate all the GUID structs, implement better debug display This replaces several of the duplicate GUID-like structs, and throws them into a struct that more closely resembles FGuid.
2025-02-23 16:14:44 -05:00
SomeID2(Guid),
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
}
#[binrw]
#[derive(Debug)]
#[br(import(key_type: &KeyType, value_type: &str))]
Add initial files
2025-02-19 19:34:13 -05:00
pub struct MapEntry {
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
#[br(args { magic: key_type})]
pub key: MapKeyProperty,
Add initial files
2025-02-19 19:34:13 -05:00
Clean up code, imports, and other misc tasks
2025-02-23 14:43:10 -05:00
#[br(args { magic: value_type })]
Add initial files
2025-02-19 19:34:13 -05:00
pub value: MabSubProperty,
}
#[binrw]
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
#[brw(repr = u32)]
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
#[derive(Debug, PartialEq, Clone)]
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
pub enum KeyType {
String = 0x1,
GUID = 0x3,
SomeID = 0x6,
SomeID2 = 0x10,
EnumAgain = 0x4,
Enum = 0x7,
StructMaybe = 0xC,
}
#[binrw::parser(reader, endian)]
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
fn custom_parser(
size_in_bytes: u32,
key_type: &KeyType,
value_type: &str,
) -> BinResult<Vec<MapEntry>> {
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
let mut result = Vec::<MapEntry>::new();
Improve error handling in the map and array custom parsers
2025-02-23 15:26:52 -05:00
let mut current = reader.stream_position()?;
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
let end = current + size_in_bytes as u64 - 5 - 3;
Clean up code, imports, and other misc tasks
2025-02-23 14:43:10 -05:00
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
while current < end {
Remove old magic-based property enum This is now replaced by the pre_assert and string-based version, which is superior.
2025-02-23 16:03:08 -05:00
result.push(MapEntry::read_options(
reader,
endian,
(key_type, value_type),
)?);
Improve error handling in the map and array custom parsers
2025-02-23 15:26:52 -05:00
current = reader.stream_position()?;
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
}
Ok(result)
Add initial files
2025-02-19 19:34:13 -05:00
}
#[binrw]
#[derive(Debug)]
pub struct MapProperty {
// Plus this int
pub size_in_bytes: u32,
Add writing support for ArrayProperty
2025-02-23 16:50:10 -05:00
#[brw(pad_before = 4)]
#[br(parse_with = read_string_with_length)]
#[bw(write_with = write_string_with_length)]
Add initial files
2025-02-19 19:34:13 -05:00
pub key_name: String,
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
#[br(parse_with = read_string_with_length)]
Add writing support for ArrayProperty
2025-02-23 16:50:10 -05:00
#[bw(write_with = write_string_with_length)]
Add initial files
2025-02-19 19:34:13 -05:00
pub value_name: String,
Add writing support for ArrayProperty
2025-02-23 16:50:10 -05:00
#[brw(pad_before = 5)]
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
pub key_type: KeyType,
#[br(parse_with = custom_parser, args(size_in_bytes, &key_type, &value_name))]
pub entries: Vec<MapEntry>,
Add initial files
2025-02-19 19:34:13 -05:00
}
#[cfg(test)]
mod tests {
use super::*;
Clean up code, imports, and other misc tasks
2025-02-23 14:43:10 -05:00
use crate::map_property::MabSubProperty::{Int, String};
Add initial files
2025-02-19 19:34:13 -05:00
use binrw::BinRead;
use std::io::Cursor;
#[test]
fn simple_strmap() {
// From LocalProfile.sav i think
let data = [
0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x53, 0x74,
0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x00, 0x0c, 0x00, 0x00, 0x00,
0x53, 0x74, 0x72, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x41, 0x52, 0x30,
0x58, 0x4a, 0x47, 0x46, 0x57, 0x41, 0x36, 0x48, 0x4e, 0x49, 0x51, 0x31, 0x41, 0x41,
0x55, 0x4a, 0x39, 0x55, 0x52, 0x38, 0x32, 0x38, 0x00, 0x07, 0x00, 0x00, 0x00, 0x4e,
0x41, 0x4d, 0x45, 0x20, 0x31, 0x00,
];
let mut cursor = Cursor::new(data);
let decoded = MapProperty::read_le(&mut cursor).unwrap();
assert_eq!(decoded.size_in_bytes, 49);
assert_eq!(decoded.key_name, "StrProperty");
assert_eq!(decoded.value_name, "StrProperty");
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
let MapKeyProperty::String(key_property) = &decoded.entries.first().unwrap().key else {
Add initial files
2025-02-19 19:34:13 -05:00
panic!("StrProperty!")
};
let String(value_property) = &decoded.entries.first().unwrap().value else {
panic!("StrProperty!")
};
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
assert_eq!(key_property.value, "AR0XJGFWA6HNIQ1AAUJ9UR828");
assert_eq!(value_property.value, "NAME 1");
Add initial files
2025-02-19 19:34:13 -05:00
}
#[test]
fn name_int_map() {
// From Persistent.sav, EventParams
let data = [
0xba, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x4e, 0x61,
0x6d, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x00, 0x0c, 0x00, 0x00,
0x00, 0x49, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x53, 0x65,
0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x00,
0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x54, 0x75, 0x74, 0x6f, 0x72, 0x69,
0x61, 0x6c, 0x5f, 0x50, 0x6f, 0x72, 0x74, 0x61, 0x6c, 0x5f, 0x30, 0x32, 0x00, 0x01,
0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x59, 0x4f,
0x5f, 0x66, 0x6c, 0x30, 0x30, 0x33, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
0x00, 0x4d, 0x30, 0x31, 0x41, 0x30, 0x31, 0x5f, 0x4e, 0x65, 0x78, 0x74, 0x53, 0x74,
0x61, 0x67, 0x65, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x4d, 0x30,
0x31, 0x41, 0x30, 0x31, 0x5f, 0x47, 0x61, 0x74, 0x65, 0x30, 0x30, 0x31, 0x00, 0x01,
0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x4d, 0x30, 0x31, 0x41, 0x30, 0x31, 0x4d,
0x6f, 0x6e, 0x6f, 0x72, 0x61, 0x69, 0x6c, 0x30, 0x30, 0x31, 0x54, 0x65, 0x73, 0x74,
0x30, 0x30, 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x4d,
0x30, 0x31, 0x41, 0x30, 0x31, 0x5f, 0x47, 0x61, 0x74, 0x65, 0x30, 0x30, 0x35, 0x00,
0x01, 0x00, 0x00, 0x00,
];
let mut cursor = Cursor::new(data);
let decoded = MapProperty::read_le(&mut cursor).unwrap();
assert_eq!(decoded.size_in_bytes, 186);
assert_eq!(decoded.key_name, "NameProperty");
assert_eq!(decoded.value_name, "IntProperty");
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
let MapKeyProperty::Enum(key_property) = &decoded.entries.first().unwrap().key else {
Add initial files
2025-02-19 19:34:13 -05:00
panic!("Name!")
};
let Int(value_property) = &decoded.entries.first().unwrap().value else {
panic!("Int!")
};
Simplify string reading A lot of them are just u32 length + byte string, and can be moved into a common parsing function.
2025-02-23 15:25:50 -05:00
assert_eq!(key_property.value, "SelectedMachine");
Implement proper map parsing, fix array parsing Finally finished and figured out how maps are handled. It didn't encode the number of items, it's based on how many bytes you read. I also fixed arrays so they're also correct, and we'll see if sets break.
2025-02-23 14:38:35 -05:00
assert_eq!(value_property.value, 2);
Add initial files
2025-02-19 19:34:13 -05:00
// TODO: test the rest of the values
}
}
Copy permalink