halbu 0.3.0

Diablo II save file parsing library.
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

//! Skills section model.
//!
//! Core API is raw index-based (`set`/`get`) so modded skill trees remain supported.
//! D2R name mapping is available via [`SkillPoints::set_by_name_d2r`]
//! and [`SkillPoints::get_by_name_d2r`].

use std::fmt;

use serde::{Deserialize, Serialize};

use crate::Class;
use crate::ParseHardError;

mod named_d2r;
#[cfg(test)]
mod tests;

pub use named_d2r::d2r_skill_index;
pub use named_d2r::d2r_skill_name;
pub use named_d2r::NamedSkillError;

const SECTION_HEADER: [u8; 2] = [0x69, 0x66];
/// Number of skill slots stored in this section.
pub const SKILL_POINTS_COUNT: usize = 30;
/// Total encoded section length including 2-byte section header.
pub const SKILLS_SECTION_LENGTH: usize = 2 + SKILL_POINTS_COUNT;

/// Skill point values indexed by class-local slot id (`0..30`).
#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
pub struct SkillPoints {
    pub points: [u8; SKILL_POINTS_COUNT],
}

impl Default for SkillPoints {
    fn default() -> Self {
        Self { points: [0; SKILL_POINTS_COUNT] }
    }
}

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

impl SkillPoints {
    /// Parse skill section bytes (`0x69 0x66` + 30 values).
    pub fn parse(skills_section_bytes: &[u8]) -> Result<SkillPoints, ParseHardError> {
        if skills_section_bytes.len() < SKILLS_SECTION_LENGTH {
            return Err(ParseHardError {
                message: format!(
                    "Skills section too short: expected at least {SKILLS_SECTION_LENGTH} bytes, found {}.",
                    skills_section_bytes.len()
                ),
            });
        }

        if skills_section_bytes[0..2] != SECTION_HEADER {
            return Err(ParseHardError {
                message: format!(
                    "Invalid skills header: expected {SECTION_HEADER:X?}, found {:X?}.",
                    &skills_section_bytes[0..2]
                ),
            });
        }

        let mut points = [0u8; SKILL_POINTS_COUNT];
        points.copy_from_slice(&skills_section_bytes[2..SKILLS_SECTION_LENGTH]);

        Ok(SkillPoints { points })
    }

    /// Serialize to skill section bytes (`0x69 0x66` + 30 values).
    pub fn to_bytes(&self) -> Vec<u8> {
        let mut skills_section_bytes = Vec::with_capacity(SKILLS_SECTION_LENGTH);
        skills_section_bytes.extend_from_slice(&SECTION_HEADER);
        skills_section_bytes.extend_from_slice(&self.points);
        skills_section_bytes
    }

    /// Set every skill slot to the same value.
    pub fn set_all(&mut self, value: u8) {
        self.points.fill(value);
    }

    /// Set skill value by raw class-local index.
    pub fn set(&mut self, skill_index: usize, value: u8) {
        self.points[skill_index] = value;
    }

    /// Get skill value by raw class-local index.
    pub fn get(&self, skill_index: usize) -> u8 {
        self.points[skill_index]
    }

    /// Resolve a default D2R skill name to a class-local slot and set its value.
    ///
    /// For modded trees, use raw indices.
    pub fn set_by_name_d2r(
        &mut self,
        class: Class,
        skill_name: &str,
        value: u8,
    ) -> Result<(), NamedSkillError> {
        let index = d2r_skill_index(class, skill_name)?;
        self.set(index, value);
        Ok(())
    }

    /// Resolve a default D2R skill name to a class-local slot and return its value.
    ///
    /// For modded trees, use raw indices.
    pub fn get_by_name_d2r(&self, class: Class, skill_name: &str) -> Result<u8, NamedSkillError> {
        let index = d2r_skill_index(class, skill_name)?;
        Ok(self.get(index))
    }
}