rpkg-rs 1.3.1

Parse Glacier ResourcePackage (rpkg) files, allowing access to the resources stored within.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use itertools::Itertools;
use std::io::{stdin, Write};
use std::path::PathBuf;
use std::str::FromStr;
use std::{env, io};
use std::time::Instant;
use rpkg_rs::misc::hash_path_list::PathList;
use rpkg_rs::misc::resource_id::ResourceID;
use rpkg_rs::resource::partition_manager::{PartitionManager, PartitionManagerPar, 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;

fn main() {
    let start = Instant::now();
    let mut path_list = PathList::new();
    let _ = path_list.parse_into("/media/dafitius/980 PRO/HitmanProjects/Tools/rpkgtools2.33/hash_list.txt").unwrap();

    // let retail_path = PathBuf::from("/media/dafitius/980 PRO/SteamLibrary/steamapps/common/Hitman™/Retail/");
    // let game_version = WoaVersion::HM2016;
    // 
    // let retail_path = PathBuf::from("/media/dafitius/980 PRO/SteamLibrary/steamapps/common/HITMAN2/Retail/");
    // let game_version = WoaVersion::HM2;
    // 
    let retail_path = PathBuf::from("/media/dafitius/980 PRO/SteamLibrary/steamapps/common/HITMAN 3/Retail/");
    let game_version = WoaVersion::HM3;

    // Discover the game paths.
    let game_paths = GamePaths::from_retail_directory(retail_path.clone()).unwrap_or_else(|e| {
        eprintln!("failed to discover game paths: {}", e);
        std::process::exit(0);
    });

    // Read and parse the package definition.
    let package_definition_source =
        PackageDefinitionSource::from_file(game_paths.package_definition_path, game_version)
            .unwrap_or_else(|e| {
                eprintln!("failed to parse package definition: {}", e);
                std::process::exit(0);
            });

    let mut partition_infos = package_definition_source.read().unwrap_or_else(|e| {
        eprintln!("failed to read package definition: {}", e);
        std::process::exit(0);
    });

    // Ignore modded patches.
    for partition in partition_infos.iter_mut() {
        partition.set_max_patch_level(9);
    }

    let mut package_manager =
        PartitionManager::new(game_paths.runtime_path, &package_definition_source).unwrap_or_else(
            |e| {
                eprintln!("failed to init package manager: {}", e);
                std::process::exit(0);
            },
        );

    //read the packagedefs here
    let mut last_index = 0;
    let mut progress = 0.0;
    let progress_callback = |current, state: &PartitionState| {
        if current != last_index {
            last_index = current;
            // print!("Mounting partition {} ", current);
        }
        if !state.installing && !state.mounted {
            println!("[Failed to mount this partition. Is it installed?]");
        }
        let install_progress = (state.install_progress * 10.0).ceil() / 10.0;

        let chars_to_add = (install_progress * 10.0 - progress * 10.0) as usize * 2;
        let chars_to_add = std::cmp::min(chars_to_add, 20);
        // print!("{}", "█".repeat(chars_to_add));
        io::stdout().flush().unwrap();

        progress = install_progress;

        if progress == 1.0 {
            progress = 0.0;

            if state.mounted {
                println!(" done :)");
            } else {
                println!(" failed :(");
            }
        }
    };

    package_manager
        .mount_partitions_par(progress_callback)
        .unwrap_or_else(|e| {
            eprintln!("failed to mount partitions: {}", e);
            std::process::exit(0);
        });

    for partition in package_manager.partitions.iter_mut() {
        println!("{}", partition.partition_info().id)
    }

    //
    // for partition in package_manager.partitions.iter() {
    //     for (resource_info, resource_patch_id) in partition.removed_resources_of_type("TEMP").iter() {
    //         let res_available = package_manager.resource_mounted(resource_info.rrid());
    //         if !res_available {
    //             let rid = path_list.get( resource_info.rrid()).and_then(|rid| Some(rid.resource_path())).unwrap_or(resource_info.rrid().to_string());
    //             println!("Removed ({}) resource {}", resource_info.references().len(), rid);
    //         }
    //     }
    // }
    println!("{}", start.elapsed().as_secs_f32());
}