Reverted and added API changes

- Returned some removed functions and gave them a #[deprecated] tag to ease out their use.
- Reverted the referenceflags naming to Legacy and Standard.
- PathList and PartitionInfo are now user constructible
- GamePaths automatic runtime folder detection will now consider case-sensitive systems

Author: dafitius

examples/mount_game_files.rs

@@ -2,10 +2,13 @@ use std::io::{stdin, Write};
 use std::path::PathBuf;
 use std::str::FromStr;
 use std::{env, io};
+use itertools::Itertools;
 
 use rpkg_rs::misc::resource_id::ResourceID;
 use rpkg_rs::resource::partition_manager::{PartitionManager, PartitionState};
 use rpkg_rs::resource::pdefs::{GamePaths, PackageDefinitionSource};
+use rpkg_rs::resource::resource_info::ResourceInfo;
+use rpkg_rs::resource::resource_partition::PatchId;
 use rpkg_rs::resource::runtime_resource_id::RuntimeResourceID;
 use rpkg_rs::WoaVersion;
 
@@ -116,6 +119,56 @@ fn main() {
 
         let rrid = RuntimeResourceID::from_resource_id(&rid);
         println!("Try to find {}", rrid);
-        package_manager.print_resource_changelog(&rrid)
+        println!("Resource: {rrid}");
+
+        for partition in &package_manager.partitions {
+            let mut last_occurence: Option<&ResourceInfo> = None;
+
+            let size =
+                |info: &ResourceInfo| info.compressed_size().unwrap_or(info.size());
+
+            let changes = partition.resource_patch_indices(&rrid);
+            let deletions = partition.resource_removal_indices(&rrid);
+            let occurrences = changes
+                .clone()
+                .into_iter()
+                .chain(deletions.clone().into_iter())
+                .collect::<Vec<PatchId>>();
+
+            for occurence in occurrences.iter().sorted() {
+                println!(
+                    "{}: {}",
+                    match occurence {
+                        PatchId::Base => {
+                            "Base"
+                        }
+                        PatchId::Patch(_) => {
+                            "Patch"
+                        }
+                    },
+                    partition.partition_info().filename(*occurence)
+                );
+
+                if deletions.contains(occurence) {
+                    println!("\t- Removal: resource deleted");
+                    last_occurence = None;
+                }
+
+                if changes.contains(occurence) {
+                    if let Ok(info) = partition.resource_info_from(&rrid, *occurence) {
+                        if let Some(last_info) = last_occurence {
+                            println!(
+                                "\t- Modification: Size changed from {} to {}",
+                                size(last_info),
+                                size(info)
+                            );
+                        } else {
+                            println!("\t- Addition: New occurrence, Size {} bytes", size(info))
+                        }
+                        last_occurence = Some(info);
+                    }
+                }
+            }
+        }
     }
 }

src/misc/hash_path_list.rs

@@ -20,7 +20,7 @@ pub enum PathListError {
 /// A rainbow table of hashed paths with associated paths.
 #[derive(Default, Debug)]
 pub struct PathList {
-    entries: HashMap<RuntimeResourceID, Option<ResourceID>>,
+    pub entries: HashMap<RuntimeResourceID, Option<ResourceID>>,
 }
 
 impl PathList {

src/resource/package_builder.rs

@@ -741,14 +741,14 @@ impl PackageBuilder {
 
                     for (_, flags) in &resource.references {
                         flags
-                            .to_v1()
+                            .to_legacy()
                             .write(writer)
                             .map_err(PackageBuilderError::SerializationError)?;
                     }
                 } else {
                     for (_, flags) in &resource.references {
                         flags
-                            .to_v2()
+                            .to_standard()
                             .write(writer)
                             .map_err(PackageBuilderError::SerializationError)?;
                     }

src/resource/partition_manager.rs

@@ -38,8 +38,8 @@ pub struct PartitionState {
 
 pub struct PartitionManager {
     runtime_directory: PathBuf,
-    partition_infos: Vec<PartitionInfo>,
-    pub partitions: Vec<ResourcePartition>,
+    partition_infos: Vec<PartitionInfo>, //All potential partitions which could be mounted with this manager
+    pub partitions: Vec<ResourcePartition>, //All mounted partitions
 }
 
 impl PartitionManager {
@@ -138,7 +138,7 @@ impl PartitionManager {
 
         partition
             .mount_resource_packages_in_partition_with_callback(runtime_directory, callback)
-            .map_err(|e| PackageManagerError::PartitionError(partition_info.id(), e))?;
+            .map_err(|e| PackageManagerError::PartitionError(partition_info.id, e))?;
 
         if state_result.mounted {
             Ok(Some(partition))
@@ -211,7 +211,7 @@ impl PartitionManager {
         let partition = self
             .partitions
             .iter()
-            .find(|partition| partition.partition_info().id() == partition_id);
+            .find(|partition| partition.partition_info().id == partition_id);
 
         if let Some(partition) = partition {
             match partition.read_resource(&rrid) {
@@ -228,15 +228,15 @@ impl PartitionManager {
     pub fn find_partition(&self, partition_id: PartitionId) -> Option<&ResourcePartition> {
         self.partitions
             .iter()
-            .find(|partition| partition.partition_info().id() == partition_id)
+            .find(|partition| partition.partition_info().id == partition_id)
     }
 
     pub fn partitions_with_resource(&self, rrid: &RuntimeResourceID) -> Vec<PartitionId> {
         self.partitions
             .iter()
             .filter_map(|partition| {
                 if partition.contains(rrid) {
-                    Some(partition.partition_info().id())
+                    Some(partition.partition_info().id.clone())
                 } else {
                     None
                 }
@@ -265,7 +265,7 @@ impl PartitionManager {
         let partition = self
             .partitions
             .iter()
-            .find(|partition| partition.partition_info().id() == *partition_id);
+            .find(|partition| partition.partition_info().id == *partition_id);
 
         if let Some(partition) = partition {
             match partition.get_resource_info(rrid) {
@@ -279,6 +279,12 @@ impl PartitionManager {
         }
     }
 
+    #[deprecated(since="1.0.0", note="prefer direct access through the partitions field")]
+    pub fn partitions(&self) -> &Vec<ResourcePartition>{
+        &self.partitions
+    }
+
+    #[deprecated(since="1.1.0", note="please implement this yourself, it is out of scope for this struct")]
     pub fn print_resource_changelog(&self, rrid: &RuntimeResourceID) {
         println!("Resource: {rrid}");
 

src/resource/pdefs/h2016_parser.rs

@@ -90,7 +90,7 @@ impl PackageDefinitionParser for H2016Parser {
                             if let Ok(rid) =
                                 ResourceID::from_str(format!("{}.{}", &m[1], &m[2]).as_str())
                             {
-                                current_partition.add_root(rid);
+                                current_partition.roots.push(rid);
                             }
                         }
                     }

src/resource/pdefs/hm2_parser.rs

@@ -59,7 +59,7 @@ impl PackageDefinitionParser for HM2Parser {
                             if let Ok(rid) =
                                 ResourceID::from_str(format!("{}.{}", &m[1], &m[2]).as_str())
                             {
-                                current_partition.add_root(rid);
+                                current_partition.roots.push(rid);
                             }
                         }
                     };

src/resource/pdefs/hm3_parser.rs

@@ -50,7 +50,7 @@ impl PackageDefinitionParser for HM3Parser {
                         if let Ok(rid) =
                             ResourceID::from_str(format!("{}.{}", &m[1], &m[2]).as_str())
                         {
-                            current_partition.add_root(rid);
+                            current_partition.roots.push(rid);
                         }
                     } else {
                         return Err(PackageDefinitionError::UnexpectedFormat("ResourceID defined before partition, are you using the correct game version?".to_string()));

src/resource/pdefs/mod.rs

@@ -13,7 +13,8 @@ use crate::misc::resource_id::ResourceID;
 use crate::resource::pdefs::PackageDefinitionSource::{HM2, HM2016, HM3};
 use crate::resource::pdefs::PartitionType::{Dlc, LanguageDlc, LanguageStandard, Standard};
 use crate::resource::resource_partition::PatchId;
-use crate::WoaVersion;
+use crate::{utils, WoaVersion};
+use crate::resource::pdefs::GameDiscoveryError::InvalidRuntimePath;
 
 pub mod h2016_parser;
 pub mod hm2_parser;
@@ -164,16 +165,16 @@ impl Display for PartitionId {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PartitionInfo {
     /// The name of the partition, if available.
-    name: Option<String>,
+    pub name: Option<String>,
     /// The parent partition's identifier, if any.
-    parent: Option<PartitionId>,
+    pub parent: Option<PartitionId>,
     /// The identifier of the partition.
     /// Example: "chunk9", "dlc12" or "dlc5langjp"
-    id: PartitionId,
+    pub id: PartitionId,
     /// The patch level of the partition. Note: This is used an an upper bound, any patch above this level will be ignored.
-    patch_level: usize,
+    pub patch_level: usize,
     /// The list of resource IDs associated with this partition.
-    roots: Vec<ResourceID>,
+    pub roots: Vec<ResourceID>,
 }
 
 impl PartitionInfo {
@@ -191,26 +192,34 @@ impl PartitionInfo {
         self.id.to_filename(patch_index)
     }
 
+    #[deprecated(since="1.1.0", note="you can push to the roots field directly")]
     pub fn add_root(&mut self, resource_id: ResourceID) {
         self.roots.push(resource_id);
     }
+    #[deprecated(since="1.1.0", note="prefer direct access through the roots field")]
     pub fn roots(&self) -> &Vec<ResourceID> {
         &self.roots
     }
 
+    #[deprecated(since="1.1.0", note="prefer direct access through the name field")]
     pub fn name(&self) -> &Option<String> {
         &self.name
     }
+    
+    #[deprecated(since="1.1.0", note="prefer direct access through the parent field")]
     pub fn parent(&self) -> &Option<PartitionId> {
         &self.parent
     }
+
+    #[deprecated(since="1.1.0", note="prefer direct access through the id field")]
     pub fn id(&self) -> PartitionId {
         self.id.clone()
     }
+    #[deprecated(since="1.1.0", note="prefer direct access through the patch_level field")]
     pub fn max_patch_level(&self) -> usize {
         self.patch_level
     }
-
+    
     pub fn set_max_patch_level(&mut self, patch_level: usize) {
         self.patch_level = patch_level
     }
@@ -284,6 +293,9 @@ pub enum GameDiscoveryError {
 
     #[error("No PROJECT_PATH found in thumbs.dat")]
     NoProjectPath,
+    
+    #[error("The Runtime path cannot be found")]
+    InvalidRuntimePath,
 
     #[error("Failed to parse the thumbs.dat file: {0}")]
     FailedToParseThumbsFile(#[from] IniFileError),
@@ -310,9 +322,14 @@ impl GamePaths {
             .options()
             .get("RUNTIME_PATH")
             .ok_or(GameDiscoveryError::NoRuntimePath)?;
-        let runtime_path = retail_directory
-            .join(project_path)
+        let mut runtime_path = retail_directory
+            .join(project_path.replace("\\", "/"))
             .join(relative_runtime_path);
+        if !runtime_path.exists(){
+            runtime_path = retail_directory.join(project_path.replace("\\", "/")).join(utils::uppercase_first_letter(relative_runtime_path));
+        }
+        
+        runtime_path = runtime_path.canonicalize().map_err(|_| InvalidRuntimePath)?;
         let package_definition_path = runtime_path.join("packagedefinition.txt");
 
         Ok(Self {