Struct rosu_pp::parse::Beatmap

pub struct Beatmap {

    pub mode: GameMode,
    pub version: u8,
    pub n_circles: u32,
    pub n_sliders: u32,
    pub n_spinners: u32,
    pub ar: f32,
    pub od: f32,
    pub cs: f32,
    pub hp: f32,
    pub slider_mult: f64,
    pub tick_rate: f64,
    pub hit_objects: Vec<HitObject>,
    pub timing_points: Vec<TimingPoint>,
    pub difficulty_points: Vec<DifficultyPoint>,
    pub stack_leniency: f32,
}

The main beatmap struct containing all data relevant for difficulty and pp calculation

Fields

mode: GameMode

The game mode.

version: u8

The version of the .osu file.

n_circles: u32

The amount of circles.

n_sliders: u32

The amount of sliders.

n_spinners: u32

The amount of spinners.

ar: f32

The approach rate.

od: f32

The overall difficulty.

cs: f32

The circle size.

hp: f32

The health drain rate.

slider_mult: f64

Base slider velocity in pixels per beat

tick_rate: f64

Amount of slider ticks per beat.

hit_objects: Vec<HitObject>

All hitobjects of the beatmap.

timing_points: Vec<TimingPoint>

Timing points that indicate a new timing section.

difficulty_points: Vec<DifficultyPoint>

Timing point for the current timing section.

stack_leniency: f32

The stack leniency that is used to calculate the stack offset for stacked positions.

Implementations

impl Beatmap

pub fn attributes(&self) -> BeatmapAttributes

Extract a beatmap’s attributes into their own type.

pub fn bpm(&self) -> f64

The beats per minute of the map.

impl Beatmap

pub fn parse<R: Read>(input: R) -> ParseResult<Self>

Parse a beatmap from a .osu file.

As argument you can give anything that implements std::io::Read. You’ll likely want to pass (a reference of) a File or the file’s content as a slice of bytes (&[u8]).

pub fn from_path<P: AsRef<Path>>(path: P) -> ParseResult<Self>

Pass the path to a .osu file.

Useful when you don’t want to create the File manually. If you have the file lying around already though (and plan on re-using it), passing &file to parse should be preferred.

Trait Implementations

impl BeatmapExt for Beatmap

fn stars(
    &self,
    mods: impl Mods,
    passed_objects: Option<usize>
) -> DifficultyAttributes

Calculate the stars and other attributes of a beatmap which are required for pp calculation.

fn max_pp(&self, mods: u32) -> PerformanceAttributes

Calculate the max pp of a beatmap.

fn pp(&self) -> AnyPP<'_>

Returns a builder for performance calculation.

fn strains(&self, mods: impl Mods) -> Strains

Calculate the strains of a map. This essentially performs the same calculation as a stars function but instead of evaluating the final strains, they are just returned as is.

fn gradual_difficulty(&self, mods: impl Mods) -> GradualDifficultyAttributes<'_>

Return an iterator that gives you the DifficultyAttributes after each hit object.

fn gradual_performance(&self, mods: u32) -> GradualPerformanceAttributes<'_>

Return a struct that gives you the PerformanceAttributes after every (few) hit object(s).

impl Clone for Beatmap

fn clone(&self) -> Beatmap

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Beatmap

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

Formats the value using the given formatter.

impl Default for Beatmap

fn default() -> Beatmap

Returns the “default value” for a type.