Struct 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 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( self, mode: GameMode, mods: &GameMods, ) -> Result<Self, ConvertError>

Attempt to convert a Beatmap to the specified mode.

pub fn convert_ref( &self, mode: GameMode, mods: &GameMods, ) -> Result<Cow<'_, Self>, ConvertError>

Attempt to convert a &Beatmap to the specified mode.

pub fn convert_mut( &mut self, mode: GameMode, mods: &GameMods, ) -> Result<(), ConvertError>

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

pub fn check_suspicion(&self) -> Result<(), TooSuspicious>

Check whether hitobjects appear too suspicious for further calculation.

Sometimes a Beatmap isn’t created for gameplay but rather to test the limits of osu! itself. Difficulty- and/or performance calculation should likely be avoided on these maps due to potential performance issues.

Trait Implementations

impl Clone for Beatmap

fn clone(&self) -> Beatmap

Returns a duplicate 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> IntoModePerformance<'a, Catch> for Beatmap

fn into_performance(self) -> <Catch as IGameMode>::Performance<'a>

impl<'a> IntoModePerformance<'a, Mania> for Beatmap

fn into_performance(self) -> <Mania as IGameMode>::Performance<'a>

impl<'a> IntoModePerformance<'a, Osu> for Beatmap

fn into_performance(self) -> <Osu as IGameMode>::Performance<'a>

impl<'a> IntoModePerformance<'a, Taiko> for Beatmap

fn into_performance(self) -> <Taiko as IGameMode>::Performance<'a>

impl<'map> IntoModePerformance<'map, Catch> for &'map Beatmap

fn into_performance(self) -> <Catch as IGameMode>::Performance<'map>

impl<'map> IntoModePerformance<'map, Mania> for &'map Beatmap

fn into_performance(self) -> <Mania as IGameMode>::Performance<'map>

impl<'map> IntoModePerformance<'map, Osu> for &'map Beatmap

fn into_performance(self) -> <Osu as IGameMode>::Performance<'map>

impl<'map> IntoModePerformance<'map, Taiko> for &'map Beatmap

fn into_performance(self) -> <Taiko as IGameMode>::Performance<'map>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for Beatmap