EZPPFarm/akatsuki-pp-rs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

osu: finished no_leniency version

Browse Source
This commit is contained in:
MaxOhn
2021-01-15 19:39:02 +01:00
parent cb5b9c8f1d
commit 9cc4cba965
15 changed files with 343 additions and 432 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+1 -1
View File
@@ -7,7 +7,7 @@ A standalone crate to calculate star ratings and performance points for all [osu
### Roadmap
- osu sr versions
- [x] no_sliders_no_leniency (i.e. oppai)
- [ ] no_sliders
- [x] no_leniency
- [ ] all included
- [x] taiko sr
- [x] ctb sr
fruits/src/curve.rs
+1
View File
@@ -25,6 +25,7 @@ pub(crate) enum Curve {
}
impl Curve {
#[inline]
pub(crate) fn linear(a: Pos2, b: Pos2) -> Self {
Self::Linear { a, b }
}
fruits/src/math_util.rs
-1
View File
@@ -71,7 +71,6 @@ pub(crate) fn point_at_distance(array: &[Pos2], distance: f32) -> Pos2 {
let mut current_distance = 0.0;
let mut new_distance = 0.0;
// TODO: Optimize
while i < array.len() - 2 {
new_distance = (array[i] - array[i + 1]).length();
current_distance += new_distance;
osu/src/curve.rs
+1
View File
@@ -25,6 +25,7 @@ pub(crate) enum Curve {
}
impl Curve {
#[inline]
pub(crate) fn linear(a: Pos2, b: Pos2) -> Self {
Self::Linear { a, b }
}
osu/src/lib.rs
+1 -1
View File
@@ -6,7 +6,7 @@ mod versions;
pub use pp::*;
pub use versions::*;
#[derive(Default)]
#[derive(Clone, Default, Debug)]
pub struct DifficultyAttributes {
pub stars: f32,
pub ar: f32,
osu/src/versions/all_included/mod.rs
+1 -6
View File
@@ -21,14 +21,9 @@ pub fn stars(map: &Beatmap, mods: impl Mods) -> DifficultyAttributes {
if map.hit_objects.len() < 2 {
return DifficultyAttributes {
stars: 0.0,
ar: attributes.ar,
od: attributes.od,
speed_strain: 0.0,
aim_strain: 0.0,
max_combo: 0,
n_circles: 0,
n_spinners: 0,
..Default::default()
};
}
osu/src/versions/no_leniency/control_point_iter.rs
+73
View File
@@ -0,0 +1,73 @@
use parse::{Beatmap, DifficultyPoint, TimingPoint};
use std::slice::Iter;
macro_rules! next_tuple {
($iter:expr, ($first:ident, $second:ident)) => {
$iter.next().map(|e| (e.$first, e.$second))
};
}
pub(crate) struct ControlPointIter<'p> {
timing_points: Iter<'p, TimingPoint>,
difficulty_points: Iter<'p, DifficultyPoint>,
next_timing: Option<(f32, f32)>,
next_difficulty: Option<(f32, f32)>,
}
impl<'p> ControlPointIter<'p> {
#[inline]
pub(crate) fn new(map: &'p Beatmap) -> Self {
let mut timing_points = map.timing_points.iter();
let mut difficulty_points = map.difficulty_points.iter();
Self {
next_timing: next_tuple!(timing_points, (time, beat_len)),
next_difficulty: next_tuple!(difficulty_points, (time, speed_multiplier)),
timing_points,
difficulty_points,
}
}
}
pub(crate) enum ControlPoint {
Timing { time: f32, beat_len: f32 },
Difficulty { time: f32, speed_mult: f32 },
}
impl ControlPoint {
#[inline]
pub(crate) fn time(&self) -> f32 {
match self {
Self::Timing { time, .. } => *time,
Self::Difficulty { time, .. } => *time,
}
}
}
impl<'p> Iterator for ControlPointIter<'p> {
type Item = ControlPoint;
fn next(&mut self) -> Option<Self::Item> {
match (self.next_timing, self.next_difficulty) {
(Some((time, beat_len)), Some((d, _))) if time <= d => {
self.next_timing = next_tuple!(self.timing_points, (time, beat_len));
Some(ControlPoint::Timing { time, beat_len })
}
(_, Some((time, speed_mult))) => {
self.next_difficulty =
next_tuple!(self.difficulty_points, (time, speed_multiplier));
Some(ControlPoint::Difficulty { time, speed_mult })
}
(Some((time, beat_len)), None) => {
self.next_timing = next_tuple!(self.timing_points, (time, beat_len));
Some(ControlPoint::Timing { time, beat_len })
}
(None, None) => None,
}
}
}
osu/src/versions/no_leniency/difficulty_object.rs
+13 -24
View File
@@ -1,9 +1,7 @@
use super::OsuObject;
const NORMALIZED_RADIUS: f32 = 52.0;
pub(crate) struct DifficultyObject {
pub(crate) base: OsuObject,
pub(crate) struct DifficultyObject<'h> {
pub(crate) base: &'h OsuObject,
pub(crate) prev: Option<(f32, f32)>, // (jump_dist, strain_time)
pub(crate) jump_dist: f32,
@@ -14,28 +12,21 @@ pub(crate) struct DifficultyObject {
pub(crate) strain_time: f32,
}
impl DifficultyObject {
impl<'h> DifficultyObject<'h> {
pub(crate) fn new(
base: OsuObject,
prev: OsuObject,
prev_diff: Option<DifficultyObject>,
base: &'h OsuObject,
prev: &OsuObject,
prev_vals: Option<(f32, f32)>, // (jump_dist, strain_time)
prev_prev: Option<OsuObject>,
clock_rate: f32,
radius: f32,
scaling_factor: f32,
) -> Self {
let delta = (base.time() - prev.time()) / clock_rate;
let delta = (base.time - prev.time) / clock_rate;
let strain_time = delta.max(50.0);
let mut scaling_factor = NORMALIZED_RADIUS / radius;
if radius < 30.0 {
let small_circle_bonus = (30.0 - radius).min(5.0) / 50.0;
scaling_factor *= 1.0 + small_circle_bonus;
}
let pos = base.pos();
let travel_dist = prev.travel_dist();
let prev_cursor_pos = prev.pos();
let pos = base.pos;
let travel_dist = prev.travel_dist.unwrap_or(0.0);
let prev_cursor_pos = prev.end_pos;
let jump_dist = if base.is_spinner() {
0.0
@@ -44,7 +35,7 @@ impl DifficultyObject {
};
let angle = prev_prev.map(|prev_prev| {
let prev_prev_cursor_pos = prev_prev.pos();
let prev_prev_cursor_pos = prev_prev.end_pos;
let v1 = prev_prev_cursor_pos - prev_cursor_pos;
let v2 = pos - prev_cursor_pos;
@@ -55,11 +46,9 @@ impl DifficultyObject {
det.atan2(dot).abs()
});
let prev = prev_diff.map(|o| (o.jump_dist, o.strain_time));
Self {
base,
prev,
prev: prev_vals,
jump_dist,
travel_dist,
osu/src/versions/no_leniency/mod.rs
+88 -79
View File
@@ -1,129 +1,131 @@
use crate::DifficultyAttributes;
mod control_point_iter;
mod difficulty_object;
mod osu_object;
mod skill;
mod skill_kind;
mod slider_state;
use difficulty_object::DifficultyObject;
use osu_object::OsuObject;
use skill::Skill;
use skill_kind::SkillKind;
use slider_state::SliderState;
use parse::{Beatmap, Mods};
const OBJECT_RADIUS: f32 = 64.0;
const SECTION_LEN: f32 = 400.0;
const DIFFICULTY_MULTIPLIER: f32 = 0.0675;
const NORMALIZED_RADIUS: f32 = 52.0;
/// Star calculation for osu!standard maps
/// Star calculation for osu!standard maps.
///
/// Slider paths are considered but stack leniency is ignored.
/// As most maps don't even make use of leniency and even if,
/// it has generally little effect on stars, the results are close to perfect.
/// This version is considerably more efficient than `all_included` since
/// processing stack leniency is relatively expensive.
pub fn stars(map: &Beatmap, mods: impl Mods) -> DifficultyAttributes {
let attributes = map.attributes().mods(mods);
let mut diff_attributes = DifficultyAttributes {
ar: attributes.ar,
od: attributes.od,
..Default::default()
};
if map.hit_objects.len() < 2 {
return DifficultyAttributes {
stars: 0.0,
ar: attributes.ar,
od: attributes.od,
speed_strain: 0.0,
aim_strain: 0.0,
max_combo: 0,
n_circles: 0,
n_spinners: 0,
};
return diff_attributes;
}
let section_len = SECTION_LEN * attributes.clock_rate;
let radius = OBJECT_RADIUS * (1.0 - 0.7 * (attributes.cs - 5.0) / 5.0) / 2.0;
let mut scaling_factor = NORMALIZED_RADIUS / radius;
if radius < 30.0 {
let small_circle_bonus = (30.0 - radius).min(5.0) / 50.0;
scaling_factor *= 1.0 + small_circle_bonus;
}
let mut slider_state = SliderState::new(&map);
let mut hit_objects = map
.hit_objects
.iter()
.map(|h| OsuObject::new(h, map, &attributes));
.map(|h| OsuObject::new(h, map, radius, &mut diff_attributes, &mut slider_state));
let mut skills = vec![Skill::new(SkillKind::Aim), Skill::new(SkillKind::Speed)];
let mut aim = Skill::new(SkillKind::Aim);
let mut speed = Skill::new(SkillKind::Speed);
// First object has no predecessor and thus no strain, handle distinctly
let mut current_section_end =
(map.hit_objects[0].start_time / section_len).ceil() * section_len;
let mut prev_prev = None;
let mut prev = hit_objects.next().unwrap();
let mut prev_diff = None;
let mut prev_vals = None;
let mut _i = 0;
// Handle second object separately to remove later if-branching
let curr = hit_objects.next().unwrap();
let h = DifficultyObject::new(
&curr,
&prev,
prev_vals,
prev_prev,
attributes.clock_rate,
scaling_factor,
);
aim.process(&h);
speed.process(&h);
prev_prev = Some(prev);
prev_vals = Some((h.jump_dist, h.strain_time));
prev = curr;
// Handle all other objects
for curr in hit_objects {
let h = DifficultyObject::new(
curr.clone(),
prev.clone(),
prev_diff,
&curr,
&prev,
prev_vals,
prev_prev,
attributes.clock_rate,
radius,
scaling_factor,
);
// println!(
// "strain_time={} | travel_dist={} | jump_dist={} | angle={:?}",
// h.strain_time, h.travel_dist, h.jump_dist, h.angle
// );
// println!("[{}] time={}", _i, curr.time());
while h.base.time() > current_section_end {
for skill in skills.iter_mut() {
skill.save_current_peak();
skill.start_new_section_from(current_section_end);
_i += 1;
}
while h.base.time > current_section_end {
aim.save_current_peak();
aim.start_new_section_from(current_section_end);
speed.save_current_peak();
speed.start_new_section_from(current_section_end);
current_section_end += section_len;
}
for skill in skills.iter_mut() {
skill.process(&h);
}
aim.process(&h);
speed.process(&h);
prev_prev = Some(prev);
prev_vals = Some((h.jump_dist, h.strain_time));
prev = curr;
prev_diff = Some(h);
}
for skill in skills.iter_mut() {
skill.save_current_peak();
}
aim.save_current_peak();
speed.save_current_peak();
// println!("Aim:");
// for (i, strain) in skills[0].strain_peaks.iter().enumerate() {
// println!("{}: {}", i, strain);
// }
let aim_strain = aim.difficulty_value().sqrt() * DIFFICULTY_MULTIPLIER;
let speed_strain = speed.difficulty_value().sqrt() * DIFFICULTY_MULTIPLIER;
// println!("Speed:");
// for (i, strain) in skills[1].strain_peaks.iter().enumerate() {
// println!("{}: {}", i, strain);
// }
let stars = aim_strain + speed_strain + (aim_strain - speed_strain).abs() / 2.0;
// println!("Aim: {:?}", skills[0].strain_peaks);
// println!("Speed: {:?}", skills[1].strain_peaks);
diff_attributes.stars = stars;
diff_attributes.speed_strain = speed_strain;
diff_attributes.aim_strain = aim_strain;
let aim_rating = skills[0].difficulty_value().sqrt() * DIFFICULTY_MULTIPLIER;
// println!("After:\n{:?}", skills[0].strain_peaks);
let speed_rating = skills[1].difficulty_value().sqrt() * DIFFICULTY_MULTIPLIER;
// println!("After:\n{:?}", skills[1].strain_peaks);
let stars = aim_rating + speed_rating + (aim_rating - speed_rating).abs() / 2.0;
DifficultyAttributes {
stars,
ar: attributes.ar,
od: attributes.od,
speed_strain: speed_rating,
aim_strain: aim_rating,
max_combo: 0, // TODO
n_circles: 0, // TODO
n_spinners: 0, // TODO
}
diff_attributes
}
#[cfg(test)]
@@ -135,14 +137,14 @@ mod tests {
#[test]
fn no_leniency_single_stars() {
// let file = match File::open("E:/Games/osu!/beatmaps/1851299.osu") {
// Ok(file) => file,
// Err(why) => panic!("Could not open file: {}", why),
// };
let file = match File::open("C:/Users/Max/Desktop/2578801.osu") {
let file = match File::open("./test/70090.osu") {
Ok(file) => file,
Err(why) => panic!("Could not open file: {}", why),
};
// let file = match File::open("C:/Users/Max/Desktop/2578801.osu") {
// Ok(file) => file,
// Err(why) => panic!("Could not open file: {}", why),
// };
let map = match Beatmap::parse(file) {
Ok(map) => map,
@@ -215,23 +217,30 @@ mod tests {
#[test]
fn no_leniency_single_pp() {
// let file = match File::open("E:/Games/osu!/beatmaps/1851299.osu") {
// Ok(file) => file,
// Err(why) => panic!("Could not open file: {}", why),
// };
let file = match File::open("C:/Users/Max/Desktop/2578801.osu") {
let file = match File::open("E:/Games/osu!/beatmaps/1241370.osu") {
Ok(file) => file,
Err(why) => panic!("Could not open file: {}", why),
};
// let file = match File::open("C:/Users/Max/Desktop/2578801.osu") {
// Ok(file) => file,
// Err(why) => panic!("Could not open file: {}", why),
// };
let map = match Beatmap::parse(file) {
Ok(map) => map,
Err(why) => panic!("Error while parsing map: {}", why),
};
let calculator = PpCalculator::new(&map).mods(0);
let calculator = PpCalculator::new(&map)
// .misses(2)
// .accuracy(96.78)
// .combo(1876)
// .n100(0)
.mods(8 + 16);
let result = calculator.calculate(stars);
println!("Stars: {}", result.attributes.stars);
println!("PP: {}", result.pp);
}
}
osu/src/versions/no_leniency/osu_object.rs
+104 -282
View File
@@ -1,101 +1,64 @@
#![allow(unused)]
use super::slider_state::SliderState;
use crate::{curve::Curve, DifficultyAttributes};
use crate::curve::Curve;
use parse::{Beatmap, HitObject, HitObjectKind, PathType, Pos2};
use parse::{Beatmap, BeatmapAttributes, HitObject, HitObjectKind, PathType, Pos2};
use std::cmp::Ordering;
macro_rules! binary_search {
($slice:expr, $target:expr) => {
$slice.binary_search_by(|p| p.time.partial_cmp(&$target).unwrap_or(Ordering::Equal))
};
}
const OBJECT_RADIUS: f32 = 64.0;
const STACK_DIST: f32 = 3.0;
const LEGACY_LAST_TICK_OFFSET: f32 = 36.0;
#[derive(Clone)] // TODO: Remove clone
pub(crate) enum OsuObject {
Circle {
pos: Pos2,
time: f32,
},
Slider {
objects: Vec<SliderTick>,
cursor_end_pos: Pos2,
cursor_travel_dist: f32,
},
Spinner {
pos: Pos2,
time: f32,
},
pub(crate) struct OsuObject {
pub(crate) time: f32,
pub(crate) pos: Pos2,
pub(crate) end_pos: Pos2,
// circle: Some(0.0) | slider: Some(_) | spinner: None
pub(crate) travel_dist: Option<f32>,
}
impl OsuObject {
pub(crate) fn new(h: &HitObject, map: &Beatmap, attributes: &BeatmapAttributes) -> Self {
let pos = h.pos;
let time = h.start_time;
let scale = (1.0 - 0.7 * (attributes.cs - 5.0) / 5.0) / 2.0;
let mut stack_height = 0.0;
pub(crate) fn new(
h: &HitObject,
map: &Beatmap,
radius: f32,
attributes: &mut DifficultyAttributes,
slider_state: &mut SliderState,
) -> Self {
attributes.max_combo += 1; // hitcircle, slider head, or spinner
match &h.kind {
HitObjectKind::Circle => Self::Circle { pos, time },
HitObjectKind::Circle => {
attributes.n_circles += 1;
Self {
time: h.start_time,
pos: h.pos,
end_pos: h.pos,
travel_dist: Some(0.0),
}
}
HitObjectKind::Slider {
pixel_len,
repeats,
curve_points,
path_type,
} => {
let (beat_len, timing_time) = {
match binary_search!(map.timing_points, time) {
Ok(idx) => {
let point = &map.timing_points[idx];
(point.beat_len, point.time)
}
Err(0) => (1000.0, 0.0),
Err(idx) => {
let point = &map.timing_points[idx - 1];
(point.beat_len, point.time)
}
}
};
let (speed_multiplier, diff_time) = {
match binary_search!(map.difficulty_points, time) {
Ok(idx) => {
let point = &map.difficulty_points[idx];
(point.speed_multiplier, point.time)
}
Err(0) => (1.0, 0.0),
Err(idx) => {
let point = &map.difficulty_points[idx - 1];
(point.speed_multiplier, point.time)
}
}
};
// Key values which are computed here
let mut end_pos = h.pos;
let mut travel_dist = 0.0;
slider_state.update(h.start_time); // Responsible for timing point values
let approx_follow_circle_radius = radius * 3.0;
let mut tick_distance = 100.0 * map.sv / map.tick_rate;
if map.version >= 8 {
tick_distance /= (100.0 / speed_multiplier).max(10.0).min(1000.0) / 100.0;
tick_distance /=
(100.0 / slider_state.speed_mult).max(10.0).min(1000.0) / 100.0;
}
let spm = if timing_time > diff_time {
1.0
} else {
speed_multiplier
};
let duration = *repeats as f32 * beat_len * pixel_len / (map.sv * spm) / 100.0;
// let velocity = *pixel_len as f32 / duration;
// println!("duration={}", duration);
// println!("velocity={}", velocity);
let duration = *repeats as f32 * slider_state.beat_len * pixel_len
/ (map.sv * slider_state.speed_mult)
/ 100.0;
let span_duration = duration / *repeats as f32;
// Ensure path type validity
let path_type = if *path_type == PathType::PerfectCurve && curve_points.len() > 3 {
PathType::Bezier
} else if curve_points.len() == 2 {
@@ -104,6 +67,7 @@ impl OsuObject {
*path_type
};
// Build the curve w.r.t. the curve points
let curve = match path_type {
PathType::Linear => Curve::linear(curve_points[0], curve_points[1]),
PathType::Bezier => Curve::bezier(&curve_points),
@@ -111,122 +75,13 @@ impl OsuObject {
PathType::PerfectCurve => Curve::perfect(&curve_points),
};
let mut current_distance = tick_distance;
let time_add = duration * (tick_distance / (pixel_len * *repeats as f32));
// Called on each slider object except for the head.
// Increases combo and adjusts `end_pos` and `travel_dist`
// w.r.t. the object position at the given time on the slider curve.
let mut compute_vertex = |time: f32| {
attributes.max_combo += 1;
let target = pixel_len - tick_distance / 8.0;
let mut ticks = Vec::with_capacity((target / tick_distance) as usize);
while current_distance < target {
let pos = curve.point_at_distance(current_distance);
let time = h.start_time + time_add * (ticks.len() + 1) as f32;
ticks.push(SliderTick::new(pos, time));
current_distance += tick_distance;
}
let mut slider_objects = Vec::with_capacity(repeats * (ticks.len() + 1));
slider_objects.push(SliderTick::new(h.pos, h.start_time));
if *repeats <= 1 {
slider_objects.append(&mut ticks);
} else {
slider_objects.append(&mut ticks.clone());
for repeat_id in 1..repeats - 1 {
let dist = (repeat_id % 2) as f32 * pixel_len;
let time_offset = (duration / *repeats as f32) * repeat_id as f32;
let pos = curve.point_at_distance(dist);
// Reverse tick / last legacy tick
slider_objects.push(SliderTick::new(pos, h.start_time + time_offset));
ticks.reverse();
slider_objects.extend_from_slice(&ticks); // tick time doesn't need to be adjusted for some reason
}
// Handling last span separatly so that `ticks` vector isn't cloned again
let dist = ((repeats - 1) % 2) as f32 * pixel_len;
let time_offset = (duration / *repeats as f32) * (repeats - 1) as f32;
let pos = curve.point_at_distance(dist);
slider_objects.push(SliderTick::new(pos, h.start_time + time_offset));
ticks.reverse();
slider_objects.append(&mut ticks);
}
// Slider tail
let span_duration = duration / *repeats as f32;
let final_span_idx = repeats.saturating_sub(1);
let final_span_start_time = h.start_time + final_span_idx as f32 * span_duration;
let final_span_end_time = (h.start_time + duration / 2.0)
.max(final_span_start_time + span_duration - LEGACY_LAST_TICK_OFFSET);
let mut final_progress =
(final_span_end_time - final_span_start_time) / span_duration;
if *repeats & 1 == 0 {
final_progress = 1.0 - final_progress;
}
// println!(
// "final_span_index={} | final_span_start_time={} | \
// final_span_end_time={} | final_progress={}",
// final_span_idx, final_span_start_time, final_span_end_time, final_progress
// );
// println!("len={}", final_progress * *pixel_len as f32);
let dist_end = (repeats % 2) as f32 * pixel_len;
let pos = curve.point_at_distance(dist_end);
slider_objects.push(SliderTick::new(pos, final_span_end_time));
// println!(
// "start_time={} | span_duration={} | vel={} | \
// tick_dist={} | dist={} | span_count={} | \
// legacy_last_tick_offset={}",
// h.start_time,
// duration / *repeats as f32,
// *pixel_len as f32 / duration,
// tick_distance,
// *pixel_len,
// *repeats,
// 36
// );
// println!("> Slider: {:?}", slider_objects);
let radius = OBJECT_RADIUS * scale;
let stack_offset = {
let c = stack_height * scale * -6.4;
Pos2 { x: c, y: c }
};
// println!("radius={} | stack_offset={:?}", radius, stack_offset);
let pos = h.pos;
let stacked_pos = pos + stack_offset; // TODO: Simplify for below
// println!(
// "stacked_pos = {:?} + {:?} = {:?}",
// pos, stack_offset, stacked_pos
// );
let mut cursor_end_pos = stacked_pos;
let mut cursor_travel_dist = 0.0;
let approx_follow_circle_radius = radius * 3.0;
// println!(
// "stacked_pos={:?} | approx_follow_circle_radius={}",
// stacked_pos, approx_follow_circle_radius
// );
// let mut curr_offset = tick_distance;
for (i, tick) in slider_objects.iter().skip(1).enumerate() {
let mut progress = (tick.time - h.start_time) / span_duration;
let mut progress = (time - h.start_time) / span_duration;
if progress % 2.0 >= 1.0 {
progress = 1.0 - progress % 1.0;
@@ -237,116 +92,83 @@ impl OsuObject {
let curr_dist = pixel_len * progress;
let curr_pos = curve.point_at_distance(curr_dist);
let diff = stacked_pos + curr_pos - pos - cursor_end_pos;
let diff = curr_pos - end_pos;
let mut dist = diff.length();
// println!(
// "position at: progress=? | d={} => {:?}",
// curr_offset, tick.pos
// );
// curr_offset += tick_distance;
println!(
"[{}] diff = {:?} + {:?} - {:?} = {:?} | dist={}",
i,
stacked_pos,
tick.pos - pos,
cursor_end_pos,
diff,
dist
);
// println!("{} > {}", dist, approx_follow_circle_radius);
if dist > approx_follow_circle_radius {
let normalized = diff.normalize();
// println!("diff before: {:?}", diff);
// println!("diff after: {:?}", normalized);
dist -= approx_follow_circle_radius;
cursor_end_pos += normalized * dist;
end_pos += diff.normalize() * dist;
travel_dist += dist;
}
};
// println!("+= {} * {} => {:?}", normalized, dist, cursor_end_pos);
let mut current_distance = tick_distance;
let time_add = duration * (tick_distance / (pixel_len * *repeats as f32));
cursor_travel_dist += dist;
// println!("+= {} => {}", dist, cursor_travel_dist);
let target = pixel_len - tick_distance / 8.0;
let mut ticks = Vec::with_capacity((target / tick_distance) as usize);
// Tick of the first span
if current_distance < target {
for tick_idx in 1.. {
let time = h.start_time + time_add * tick_idx as f32;
compute_vertex(time);
ticks.push(time);
current_distance += tick_distance;
if current_distance >= target {
break;
}
}
}
println!("cursor_travel_dist={}", cursor_travel_dist);
// Other spans
if *repeats > 1 {
for repeat_id in 1..*repeats {
let time_offset = (duration / *repeats as f32) * repeat_id as f32;
println!("---");
// Reverse tick
compute_vertex(h.start_time + time_offset);
Self::Slider {
objects: slider_objects,
// Actual ticks
if repeat_id & 1 == 1 {
ticks.iter().rev().for_each(|&time| compute_vertex(time));
} else {
ticks.iter().for_each(|&time| compute_vertex(time));
}
}
}
cursor_end_pos,
cursor_travel_dist,
// Slider tail
let final_span_idx = repeats.saturating_sub(1);
let final_span_start_time = h.start_time + final_span_idx as f32 * span_duration;
let final_span_end_time = (h.start_time + duration / 2.0)
.max(final_span_start_time + span_duration - LEGACY_LAST_TICK_OFFSET);
compute_vertex(final_span_end_time);
Self {
time: h.start_time,
pos: h.pos,
end_pos,
travel_dist: Some(travel_dist),
}
}
HitObjectKind::Spinner { .. } => {
attributes.n_spinners += 1;
Self {
time: h.start_time,
pos: h.pos,
end_pos: h.pos,
travel_dist: None,
}
}
HitObjectKind::Spinner { .. } => Self::Spinner { pos, time },
HitObjectKind::Hold { .. } => panic!("found Hold object in osu!standard file"),
}
}
#[inline]
pub(crate) fn time(&self) -> f32 {
match self {
Self::Circle { time, .. } => *time,
Self::Slider { objects, .. } => objects[0].time,
Self::Spinner { time, .. } => *time,
}
}
#[inline]
pub(crate) fn travel_dist(&self) -> f32 {
match self {
Self::Slider {
cursor_travel_dist, ..
} => *cursor_travel_dist,
_ => 0.0,
}
}
#[inline]
pub(crate) fn cursor_end_position(&self) -> Pos2 {
match self {
Self::Circle { pos, .. } => *pos,
Self::Slider { cursor_end_pos, .. } => *cursor_end_pos,
Self::Spinner { pos, .. } => *pos,
}
}
#[inline]
pub(crate) fn is_spinner(&self) -> bool {
matches!(self, Self::Spinner { .. })
}
// TODO: Remove pub
#[inline]
pub fn pos(&self) -> Pos2 {
match self {
Self::Circle { pos, .. } => *pos,
Self::Slider { objects, .. } => objects[0].pos,
Self::Spinner { .. } => Pos2::default(),
}
}
}
#[derive(Copy, Clone)]
pub(crate) struct SliderTick {
pos: Pos2,
time: f32,
}
impl SliderTick {
fn new(pos: Pos2, time: f32) -> Self {
Self { pos, time }
}
}
// TODO: Remove
impl std::fmt::Debug for SliderTick {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "{{pos={:?} | time={}}}", self.pos, self.time)
self.travel_dist.is_none()
}
}
osu/src/versions/no_leniency/skill.rs
+5 -9
View File
@@ -11,11 +11,11 @@ const AIM_STRAIN_DECAY_BASE: f32 = 0.15;
const DECAY_WEIGHT: f32 = 0.9;
pub(crate) struct Skill {
pub current_strain: f32,
current_strain: f32,
current_section_peak: f32,
kind: SkillKind,
pub strain_peaks: Vec<f32>, // TODO: Remove pub
strain_peaks: Vec<f32>,
prev_time: Option<f32>,
}
@@ -36,16 +36,12 @@ impl Skill {
#[inline]
pub(crate) fn save_current_peak(&mut self) {
if self.prev_time.is_some() {
self.strain_peaks.push(self.current_section_peak);
}
self.strain_peaks.push(self.current_section_peak);
}
#[inline]
pub(crate) fn start_new_section_from(&mut self, time: f32) {
if let Some(prev) = self.prev_time {
self.current_section_peak = self.peak_strain(time - prev);
}
self.current_section_peak = self.peak_strain(time - self.prev_time.unwrap());
}
#[inline]
@@ -53,7 +49,7 @@ impl Skill {
self.current_strain *= self.strain_decay(current.delta);
self.current_strain += self.kind.strain_value_of(&current) * self.skill_multiplier();
self.current_section_peak = self.current_section_peak.max(self.current_strain);
self.prev_time.replace(current.base.time());
self.prev_time.replace(current.base.time);
}
pub(crate) fn difficulty_value(&mut self) -> f32 {
osu/src/versions/no_leniency/skill_kind.rs
-19
View File
@@ -26,8 +26,6 @@ impl SkillKind {
return 0.0;
}
// println!("pos={:?}", current.base.pos());
let mut result = 0.0;
if let Some((prev_jump_dist, prev_strain_time)) = current.prev {
@@ -39,23 +37,14 @@ impl SkillKind {
* (current.jump_dist - scale).max(0.0))
.sqrt();
// println!("angle_bonus={}", angle_bonus);
result = 1.5 * apply_diminishing_exp(angle_bonus.max(0.0))
/ (TIMING_THRESHOLD).max(prev_strain_time)
} else {
// println!("nop");
}
} else {
// println!("no prev");
}
let jump_dist_exp = apply_diminishing_exp(current.jump_dist);
let travel_dist_exp = apply_diminishing_exp(current.travel_dist);
// println!("jump_dist={} => {}", current.jump_dist, jump_dist_exp);
// println!("travel_dist={} => {}", current.travel_dist, travel_dist_exp);
let dist_exp =
jump_dist_exp + travel_dist_exp + (travel_dist_exp * jump_dist_exp).sqrt();
@@ -79,8 +68,6 @@ impl SkillKind {
let mut angle_bonus = 1.0;
// println!("angle: {:?}", current.angle);
if let Some(angle) = current.angle.filter(|a| *a < SPEED_ANGLE_BONUS_BEGIN) {
let exp_base = (1.5 * (SPEED_ANGLE_BONUS_BEGIN - angle)).sin();
angle_bonus = 1.0 + exp_base * exp_base / 3.57;
@@ -88,7 +75,6 @@ impl SkillKind {
if angle < PI_OVER_2 {
angle_bonus = 1.28;
// TODO: Improve ifs
if dist < 90.0 && angle < PI_OVER_4 {
angle_bonus += (1.0 - angle_bonus) * ((90.0 - dist) / 10.0).min(1.0);
} else if dist < 90.0 {
@@ -99,11 +85,6 @@ impl SkillKind {
}
}
// println!(
// "dist={} | speed_bonus={} | angle_bonus={}",
// dist, speed_bonus, angle_bonus
// );
(1.0 + (speed_bonus - 1.0) * 0.75)
* angle_bonus
* (0.95 + speed_bonus * (dist / SINGLE_SPACING_TRESHOLD).powf(3.5))
osu/src/versions/no_leniency/slider_state.rs
+45
View File
@@ -0,0 +1,45 @@
use super::control_point_iter::{ControlPoint, ControlPointIter};
use parse::Beatmap;
pub(crate) struct SliderState<'p> {
control_points: ControlPointIter<'p>,
next: Option<ControlPoint>,
pub(crate) beat_len: f32,
pub(crate) speed_mult: f32,
}
impl<'p> SliderState<'p> {
#[inline]
pub(crate) fn new(map: &'p Beatmap) -> Self {
let mut control_points = ControlPointIter::new(map);
let (beat_len, speed_mult) = match control_points.next() {
Some(ControlPoint::Timing { beat_len, .. }) => (beat_len, 1.0),
Some(ControlPoint::Difficulty { speed_mult, .. }) => (1000.0, speed_mult),
None => (1000.0, 1.0),
};
Self {
next: control_points.next(),
control_points,
beat_len,
speed_mult,
}
}
#[inline]
pub(crate) fn update(&mut self, time: f32) {
while let Some(next) = self.next.as_ref().filter(|n| time >= n.time()) {
match next {
ControlPoint::Timing { beat_len, .. } => {
self.beat_len = *beat_len;
self.speed_mult = 1.0;
}
ControlPoint::Difficulty { speed_mult, .. } => self.speed_mult = *speed_mult,
}
self.next = self.control_points.next();
}
}
}
osu/src/versions/no_sliders_no_leniency/control_point_iter.rs
+1 -1
View File
@@ -36,7 +36,7 @@ impl<'p> Iterator for ControlPointIter<'p> {
fn next(&mut self) -> Option<Self::Item> {
match (self.next_timing, self.next_difficulty) {
(Some(time), Some((d, _))) if time < d => {
(Some(time), Some((d, _))) if time <= d => {
self.next_timing = self.timing_points.next().map(|t| t.time);
Some(ControlPoint::Timing { time })
osu/src/versions/no_sliders_no_leniency/mod.rs
+9 -9
View File
@@ -172,8 +172,8 @@ mod tests {
use std::fs::File;
#[test]
fn no_sliders_no_leniency_single_stars() {
let file = match File::open("E:/Games/osu!/beatmaps/1241370.osu") {
fn no_sliders_single_stars() {
let file = match File::open("E:/Games/osu!/beatmaps/70090.osu") {
Ok(file) => file,
Err(why) => panic!("Could not open file: {}", why),
};
@@ -187,14 +187,14 @@ mod tests {
Err(why) => panic!("Error while parsing map: {}", why),
};
let stars = stars(&map, 0).stars;
let stars = stars(&map, 1024 + 8 + 64 + 16).stars;
println!("Stars: {}", stars);
}
#[test]
#[ignore]
fn no_sliders_no_leniency_stars() {
fn no_sliders_stars() {
let margin = 0.5;
#[rustfmt::skip]
@@ -252,7 +252,7 @@ mod tests {
}
#[test]
fn no_sliders_no_leniency_single_pp() {
fn no_sliders_single_pp() {
let file = match File::open("E:/Games/osu!/beatmaps/1241370.osu") {
Ok(file) => file,
Err(why) => panic!("Could not open file: {}", why),
@@ -268,11 +268,11 @@ mod tests {
};
let calculator = PpCalculator::new(&map)
// .misses(2)
// .accuracy(96.78)
// .combo(100)
.misses(2)
.accuracy(96.78)
.combo(1876)
// .n100(0)
.mods(0);
.mods(8 + 16);
let result = calculator.calculate(stars);