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

use crate::{CompatibilityCode, CompatibilityIssue, EncodeError, ExpansionType, GameEdition, Save};

use super::FormatId;

fn class_compatibility_issues(
    class: crate::Class,
    expansion_type: ExpansionType,
    target: FormatId,
) -> Vec<CompatibilityIssue> {
    let mut issues = Vec::new();

    match class {
        crate::Class::Unknown(class_id) => {
            if matches!(target, FormatId::V99 | FormatId::V105) {
                issues.push(CompatibilityIssue {
                    code: CompatibilityCode::UnknownClassRequiresKnownTarget,
                    blocking: true,
                    message: format!(
                        "Unknown class id {class_id} cannot be converted to {target:?}."
                    ),
                });
            }
        }
        crate::Class::Warlock => {
            if target.edition().is_some_and(|edition| edition != GameEdition::RotW) {
                issues.push(CompatibilityIssue {
                    code: CompatibilityCode::WarlockRequiresRotW,
                    blocking: true,
                    message: "Warlock can only be encoded as RotW.".to_string(),
                });
            }

            if expansion_type != ExpansionType::RotW {
                issues.push(CompatibilityIssue {
                    code: CompatibilityCode::WarlockRequiresRotWExpansion,
                    blocking: true,
                    message: "Warlock requires RotW expansion mode.".to_string(),
                });
            }
        }
        crate::Class::Druid | crate::Class::Assassin => {
            if expansion_type == ExpansionType::Classic {
                issues.push(CompatibilityIssue {
                    code: CompatibilityCode::ExpansionClassRequiresExpansionMode,
                    blocking: true,
                    message: "Druid and Assassin cannot be encoded in Classic mode.".to_string(),
                });
            }
        }
        _ => {}
    }

    issues
}

pub(crate) fn compatibility_issues(save: &Save, target: FormatId) -> Vec<CompatibilityIssue> {
    let mut issues =
        class_compatibility_issues(save.character.class, save.expansion_type(), target);

    if save.items.mercenary_hire_state_changed(save.character.mercenary.is_hired()) {
        issues.push(CompatibilityIssue {
            code: CompatibilityCode::MercenaryHireStateToggleUnsupported,
            blocking: true,
            message: "Changing mercenary.id between 0 (no mercenary hired) and nonzero (mercenary hired) is not supported by this version of halbu, because the mercenary item subsection in the raw item tail is not rewritten yet.".to_string(),
        });
    }

    if target.edition().is_some_and(|edition| edition != GameEdition::RotW)
        && save.expansion_type() == ExpansionType::RotW
    {
        issues.push(CompatibilityIssue {
            code: CompatibilityCode::RotWExpansionRequiresRotWEdition,
            blocking: true,
            message: "RotW expansion mode cannot be encoded to non-RotW formats.".to_string(),
        });
    }

    issues
}

pub(crate) fn validate_encode_compatibility(
    save: &Save,
    target: FormatId,
) -> Result<(), EncodeError> {
    let errors: Vec<CompatibilityIssue> =
        compatibility_issues(save, target).into_iter().filter(|issue| issue.blocking).collect();
    if errors.is_empty() {
        return Ok(());
    }

    let message = errors.iter().map(|issue| issue.message.as_str()).collect::<Vec<_>>().join(" ");
    Err(EncodeError::new(message))
}