Beatsaber Rust Utilities: A Beatsaber V3 parsing library.
beatsaber
beatmap
Added `get_relative_index` and fixed bug in `is_in_filter`.
+51
-6
+51
-6
src/difficulty/lightshow/filter.rs
+51
-6
src/difficulty/lightshow/filter.rs
···
55
55
/// # Unknown
56
56
/// If the [`FilterType`] is `Unknown` then the result will be `true`.
57
57
/// # Panics
58
-
/// Will panic if the light id is greater than or equal to the group size.
58
+
/// Will panic if the light ID is greater than or equal to the group size.
59
+
#[must_use]
59
60
pub fn is_in_filter(&self, mut light_id: i32, group_size: i32) -> bool {
60
61
assert!(light_id < group_size);
61
62
···
71
72
}
72
73
FilterType::StepAndOffset => {
73
74
let offset_light_id = light_id - self.parameter1;
74
-
offset_light_id % self.parameter2.max(1) == 0
75
+
offset_light_id % self.parameter2.max(1) == 0 && offset_light_id >= 0
75
76
}
76
77
FilterType::Unknown(_) => true,
77
78
}
···
80
81
/// Returns the number of lights effected by the filter.
81
82
/// # Unknown
82
83
/// If the [`FilterType`] is `Unknown` then the result will be the same as `group_size`.
84
+
#[must_use]
83
85
pub fn count_filtered(&self, group_size: i32) -> i32 {
84
86
match self.filter_type {
85
87
FilterType::Division => {
···
93
95
FilterType::Unknown(_) => group_size,
94
96
}
95
97
}
98
+
99
+
/// Returns the light ID relative to the filtered count.
100
+
/// # Unknown
101
+
/// If the [`FilterType`] is `Unknown` then the result will be the same as `light_id`.
102
+
/// # Panics
103
+
/// Will panic if the light ID is greater than or equal to the group size.
104
+
#[must_use]
105
+
pub fn get_relative_index(&self, mut light_id: i32, group_size: i32) -> i32 {
106
+
assert!(light_id < group_size);
107
+
108
+
if self.reverse.as_bool() {
109
+
light_id = group_size - light_id;
110
+
}
111
+
112
+
match self.filter_type {
113
+
FilterType::Division => {
114
+
let start = self.parameter2 * group_size / self.parameter1.max(1);
115
+
light_id - start
116
+
}
117
+
FilterType::StepAndOffset => {
118
+
let offset_light_id = light_id - self.parameter1;
119
+
offset_light_id / self.parameter2.max(1)
120
+
}
121
+
FilterType::Unknown(_) => group_size,
122
+
}
123
+
}
96
124
}
97
125
98
126
loose_enum! {
···
133
161
assert!((0..6).all(|i| filter.is_in_filter(i, 12)));
134
162
assert!((6..12).all(|i| !filter.is_in_filter(i, 12)));
135
163
assert_eq!(filter.count_filtered(12), 6);
164
+
assert!((0..6).all(|i| filter.get_relative_index(i, 12) == i));
136
165
}
137
166
138
167
#[test]
···
147
176
assert!((0..6).all(|i| !filter.is_in_filter(i, 12)));
148
177
assert!((6..12).all(|i| filter.is_in_filter(i, 12)));
149
178
assert_eq!(filter.count_filtered(12), 6);
179
+
assert!((6..12).all(|i| filter.get_relative_index(i, 12) == i - 6));
150
180
}
151
181
152
182
#[test]
···
162
192
assert!((0..6).all(|i| !filter.is_in_filter(i, 12)));
163
193
assert!((6..12).all(|i| filter.is_in_filter(i, 12)));
164
194
assert_eq!(filter.count_filtered(12), 6);
195
+
assert!((6..12).all(|i| filter.get_relative_index(i, 12) == 12 - i));
165
196
}
166
197
167
198
#[test]
···
177
208
assert!((0..6).all(|i| filter.is_in_filter(i, 12)));
178
209
assert!((6..12).all(|i| !filter.is_in_filter(i, 12)));
179
210
assert_eq!(filter.count_filtered(12), 6);
211
+
assert!((0..6).all(|i| filter.get_relative_index(i, 12) == 6 - i));
180
212
}
181
213
182
214
#[test]
···
190
222
191
223
assert!((0..12).all(|i| filter.is_in_filter(i, 12)));
192
224
assert_eq!(filter.count_filtered(12), 12);
225
+
assert!((0..12).all(|i| filter.get_relative_index(i, 12) == i));
193
226
}
194
227
195
228
#[test]
···
203
236
204
237
assert!((0..12).all(|i| filter.is_in_filter(i, 12)));
205
238
assert_eq!(filter.count_filtered(12), 12);
239
+
assert!((0..12).all(|i| filter.get_relative_index(i, 12) == i));
206
240
}
207
241
208
242
#[test]
209
243
fn step_start_index() {
210
-
for i in 0..12 {
244
+
for outer in 0..12 {
211
245
let filter = Filter {
212
246
filter_type: FilterType::StepAndOffset,
213
-
parameter1: i,
247
+
parameter1: outer,
214
248
parameter2: 1,
215
249
..Default::default()
216
250
};
217
-
assert!((i..12).all(|i| filter.is_in_filter(i, 12)));
218
-
assert_eq!(filter.count_filtered(12), 12 - i);
251
+
println!("{outer}");
252
+
assert!((0..outer).all(|i| !filter.is_in_filter(i, 12)));
253
+
assert!((outer..12).all(|i| filter.is_in_filter(i, 12)));
254
+
assert_eq!(filter.count_filtered(12), 12 - outer);
255
+
assert!((outer..12).all(|i| filter.get_relative_index(i, 12) == i - outer));
219
256
}
220
257
}
221
258
···
230
267
231
268
for i in 0..12 {
232
269
assert_eq!(filter.is_in_filter(i, 12), i % 2 == 0);
270
+
271
+
if i % 2 == 0 {
272
+
assert_eq!(filter.get_relative_index(i, 12), i / 2);
273
+
}
233
274
}
234
275
assert_eq!(filter.count_filtered(12), 6);
235
276
}
···
245
286
246
287
for i in 0..12 {
247
288
assert_eq!(filter.is_in_filter(i, 12), i % 2 != 0);
289
+
290
+
if i % 2 != 0 {
291
+
assert_eq!(filter.get_relative_index(i, 12), i / 2);
292
+
}
248
293
}
249
294
assert_eq!(filter.count_filtered(12), 6);
250
295
}