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

fruits, mania & taiko: handle 2nd object separately

Browse Source
This commit is contained in:
MaxOhn
2021-01-16 09:55:45 +01:00
parent 260939a7ec
commit c95de10b9b
8 changed files with 194 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/fruits/mod.rs
+26
View File
@@ -205,6 +205,32 @@ pub fn stars(map: &Beatmap, mods: impl Mods) -> DifficultyAttributes {
&mut last_excess,
);
// Handle second object separately to remove later if-branching
let next = hit_objects.next().unwrap();
curr.init_hyper_dash(
half_catcher_width,
&next,
&mut last_direction,
&mut last_excess,
);
let h = DifficultyObject::new(
&curr,
&prev,
movement.half_catcher_width,
attributes.clock_rate,
);
while h.base.time > current_section_end {
current_section_end += section_len;
}
movement.process(&h);
prev = curr;
curr = next;
// Handle all other objects
for next in hit_objects {
curr.init_hyper_dash(
half_catcher_width,
src/fruits/movement.rs
+2 -7
View File
@@ -47,17 +47,12 @@ impl Movement {
#[inline]
pub(crate) fn save_current_peak(&mut self) {
// TODO: Remove branching
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_time) = self.prev_time {
self.current_section_peak = self.peak_strain(time - prev_time);
}
self.current_section_peak = self.peak_strain(time - self.prev_time.unwrap());
}
pub(crate) fn process(&mut self, current: &DifficultyObject) {
src/mania/mod.rs
+14 -129
View File
@@ -1,5 +1,7 @@
mod pp;
mod strain;
pub use pp::*;
use strain::Strain;
use crate::{Beatmap, HitObject, Mods};
@@ -9,7 +11,7 @@ const STAR_SCALING_FACTOR: f32 = 0.018;
/// Star calculation for osu!mania maps
pub fn stars(map: &Beatmap, mods: impl Mods) -> f32 {
if map.hit_objects.is_empty() {
if map.hit_objects.len() < 2 {
return 0.0;
}
@@ -17,7 +19,7 @@ pub fn stars(map: &Beatmap, mods: impl Mods) -> f32 {
let section_len = SECTION_LEN * clock_rate;
let mut strain = Strain::new(map.cs as u8);
let hit_objects = map
let mut hit_objects = map
.hit_objects
.iter()
.skip(1)
@@ -28,6 +30,16 @@ pub fn stars(map: &Beatmap, mods: impl Mods) -> f32 {
let mut current_section_end =
(map.hit_objects[0].start_time / section_len).ceil() * section_len;
// Handle second object separately to remove later if-branching
let h = hit_objects.next().unwrap();
while h.base.start_time > current_section_end {
current_section_end += section_len;
}
strain.process(&h);
// Handle all other objects
for h in hit_objects {
while h.base.start_time > current_section_end {
strain.save_current_peak();
@@ -64,133 +76,6 @@ impl<'o> DifficultyHitObject<'o> {
}
}
pub struct PpResult {
pub pp: f32,
pub stars: f32,
}
pub trait PpProvider {
fn pp(&self) -> PpCalculator;
}
impl PpProvider for Beatmap {
#[inline]
fn pp(&self) -> PpCalculator {
PpCalculator::new(self)
}
}
// TODO: Allow partial plays
pub struct PpCalculator<'m> {
map: &'m Beatmap,
stars: Option<f32>,
mods: u32,
score: f32,
}
impl<'m> PpCalculator<'m> {
#[inline]
pub fn new(map: &'m Beatmap) -> Self {
Self {
map,
stars: None,
mods: 0,
score: 1_000_000.0,
}
}
#[inline]
pub fn stars(mut self, stars: f32) -> Self {
self.stars.replace(stars);
self
}
#[inline]
pub fn mods(mut self, mods: u32) -> Self {
self.mods = mods;
self
}
#[inline]
pub fn score(mut self, score: u32) -> Self {
self.score = score as f32;
self
}
pub fn calculate(self) -> PpResult {
let stars = self.stars.unwrap_or_else(|| stars(self.map, self.mods));
let ez = self.mods.ez();
let nf = self.mods.nf();
let ht = self.mods.ht();
let score_multiplier = 0.5_f32.powi(ez as i32 + nf as i32 + ht as i32);
let scaled_score = self.score / score_multiplier;
let mut multiplier = 0.8;
if nf {
multiplier *= 0.9;
}
if ez {
multiplier *= 0.5;
}
let hit_window = {
let od = (10.0 - self.map.od).max(0.0).min(10.0);
let mut val = 34.0 + 3.0 * od;
if ez {
val *= 1.4;
} else if self.mods.hr() {
val /= 1.4;
}
val * self.mods.speed()
};
let strain_value = self.compute_strain(scaled_score, stars);
let acc_value = self.compute_accuracy_value(scaled_score, strain_value, hit_window);
let pp = (strain_value.powf(1.1) + acc_value.powf(1.1)).powf(1.0 / 1.1) * multiplier;
PpResult { pp, stars }
}
fn compute_strain(&self, score: f32, stars: f32) -> f32 {
let mut strain_value = (5.0 * (stars / 0.2).max(1.0) - 4.0).powf(2.2) / 135.0;
strain_value *= 1.0 + 0.1 * (self.map.hit_objects.len() as f32 / 1500.0).min(1.0);
if score <= 500_000.0 {
strain_value = 0.0;
} else if score <= 600_000.0 {
strain_value *= (score - 500_000.0) / 100_000.0 * 0.3;
} else if score <= 700_000.0 {
strain_value *= 0.3 + (score - 600_000.0) / 100_000.0 * 0.25;
} else if score <= 800_000.0 {
strain_value *= 0.55 + (score - 700_000.0) / 100_000.0 * 0.2;
} else if score <= 900_000.0 {
strain_value *= 0.75 + (score - 800_000.0) / 100_000.0 * 0.15;
} else {
strain_value *= 0.9 + (score - 900_000.0) / 100_000.0 * 0.1;
}
strain_value
}
#[inline]
fn compute_accuracy_value(&self, score: f32, strain: f32, hit_window: f32) -> f32 {
(0.2 - (hit_window - 34.0) * 0.006667).max(0.0)
* strain
* ((score - 960_000.0).max(0.0) / 40_000.0).powf(1.1)
}
}
#[cfg(test)]
mod tests {
use super::*;
src/mania/pp.rs
+129
View File
@@ -0,0 +1,129 @@
use super::stars;
use crate::{Beatmap, Mods};
pub struct PpResult {
pub pp: f32,
pub stars: f32,
}
pub trait PpProvider {
fn pp(&self) -> PpCalculator;
}
impl PpProvider for Beatmap {
#[inline]
fn pp(&self) -> PpCalculator {
PpCalculator::new(self)
}
}
// TODO: Allow partial plays
pub struct PpCalculator<'m> {
map: &'m Beatmap,
stars: Option<f32>,
mods: u32,
score: f32,
}
impl<'m> PpCalculator<'m> {
#[inline]
pub fn new(map: &'m Beatmap) -> Self {
Self {
map,
stars: None,
mods: 0,
score: 1_000_000.0,
}
}
#[inline]
pub fn stars(mut self, stars: f32) -> Self {
self.stars.replace(stars);
self
}
#[inline]
pub fn mods(mut self, mods: u32) -> Self {
self.mods = mods;
self
}
#[inline]
pub fn score(mut self, score: u32) -> Self {
self.score = score as f32;
self
}
pub fn calculate(self) -> PpResult {
let stars = self.stars.unwrap_or_else(|| stars(self.map, self.mods));
let ez = self.mods.ez();
let nf = self.mods.nf();
let ht = self.mods.ht();
let score_multiplier = 0.5_f32.powi(ez as i32 + nf as i32 + ht as i32);
let scaled_score = self.score / score_multiplier;
let mut multiplier = 0.8;
if nf {
multiplier *= 0.9;
}
if ez {
multiplier *= 0.5;
}
let hit_window = {
let od = (10.0 - self.map.od).max(0.0).min(10.0);
let mut val = 34.0 + 3.0 * od;
if ez {
val *= 1.4;
} else if self.mods.hr() {
val /= 1.4;
}
val * self.mods.speed()
};
let strain_value = self.compute_strain(scaled_score, stars);
let acc_value = self.compute_accuracy_value(scaled_score, strain_value, hit_window);
let pp = (strain_value.powf(1.1) + acc_value.powf(1.1)).powf(1.0 / 1.1) * multiplier;
PpResult { pp, stars }
}
fn compute_strain(&self, score: f32, stars: f32) -> f32 {
let mut strain_value = (5.0 * (stars / 0.2).max(1.0) - 4.0).powf(2.2) / 135.0;
strain_value *= 1.0 + 0.1 * (self.map.hit_objects.len() as f32 / 1500.0).min(1.0);
if score <= 500_000.0 {
strain_value = 0.0;
} else if score <= 600_000.0 {
strain_value *= (score - 500_000.0) / 100_000.0 * 0.3;
} else if score <= 700_000.0 {
strain_value *= 0.3 + (score - 600_000.0) / 100_000.0 * 0.25;
} else if score <= 800_000.0 {
strain_value *= 0.55 + (score - 700_000.0) / 100_000.0 * 0.2;
} else if score <= 900_000.0 {
strain_value *= 0.75 + (score - 800_000.0) / 100_000.0 * 0.15;
} else {
strain_value *= 0.9 + (score - 900_000.0) / 100_000.0 * 0.1;
}
strain_value
}
#[inline]
fn compute_accuracy_value(&self, score: f32, strain: f32, hit_window: f32) -> f32 {
(0.2 - (hit_window - 34.0) * 0.006667).max(0.0)
* strain
* ((score - 960_000.0).max(0.0) / 40_000.0).powf(1.1)
}
}
src/osu/versions/no_leniency/mod.rs
+4
View File
@@ -85,6 +85,10 @@ pub fn stars(map: &Beatmap, mods: impl Mods) -> DifficultyAttributes {
scaling_factor,
);
while h.base.time > current_section_end {
current_section_end += section_len;
}
aim.process(&h);
speed.process(&h);
src/osu/versions/no_sliders_no_leniency/mod.rs
+4
View File
@@ -100,6 +100,10 @@ pub fn stars(map: &Beatmap, mods: impl Mods) -> DifficultyAttributes {
scaling_factor,
);
while h.base.start_time > current_section_end {
current_section_end += section_len;
}
aim.process(&h);
speed.process(&h);
src/taiko/mod.rs
+13 -1
View File
@@ -50,7 +50,7 @@ pub fn stars(map: &Beatmap, mods: impl Mods) -> f32 {
let mut current_section_end =
(map.hit_objects[0].start_time / section_len).ceil() * section_len;
let hit_objects = map
let mut hit_objects = map
.hit_objects
.iter()
.enumerate()
@@ -61,6 +61,18 @@ pub fn stars(map: &Beatmap, mods: impl Mods) -> f32 {
DifficultyObject::new(idx, base, prev, prev_prev, clock_rate)
});
// Handle second object separately to remove later if-branching
let h = hit_objects.next().unwrap();
while h.base.start_time > current_section_end {
current_section_end += section_len;
}
for skill in skills.iter_mut() {
skill.process(&h, &cheese);
}
// Handle all other objects
for h in hit_objects {
while h.base.start_time > current_section_end {
for skill in skills.iter_mut() {
src/taiko/skill.rs
+2 -6
View File
@@ -30,16 +30,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]