1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-17 22:22:54 +08:00
Commit Graph

19 Commits

Author SHA1 Message Date
Dan Balasescu
a2fd7707a1 Allow toggling SVs in the editor 2023-08-18 18:55:24 +09:00
Dan Balasescu
7bc8908ca9 Partial everything 2022-11-27 00:00:27 +09:00
Dean Herbert
a7d4a74ed6
Update osu.Game/Tests/Visual/ScrollingTestContainer.cs
Co-authored-by: Bartłomiej Dach <dach.bartlomiej@gmail.com>
2022-10-20 08:07:56 +09:00
Dean Herbert
d237c818f6 Fix nested objects in overlapping scrolling hit object container ruleset not using correct reference time 2022-10-18 16:15:21 +09:00
Dan Balasescu
f8830c6850 Automated #nullable processing 2022-06-17 16:37:17 +09:00
smoogipoo
6df45164fa Expose direction from scrolling test container 2020-04-23 11:17:16 +09:00
Dean Herbert
18c28390ef Setup drumroll testing 2020-04-15 16:29:39 +09:00
Bartłomiej Dach
5fde4f2c0c Fix lifetime calculation in overlapping algorithm
Changes to lifetime calculation in scrolling rulesets introduced in
#7367, which aimed to account for the distance between hit objects'
origin and its edge entering the scrolling area, fixed some issues with
hitobjects appearing abruptly, but also regressed some other scenarios.

Upon investigation, the regression was localised to the overlapping
scroll algorithm. The reason for this was two-fold:

* The previous code used TimeAt() to calculate the time of travel from
  the hit object's edge to its origin. For other algorithms, that time
  can be accurately reconstructed, because they don't have periods of
  time where there are multiple hit objects scrolling at different
  velocities.

  That invariant does not hold for the overlapping algorithm, therefore
  it is possible for different values to be technically correct for
  TimeAt(). However, the only value that matters for the adjustment
  is the one that's indicated by the control point that applies to the
  hit object origin, which can be uniquely identified.

* Additionally, the offset returned (even if correct) was applied
  externally to the hit object's start time and passed to
  GetDisplayStartTime(). In the overlapping algorithm, the choice of
  control point used in GetDisplayStartTime() is important, since
  the value of the speed multiplier is read within.

  Externally rewinding the hit object's start time meant that in some
  cases the speed multiplier of the *previous* control point is applied,
  which led to hit objects appearing too late if the scrolling rate
  decreased.

Because of the above, modify GetDisplayStartTime() to take the offset
into account in all algorithms, and apply the adjustment correctly
inside of them. The constant and sequential algorithms needed no
adjustment from the previous logic, since:

* the constant algorithm disregarded control points, and
* the sequential algorithm would effectively rewind to time = 0,
  calculate the absolute distance from time = 0 to the hit object start,
  apply the origin offset *to the absolute distance*, and then convert
  back to time, applying all control points in sequence. Due to this
  it was impossible for control points to get mixed up while
  calculating.

As for the overlapping algorithm, the high-level logic is as follows:

* The distance that the origin has to travel is the length of the scroll
  plus the distance from the origin to the object edge.
* The above distance divided by the scroll length gives the relative
  scroll lengths that the object has to travel.
* As one relative scroll length takes one time range, the relative
  travel length multiplied by the time range gives the absolute travel
  time of the object origin.
* Finally, the control point multiplier applicable at origin time is
  applied to the whole travel time.

Correctness of the above is demonstrated by visual tests added before
and headless unit tests of the algorithms themselves. The sequential
scroll algorithm was not covered by unit tests, and remains uncovered
due to floating-point inaccuracies that should be addressed separately.
2020-02-06 23:13:28 +01:00
Bartłomiej Dach
434c0d92e4 Use Bindable{Float,Double}s everywhere
To avoid further floating-point comparison bugs, remove all usages of
Bindable<{float,double}>, replacing them with their
Bindable<Float,Double> counterparts.
2020-02-01 22:50:29 +01:00
Dean Herbert
c39c37a18d Apply more missed cases 2019-04-01 12:44:46 +09:00
Dean Herbert
26d53d06a9 Fix remaining issues 2019-02-28 13:31:40 +09:00
smoogipoo
d8c55bc729 Adjust namespaces 2019-02-21 19:05:52 +09:00
Dean Herbert
8617aaa2a7 Update licence header (and remove year) 2019-01-24 17:43:03 +09:00
smoogipoo
3d8ef97e81 Add testcase 2018-11-12 19:41:06 +09:00
smoogipoo
3a1fee59fb Implement note placement 2018-11-12 18:24:18 +09:00
smoogipoo
d8e7ad8241 Fix post-rebase issues 2018-11-12 17:36:19 +09:00
smoogipoo
10543cf1b6 Move rest of ScrollingPlayfield into ScrollingRulesetContainer 2018-11-12 17:34:35 +09:00
smoogipoo
e7969ecec7 Move ScrollAlgorithm inside IScrollingInfo 2018-11-12 17:34:35 +09:00
smoogipoo
ad45bc7666 Move scroll direction to scrollinginfo 2018-11-12 17:34:35 +09:00