quaver-rs 0.1.0

A Rust library for parsing and analyzing Quaver rhythm game maps
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

/// Game mode enum matching the C# version
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum GameMode {
    Keys4 = 1,
    Keys7 = 2,
    Keys1 = 3,
    Keys2 = 4,
    Keys3 = 5,
    Keys5 = 6,
    Keys6 = 7,
    Keys8 = 8,
    Keys9 = 9,
    Keys10 = 10,
}

impl GameMode {
    /// Convert to key count
    pub fn to_key_count(&self, has_scratch: bool) -> i32 {
        let base_count = match self {
            GameMode::Keys1 => 1,
            GameMode::Keys2 => 2,
            GameMode::Keys3 => 3,
            GameMode::Keys4 => 4,
            GameMode::Keys5 => 5,
            GameMode::Keys6 => 6,
            GameMode::Keys7 => 7,
            GameMode::Keys8 => 8,
            GameMode::Keys9 => 9,
            GameMode::Keys10 => 10,
        };
        base_count + if has_scratch { 1 } else { 0 }
    }

    /// Convert to short hand string (e.g., "4K", "7K")
    pub fn to_short_hand(&self, has_scratch: bool) -> String {
        let base = match self {
            GameMode::Keys1 => "1K",
            GameMode::Keys2 => "2K",
            GameMode::Keys3 => "3K",
            GameMode::Keys4 => "4K",
            GameMode::Keys5 => "5K",
            GameMode::Keys6 => "6K",
            GameMode::Keys7 => "7K",
            GameMode::Keys8 => "8K",
            GameMode::Keys9 => "9K",
            GameMode::Keys10 => "10K",
        };
        format!("{}{}", base, if has_scratch { "+1" } else { "" })
    }

    /// Convert to long hand string (e.g., "4 Keys", "7 Keys")
    pub fn to_long_hand(&self) -> String {
        match self {
            GameMode::Keys1 => "1 Keys",
            GameMode::Keys2 => "2 Keys",
            GameMode::Keys3 => "3 Keys",
            GameMode::Keys4 => "4 Keys",
            GameMode::Keys5 => "5 Keys",
            GameMode::Keys6 => "6 Keys",
            GameMode::Keys7 => "7 Keys",
            GameMode::Keys8 => "8 Keys",
            GameMode::Keys9 => "9 Keys",
            GameMode::Keys10 => "10 Keys",
        }.to_string()
    }

    /// Check if this is a ranked mode
    pub fn is_ranked(&self) -> bool {
        matches!(self, GameMode::Keys4 | GameMode::Keys7)
    }

    /// Check if this is a key mode (always true for now)
    pub fn is_key_mode(&self) -> bool {
        true
    }

    /// Create from key count
    pub fn from_key_count(key_count: i32) -> Result<Self, String> {
        match key_count {
            1 => Ok(GameMode::Keys1),
            2 => Ok(GameMode::Keys2),
            3 => Ok(GameMode::Keys3),
            4 => Ok(GameMode::Keys4),
            5 => Ok(GameMode::Keys5),
            6 => Ok(GameMode::Keys6),
            7 => Ok(GameMode::Keys7),
            8 => Ok(GameMode::Keys8),
            9 => Ok(GameMode::Keys9),
            10 => Ok(GameMode::Keys10),
            _ => Err(format!("Invalid key count: {}", key_count)),
        }
    }
}