rosu_memory_lib/reader/beatmap/
mod.rs

1pub mod common;
2pub mod stable;
3
4use rosu_mem::process::{Process};
5use crate::reader::beatmap::common::BeatmapInfo;
6use crate::reader::structs::State;
7use crate::reader::common::OsuType;
8use crate::reader::common::GameMode;
9use crate::reader::beatmap::common::BeatmapStatus;
10use crate::reader::beatmap::common::BeatmapStarRating;
11use crate::reader::beatmap::common::BeatmapStats;
12
13
14
15pub struct BeatmapReader<'a> { pub process : &'a Process, pub state : &'a mut State, pub osu_type : OsuType}
16
17impl<'a> BeatmapReader<'a> {
18    pub fn new(p: &'a Process, state: &'a mut State, osu_type: OsuType) -> eyre::Result<Self> {
19        Ok(Self { process: p, state, osu_type })
20    }
21
22    pub fn get_beatmap_info(&mut self) -> eyre::Result<BeatmapInfo> {
23        match self.osu_type {
24            OsuType::Stable => stable::memory::get_beatmap_info(self.process, self.state),
25            _ => Err(eyre::eyre!("Unsupported osu type for now")),
26        }
27    }
28
29
30    pub fn get_beatmap_path(&mut self) -> eyre::Result<String> {
31        match self.osu_type {
32            OsuType::Stable => stable::file::get_beatmap_path(self.process, self.state),
33            _ => Err(eyre::eyre!("Unsupported osu type for now")),
34        }
35    }
36
37    pub fn get_audio_path(&mut self) -> eyre::Result<String> {
38        match self.osu_type {
39            OsuType::Stable => stable::file::get_audio_path(self.process, self.state),
40            _ => Err(eyre::eyre!("Unsupported osu type for now")),
41        }
42    }
43
44    pub fn get_beatmap_md5(&mut self) -> eyre::Result<String> {
45        match self.osu_type {
46            OsuType::Stable => stable::memory::get_beatmap_md5(self.process, self.state),
47            _ => Err(eyre::eyre!("Unsupported osu type for now")),
48        }
49    }
50
51    pub fn get_beatmap_id(&mut self) -> eyre::Result<i32> {
52        match self.osu_type {
53            OsuType::Stable => stable::memory::get_beatmap_id(self.process, self.state),
54            _ => Err(eyre::eyre!("Unsupported osu type for now")),
55        }
56    }
57
58    pub fn get_beatmap_set_id(&mut self) -> eyre::Result<i32> {
59        match self.osu_type {
60            OsuType::Stable => stable::memory::get_beatmap_set_id(self.process, self.state),
61            _ => Err(eyre::eyre!("Unsupported osu type for now")),
62        }
63    }
64
65    pub fn get_beatmap_mode(&mut self) -> eyre::Result<GameMode> {
66        match self.osu_type {
67            OsuType::Stable => stable::memory::get_beatmap_mode(self.process, self.state),
68            _ => Err(eyre::eyre!("Unsupported osu type for now")),
69        }
70    }
71
72    pub fn get_beatmap_tags(&mut self) -> eyre::Result<String> {
73        match self.osu_type {
74            OsuType::Stable => stable::memory::get_beatmap_tags(self.process, self.state),
75            _ => Err(eyre::eyre!("Unsupported osu type for now")),
76        }
77    }
78
79    pub fn get_beatmap_length(&mut self) -> eyre::Result<i32> {
80        match self.osu_type {
81            OsuType::Stable => stable::memory::get_beatmap_length(self.process, self.state),
82            _ => Err(eyre::eyre!("Unsupported osu type for now")),
83        }
84    }
85
86    pub fn get_beatmap_drain_time(&mut self) -> eyre::Result<i32> {
87            match self.osu_type {
88                OsuType::Stable => stable::memory::get_beatmap_drain_time(self.process, self.state),
89                _ => Err(eyre::eyre!("Unsupported osu type for now")),
90            }
91        }
92
93        pub fn get_beatmap_status(&mut self) -> eyre::Result<BeatmapStatus> {
94            match self.osu_type {
95                OsuType::Stable => stable::memory::get_beatmap_status(self.process, self.state),
96                _ => Err(eyre::eyre!("Unsupported osu type for now")),
97            }
98        }
99
100        pub fn get_author(&mut self) -> eyre::Result<String> {
101            match self.osu_type {
102                OsuType::Stable => stable::memory::get_author(self.process, self.state),
103                _ => Err(eyre::eyre!("Unsupported osu type for now")),
104            }
105        }
106
107        pub fn get_creator(&mut self) -> eyre::Result<String> {
108            match self.osu_type {
109                OsuType::Stable => stable::memory::get_creator(self.process, self.state),
110                _ => Err(eyre::eyre!("Unsupported osu type for now")),
111            }
112        }
113
114        pub fn get_title_romanized(&mut self) -> eyre::Result<String> {
115            match self.osu_type {
116                OsuType::Stable => stable::memory::get_title_romanized(self.process, self.state),
117                _ => Err(eyre::eyre!("Unsupported osu type for now")),
118            }
119        }
120
121        pub fn get_title_original(&mut self) -> eyre::Result<String> {
122            match self.osu_type {
123                OsuType::Stable => stable::memory::get_title_original(self.process, self.state),
124                _ => Err(eyre::eyre!("Unsupported osu type for now")),
125            }
126        }
127
128        pub fn get_difficulty(&mut self) -> eyre::Result<String> {
129            match self.osu_type {
130                OsuType::Stable => stable::memory::get_difficulty(self.process, self.state),
131                _ => Err(eyre::eyre!("Unsupported osu type for now")),
132            }
133        }
134
135        pub fn get_beatmap_od(&mut self) -> eyre::Result<f32> {
136            match self.osu_type {
137                OsuType::Stable => stable::memory::get_beatmap_od(self.process, self.state),
138                _ => Err(eyre::eyre!("Unsupported osu type for now")),
139            }
140        }
141
142        pub fn get_beatmap_ar(&mut self) -> eyre::Result<f32> { 
143            match self.osu_type {
144                OsuType::Stable => stable::memory::get_beatmap_ar(self.process, self.state),
145                _ => Err(eyre::eyre!("Unsupported osu type for now")),
146            }
147        }
148
149        pub fn get_beatmap_cs(&mut self) -> eyre::Result<f32> {
150            match self.osu_type {
151                OsuType::Stable => stable::memory::get_beatmap_cs(self.process, self.state),   
152                _ => Err(eyre::eyre!("Unsupported osu type for now")),
153            }
154        }
155
156        pub fn get_beatmap_hp(&mut self) -> eyre::Result<f32> {
157            match self.osu_type {
158                OsuType::Stable => stable::memory::get_beatmap_hp(self.process, self.state),
159                _ => Err(eyre::eyre!("Unsupported osu type for now")),
160            }
161        }
162        
163
164        pub fn get_beatmap_object_count(&mut self) -> eyre::Result<u32> {
165            match self.osu_type {
166                OsuType::Stable => stable::memory::get_beatmap_object_count(self.process, self.state),
167                _ => Err(eyre::eyre!("Unsupported osu type for now")),
168            }
169        }
170
171        pub fn get_beatmap_slider_count(&mut self) -> eyre::Result<i32> {
172            match self.osu_type {
173                OsuType::Stable => stable::memory::get_beatmap_slider_count(self.process, self.state),
174                _ => Err(eyre::eyre!("Unsupported osu type for now")),
175            }
176        }
177        
178
179
180        pub fn get_beatmap_star_rating(&mut self) -> eyre::Result<BeatmapStarRating> {
181            match self.osu_type {
182                OsuType::Stable => stable::file::get_beatmap_star_rating(self.process, self.state),
183                _ => Err(eyre::eyre!("Unsupported osu type for now")),
184            }
185        }
186
187        pub fn get_beatmap_stats(&mut self) -> eyre::Result<BeatmapStats> {
188            match self.osu_type {
189                OsuType::Stable => stable::memory::get_beatmap_stats(self.process, self.state),
190                _ => Err(eyre::eyre!("Unsupported osu type for now")),
191            }
192        }
193        
194}
rosu_memory_lib/reader/beatmap/mod.rs

rosu_memory_lib/reader/beatmap/
mod.rs
