CHANGELOG.md

v1.0.0 (2024-04-02)

The rosu-pp interface and internal structure has been rewritten completely. Fields have been modified, builders work differently, function arguments have changed, and some types are no longer exposed.

Additionally, osu!catch has finally been updated to match osu!lazer as closely as possible, just like the other modes already did.

• Beatmap converts
  • Each mode now has a ZST, i.e. Osu, Taiko, Catch, and Mania, which are used to specify a mode at compile-time. Most of their utility comes from the new IGameMode trait.
  • Each mode's calculators now require Converted beatmaps to make sure they're valid for the mode, e.g. the TaikoPerformance calculator no longer takes a simple Beatmap but a Converted<'_, Taiko> (or its alias TaikoBeatmap<'_>).
  • Conversion between Beatmap and Converted<'_, M> either
    • is essentially a free operation if the map's mode already matches M,
    • or performs the required conversion by modifying hitobjects & co,
    • or indicates an error due to incompatible mode conversion, e.g. a mania map cannot be converted to a taiko map
• Difficulty calculation
  • The Difficulty type is the core of all difficulty calculations and acts as a builder to specify various parameters.
  • To calculate values for a specific mode, the method Difficulty::with_mode will produce a builder to calculate values for that mode.
  • Recycled attributes are only valid if all difficulty parameters match, i.e. it must be on the same map, use the same mods, clock rate, custom beatmap attributes, and passed object count (and hardrock offset for osu!catch).
  • Clockrate is now always clamped between 0.01 and 100 and custom beatmap attributes are clamped between -20 and 20.
• Performance calculation
  • Each mode's performance calculator was renamed from [Mode]PP to [Mode]Performance and AnyPP is now called Performance.
  • Difficulty attributes now contain a few more values so that the beatmap is no longer necessary for performance calculation as long as difficulty attributes are available.
  • The functions [Mode]Performance::new now take an argument implementing the trait Into(Mode)Performance, i.e. either a beatmap (as before), or attributes (difficulty or performance). Since attributes speed up the calculation, they should be prefered whenever available. However, be mindful that they have been calculated for the same map and difficulty settings. Otherwise, the final attributes will be incorrect.
• Features
  • The tracing feature has been added. Its sole functionality is that errors during beatmap parsing will emit a tracing event on the ERROR level. If this features is not explicitely enabled, parsing errors will be ignored entirely.
  • The gradual features has been removed. Types for gradual calculation are now always available.
  • The sync feature has been added. Taiko's gradual calculation types contain types that are not thread-safe by default. Enabling this feature will add some performance penalty but use types that do allow moving gradual calculation across threads.
  • The compact_strains feature is now enabled by default and causes strain values during difficulty calculation to be stored in a space-efficient way to prevent out-of-memory issues on maliciously long maps. This comes at a small performance cost.
• Misc
  • Async is no longer supported. Beatmap parsing now works through rosu-map which does not support async since evidently it's generally slower than regular sequential code.
  • Errors while parsing a beatmap will never be propagated. The only errors that will be propagated are those occuring while decoding, e.g. a file couldn't be read or other IO errors. Notably, this means that some content is now parsed successfully into a Beatmap whereas in previous rosu-pp versions it would error, e.g. an empty file is now a valid Beatmap.
  • Although new lazer mods such as DifficultyAdjust or DoubleTime with a custom clockrate are essentially supported by providing methods to specify their parameters, mods themselves are still specified by their bit value. This means:
    • Daycore will not be considered unless its clockrate change is explicitly specified
    • /!\ Blinds will not be considered for osu! performance calculation /!\
  • Most usize types are now u32, e.g. fields of ScoreState or max_combo in attributes.
  • n_misses has generally been renamed to misses for both fields and methods.
  • Types such as NestedObjectKind, ManiaObject, or Mods that were only used for internal calculations are no longer publicly exposed.

v0.10.0 (2023-11-19)

Essentially only adjustments to the API so bindings won't need an update.

• Additions:

  • Added From<u8> impl for GameMode
  • Added the method AnyPP::hitresult_priority
  • Added the method [Mode]PP::generate_state which returns the score state that will be used for performance calculation (#23)
  • The struct SortedVec has now an improved public interface so it can be constructed and pushed onto (#22)

• Breaking adjustments:

  • Removed the method HitObject::end_time from the public api. (#25)
  • The fields control_points and edge_sounds of HitObjectKind::Slider are now stored in a Box rather than a Vec. (#26)
  • Overhauled gradual calculation. All relevant types are now gated behind the gradual feature which must be enabled. (#24)
  • *GradualDifficultyAttributes has been renamed to *GradualDifficulty and *GradualPerformanceAttributes has been renamed to *GradualPerformance.
  • Types for gradual calculation that depend on a lifetime now have a counterpart without a lifetime that might clone underlying data along the way. E.g. now there is CatchOwnedGradualDifficulty and [Mode]OwnedGradualPerformance.
  • OsuGradualDifficulty and thus GradualDifficulty no longer implement Clone.
  • Gradual performance calculators' method process_next_object has been renamed to next and process_next_n_objects has been renamed to nth. They now also have the new method last.
  • Similar to Iterator::nth, gradual performance calculators' method nth is now zero-indexed i.e. passing n=0 will process 1 object, n=1 will process 2, and so on.

v0.9.5 (2023-09-06)

• Additions:

  • Added the method {AnyStars/AnyPP}::is_convert which needs to be used if the map was manually converted beforehand

• Adjustments:

  • Specified clock rates can go below 0.001 again

• Fixes:

  • Fixed underflow for osu!std scores that were FCs but quit mid-slider
  • Fixed panic on incorrect file headers (#21)

v0.9.4 (2023-02-09)

• Additions:

  • Added the method {TaikoPP/ManiaPP}::is_convert which needs to be used if the map was manually converted beforehand

• Adjustments:

  • Specified clock rates can no longer go below 0.001 to prevent crashing due to memory hogging.
  • (technically breaking) The only reasons for parsing to fail are now IO errors or invalid file headers. All other ParseError variants have been removed and instead of throwing an error the line is just ignored.

• Fixes:

  • The Beatmap::bpm method now works properly by considering the most common beat length instead of just the first one

v0.9.3 (2023-01-28)

• Additions:

  • Added the method ScoreState::total_hits
  • Added the trait methods BeatmapExt::{mode}_hitobjects which return a list of mode-specific processed HitObjects (#20)

• Fixes:

  • Lines with invalid curve points are now ignored instead of throwing an error while parsing
  • Fixed a niche capacity overflow in curve generation

v0.9.2 (2022-11-08)

• Adjustments:

  • When passing an osu!std map to TaikoGradualDifficultyAttributes or ManiaGradualDifficultyAttributes, it now automatically converts the map internally. For osu!catch it was already happening trivially.

• Fixes:

  • Fixed passed object count for taiko by ignoring non-circles
  • Fixed a niche panic on UTF-16 encoded maps (#18)
  • Fixed an occasional underflow when calculating accuracy pp
  • Fixed an infinite loop on special ctb maps

v0.9.1 (2022-10-26)

• Adjustments:

  • When passing an osu!std map to TaikoPP or ManiaPP, it now automatically converts the map internally. For osu!catch it was already happening trivially.

• Fixes:

  • The fields section_len for all strain structs no longer depends on the clock rate.

v0.9.0 (2022-10-24)

Big changes including the most recent osu!, taiko, and mania updates, aswell as various breaking changes.

• Breaking changes:

  • TimingPoint and DifficultyPoint no longer contain a kiai field
  • DifficultyPoint now has the additional fields bpm_mult and generate_ticks
  • Beatmap now stores timing- and difficulty points in a SortedVec
  • Beatmap now has the additional field effect_points
  • For the performance calculators OsuPP, TaikoPP, ManiaPP, and AnyPP the method misses has been renamed to n_misses
  • The accuracy method for OsuPP, TaikoPP, and ManiaPP is no longer required to be called last
  • ManiaPP no longer has a score method. Instead it has n320, n300. n200, n100, n50, and n_misses methods, aswell as a state method
  • Gradual performance calculation for mania now requires a ManiaScoreState instead of score
  • ManiaDifficultyAttributes now have a max_combo field and method
  • OsuDifficultyAttributes now have a speed_note_count field
  • OsuPerformanceAttributes and TaikoPerformanceAttributes now have a effective_miss_count field
  • TaikoDifficultyAttributes now have a peak and hit_window field
  • Some other things I likely forgot about :S

• Additions:

  • The performance calculators OsuPP, TaikoPP, ManiaPP, and AnyPP now have a hitresult_priority method to specify how hitresults should be generated

• Fixes:

  • Fixed a bunch of fringe yet significant bugs for taiko and mania converts
  • Fixed various floating point inaccuracies for osu!standard
  • Fixed parsing difficulty points from .osu files
  • Instead of throwing an error, invalid lines during parsing will just be ignored in some cases
  • Fixed an unsafe transmute between incompatible types while parsing sliders

v0.8.0 (2022-08-02)

• Fixes:
  • Fixed stack overflow bug when allocating ticks for some sliders on converted catch maps (#14)
• Breaking changes:
  • Beatmap::attributes now returns a new type BeatmapAttributesBuilder to allow for more fine-grained calculations. BeatmapAttributes now contains expected values and also includes a BeatmapHitWindows field containing the AR (preempt) and OD (great) hit windows in milliseconds. (#15)

v0.7.1 (2022-07-12)

• Fixes:
  • Parsing edge sounds is now mindful about overflowing a byte (ref. ranked map id 80799)
  • Parsing the event section now attempts to read non-ASCII before eventually failing (ref. ranked map id 49374)

v0.7.0 (2022-07-06)

• Fixes:
  • Slider velocity is now adjusted properly for taiko converts
  • Fixed missing slider sounds for taiko converts
• Breaking changes:
  • Replaced the simple Strains struct with a new struct {Mode}Strains that contains more detail w.r.t. the mode.
  • Renamed all GameMode variants to more idiomatic names
  • Renamed ParseError::IOError to ParseError::IoError

v0.6.0 (2022-07-05)

• Additions:
  • Added the ControlPoint and ControlPointerIter types to the public interface
  • TimingPoint and DifficultyPoint now implement Default
  • Added new methods to Beatmap:
    • convert_mode: Convert a map into another mode. (doesn't do anything if the starting map is not osu!standard)
    • control_points: Return an iterator over all control points of a map
    • total_break_time: Return the accumulated break time in milliseconds
    • timing_point_at: Return the timing point for the given timestamp
    • difficulty_point_at: Return the difficulty point for the given timestamp if available
• Breaking changes:
  • Moved some types to a different module. The following types can now be found in rosu_pp::beatmap:
    • Beatmap
    • BeatmapAttributes
    • ControlPoint
    • ControlPointIter
    • DifficultyPoint
    • GameMode
    • TimingPoint
  • Added a new field kiai: bool to both TimingPoint and DifficultyPoint to denote whether the current timing section is in kiai mode
  • Added a new field breaks: Vec<Break> to Beatmap that contains all breaks throughout the map
  • Added a new field edge_sounds: Vec<u8> to the Slider variant of HitObjectKind to denote the sample played on slider heads, ends, and repeats
• Other:
  • Small performance improvements for osu!taiko calculations

v0.5.2 (2022-06-14)

• Fixes:
  • Fixed parsing non-UTF-8 encoded files and improved parse performance overall (#9)
  • Handle missing approach rate properly this time

v0.5.1 (2022-03-21)

• Fixes:
  • Performance calculation for taiko & mania now considers custom clock rates properly

v0.5.0 (2022-03-21)

• Fixes:
  • Fixed panic on maps with 0 objects
  • Fixed droplet timings on juicestreams with span count >1
  • Fixed timing point parsing on some (older) maps where "uninherited" value did not coincide with beat length
  • Fixed handling .osu files with missing difficulty attributes
  • Fixed huge memory allocations caused by incorrectly parsing .osu files
• Breaking changes:
  • The stars and strains functions for all modes were removed. Instead use the {Mode}Stars builder pattern which is similar to {Mode}PP.
  • BeatmapExt::stars's definition was adjusted to use the AnyStars builder struct
  • Store HitObject::sound in Beatmap::sounds instead to reduce the struct size
  • Removed the mode features osu, fruits, taiko, and mania. Now all modes are always supported.
  • Renamed the rosu_pp::fruits module to rosu_pp::catch. Similarly, all structs Fruits{Name} were renamed to Catch{Name} and enums over the mode have their Fruits variant renamed to Catch
  • Renamed Mods' method speed to clock_rate
• Additions:
  • Added AttributeProvider impl for {Mode}PerformanceAttributes
  • Added the method clock_rate to {Mode}PP and {Mode}Stars to consider a custom clock rate instead of the one dictated by mods.

v0.4.0 (2021-11-25)

• Fixed out of bounds panic on maps with single-control-point linear sliders
• Fixed incorrect attributes on maps with only 1 or 2 hit objects for all modes
• Added method Beatmap::from_path so the file does not have to be created manually for Beatmap::parse.
• Added a bunch of documentation.
• Added method Beatmap::bpm
• Added method max_combo for DifficultyAttributes, PerformanceAttributes, and all {Mode}PerformanceAttributes
• Added methods TaikoDifficultyAttributes::max_combo and OsuDifficultyAttributes::max_combo
• Added structs {Mode}GradualDifficultyAttributes to calculate a map's difficulty after every or every few objects instead of calling the mode's stars function over and over.
• Added structs {Mode}GradualPerformanceAttributes to calculate the performance on a map after every or every few objects instead of using {Mode}PP over and over.
• Added BeatmapExt::gradual_difficulty and BeatmapExt::gradual_performance to gradually calculate the difficulty or performance on maps of any mode, hit object by hit object.
• Added methods {Mode}PP::state that take a {Mode}ScoreState (same for AnyPP and ScoreState) to set all parameters at once.
• [BREAKING] Removed the ParseError variants InvalidPathType and InvalidTimingSignature and renamed InvalidFloatingPoint to InvalidDecimalNumber.
• [BREAKING] Removed the last_control_point field of HitObjectKind::Slider when neither the osu nor the fruits feature is enabled.
• [BREAKING] Added the field TaikoDifficultyAttributes::max_combo
• [BREAKING] Renamed the attributes field to difficulty for all {Mode}PerformanceAttributes structs
• [BREAKING] Replaced field FruitsDifficultyAttributes::max_combo by a method with the same name

v0.3.0 (2021-11-14)

• [BREAKING] With the importance of sliders for osu!standard, the no_sliders_no_leniency feature became too inaccurate. Additionally, since considering sliders now inherently drags performance down a little more, the difference between no_leniency and all_included became too small. Hence, the three osu features no_sliders_no_leniency, no_leniency, and all_included were removed. When the osu feature is enabled, it will now essentially use all_included under the hood. Additionally, instead of importing through rosu_pp::osu::{version}, you now have to import through rosu_pp::osu.
• [BREAKING] Instead of returning PpResult, performance calculations now return {Mode}PerformanceAttributes and PpResult has been renamed to PerformanceAttributes.
• [BREAKING] Instead of returning StarResult, difficulty calculations now return {Mode}DifficultyAttributes and StarResult has been renamed to DifficultyAttributes.
• [BREAKING] Various fields and methods now include f64 instead of f32 to stay true to osu!'s original code
• Added internal binary crate pp-gen to calculate difficulty & pp values via PerformanceCalculator.dll
• Added internal binary crate pp-plot to plot out differences between pp-gen's output and rosu-pp values
• osu: Updated up to commit 9fb2402781ad91c197d51aeec716b0000f52c4d1 (2021-11-12)

v0.2.3 (2021-08-09)

• Reduced amount of required features of async_std and async_tokio
• Fixed a panic for some mania difficulty calculations on converts
• Updated the difficulty & pp changes from 21.07.27
• Fixed dead loop when reading empty .osu files (#2 - @Pure-Peace)
• Updated osu's clockrate bugfix for all modes

v0.2.2 (2021-05-05)

• osu & fruits:

  • Fixed specific slider patterns

  • Optimized Bezier, Catmull, and other small things

    Benchmarking for osu!standard showed a 25%+ improvement for performance aswell as accuracy

• fruits:

  • Fixed tick timing for reverse sliders

• taiko:

  • Micro optimizations

v0.2.1 (2021-04-17)

• parse & osu:
  • Cleanup and tiny optimizations

v0.2.0 (2021-02-25)

• Async beatmap parsing through features async_tokio or async_std (#1 - @Pure-Peace)
• [BREAKING] Hide various parsing related types further inwards, i.e. rosu_pp::parse::some_type instead of rosu_pp::some_type
  • Affected types: DifficultyPoint, HitObject, Pos2, TimingPoint, HitObjectKind, PathType, HitSound

v0.1.1 (2021-02-15)

• parse:

  • Efficiently handle huge amounts of curvepoints

• osu:

  • Fixed panic on unwrapping unavailable hit results
  • Fixed occasional underflow when calculating pp with passed_objects

• taiko:

  • Fixed missing flooring of hitwindow for pp calculation

• fruits:

  • Fixed passed objects in star calculation

• mania:

  • Fixed pp calculation on HR