wz_reader 0.0.22

A wz file reader to resolve wz file with thread safe
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use crate::{
    util::{offset::WzOffsetVersion, string_decryptor::DecrypterType},
    version::pkg2::{Pkg2VersionGen, Pkg2VersionGenV6},
};
use std::sync::{LazyLock, RwLock};

#[derive(Debug, Clone, Copy, Default, Eq, PartialEq)]
pub enum WzProfileVersion {
    #[default]
    Pkg1,
    Pkg2V1202,
    Pkg2V1201,
    Pkg2V1200,
    Pkg2V1199,
    Pkg2V1198,
    Pkg2V1197,
    Pkg2V1196,
}

impl std::fmt::Display for WzProfileVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

#[derive(Debug, Clone)]
pub struct WzProfile {
    pub name: WzProfileVersion,
    pub decryptor_type: DecrypterType,
    pub version_gen: Pkg2VersionGen,
    pub offset_version: WzOffsetVersion,
}

impl Default for WzProfile {
    fn default() -> Self {
        Self {
            name: WzProfileVersion::Pkg1,
            decryptor_type: DecrypterType::Unknown,
            version_gen: Pkg2VersionGen::Unknown,
            offset_version: WzOffsetVersion::Pkg1,
        }
    }
}

impl WzProfile {
    pub fn should_be_pkg2_64(&self) -> bool {
        self.name == WzProfileVersion::Pkg2V1202
    }
    pub fn get_hash_iter(&self, hash1: u64, hash2: u64) -> Box<dyn Iterator<Item = u64>> {
        if self.version_gen.is_u64_hash() {
            Box::new(
                self.version_gen
                    .get_generator_u64(hash1, hash2)
                    .get_iter(),
            )
        } else {
            Box::new(
                self.version_gen
                    .get_generator(hash1, hash2)
                    .get_iter()
                    .map(|x| x as u64),
            ) as Box<dyn Iterator<Item = u64>>
        }
    }
}

pub fn get_all_pkg2_profiles() -> Vec<WzProfile> {
    vec![
        WzProfile {
            name: WzProfileVersion::Pkg2V1202,
            decryptor_type: DecrypterType::KMST1202,
            version_gen: Pkg2VersionGen::V6,
            offset_version: WzOffsetVersion::Pkg2_64V1,
        },
        WzProfile {
            name: WzProfileVersion::Pkg2V1201,
            decryptor_type: DecrypterType::KMST1199,
            version_gen: Pkg2VersionGen::V4,
            offset_version: WzOffsetVersion::Pkg2V3,
        },
        WzProfile {
            name: WzProfileVersion::Pkg2V1200,
            decryptor_type: DecrypterType::KMST1199,
            version_gen: Pkg2VersionGen::V5,
            offset_version: WzOffsetVersion::Pkg2V3,
        },
        WzProfile {
            name: WzProfileVersion::Pkg2V1199,
            decryptor_type: DecrypterType::KMST1199,
            version_gen: Pkg2VersionGen::V4,
            offset_version: WzOffsetVersion::Pkg2V3,
        },
        WzProfile {
            name: WzProfileVersion::Pkg2V1198,
            decryptor_type: DecrypterType::KMST1198,
            version_gen: Pkg2VersionGen::V3,
            offset_version: WzOffsetVersion::Pkg2V2,
        },
        WzProfile {
            name: WzProfileVersion::Pkg2V1197,
            decryptor_type: DecrypterType::Unknown,
            version_gen: Pkg2VersionGen::V2,
            offset_version: WzOffsetVersion::Pkg2V2,
        },
        WzProfile {
            name: WzProfileVersion::Pkg2V1196,
            decryptor_type: DecrypterType::Unknown,
            version_gen: Pkg2VersionGen::V1,
            offset_version: WzOffsetVersion::Pkg2V1,
        },
    ]
}

pub static PKG2_PROFILE_CACHE: LazyLock<RwLock<Vec<Pkg2Profile>>> =
    LazyLock::new(|| RwLock::new(Vec::new()));

#[derive(Debug, Clone)]
pub struct Pkg2Profile {
    pub profile: WzProfile,
    pub hash: u64,
}

impl Pkg2Profile {
    pub fn new(profile: WzProfile, hash: u64) -> Self {
        Self { profile, hash }
    }

    pub fn verify_hash(&self, hash1: u64, hash2: u64) -> bool {
        if self.profile.version_gen.is_u64_hash() {
            Pkg2VersionGenV6::verify_hash(hash1, hash2, self.hash)
        } else {
            self.profile
                .version_gen
                .get_generator(hash1, hash2)
                .get_verifier()(hash1 as u32, hash2 as u32, self.hash as u32)
        }
    }
}