Struct peace_performance::OsuPP

pub struct OsuPP<'m> {
    pub map: &'m Beatmap,
    pub attributes: Option<DifficultyAttributes>,
    pub mods: u32,
    pub combo: Option<usize>,
    pub acc: Option<f32>,
    pub n300: Option<usize>,
    pub n100: Option<usize>,
    pub n50: Option<usize>,
    pub n_misses: usize,
    pub passed_objects: Option<usize>,
}

Calculator for pp on osu!standard maps.

Example

let map: Beatmap = ...
let pp_result: PpResult = OsuPP::new(&map)
    .mods(8 + 64) // HDDT
    .combo(1234)
    .misses(1)
    .accuracy(98.5) // should be set last
    .calculate();

println!("PP: {} | Stars: {}", pp_result.pp(), pp_result.stars());

let next_result = OsuPP::new(&map)
    .attributes(pp_result)  // reusing previous results for performance
    .mods(8 + 64)           // has to be the same to reuse attributes
    .accuracy(99.5)
    .calculate();

println!("PP: {} | Stars: {}", next_result.pp(), next_result.stars());

Fields

map: &'m Beatmap

attributes: Option<DifficultyAttributes>

mods: u32

combo: Option<usize>

acc: Option<f32>

n300: Option<usize>

n100: Option<usize>

n50: Option<usize>

n_misses: usize

passed_objects: Option<usize>

Implementations

impl<'m> OsuPP<'m>

pub fn new(map: &'m Beatmap) -> Self

pub fn attributes(self, attributes: impl OsuAttributeProvider) -> Self

OsuAttributeProvider is implemented by DifficultyAttributes and by PpResult meaning you can give the result of a star calculation or a pp calculation. If you already calculated the attributes for the current map-mod combination, be sure to put them in here so that they don’t have to be recalculated.

pub fn mods(self, mods: u32) -> Self

Specify mods through their bit values.

See https://github.com/ppy/osu-api/wiki#mods

pub fn combo(self, combo: usize) -> Self

Specify the max combo of the play.

pub fn n300(self, n300: usize) -> Self

Specify the amount of 300s of a play.

pub fn n100(self, n100: usize) -> Self

Specify the amount of 100s of a play.

pub fn n50(self, n50: usize) -> Self

Specify the amount of 50s of a play.

pub fn misses(self, n_misses: usize) -> Self

Specify the amount of misses of a play.

pub fn passed_objects(self, passed_objects: usize) -> Self

Amount of passed objects for partial plays, e.g. a fail.

pub fn accuracy(self, acc: f32) -> Self

Generate the hit results with respect to the given accuracy between 0 and 100.

Be sure to set misses beforehand! In case of a partial play, be also sure to set passed_objects beforehand!

pub fn set_accuracy(&mut self, acc: f32)

Set acc value

If it is used to calculate the PP of multiple different ACCs, it should be called from high to low according to the ACC value, otherwise it is invalid.

Examples:

// valid
let acc_100 = {
    c.set_accuracy(100.0);
    c.calculate().await
};
let acc_99 = {
    c.set_accuracy(99.0);
    c.calculate().await
};
let acc_98 = {
    c.set_accuracy(98.0);
    c.calculate().await
};
let acc_95 = {
    c.set_accuracy(95.0);
    c.calculate().await
};

// invalid
let acc_95 = {
    c.set_accuracy(95.0);
    c.calculate().await
};
let acc_98 = {
    c.set_accuracy(98.0);
    c.calculate().await
};
let acc_99 = {
    c.set_accuracy(99.0);
    c.calculate().await
};
let acc_100 = {
    c.set_accuracy(100.0);
    c.calculate().await
};

pub fn calculate(&mut self) -> PpResult

Returns an object which contains the pp and DifficultyAttributes containing stars and other attributes.

pub async fn calculate_async(&mut self) -> PpResult

Trait Implementations

impl<'m> Clone for OsuPP<'m>

fn clone(&self) -> OsuPP<'m>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'m> Debug for OsuPP<'m>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.