Struct rosu_pp::Beatmap

pub struct Beatmap {

    pub version: i32,
    pub is_convert: bool,
    pub stack_leniency: f32,
    pub mode: GameMode,
    pub ar: f32,
    pub cs: f32,
    pub hp: f32,
    pub od: f32,
    pub slider_multiplier: f64,
    pub slider_tick_rate: f64,
    pub breaks: Vec<BreakPeriod>,
    pub timing_points: Vec<TimingPoint>,
    pub difficulty_points: Vec<DifficultyPoint>,
    pub effect_points: Vec<EffectPoint>,
    pub hit_objects: Vec<HitObject>,
    pub hit_sounds: Vec<HitSoundType>,
}

All beatmap data that is relevant for difficulty and performance calculation.

Fields

version: i32

is_convert: bool

stack_leniency: f32

mode: GameMode

ar: f32

cs: f32

hp: f32

od: f32

slider_multiplier: f64

slider_tick_rate: f64

breaks: Vec<BreakPeriod>

timing_points: Vec<TimingPoint>

difficulty_points: Vec<DifficultyPoint>

effect_points: Vec<EffectPoint>

hit_objects: Vec<HitObject>

hit_sounds: Vec<HitSoundType>

Implementations

impl Beatmap

pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self, Error>

Parse a Beatmap by providing a path to a .osu file.

pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error>

Parse a Beatmap by providing the content of a .osu file as a slice of bytes.

pub const fn attributes(&self) -> BeatmapAttributesBuilder

Returns a BeatmapAttributesBuilder to calculate modified beatmap attributes.

pub fn bpm(&self) -> f64

The beats per minute of the map.

pub fn performance(&self) -> Performance<'_>

Create a performance calculator for this Beatmap.

pub fn gradual_difficulty(&self, difficulty: Difficulty) -> GradualDifficulty

Create a gradual difficulty calculator for this Beatmap.

pub fn gradual_performance(&self, difficulty: Difficulty) -> GradualPerformance

Create a gradual performance calculator for this Beatmap.

pub fn total_break_time(&self) -> f64

Sum up the duration of all breaks (in milliseconds).

pub fn convert_in_place(&mut self, mode: GameMode) -> ConvertStatus

Convert a &mut Beatmap to the specified mode with an argument instead of a generic parameter.

pub fn try_as_converted<M: IGameMode>(&self) -> Option<Converted<'_, M>>

Attempt to convert a &Beatmap to the specified mode.

If the conversion is incompatible, None is returned.

pub fn unchecked_as_converted<M: IGameMode>(&self) -> Converted<'_, M>

Convert a &Beatmap to the specified mode.

Panics

Panics if the conversion is incompatible.

pub fn try_as_converted_mut<M: IGameMode>(&mut self) -> Option<Converted<'_, M>>

Attempt to convert a &mut Beatmap to the specified mode.

If the conversion is incompatible, None is returned.

pub fn unchecked_as_converted_mut<M: IGameMode>(&mut self) -> Converted<'_, M>

Convert a &mut Beatmap to the specified mode.

Panics

Panics if the conversion is incompatible.

pub fn try_into_converted<'a, M: IGameMode>( self ) -> Result<Converted<'a, M>, Self>

Attempt to convert a Beatmap to the specified mode.

If the conversion is incompatible the Beatmap will be returned unchanged as Err.

pub fn unchecked_into_converted<'a, M: IGameMode>(self) -> Converted<'a, M>

Convert a Beatmap to the specified mode.

Panics

Panics if the conversion is incompatible.

Trait Implementations

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 DecodeBeatmap for Beatmap

type Error = ParseBeatmapError

Error type in case something goes wrong while parsing.

type State = BeatmapState

The parsing state which will be updated on each line and turned into Self at the end.

fn parse_general(state: &mut Self::State, line: &str) -> Result<(), Self::Error>

Update the state based on a line of the [General] section.

fn parse_editor(_: &mut Self::State, _: &str) -> Result<(), Self::Error>

Update the state based on a line of the [Editor] section.

fn parse_metadata(_: &mut Self::State, _: &str) -> Result<(), Self::Error>

Update the state based on a line of the [Metadata] section.

fn parse_difficulty( state: &mut Self::State, line: &str ) -> Result<(), Self::Error>

Update the state based on a line of the [Difficulty] section.

fn parse_events(state: &mut Self::State, line: &str) -> Result<(), Self::Error>

Update the state based on a line of the [Events] section.

fn parse_timing_points( state: &mut Self::State, line: &str ) -> Result<(), Self::Error>

Update the state based on a line of the [TimingPoints] section.

fn parse_colors(_: &mut Self::State, _: &str) -> Result<(), Self::Error>

Update the state based on a line of the [Colours] section.

fn parse_hit_objects( state: &mut Self::State, line: &str ) -> Result<(), Self::Error>

Update the state based on a line of the [HitObjects] section.

fn parse_variables(_: &mut Self::State, _: &str) -> Result<(), Self::Error>

Update the state based on a line of the [Variables] section.

fn parse_catch_the_beat(_: &mut Self::State, _: &str) -> Result<(), Self::Error>

Update the state based on a line of the [CatchTheBeat] section.

fn parse_mania(_: &mut Self::State, _: &str) -> Result<(), Self::Error>

Update the state based on a line of the [Mania] section.

fn decode<R>(src: R) -> Result<Self, Error>

where R: BufRead,

The key method to read and parse content of a .osu file into Self.

fn should_skip_line(line: &str) -> bool

Whether a line should not be forwarded to the parsing methods.

impl Default for Beatmap

fn default() -> Self

Returns the “default value” for a type.

impl From<&Beatmap> for BeatmapAttributesBuilder

fn from(map: &Beatmap) -> Self

Converts to this type from the input type.

impl From<BeatmapState> for Beatmap

fn from(state: BeatmapState) -> Self

Converts to this type from the input type.

impl FromStr for Beatmap

fn from_str(s: &str) -> Result<Self, Self::Err>

Parse a Beatmap by providing the content of a .osu file as a string.

type Err = Error

The associated error which can be returned from parsing.

impl<'a> IntoPerformance<'a> for Beatmap

fn into_performance(self) -> Performance<'a>

impl<'map> IntoPerformance<'map> for &'map Beatmap

fn into_performance(self) -> Performance<'map>

impl PartialEq for Beatmap

fn eq(&self, other: &Beatmap) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Beatmap