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

338 lines
11 KiB
Rust
Raw Normal View History

Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
use crate::common::{
read_bool_from, read_string_with_length, write_bool_as, write_string_with_length,
};
use crate::guid::Guid;
Add initial files
2025-02-19 19:34:13 -05:00
use crate::struct_property::Struct;
use crate::structs::PrimaryAssetNameProperty;
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};
Add initial files
2025-02-19 19:34:13 -05:00
Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
// parse until we can't parse no more. kind of a hack for how we run into the end of Persistent.Sav
#[binrw::parser(reader, endian)]
fn cc() -> BinResult<Vec<PrimaryAssetNameProperty>> {
let mut result = Vec::<PrimaryAssetNameProperty>::new();
loop {
if let Ok(str) = PrimaryAssetNameProperty::read_options(reader, endian, ()) {
result.push(str);
} else {
break;
}
}
Ok(result)
Add initial files
2025-02-19 19:34:13 -05:00
}
#[binrw]
#[derive(Debug)]
pub struct MapSubStructProperty {
Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
#[br(parse_with = cc)]
fields: Vec<PrimaryAssetNameProperty>,
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 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
Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
#[br(parse_with = read_string_with_length)]
#[bw(write_with = write_string_with_length)]
pub struct_name: String,
#[br(args { magic: &struct_name })]
#[brw(pad_before = 17)]
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>)]
Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
#[bw(map = write_bool_as::<u8>)]
Add initial files
2025-02-19 19:34:13 -05:00
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),
Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
#[br(pre_assert(*magic == KeyType::ArrayStruct))]
ArrayStruct(StructMaybeKey),
#[br(pre_assert(*magic == KeyType::Unknown2))]
SomeID3(Guid),
Add support for SoftObjectProperty With this, my Persistent.sav can be now be parsed without errors!
2025-02-24 18:19:23 -05:00
#[br(pre_assert(*magic == KeyType::SoftObjectProperty))]
SoftObjectProperty(StringMapKey),
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,
}
Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
// TODO: im worried that set/array/map actually share same of the same values...
Add initial files
2025-02-19 19:34:13 -05:00
#[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 {
Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
None = 0x0,
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
String = 0x1,
Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
SetStruct = 0x2,
SetStruct2 = 0x2f,
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
GUID = 0x3,
Add support for SoftObjectProperty With this, my Persistent.sav can be now be parsed without errors!
2025-02-24 18:19:23 -05:00
// Seen in ReadDialogues
SoftObjectProperty = 0x5,
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
SomeID = 0x6,
SomeID2 = 0x10,
EnumAgain = 0x4,
Enum = 0x7,
StructMaybe = 0xC,
Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
ArrayStruct = 0xA, // Only used in ArrayProperty
Unknown = 0x2E, // AcquiredItemBoxIds in Persistent.sav
Unknown2 = 0x33, // CharacterPersistentDataList in Persistent.sav
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::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
}
Add writing support for MapProperty
2025-02-23 16:52:54 -05:00
fn calc_size_in_bytes(entries: &Vec<MapEntry>) -> u32 {
// TODO: stub
49
}
Add initial files
2025-02-19 19:34:13 -05:00
#[binrw]
#[derive(Debug)]
pub struct MapProperty {
Add writing support for MapProperty
2025-02-23 16:52:54 -05:00
#[bw(calc = calc_size_in_bytes(entries))]
Add initial files
2025-02-19 19:34:13 -05:00
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)]
Add support for SoftObjectProperty With this, my Persistent.sav can be now be parsed without errors!
2025-02-24 18:19:23 -05:00
#[br(dbg)]
Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
pub map_key_type: KeyType,
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
Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
#[br(parse_with = custom_parser, args(size_in_bytes, &map_key_type, &value_name))]
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 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 writing support for MapProperty
2025-02-23 16:52:54 -05:00
use binrw::{BinRead, BinWrite};
Add initial files
2025-02-19 19:34:13 -05:00
use std::io::Cursor;
#[test]
Add writing support for MapProperty
2025-02-23 16:52:54 -05:00
fn read_simple_strmap() {
Add initial files
2025-02-19 19:34:13 -05:00
// 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.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
}
Add writing support for MapProperty
2025-02-23 16:52:54 -05:00
#[test]
fn write_simple_map() {
let expected_data: [u8; 90] = [
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 property = MapProperty {
key_name: "StrProperty".to_string(),
value_name: "StrProperty".to_string(),
Complete Persistent.sav parsing, fix up a ton of things This is unfortunately one giant commit, but this now (partially) parses Persistent.sav. There is still some structs and data left to parse, and we're suspiciously missing 3KiB of data at the end. But... progress!
2025-02-24 00:30:16 -05:00
map_key_type: KeyType::String,
entries: vec![MapEntry {
key: MapKeyProperty::String(StringMapKey {
value: "AR0XJGFWA6HNIQ1AAUJ9UR828".to_string(),
}),
value: String(MapSubStrProperty {
value: "NAME 1".to_string(),
}),
}],
Add writing support for MapProperty
2025-02-23 16:52:54 -05:00
};
let mut buffer: Vec<u8> = Vec::new();
{
let mut cursor = Cursor::new(&mut buffer);
property.write_le(&mut cursor).unwrap();
}
assert_eq!(expected_data, &buffer[..]);
}
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.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