rosu-memory-lib 1.3.1

A library to read osu! memory
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use crate::common::GameMode;

#[derive(Debug, Clone)]
pub struct BeatmapInfo {
    pub metadata: BeatmapMetadata,
    pub location: BeatmapLocation,
    pub stats: BeatmapStats,
    pub technical: BeatmapTechnicalInfo,
}

#[derive(Debug, Clone)]
pub struct BeatmapMetadata {
    pub author: String,
    pub creator: String,
    pub title_romanized: String,
    pub title_original: String,
    pub difficulty: String,
    pub tags: String,
}
#[derive(Debug, Clone)]
pub struct BeatmapTechnicalInfo {
    pub md5: String,
    pub id: i32,
    pub set_id: i32,
    pub mode: GameMode,
    pub ranked_status: BeatmapStatus,
}
#[derive(Debug, Clone)]
pub struct BeatmapLocation {
    pub folder: String,
    pub filename: String,
    pub audio: String,
    pub cover: String,
}

impl BeatmapLocation {
    pub fn get_file_path(&self) -> String {
        format!("{}/{}", self.folder, self.filename)
    }
    pub fn get_audio_path(&self) -> String {
        format!("{}/{}", self.folder, self.audio)
    }
    pub fn get_cover_path(&self) -> String {
        format!("{}/{}", self.folder, self.cover)
    }
}

#[derive(Debug, Clone)]
pub struct BeatmapStarRating {
    pub no_mod: f64,
    pub dt: f64,
    pub ht: f64,
}

#[derive(Debug, Clone)]
pub struct BeatmapStats {
    pub ar: f32,
    pub od: f32,
    pub cs: f32,
    pub hp: f32,
    pub length: i32,
    pub star_rating: BeatmapStarRating,
    pub object_count: i32,
    pub slider_count: i32,
}

#[derive(Debug, Default, PartialEq, Eq, Copy, Clone)]
#[repr(i16)]
pub enum BeatmapStatus {
    #[default]
    Unknown = 0,
    Unsubmitted = 1,
    Unranked = 2,
    Unused = 3,
    Ranked = 4,
    Approved = 5,
    Qualified = 6,
    Loved = 7,
}

impl BeatmapStatus {
    #[allow(clippy::inherent_to_string)]
    pub fn to_string(&self) -> String {
        match self {
            BeatmapStatus::Unknown => "unknown".to_string(),
            BeatmapStatus::Unsubmitted => "unsubmitted".to_string(),
            BeatmapStatus::Unranked => "unranked".to_string(),
            BeatmapStatus::Unused => "unused".to_string(),
            BeatmapStatus::Ranked => "ranked".to_string(),
            BeatmapStatus::Approved => "approved".to_string(),
            BeatmapStatus::Qualified => "qualified".to_string(),
            BeatmapStatus::Loved => "loved".to_string(),
        }
    }
}

impl From<i16> for BeatmapStatus {
    fn from(value: i16) -> Self {
        match value {
            1 => Self::Unsubmitted,
            2 => Self::Unranked,
            3 => Self::Unused,
            4 => Self::Ranked,
            5 => Self::Approved,
            6 => Self::Qualified,
            7 => Self::Loved,
            _ => Self::Unknown,
        }
    }
}

impl From<i32> for BeatmapStatus {
    fn from(value: i32) -> Self {
        Self::from(value as i16)
    }
}

pub(crate) struct BeatmapOffset {
    pub ptr: i32,
    pub metadata: BeatmapMetadataOffset,
    pub location: BeatmapLocationOffset,
    pub stats: BeatmapStatsOffset,
    pub technical: BeatmapTechnicalOffset,
}

pub struct BeatmapStatsOffset {
    pub ar: i32,
    pub od: i32,
    pub cs: i32,
    pub hp: i32,
    pub object_count: i32,
    pub total_length: i32,
    pub drain_time: i32,
    pub star_rating: i32,
    pub slider_count: i32,
}

pub struct BeatmapLocationOffset {
    pub folder: i32,
    pub filename: i32,
    pub audio: i32,
    pub cover: i32,
}

pub struct BeatmapTechnicalOffset {
    pub md5: i32,
    pub id: i32,
    pub set_id: i32,
    pub mode: i32,
    pub ranked_status: i32,
}

pub struct BeatmapMetadataOffset {
    pub author: i32,
    pub creator: i32,
    pub title_romanized: i32,
    pub title_original: i32,
    pub difficulty: i32,
    pub tags: i32,
}