sim1222/osukey
1
1
Fork 0
mirror of https://github.com/osukey/osukey.git synced 2025-08-06 16:13:57 +09:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into fix-hitcircle-glow-on-skin-change

Browse Source
This commit is contained in:
Dean Herbert
2020-11-06 16:47:56 +09:00
committed by GitHub
parent f9fc58c45c ca94d93d29
commit e0ef777e87
81 changed files with 830 additions and 615 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -334,3 +334,5 @@ inspectcode
# BenchmarkDotNet # BenchmarkDotNet
/BenchmarkDotNet.Artifacts /BenchmarkDotNet.Artifacts
*.GeneratedMSBuildEditorConfig.editorconfig

1
CodeAnalysis/BannedSymbols.txt
View File

@ -4,5 +4,6 @@ M:System.ValueType.Equals(System.Object)~System.Boolean;Don't use object.Equals(
M:System.Nullable`1.Equals(System.Object)~System.Boolean;Use == instead. M:System.Nullable`1.Equals(System.Object)~System.Boolean;Use == instead.
T:System.IComparable;Don't use non-generic IComparable. Use generic version instead. T:System.IComparable;Don't use non-generic IComparable. Use generic version instead.
M:osu.Framework.Graphics.Sprites.SpriteText.#ctor;Use OsuSpriteText. M:osu.Framework.Graphics.Sprites.SpriteText.#ctor;Use OsuSpriteText.
M:osu.Framework.Bindables.IBindableList`1.GetBoundCopy();Fails on iOS. Use manual ctor + BindTo instead. (see https://github.com/mono/mono/issues/19900)
T:Microsoft.EntityFrameworkCore.Internal.EnumerableExtensions;Don't use internal extension methods. T:Microsoft.EntityFrameworkCore.Internal.EnumerableExtensions;Don't use internal extension methods.
T:Microsoft.EntityFrameworkCore.Internal.TypeExtensions;Don't use internal extension methods. T:Microsoft.EntityFrameworkCore.Internal.TypeExtensions;Don't use internal extension methods.

2
osu.Android.props
View File

@ -52,6 +52,6 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<PackageReference Include="ppy.osu.Game.Resources" Version="2020.1030.0" /> <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1030.0" />
<PackageReference Include="ppy.osu.Framework.Android" Version="2020.1029.1" /> <PackageReference Include="ppy.osu.Framework.Android" Version="2020.1105.0" />
</ItemGroup> </ItemGroup>
</Project> </Project>

6
osu.Game.Rulesets.Catch/Mods/CatchModHidden.cs
View File

@ -17,9 +17,11 @@ namespace osu.Game.Rulesets.Catch.Mods
private const double fade_out_offset_multiplier = 0.6; private const double fade_out_offset_multiplier = 0.6;
private const double fade_out_duration_multiplier = 0.44; private const double fade_out_duration_multiplier = 0.44;
protected override void ApplyHiddenState(DrawableHitObject drawable, ArmedState state) protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
{ {
if (!(drawable is DrawableCatchHitObject catchDrawable)) base.ApplyNormalVisibilityState(hitObject, state);
if (!(hitObject is DrawableCatchHitObject catchDrawable))
return; return;
if (catchDrawable.NestedHitObjects.Any()) if (catchDrawable.NestedHitObjects.Any())

2
osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs
View File

@ -295,7 +295,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
private void assertControlPointPosition(int index, Vector2 position) => private void assertControlPointPosition(int index, Vector2 position) =>
AddAssert($"control point {index} at {position}", () => Precision.AlmostEquals(position, getSlider().Path.ControlPoints[index].Position.Value, 1)); AddAssert($"control point {index} at {position}", () => Precision.AlmostEquals(position, getSlider().Path.ControlPoints[index].Position.Value, 1));
private Slider getSlider() => HitObjectContainer.Count > 0 ? (Slider)((DrawableSlider)HitObjectContainer[0]).HitObject : null; private Slider getSlider() => HitObjectContainer.Count > 0 ? ((DrawableSlider)HitObjectContainer[0]).HitObject : null;
protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableSlider((Slider)hitObject); protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableSlider((Slider)hitObject);
protected override PlacementBlueprint CreateBlueprint() => new SliderPlacementBlueprint(); protected override PlacementBlueprint CreateBlueprint() => new SliderPlacementBlueprint();

10
osu.Game.Rulesets.Osu.Tests/TestSceneFollowPoints.cs
View File

@ -171,7 +171,7 @@ namespace osu.Game.Rulesets.Osu.Tests
} }
hitObjectContainer.Add(drawableObject); hitObjectContainer.Add(drawableObject);
followPointRenderer.AddFollowPoints(drawableObject); followPointRenderer.AddFollowPoints(objects[i]);
} }
}); });
} }
@ -180,10 +180,10 @@ namespace osu.Game.Rulesets.Osu.Tests
{ {
AddStep("remove hitobject", () => AddStep("remove hitobject", () =>
{ {
var drawableObject = getFunc?.Invoke(); var drawableObject = getFunc.Invoke();
hitObjectContainer.Remove(drawableObject); hitObjectContainer.Remove(drawableObject);
followPointRenderer.RemoveFollowPoints(drawableObject); followPointRenderer.RemoveFollowPoints(drawableObject.HitObject);
}); });
} }
@ -215,10 +215,10 @@ namespace osu.Game.Rulesets.Osu.Tests
DrawableOsuHitObject expectedStart = getObject(i); DrawableOsuHitObject expectedStart = getObject(i);
DrawableOsuHitObject expectedEnd = i < hitObjectContainer.Count - 1 ? getObject(i + 1) : null; DrawableOsuHitObject expectedEnd = i < hitObjectContainer.Count - 1 ? getObject(i + 1) : null;
if (getGroup(i).Start != expectedStart) if (getGroup(i).Start != expectedStart.HitObject)
throw new AssertionException($"Object {i} expected to be the start of group {i}."); throw new AssertionException($"Object {i} expected to be the start of group {i}.");
if (getGroup(i).End != expectedEnd) if (getGroup(i).End != expectedEnd?.HitObject)
throw new AssertionException($"Object {(expectedEnd == null ? "null" : i.ToString())} expected to be the end of group {i}."); throw new AssertionException($"Object {(expectedEnd == null ? "null" : i.ToString())} expected to be the end of group {i}.");
} }

18
osu.Game.Rulesets.Osu.Tests/TestSceneSlider.cs
View File

@ -112,10 +112,10 @@ namespace osu.Game.Rulesets.Osu.Tests
new HitSampleInfo { Name = HitSampleInfo.HIT_WHISTLE }, new HitSampleInfo { Name = HitSampleInfo.HIT_WHISTLE },
}); });
AddAssert("head samples updated", () => assertSamples(((Slider)slider.HitObject).HeadCircle)); AddAssert("head samples updated", () => assertSamples(slider.HitObject.HeadCircle));
AddAssert("tick samples not updated", () => ((Slider)slider.HitObject).NestedHitObjects.OfType<SliderTick>().All(assertTickSamples)); AddAssert("tick samples not updated", () => slider.HitObject.NestedHitObjects.OfType<SliderTick>().All(assertTickSamples));
AddAssert("repeat samples updated", () => ((Slider)slider.HitObject).NestedHitObjects.OfType<SliderRepeat>().All(assertSamples)); AddAssert("repeat samples updated", () => slider.HitObject.NestedHitObjects.OfType<SliderRepeat>().All(assertSamples));
AddAssert("tail has no samples", () => ((Slider)slider.HitObject).TailCircle.Samples.Count == 0); AddAssert("tail has no samples", () => slider.HitObject.TailCircle.Samples.Count == 0);
static bool assertTickSamples(SliderTick tick) => tick.Samples.Single().Name == "slidertick"; static bool assertTickSamples(SliderTick tick) => tick.Samples.Single().Name == "slidertick";
@ -136,7 +136,7 @@ namespace osu.Game.Rulesets.Osu.Tests
slider = (DrawableSlider)createSlider(repeats: 1); slider = (DrawableSlider)createSlider(repeats: 1);
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; i++)
((Slider)slider.HitObject).NodeSamples.Add(new List<HitSampleInfo> { new HitSampleInfo { Name = HitSampleInfo.HIT_FINISH } }); slider.HitObject.NodeSamples.Add(new List<HitSampleInfo> { new HitSampleInfo { Name = HitSampleInfo.HIT_FINISH } });
Add(slider); Add(slider);
}); });
@ -147,10 +147,10 @@ namespace osu.Game.Rulesets.Osu.Tests
new HitSampleInfo { Name = HitSampleInfo.HIT_WHISTLE }, new HitSampleInfo { Name = HitSampleInfo.HIT_WHISTLE },
}); });
AddAssert("head samples not updated", () => assertSamples(((Slider)slider.HitObject).HeadCircle)); AddAssert("head samples not updated", () => assertSamples(slider.HitObject.HeadCircle));
AddAssert("tick samples not updated", () => ((Slider)slider.HitObject).NestedHitObjects.OfType<SliderTick>().All(assertTickSamples)); AddAssert("tick samples not updated", () => slider.HitObject.NestedHitObjects.OfType<SliderTick>().All(assertTickSamples));
AddAssert("repeat samples not updated", () => ((Slider)slider.HitObject).NestedHitObjects.OfType<SliderRepeat>().All(assertSamples)); AddAssert("repeat samples not updated", () => slider.HitObject.NestedHitObjects.OfType<SliderRepeat>().All(assertSamples));
AddAssert("tail has no samples", () => ((Slider)slider.HitObject).TailCircle.Samples.Count == 0); AddAssert("tail has no samples", () => slider.HitObject.TailCircle.Samples.Count == 0);
static bool assertTickSamples(SliderTick tick) => tick.Samples.Single().Name == "slidertick"; static bool assertTickSamples(SliderTick tick) => tick.Samples.Single().Name == "slidertick";

2
osu.Game.Rulesets.Osu.Tests/TestSceneSpinner.cs
View File

@ -20,8 +20,8 @@ namespace osu.Game.Rulesets.Osu.Tests
private TestDrawableSpinner drawableSpinner; private TestDrawableSpinner drawableSpinner;
[TestCase(false)]
[TestCase(true)] [TestCase(true)]
[TestCase(false)]
public void TestVariousSpinners(bool autoplay) public void TestVariousSpinners(bool autoplay)
{ {
string term = autoplay ? "Hit" : "Miss"; string term = autoplay ? "Hit" : "Miss";

2
osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
View File

@ -82,7 +82,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
protected override void OnSelected() protected override void OnSelected()
{ {
AddInternal(ControlPointVisualiser = new PathControlPointVisualiser((Slider)slider.HitObject, true) AddInternal(ControlPointVisualiser = new PathControlPointVisualiser(slider.HitObject, true)
{ {
RemoveControlPointsRequested = removeControlPoints RemoveControlPointsRequested = removeControlPoints
}); });

33
osu.Game.Rulesets.Osu/Mods/OsuModHidden.cs
View File

@ -3,7 +3,6 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Game.Rulesets.Mods; using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Objects; using osu.Game.Rulesets.Objects;
@ -23,28 +22,38 @@ namespace osu.Game.Rulesets.Osu.Mods
private const double fade_in_duration_multiplier = 0.4; private const double fade_in_duration_multiplier = 0.4;
private const double fade_out_duration_multiplier = 0.3; private const double fade_out_duration_multiplier = 0.3;
protected override bool IsFirstHideableObject(DrawableHitObject hitObject) => !(hitObject is DrawableSpinner); protected override bool IsFirstAdjustableObject(HitObject hitObject) => !(hitObject is Spinner);
public override void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables) public override void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
{ {
static void adjustFadeIn(OsuHitObject h) => h.TimeFadeIn = h.TimePreempt * fade_in_duration_multiplier; foreach (var d in drawables)
d.ApplyCustomUpdateState += applyFadeInAdjustment;
foreach (var d in drawables.OfType<DrawableOsuHitObject>())
{
adjustFadeIn(d.HitObject);
foreach (var h in d.HitObject.NestedHitObjects.OfType<OsuHitObject>())
adjustFadeIn(h);
}
base.ApplyToDrawableHitObjects(drawables); base.ApplyToDrawableHitObjects(drawables);
} }
private void applyFadeInAdjustment(DrawableHitObject hitObject, ArmedState state)
{
if (!(hitObject is DrawableOsuHitObject d))
return;
d.HitObject.TimeFadeIn = d.HitObject.TimePreempt * fade_in_duration_multiplier;
}
private double lastSliderHeadFadeOutStartTime; private double lastSliderHeadFadeOutStartTime;
private double lastSliderHeadFadeOutDuration; private double lastSliderHeadFadeOutDuration;
protected override void ApplyFirstObjectIncreaseVisibilityState(DrawableHitObject drawable, ArmedState state) => applyState(drawable, true); protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
{
base.ApplyIncreasedVisibilityState(hitObject, state);
applyState(hitObject, true);
}
protected override void ApplyHiddenState(DrawableHitObject drawable, ArmedState state) => applyState(drawable, false); protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
{
base.ApplyNormalVisibilityState(hitObject, state);
applyState(hitObject, false);
}
private void applyState(DrawableHitObject drawable, bool increaseVisibility) private void applyState(DrawableHitObject drawable, bool increaseVisibility)
{ {

31
osu.Game.Rulesets.Osu/Mods/OsuModObjectScaleTween.cs
View File

@ -2,11 +2,8 @@
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using System; using System;
using System.Collections.Generic;
using System.Linq;
using osu.Framework.Bindables; using osu.Framework.Bindables;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Rulesets.Mods; using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Objects.Drawables; using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Osu.Objects; using osu.Game.Rulesets.Osu.Objects;
@ -17,7 +14,7 @@ namespace osu.Game.Rulesets.Osu.Mods
/// <summary> /// <summary>
/// Adjusts the size of hit objects during their fade in animation. /// Adjusts the size of hit objects during their fade in animation.
/// </summary> /// </summary>
public abstract class OsuModObjectScaleTween : Mod, IReadFromConfig, IApplicableToDrawableHitObjects public abstract class OsuModObjectScaleTween : ModWithVisibilityAdjustment
{ {
public override ModType Type => ModType.Fun; public override ModType Type => ModType.Fun;
@ -27,33 +24,19 @@ namespace osu.Game.Rulesets.Osu.Mods
protected virtual float EndScale => 1; protected virtual float EndScale => 1;
private Bindable<bool> increaseFirstObjectVisibility = new Bindable<bool>();
public override Type[] IncompatibleMods => new[] { typeof(OsuModSpinIn), typeof(OsuModTraceable) }; public override Type[] IncompatibleMods => new[] { typeof(OsuModSpinIn), typeof(OsuModTraceable) };
public void ReadFromConfig(OsuConfigManager config) protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
{ {
increaseFirstObjectVisibility = config.GetBindable<bool>(OsuSetting.IncreaseFirstObjectVisibility);
} }
public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables) protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyCustomState(hitObject, state);
{
foreach (var drawable in drawables.Skip(increaseFirstObjectVisibility.Value ? 1 : 0))
{
switch (drawable)
{
case DrawableSpinner _:
continue;
default: private void applyCustomState(DrawableHitObject drawable, ArmedState state)
drawable.ApplyCustomUpdateState += ApplyCustomState;
break;
}
}
}
protected virtual void ApplyCustomState(DrawableHitObject drawable, ArmedState state)
{ {
if (drawable is DrawableSpinner)
return;
var h = (OsuHitObject)drawable.HitObject; var h = (OsuHitObject)drawable.HitObject;
// apply grow effect // apply grow effect

30
osu.Game.Rulesets.Osu/Mods/OsuModSpinIn.cs
View File

@ -2,12 +2,8 @@
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using System; using System;
using System.Collections.Generic;
using System.Linq;
using osu.Framework.Bindables;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Framework.Graphics.Sprites; using osu.Framework.Graphics.Sprites;
using osu.Game.Configuration;
using osu.Game.Rulesets.Mods; using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Objects.Drawables; using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Osu.Objects; using osu.Game.Rulesets.Osu.Objects;
@ -16,7 +12,7 @@ using osuTK;
namespace osu.Game.Rulesets.Osu.Mods namespace osu.Game.Rulesets.Osu.Mods
{ {
public class OsuModSpinIn : Mod, IApplicableToDrawableHitObjects, IReadFromConfig public class OsuModSpinIn : ModWithVisibilityAdjustment
{ {
public override string Name => "Spin In"; public override string Name => "Spin In";
public override string Acronym => "SI"; public override string Acronym => "SI";
@ -31,31 +27,17 @@ namespace osu.Game.Rulesets.Osu.Mods
private const int rotate_offset = 360; private const int rotate_offset = 360;
private const float rotate_starting_width = 2; private const float rotate_starting_width = 2;
private Bindable<bool> increaseFirstObjectVisibility = new Bindable<bool>(); protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
public void ReadFromConfig(OsuConfigManager config)
{ {
increaseFirstObjectVisibility = config.GetBindable<bool>(OsuSetting.IncreaseFirstObjectVisibility);
} }
public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables) protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyZoomState(hitObject, state);
{
foreach (var drawable in drawables.Skip(increaseFirstObjectVisibility.Value ? 1 : 0))
{
switch (drawable)
{
case DrawableSpinner _:
continue;
default:
drawable.ApplyCustomUpdateState += applyZoomState;
break;
}
}
}
private void applyZoomState(DrawableHitObject drawable, ArmedState state) private void applyZoomState(DrawableHitObject drawable, ArmedState state)
{ {
if (drawable is DrawableSpinner)
return;
var h = (OsuHitObject)drawable.HitObject; var h = (OsuHitObject)drawable.HitObject;
switch (drawable) switch (drawable)

18
osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs
View File

@ -2,12 +2,8 @@
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using System; using System;
using System.Linq;
using osu.Framework.Bindables;
using System.Collections.Generic;
using osu.Framework.Extensions.Color4Extensions; using osu.Framework.Extensions.Color4Extensions;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Rulesets.Mods; using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Objects.Drawables; using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Osu.Objects.Drawables; using osu.Game.Rulesets.Osu.Objects.Drawables;
@ -15,7 +11,7 @@ using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
namespace osu.Game.Rulesets.Osu.Mods namespace osu.Game.Rulesets.Osu.Mods
{ {
internal class OsuModTraceable : Mod, IReadFromConfig, IApplicableToDrawableHitObjects internal class OsuModTraceable : ModWithVisibilityAdjustment
{ {
public override string Name => "Traceable"; public override string Name => "Traceable";
public override string Acronym => "TC"; public override string Acronym => "TC";
@ -24,20 +20,14 @@ namespace osu.Game.Rulesets.Osu.Mods
public override double ScoreMultiplier => 1; public override double ScoreMultiplier => 1;
public override Type[] IncompatibleMods => new[] { typeof(OsuModHidden), typeof(OsuModSpinIn), typeof(OsuModObjectScaleTween) }; public override Type[] IncompatibleMods => new[] { typeof(OsuModHidden), typeof(OsuModSpinIn), typeof(OsuModObjectScaleTween) };
private Bindable<bool> increaseFirstObjectVisibility = new Bindable<bool>();
public void ReadFromConfig(OsuConfigManager config) protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
{ {
increaseFirstObjectVisibility = config.GetBindable<bool>(OsuSetting.IncreaseFirstObjectVisibility);
} }
public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables) protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTraceableState(hitObject, state);
{
foreach (var drawable in drawables.Skip(increaseFirstObjectVisibility.Value ? 1 : 0))
drawable.ApplyCustomUpdateState += ApplyTraceableState;
}
protected void ApplyTraceableState(DrawableHitObject drawable, ArmedState state) private void applyTraceableState(DrawableHitObject drawable, ArmedState state)
{ {
if (!(drawable is DrawableOsuHitObject)) if (!(drawable is DrawableOsuHitObject))
return; return;

11
osu.Game.Rulesets.Osu/Mods/OsuModTransform.cs
View File

@ -2,7 +2,6 @@
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using System; using System;
using System.Collections.Generic;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Framework.Graphics.Sprites; using osu.Framework.Graphics.Sprites;
using osu.Game.Rulesets.Mods; using osu.Game.Rulesets.Mods;
@ -13,7 +12,7 @@ using osuTK;
namespace osu.Game.Rulesets.Osu.Mods namespace osu.Game.Rulesets.Osu.Mods
{ {
internal class OsuModTransform : Mod, IApplicableToDrawableHitObjects internal class OsuModTransform : ModWithVisibilityAdjustment
{ {
public override string Name => "Transform"; public override string Name => "Transform";
public override string Acronym => "TR"; public override string Acronym => "TR";
@ -25,11 +24,9 @@ namespace osu.Game.Rulesets.Osu.Mods
private float theta; private float theta;
public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables) protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTransform(hitObject, state);
{
foreach (var drawable in drawables) protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTransform(hitObject, state);
drawable.ApplyCustomUpdateState += applyTransform;
}
private void applyTransform(DrawableHitObject drawable, ArmedState state) private void applyTransform(DrawableHitObject drawable, ArmedState state)
{ {

11
osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs
View File

@ -2,7 +2,6 @@
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using System; using System;
using System.Collections.Generic;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Framework.Graphics.Sprites; using osu.Framework.Graphics.Sprites;
using osu.Game.Rulesets.Mods; using osu.Game.Rulesets.Mods;
@ -13,7 +12,7 @@ using osuTK;
namespace osu.Game.Rulesets.Osu.Mods namespace osu.Game.Rulesets.Osu.Mods
{ {
internal class OsuModWiggle : Mod, IApplicableToDrawableHitObjects internal class OsuModWiggle : ModWithVisibilityAdjustment
{ {
public override string Name => "Wiggle"; public override string Name => "Wiggle";
public override string Acronym => "WG"; public override string Acronym => "WG";
@ -26,11 +25,9 @@ namespace osu.Game.Rulesets.Osu.Mods
private const int wiggle_duration = 90; // (ms) Higher = fewer wiggles private const int wiggle_duration = 90; // (ms) Higher = fewer wiggles
private const int wiggle_strength = 10; // Higher = stronger wiggles private const int wiggle_strength = 10; // Higher = stronger wiggles
public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables) protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state) => drawableOnApplyCustomUpdateState(hitObject, state);
{
foreach (var drawable in drawables) protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => drawableOnApplyCustomUpdateState(hitObject, state);
drawable.ApplyCustomUpdateState += drawableOnApplyCustomUpdateState;
}
private void drawableOnApplyCustomUpdateState(DrawableHitObject drawable, ArmedState state) private void drawableOnApplyCustomUpdateState(DrawableHitObject drawable, ArmedState state)
{ {

44
osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointConnection.cs
View File

@ -2,6 +2,7 @@
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using System; using System;
using System.Diagnostics;
using JetBrains.Annotations; using JetBrains.Annotations;
using osu.Framework.Bindables; using osu.Framework.Bindables;
using osu.Framework.Graphics; using osu.Framework.Graphics;
@ -31,19 +32,19 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
/// The <see cref="DrawableOsuHitObject"/> which <see cref="FollowPoint"/>s will exit from. /// The <see cref="DrawableOsuHitObject"/> which <see cref="FollowPoint"/>s will exit from.
/// </summary> /// </summary>
[NotNull] [NotNull]
public readonly DrawableOsuHitObject Start; public readonly OsuHitObject Start;
/// <summary> /// <summary>
/// Creates a new <see cref="FollowPointConnection"/>. /// Creates a new <see cref="FollowPointConnection"/>.
/// </summary> /// </summary>
/// <param name="start">The <see cref="DrawableOsuHitObject"/> which <see cref="FollowPoint"/>s will exit from.</param> /// <param name="start">The <see cref="DrawableOsuHitObject"/> which <see cref="FollowPoint"/>s will exit from.</param>
public FollowPointConnection([NotNull] DrawableOsuHitObject start) public FollowPointConnection([NotNull] OsuHitObject start)
{ {
Start = start; Start = start;
RelativeSizeAxes = Axes.Both; RelativeSizeAxes = Axes.Both;
StartTime.BindTo(Start.HitObject.StartTimeBindable); StartTime.BindTo(start.StartTimeBindable);
} }
protected override void LoadComplete() protected override void LoadComplete()
@ -52,13 +53,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
bindEvents(Start); bindEvents(Start);
} }
private DrawableOsuHitObject end; private OsuHitObject end;
/// <summary> /// <summary>
/// The <see cref="DrawableOsuHitObject"/> which <see cref="FollowPoint"/>s will enter. /// The <see cref="DrawableOsuHitObject"/> which <see cref="FollowPoint"/>s will enter.
/// </summary> /// </summary>
[CanBeNull] [CanBeNull]
public DrawableOsuHitObject End public OsuHitObject End
{ {
get => end; get => end;
set set
@ -75,10 +76,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
} }
} }
private void bindEvents(DrawableOsuHitObject drawableObject) private void bindEvents(OsuHitObject obj)
{ {
drawableObject.HitObject.PositionBindable.BindValueChanged(_ => scheduleRefresh()); obj.PositionBindable.BindValueChanged(_ => scheduleRefresh());
drawableObject.HitObject.DefaultsApplied += _ => scheduleRefresh(); obj.DefaultsApplied += _ => scheduleRefresh();
} }
private void scheduleRefresh() private void scheduleRefresh()
@ -88,23 +89,20 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
private void refresh() private void refresh()
{ {
OsuHitObject osuStart = Start.HitObject; double startTime = Start.GetEndTime();
double startTime = osuStart.GetEndTime();
LifetimeStart = startTime; LifetimeStart = startTime;
OsuHitObject osuEnd = End?.HitObject; if (End == null || End.NewCombo || Start is Spinner || End is Spinner)
if (osuEnd == null || osuEnd.NewCombo || osuStart is Spinner || osuEnd is Spinner)
{ {
// ensure we always set a lifetime for full LifetimeManagementContainer benefits // ensure we always set a lifetime for full LifetimeManagementContainer benefits
LifetimeEnd = LifetimeStart; LifetimeEnd = LifetimeStart;
return; return;
} }
Vector2 startPosition = osuStart.StackedEndPosition; Vector2 startPosition = Start.StackedEndPosition;
Vector2 endPosition = osuEnd.StackedPosition; Vector2 endPosition = End.StackedPosition;
double endTime = osuEnd.StartTime; double endTime = End.StartTime;
Vector2 distanceVector = endPosition - startPosition; Vector2 distanceVector = endPosition - startPosition;
int distance = (int)distanceVector.Length; int distance = (int)distanceVector.Length;
@ -130,10 +128,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
AddInternal(fp = new FollowPoint()); AddInternal(fp = new FollowPoint());
Debug.Assert(End != null);
fp.Position = pointStartPosition; fp.Position = pointStartPosition;
fp.Rotation = rotation; fp.Rotation = rotation;
fp.Alpha = 0; fp.Alpha = 0;
fp.Scale = new Vector2(1.5f * osuEnd.Scale); fp.Scale = new Vector2(1.5f * End.Scale);
firstTransformStartTime ??= fadeInTime; firstTransformStartTime ??= fadeInTime;
@ -141,12 +141,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
using (fp.BeginAbsoluteSequence(fadeInTime)) using (fp.BeginAbsoluteSequence(fadeInTime))
{ {
fp.FadeIn(osuEnd.TimeFadeIn); fp.FadeIn(End.TimeFadeIn);
fp.ScaleTo(osuEnd.Scale, osuEnd.TimeFadeIn, Easing.Out); fp.ScaleTo(End.Scale, End.TimeFadeIn, Easing.Out);
fp.MoveTo(pointEndPosition, osuEnd.TimeFadeIn, Easing.Out); fp.MoveTo(pointEndPosition, End.TimeFadeIn, Easing.Out);
fp.Delay(fadeOutTime - fadeInTime).FadeOut(osuEnd.TimeFadeIn); fp.Delay(fadeOutTime - fadeInTime).FadeOut(End.TimeFadeIn);
finalTransformEndTime = fadeOutTime + osuEnd.TimeFadeIn; finalTransformEndTime = fadeOutTime + End.TimeFadeIn;
} }
point++; point++;

12
osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointRenderer.cs
View File

@ -24,19 +24,19 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
public override bool RemoveCompletedTransforms => false; public override bool RemoveCompletedTransforms => false;
/// <summary> /// <summary>
/// Adds the <see cref="FollowPoint"/>s around a <see cref="DrawableOsuHitObject"/>. /// Adds the <see cref="FollowPoint"/>s around an <see cref="OsuHitObject"/>.
/// This includes <see cref="FollowPoint"/>s leading into <paramref name="hitObject"/>, and <see cref="FollowPoint"/>s exiting <paramref name="hitObject"/>. /// This includes <see cref="FollowPoint"/>s leading into <paramref name="hitObject"/>, and <see cref="FollowPoint"/>s exiting <paramref name="hitObject"/>.
/// </summary> /// </summary>
/// <param name="hitObject">The <see cref="DrawableOsuHitObject"/> to add <see cref="FollowPoint"/>s for.</param> /// <param name="hitObject">The <see cref="OsuHitObject"/> to add <see cref="FollowPoint"/>s for.</param>
public void AddFollowPoints(DrawableOsuHitObject hitObject) public void AddFollowPoints(OsuHitObject hitObject)
=> addConnection(new FollowPointConnection(hitObject).With(g => g.StartTime.BindValueChanged(_ => onStartTimeChanged(g)))); => addConnection(new FollowPointConnection(hitObject).With(g => g.StartTime.BindValueChanged(_ => onStartTimeChanged(g))));
/// <summary> /// <summary>
/// Removes the <see cref="FollowPoint"/>s around a <see cref="DrawableOsuHitObject"/>. /// Removes the <see cref="FollowPoint"/>s around an <see cref="OsuHitObject"/>.
/// This includes <see cref="FollowPoint"/>s leading into <paramref name="hitObject"/>, and <see cref="FollowPoint"/>s exiting <paramref name="hitObject"/>. /// This includes <see cref="FollowPoint"/>s leading into <paramref name="hitObject"/>, and <see cref="FollowPoint"/>s exiting <paramref name="hitObject"/>.
/// </summary> /// </summary>
/// <param name="hitObject">The <see cref="DrawableOsuHitObject"/> to remove <see cref="FollowPoint"/>s for.</param> /// <param name="hitObject">The <see cref="OsuHitObject"/> to remove <see cref="FollowPoint"/>s for.</param>
public void RemoveFollowPoints(DrawableOsuHitObject hitObject) => removeGroup(connections.Single(g => g.Start == hitObject)); public void RemoveFollowPoints(OsuHitObject hitObject) => removeGroup(connections.Single(g => g.Start == hitObject));
/// <summary> /// <summary>
/// Adds a <see cref="FollowPointConnection"/> to this <see cref="FollowPointRenderer"/>. /// Adds a <see cref="FollowPointConnection"/> to this <see cref="FollowPointRenderer"/>.

39
osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs
View File

@ -4,7 +4,6 @@
using System; using System;
using System.Diagnostics; using System.Diagnostics;
using osu.Framework.Allocation; using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers; using osu.Framework.Graphics.Containers;
using osu.Framework.Input; using osu.Framework.Input;
@ -21,28 +20,25 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
{ {
public class DrawableHitCircle : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach public class DrawableHitCircle : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach
{ {
public ApproachCircle ApproachCircle { get; }
private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
private readonly IBindable<int> stackHeightBindable = new Bindable<int>();
private readonly IBindable<float> scaleBindable = new BindableFloat();
public OsuAction? HitAction => HitArea.HitAction; public OsuAction? HitAction => HitArea.HitAction;
public readonly HitReceptor HitArea;
public readonly SkinnableDrawable CirclePiece;
private readonly Container scaleContainer;
protected virtual OsuSkinComponents CirclePieceComponent => OsuSkinComponents.HitCircle; protected virtual OsuSkinComponents CirclePieceComponent => OsuSkinComponents.HitCircle;
public ApproachCircle ApproachCircle { get; private set; }
public HitReceptor HitArea { get; private set; }
public SkinnableDrawable CirclePiece { get; private set; }
private Container scaleContainer;
private InputManager inputManager; private InputManager inputManager;
public DrawableHitCircle(HitCircle h) public DrawableHitCircle(HitCircle h)
: base(h) : base(h)
{ {
Origin = Anchor.Centre; }
Position = HitObject.StackedPosition; [BackgroundDependencyLoader]
private void load()
{
Origin = Anchor.Centre;
InternalChildren = new Drawable[] InternalChildren = new Drawable[]
{ {
@ -75,19 +71,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
}; };
Size = HitArea.DrawSize; Size = HitArea.DrawSize;
}
[BackgroundDependencyLoader]
private void load()
{
positionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
stackHeightBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
scaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue), true);
positionBindable.BindTo(HitObject.PositionBindable);
stackHeightBindable.BindTo(HitObject.StackHeightBindable);
scaleBindable.BindTo(HitObject.ScaleBindable);
PositionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition, true);
StackHeightBindable.BindValueChanged(_ => Position = HitObject.StackedPosition, true);
ScaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue), true);
AccentColour.BindValueChanged(accent => ApproachCircle.Colour = accent.NewValue, true); AccentColour.BindValueChanged(accent => ApproachCircle.Colour = accent.NewValue, true);
} }

22
osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs
View File

@ -2,18 +2,24 @@
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using System; using System;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Game.Rulesets.Objects.Drawables; using osu.Game.Rulesets.Objects.Drawables;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Game.Rulesets.Judgements; using osu.Game.Rulesets.Judgements;
using osu.Game.Rulesets.Osu.Judgements; using osu.Game.Rulesets.Osu.Judgements;
using osu.Game.Graphics.Containers; using osu.Game.Graphics.Containers;
using osu.Game.Rulesets.Osu.UI; using osu.Game.Rulesets.Osu.UI;
using osuTK;
namespace osu.Game.Rulesets.Osu.Objects.Drawables namespace osu.Game.Rulesets.Osu.Objects.Drawables
{ {
public class DrawableOsuHitObject : DrawableHitObject<OsuHitObject> public class DrawableOsuHitObject : DrawableHitObject<OsuHitObject>
{ {
private readonly ShakeContainer shakeContainer; public readonly IBindable<Vector2> PositionBindable = new Bindable<Vector2>();
public readonly IBindable<int> StackHeightBindable = new Bindable<int>();
public readonly IBindable<float> ScaleBindable = new BindableFloat();
public readonly IBindable<int> IndexInCurrentComboBindable = new Bindable<int>();
// Must be set to update IsHovered as it's used in relax mdo to detect osu hit objects. // Must be set to update IsHovered as it's used in relax mdo to detect osu hit objects.
public override bool HandlePositionalInput => true; public override bool HandlePositionalInput => true;
@ -26,16 +32,28 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
/// </summary> /// </summary>
public Func<DrawableHitObject, double, bool> CheckHittable; public Func<DrawableHitObject, double, bool> CheckHittable;
private ShakeContainer shakeContainer;
protected DrawableOsuHitObject(OsuHitObject hitObject) protected DrawableOsuHitObject(OsuHitObject hitObject)
: base(hitObject) : base(hitObject)
{ {
}
[BackgroundDependencyLoader]
private void load()
{
Alpha = 0;
base.AddInternal(shakeContainer = new ShakeContainer base.AddInternal(shakeContainer = new ShakeContainer
{ {
ShakeDuration = 30, ShakeDuration = 30,
RelativeSizeAxes = Axes.Both RelativeSizeAxes = Axes.Both
}); });
Alpha = 0; IndexInCurrentComboBindable.BindTo(HitObject.IndexInCurrentComboBindable);
PositionBindable.BindTo(HitObject.PositionBindable);
StackHeightBindable.BindTo(HitObject.StackHeightBindable);
ScaleBindable.BindTo(HitObject.ScaleBindable);
} }
// Forward all internal management to shakeContainer. // Forward all internal management to shakeContainer.

22
osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuJudgement.cs
View File

@ -2,22 +2,17 @@
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using osu.Framework.Allocation; using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Game.Configuration; using osu.Game.Configuration;
using osuTK; using osuTK;
using osu.Game.Rulesets.Judgements; using osu.Game.Rulesets.Judgements;
using osu.Game.Rulesets.Objects.Drawables; using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Skinning;
using osuTK.Graphics;
namespace osu.Game.Rulesets.Osu.Objects.Drawables namespace osu.Game.Rulesets.Osu.Objects.Drawables
{ {
public class DrawableOsuJudgement : DrawableJudgement public class DrawableOsuJudgement : DrawableJudgement
{ {
protected SkinnableSprite Lighting; protected SkinnableLighting Lighting { get; private set; }
private Bindable<Color4> lightingColour;
[Resolved] [Resolved]
private OsuConfigManager config { get; set; } private OsuConfigManager config { get; set; }
@ -34,7 +29,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load() private void load()
{ {
AddInternal(Lighting = new SkinnableSprite("lighting") AddInternal(Lighting = new SkinnableLighting
{ {
Anchor = Anchor.Centre, Anchor = Anchor.Centre,
Origin = Anchor.Centre, Origin = Anchor.Centre,
@ -59,19 +54,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
{ {
base.PrepareForUse(); base.PrepareForUse();
lightingColour?.UnbindAll();
Lighting.ResetAnimation(); Lighting.ResetAnimation();
Lighting.SetColourFrom(JudgedObject, Result);
if (JudgedObject != null)
{
lightingColour = JudgedObject.AccentColour.GetBoundCopy();
lightingColour.BindValueChanged(colour => Lighting.Colour = Result.IsHit ? colour.NewValue : Color4.Transparent, true);
}
else
{
Lighting.Colour = Color4.White;
}
} }
private double fadeOutDelay; private double fadeOutDelay;

58
osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs
View File

@ -20,62 +20,54 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
{ {
public class DrawableSlider : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach public class DrawableSlider : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach
{ {
public new Slider HitObject => (Slider)base.HitObject;
public DrawableSliderHead HeadCircle => headContainer.Child; public DrawableSliderHead HeadCircle => headContainer.Child;
public DrawableSliderTail TailCircle => tailContainer.Child; public DrawableSliderTail TailCircle => tailContainer.Child;
public readonly SliderBall Ball; public SliderBall Ball { get; private set; }
public readonly SkinnableDrawable Body; public SkinnableDrawable Body { get; private set; }
public override bool DisplayResult => false; public override bool DisplayResult => false;
private PlaySliderBody sliderBody => Body.Drawable as PlaySliderBody; private PlaySliderBody sliderBody => Body.Drawable as PlaySliderBody;
private readonly Container<DrawableSliderHead> headContainer; public readonly IBindable<int> PathVersion = new Bindable<int>();
private readonly Container<DrawableSliderTail> tailContainer;
private readonly Container<DrawableSliderTick> tickContainer;
private readonly Container<DrawableSliderRepeat> repeatContainer;
private readonly Slider slider; private Container<DrawableSliderHead> headContainer;
private Container<DrawableSliderTail> tailContainer;
private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>(); private Container<DrawableSliderTick> tickContainer;
private readonly IBindable<int> stackHeightBindable = new Bindable<int>(); private Container<DrawableSliderRepeat> repeatContainer;
private readonly IBindable<float> scaleBindable = new BindableFloat();
public DrawableSlider(Slider s) public DrawableSlider(Slider s)
: base(s) : base(s)
{ {
slider = s; }
Position = s.StackedPosition;
[BackgroundDependencyLoader]
private void load()
{
InternalChildren = new Drawable[] InternalChildren = new Drawable[]
{ {
Body = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderBody), _ => new DefaultSliderBody(), confineMode: ConfineMode.NoScaling), Body = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderBody), _ => new DefaultSliderBody(), confineMode: ConfineMode.NoScaling),
tailContainer = new Container<DrawableSliderTail> { RelativeSizeAxes = Axes.Both }, tailContainer = new Container<DrawableSliderTail> { RelativeSizeAxes = Axes.Both },
tickContainer = new Container<DrawableSliderTick> { RelativeSizeAxes = Axes.Both }, tickContainer = new Container<DrawableSliderTick> { RelativeSizeAxes = Axes.Both },
repeatContainer = new Container<DrawableSliderRepeat> { RelativeSizeAxes = Axes.Both }, repeatContainer = new Container<DrawableSliderRepeat> { RelativeSizeAxes = Axes.Both },
Ball = new SliderBall(s, this) Ball = new SliderBall(this)
{ {
GetInitialHitAction = () => HeadCircle.HitAction, GetInitialHitAction = () => HeadCircle.HitAction,
BypassAutoSizeAxes = Axes.Both, BypassAutoSizeAxes = Axes.Both,
Scale = new Vector2(s.Scale),
AlwaysPresent = true, AlwaysPresent = true,
Alpha = 0 Alpha = 0
}, },
headContainer = new Container<DrawableSliderHead> { RelativeSizeAxes = Axes.Both }, headContainer = new Container<DrawableSliderHead> { RelativeSizeAxes = Axes.Both },
}; };
}
[BackgroundDependencyLoader] PathVersion.BindTo(HitObject.Path.Version);
private void load()
{
positionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
stackHeightBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
scaleBindable.BindValueChanged(scale => Ball.Scale = new Vector2(scale.NewValue));
positionBindable.BindTo(HitObject.PositionBindable); PositionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition, true);
stackHeightBindable.BindTo(HitObject.StackHeightBindable); StackHeightBindable.BindValueChanged(_ => Position = HitObject.StackedPosition, true);
scaleBindable.BindTo(HitObject.ScaleBindable); ScaleBindable.BindValueChanged(scale => Ball.Scale = new Vector2(scale.NewValue), true);
AccentColour.BindValueChanged(colour => AccentColour.BindValueChanged(colour =>
{ {
@ -162,20 +154,20 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
switch (hitObject) switch (hitObject)
{ {
case SliderTailCircle tail: case SliderTailCircle tail:
return new DrawableSliderTail(slider, tail); return new DrawableSliderTail(tail);
case SliderHeadCircle head: case SliderHeadCircle head:
return new DrawableSliderHead(slider, head) return new DrawableSliderHead(HitObject, head)
{ {
OnShake = Shake, OnShake = Shake,
CheckHittable = (d, t) => CheckHittable?.Invoke(d, t) ?? true CheckHittable = (d, t) => CheckHittable?.Invoke(d, t) ?? true
}; };
case SliderTick tick: case SliderTick tick:
return new DrawableSliderTick(tick) { Position = tick.Position - slider.Position }; return new DrawableSliderTick(tick) { Position = tick.Position - HitObject.Position };
case SliderRepeat repeat: case SliderRepeat repeat:
return new DrawableSliderRepeat(repeat, this) { Position = repeat.Position - slider.Position }; return new DrawableSliderRepeat(repeat, this) { Position = repeat.Position - HitObject.Position };
} }
return base.CreateNestedHitObject(hitObject); return base.CreateNestedHitObject(hitObject);
@ -200,14 +192,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
// keep the sliding sample playing at the current tracking position // keep the sliding sample playing at the current tracking position
slidingSample.Balance.Value = CalculateSamplePlaybackBalance(Ball.X / OsuPlayfield.BASE_SIZE.X); slidingSample.Balance.Value = CalculateSamplePlaybackBalance(Ball.X / OsuPlayfield.BASE_SIZE.X);
double completionProgress = Math.Clamp((Time.Current - slider.StartTime) / slider.Duration, 0, 1); double completionProgress = Math.Clamp((Time.Current - HitObject.StartTime) / HitObject.Duration, 0, 1);
Ball.UpdateProgress(completionProgress); Ball.UpdateProgress(completionProgress);
sliderBody?.UpdateProgress(completionProgress); sliderBody?.UpdateProgress(completionProgress);
foreach (DrawableHitObject hitObject in NestedHitObjects) foreach (DrawableHitObject hitObject in NestedHitObjects)
{ {
if (hitObject is ITrackSnaking s) s.UpdateSnakingPosition(slider.Path.PositionAt(sliderBody?.SnakedStart ?? 0), slider.Path.PositionAt(sliderBody?.SnakedEnd ?? 0)); if (hitObject is ITrackSnaking s) s.UpdateSnakingPosition(HitObject.Path.PositionAt(sliderBody?.SnakedStart ?? 0), HitObject.Path.PositionAt(sliderBody?.SnakedEnd ?? 0));
if (hitObject is IRequireTracking t) t.Tracking = Ball.Tracking; if (hitObject is IRequireTracking t) t.Tracking = Ball.Tracking;
} }
@ -239,7 +231,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
protected override void CheckForResult(bool userTriggered, double timeOffset) protected override void CheckForResult(bool userTriggered, double timeOffset)
{ {
if (userTriggered || Time.Current < slider.EndTime) if (userTriggered || Time.Current < HitObject.EndTime)
return; return;
ApplyResult(r => r.Type = r.Judgement.MaxResult); ApplyResult(r => r.Type = r.Judgement.MaxResult);

5
osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderHead.cs
View File

@ -5,13 +5,11 @@ using System;
using osu.Framework.Allocation; using osu.Framework.Allocation;
using osu.Framework.Bindables; using osu.Framework.Bindables;
using osu.Game.Rulesets.Objects.Types; using osu.Game.Rulesets.Objects.Types;
using osuTK;
namespace osu.Game.Rulesets.Osu.Objects.Drawables namespace osu.Game.Rulesets.Osu.Objects.Drawables
{ {
public class DrawableSliderHead : DrawableHitCircle public class DrawableSliderHead : DrawableHitCircle
{ {
private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
private readonly IBindable<int> pathVersion = new Bindable<int>(); private readonly IBindable<int> pathVersion = new Bindable<int>();
protected override OsuSkinComponents CirclePieceComponent => OsuSkinComponents.SliderHeadHitCircle; protected override OsuSkinComponents CirclePieceComponent => OsuSkinComponents.SliderHeadHitCircle;
@ -27,10 +25,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load() private void load()
{ {
positionBindable.BindTo(HitObject.PositionBindable);
pathVersion.BindTo(slider.Path.Version); pathVersion.BindTo(slider.Path.Version);
positionBindable.BindValueChanged(_ => updatePosition()); PositionBindable.BindValueChanged(_ => updatePosition());
pathVersion.BindValueChanged(_ => updatePosition(), true); pathVersion.BindValueChanged(_ => updatePosition(), true);
} }

25
osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderRepeat.cs
View File

@ -4,7 +4,6 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using osu.Framework.Allocation; using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers; using osu.Framework.Graphics.Containers;
using osu.Framework.Utils; using osu.Framework.Utils;
@ -22,9 +21,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
private double animDuration; private double animDuration;
private readonly Drawable scaleContainer; public Drawable CirclePiece { get; private set; }
private Drawable scaleContainer;
public readonly Drawable CirclePiece; private ReverseArrowPiece arrow;
public override bool DisplayResult => false; public override bool DisplayResult => false;
@ -33,10 +32,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
{ {
this.sliderRepeat = sliderRepeat; this.sliderRepeat = sliderRepeat;
this.drawableSlider = drawableSlider; this.drawableSlider = drawableSlider;
}
Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2); [BackgroundDependencyLoader]
private void load()
{
Origin = Anchor.Centre; Origin = Anchor.Centre;
Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
InternalChild = scaleContainer = new Container InternalChild = scaleContainer = new Container
{ {
@ -50,15 +52,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
arrow = new ReverseArrowPiece(), arrow = new ReverseArrowPiece(),
} }
}; };
}
private readonly IBindable<float> scaleBindable = new BindableFloat(); ScaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue), true);
[BackgroundDependencyLoader]
private void load()
{
scaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue), true);
scaleBindable.BindTo(HitObject.ScaleBindable);
} }
protected override void CheckForResult(bool userTriggered, double timeOffset) protected override void CheckForResult(bool userTriggered, double timeOffset)
@ -100,8 +95,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
private bool hasRotation; private bool hasRotation;
private readonly ReverseArrowPiece arrow;
public void UpdateSnakingPosition(Vector2 start, Vector2 end) public void UpdateSnakingPosition(Vector2 start, Vector2 end)
{ {
// When the repeat is hit, the arrow should fade out on spot rather than following the slider // When the repeat is hit, the arrow should fade out on spot rather than following the slider

23
osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs
View File

@ -3,7 +3,6 @@
using System.Diagnostics; using System.Diagnostics;
using osu.Framework.Allocation; using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers; using osu.Framework.Graphics.Containers;
using osu.Game.Rulesets.Objects.Drawables; using osu.Game.Rulesets.Objects.Drawables;
@ -23,18 +22,19 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
public bool Tracking { get; set; } public bool Tracking { get; set; }
private readonly IBindable<float> scaleBindable = new BindableFloat(); private SkinnableDrawable circlePiece;
private Container scaleContainer;
private readonly SkinnableDrawable circlePiece; public DrawableSliderTail(SliderTailCircle tailCircle)
private readonly Container scaleContainer;
public DrawableSliderTail(Slider slider, SliderTailCircle tailCircle)
: base(tailCircle) : base(tailCircle)
{ {
this.tailCircle = tailCircle; this.tailCircle = tailCircle;
Origin = Anchor.Centre; }
[BackgroundDependencyLoader]
private void load()
{
Origin = Anchor.Centre;
Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2); Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
InternalChildren = new Drawable[] InternalChildren = new Drawable[]
@ -51,13 +51,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
} }
}, },
}; };
}
[BackgroundDependencyLoader] ScaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue), true);
private void load()
{
scaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue), true);
scaleBindable.BindTo(HitObject.ScaleBindable);
} }
protected override void UpdateInitialTransforms() protected override void UpdateInitialTransforms()

17
osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTick.cs
View File

@ -2,7 +2,6 @@
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using osu.Framework.Allocation; using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Game.Rulesets.Objects.Drawables; using osu.Game.Rulesets.Objects.Drawables;
using osuTK; using osuTK;
@ -23,10 +22,15 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
public override bool DisplayResult => false; public override bool DisplayResult => false;
private readonly SkinnableDrawable scaleContainer; private SkinnableDrawable scaleContainer;
public DrawableSliderTick(SliderTick sliderTick) public DrawableSliderTick(SliderTick sliderTick)
: base(sliderTick) : base(sliderTick)
{
}
[BackgroundDependencyLoader]
private void load()
{ {
Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2); Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
Origin = Anchor.Centre; Origin = Anchor.Centre;
@ -49,15 +53,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
Anchor = Anchor.Centre, Anchor = Anchor.Centre,
Origin = Anchor.Centre, Origin = Anchor.Centre,
}; };
}
private readonly IBindable<float> scaleBindable = new BindableFloat(); ScaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue), true);
[BackgroundDependencyLoader]
private void load()
{
scaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue), true);
scaleBindable.BindTo(HitObject.ScaleBindable);
} }
protected override void CheckForResult(bool userTriggered, double timeOffset) protected override void CheckForResult(bool userTriggered, double timeOffset)

46
osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
View File

@ -16,34 +16,33 @@ using osu.Game.Rulesets.Osu.Skinning;
using osu.Game.Rulesets.Scoring; using osu.Game.Rulesets.Scoring;
using osu.Game.Screens.Ranking; using osu.Game.Screens.Ranking;
using osu.Game.Skinning; using osu.Game.Skinning;
using osuTK;
namespace osu.Game.Rulesets.Osu.Objects.Drawables namespace osu.Game.Rulesets.Osu.Objects.Drawables
{ {
public class DrawableSpinner : DrawableOsuHitObject public class DrawableSpinner : DrawableOsuHitObject
{ {
protected readonly Spinner Spinner; public new Spinner HitObject => (Spinner)base.HitObject;
private readonly Container<DrawableSpinnerTick> ticks; public SpinnerRotationTracker RotationTracker { get; private set; }
public SpinnerSpmCounter SpmCounter { get; private set; }
public readonly SpinnerRotationTracker RotationTracker; private Container<DrawableSpinnerTick> ticks;
public readonly SpinnerSpmCounter SpmCounter; private SpinnerBonusDisplay bonusDisplay;
private readonly SpinnerBonusDisplay bonusDisplay;
private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
private Bindable<bool> isSpinning;
private bool spinnerFrequencyModulate; private bool spinnerFrequencyModulate;
public DrawableSpinner(Spinner s) public DrawableSpinner(Spinner s)
: base(s) : base(s)
{
}
[BackgroundDependencyLoader]
private void load(OsuColour colours)
{ {
Origin = Anchor.Centre; Origin = Anchor.Centre;
Position = s.Position;
RelativeSizeAxes = Axes.Both; RelativeSizeAxes = Axes.Both;
Spinner = s;
InternalChildren = new Drawable[] InternalChildren = new Drawable[]
{ {
ticks = new Container<DrawableSpinnerTick>(), ticks = new Container<DrawableSpinnerTick>(),
@ -55,7 +54,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
Children = new Drawable[] Children = new Drawable[]
{ {
new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SpinnerBody), _ => new DefaultSpinnerDisc()), new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SpinnerBody), _ => new DefaultSpinnerDisc()),
RotationTracker = new SpinnerRotationTracker(Spinner) RotationTracker = new SpinnerRotationTracker(this)
} }
}, },
SpmCounter = new SpinnerSpmCounter SpmCounter = new SpinnerSpmCounter
@ -72,9 +71,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
Y = -120, Y = -120,
} }
}; };
}
private Bindable<bool> isSpinning; PositionBindable.BindValueChanged(pos => Position = pos.NewValue, true);
}
protected override void LoadComplete() protected override void LoadComplete()
{ {
@ -172,13 +171,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
return base.CreateNestedHitObject(hitObject); return base.CreateNestedHitObject(hitObject);
} }
[BackgroundDependencyLoader]
private void load(OsuColour colours)
{
positionBindable.BindValueChanged(pos => Position = pos.NewValue);
positionBindable.BindTo(HitObject.PositionBindable);
}
protected override void ApplySkin(ISkinSource skin, bool allowFallback) protected override void ApplySkin(ISkinSource skin, bool allowFallback)
{ {
base.ApplySkin(skin, allowFallback); base.ApplySkin(skin, allowFallback);
@ -192,12 +184,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
{ {
get get
{ {
if (Spinner.SpinsRequired == 0) if (HitObject.SpinsRequired == 0)
// some spinners are so short they can't require an integer spin count. // some spinners are so short they can't require an integer spin count.
// these become implicitly hit. // these become implicitly hit.
return 1; return 1;
return Math.Clamp(RotationTracker.RateAdjustedRotation / 360 / Spinner.SpinsRequired, 0, 1); return Math.Clamp(RotationTracker.RateAdjustedRotation / 360 / HitObject.SpinsRequired, 0, 1);
} }
} }
@ -207,7 +199,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
RotationTracker.Complete.Value = Progress >= 1; RotationTracker.Complete.Value = Progress >= 1;
if (userTriggered || Time.Current < Spinner.EndTime) if (userTriggered || Time.Current < HitObject.EndTime)
return; return;
// Trigger a miss result for remaining ticks to avoid infinite gameplay. // Trigger a miss result for remaining ticks to avoid infinite gameplay.
@ -222,7 +214,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
r.Type = HitResult.Ok; r.Type = HitResult.Ok;
else if (Progress > .75) else if (Progress > .75)
r.Type = HitResult.Meh; r.Type = HitResult.Meh;
else if (Time.Current >= Spinner.EndTime) else if (Time.Current >= HitObject.EndTime)
r.Type = r.Judgement.MinResult; r.Type = r.Judgement.MinResult;
}); });
} }
@ -274,7 +266,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
{ {
tick.TriggerResult(true); tick.TriggerResult(true);
if (tick is DrawableSpinnerBonusTick) if (tick is DrawableSpinnerBonusTick)
bonusDisplay.SetBonusCount(spins - Spinner.SpinsRequired); bonusDisplay.SetBonusCount(spins - HitObject.SpinsRequired);
} }
wholeSpins++; wholeSpins++;

2
osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/CirclePiece.cs
View File

@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
Origin = Anchor.Centre, Origin = Anchor.Centre,
Texture = textures.Get(@"Gameplay/osu/disc"), Texture = textures.Get(@"Gameplay/osu/disc"),
}, },
new TrianglesPiece((int)drawableHitObject.HitObject.StartTime) new TrianglesPiece(drawableHitObject.GetHashCode())
{ {
RelativeSizeAxes = Axes.Both, RelativeSizeAxes = Axes.Both,
Blending = BlendingParameters.Additive, Blending = BlendingParameters.Additive,

5
osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/DefaultSpinnerDisc.cs
View File

@ -18,8 +18,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
{ {
private DrawableSpinner drawableSpinner; private DrawableSpinner drawableSpinner;
private Spinner spinner;
private const float initial_scale = 1.3f; private const float initial_scale = 1.3f;
private const float idle_alpha = 0.2f; private const float idle_alpha = 0.2f;
private const float tracking_alpha = 0.4f; private const float tracking_alpha = 0.4f;
@ -52,7 +50,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
private void load(OsuColour colours, DrawableHitObject drawableHitObject) private void load(OsuColour colours, DrawableHitObject drawableHitObject)
{ {
drawableSpinner = (DrawableSpinner)drawableHitObject; drawableSpinner = (DrawableSpinner)drawableHitObject;
spinner = (Spinner)drawableSpinner.HitObject;
normalColour = colours.BlueDark; normalColour = colours.BlueDark;
completeColour = colours.YellowLight; completeColour = colours.YellowLight;
@ -130,6 +127,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
if (!(drawableHitObject is DrawableSpinner)) if (!(drawableHitObject is DrawableSpinner))
return; return;
Spinner spinner = drawableSpinner.HitObject;
using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt, true)) using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt, true))
{ {
this.ScaleTo(initial_scale); this.ScaleTo(initial_scale);

4
osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/MainCirclePiece.cs
View File

@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load() private void load()
{ {
var osuObject = (OsuHitObject)drawableObject.HitObject; var drawableOsuObject = (DrawableOsuHitObject)drawableObject;
state.BindTo(drawableObject.State); state.BindTo(drawableObject.State);
state.BindValueChanged(updateState, true); state.BindValueChanged(updateState, true);
@ -61,7 +61,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
circle.Colour = colour.NewValue; circle.Colour = colour.NewValue;
}, true); }, true);
indexInCurrentCombo.BindTo(osuObject.IndexInCurrentComboBindable); indexInCurrentCombo.BindTo(drawableOsuObject.IndexInCurrentComboBindable);
indexInCurrentCombo.BindValueChanged(index => number.Text = (index.NewValue + 1).ToString(), true); indexInCurrentCombo.BindValueChanged(index => number.Text = (index.NewValue + 1).ToString(), true);
} }

13
osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/PlaySliderBody.cs
View File

@ -17,23 +17,18 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
private IBindable<int> pathVersion; private IBindable<int> pathVersion;
private IBindable<Color4> accentColour; private IBindable<Color4> accentColour;
[Resolved]
private DrawableHitObject drawableObject { get; set; }
[Resolved(CanBeNull = true)] [Resolved(CanBeNull = true)]
private OsuRulesetConfigManager config { get; set; } private OsuRulesetConfigManager config { get; set; }
private Slider slider;
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load(ISkinSource skin) private void load(ISkinSource skin, DrawableHitObject drawableObject)
{ {
slider = (Slider)drawableObject.HitObject; var drawableSlider = (DrawableSlider)drawableObject;
scaleBindable = slider.ScaleBindable.GetBoundCopy(); scaleBindable = drawableSlider.ScaleBindable.GetBoundCopy();
scaleBindable.BindValueChanged(scale => PathRadius = OsuHitObject.OBJECT_RADIUS * scale.NewValue, true); scaleBindable.BindValueChanged(scale => PathRadius = OsuHitObject.OBJECT_RADIUS * scale.NewValue, true);
pathVersion = slider.Path.Version.GetBoundCopy(); pathVersion = drawableSlider.PathVersion.GetBoundCopy();
pathVersion.BindValueChanged(_ => Refresh()); pathVersion.BindValueChanged(_ => Refresh());
accentColour = drawableObject.AccentColour.GetBoundCopy(); accentColour = drawableObject.AccentColour.GetBoundCopy();

12
osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SliderBall.cs
View File

@ -30,15 +30,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
set => ball.Colour = value; set => ball.Colour = value;
} }
private readonly Slider slider;
private readonly Drawable followCircle; private readonly Drawable followCircle;
private readonly DrawableSlider drawableSlider; private readonly DrawableSlider drawableSlider;
private readonly Drawable ball; private readonly Drawable ball;
public SliderBall(Slider slider, DrawableSlider drawableSlider = null) public SliderBall(DrawableSlider drawableSlider)
{ {
this.drawableSlider = drawableSlider; this.drawableSlider = drawableSlider;
this.slider = slider;
Origin = Anchor.Centre; Origin = Anchor.Centre;
@ -133,7 +131,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
if (headCircleHitAction == null) if (headCircleHitAction == null)
timeToAcceptAnyKeyAfter = null; timeToAcceptAnyKeyAfter = null;
var actions = drawableSlider?.OsuActionInputManager?.PressedActions; var actions = drawableSlider.OsuActionInputManager?.PressedActions;
// if the head circle was hit with a specific key, tracking should only occur while that key is pressed. // if the head circle was hit with a specific key, tracking should only occur while that key is pressed.
if (headCircleHitAction != null && timeToAcceptAnyKeyAfter == null) if (headCircleHitAction != null && timeToAcceptAnyKeyAfter == null)
@ -147,7 +145,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
Tracking = Tracking =
// in valid time range // in valid time range
Time.Current >= slider.StartTime && Time.Current < slider.EndTime && Time.Current >= drawableSlider.HitObject.StartTime && Time.Current < drawableSlider.HitObject.EndTime &&
// in valid position range // in valid position range
lastScreenSpaceMousePosition.HasValue && followCircle.ReceivePositionalInputAt(lastScreenSpaceMousePosition.Value) && lastScreenSpaceMousePosition.HasValue && followCircle.ReceivePositionalInputAt(lastScreenSpaceMousePosition.Value) &&
// valid action // valid action
@ -172,9 +170,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
public void UpdateProgress(double completionProgress) public void UpdateProgress(double completionProgress)
{ {
var newPos = slider.CurvePositionAt(completionProgress); var newPos = drawableSlider.HitObject.CurvePositionAt(completionProgress);
var diff = lastPosition.HasValue ? lastPosition.Value - newPos : newPos - slider.CurvePositionAt(completionProgress + 0.01f); var diff = lastPosition.HasValue ? lastPosition.Value - newPos : newPos - drawableSlider.HitObject.CurvePositionAt(completionProgress + 0.01f);
if (diff == Vector2.Zero) if (diff == Vector2.Zero)
return; return;

16
osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SnakingSliderBody.cs
View File

@ -51,18 +51,23 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
/// </summary> /// </summary>
private Vector2 snakedPathOffset; private Vector2 snakedPathOffset;
private Slider slider; private DrawableSlider drawableSlider;
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load(DrawableHitObject drawableObject) private void load(DrawableHitObject drawableObject)
{ {
slider = (Slider)drawableObject.HitObject; drawableSlider = (DrawableSlider)drawableObject;
Refresh(); Refresh();
} }
public void UpdateProgress(double completionProgress) public void UpdateProgress(double completionProgress)
{ {
if (drawableSlider == null)
return;
Slider slider = drawableSlider.HitObject;
var span = slider.SpanAt(completionProgress); var span = slider.SpanAt(completionProgress);
var spanProgress = slider.ProgressAt(completionProgress); var spanProgress = slider.ProgressAt(completionProgress);
@ -87,8 +92,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
public void Refresh() public void Refresh()
{ {
if (drawableSlider == null)
return;
// Generate the entire curve // Generate the entire curve
slider.Path.GetPathToProgress(CurrentCurve, 0, 1); drawableSlider.HitObject.Path.GetPathToProgress(CurrentCurve, 0, 1);
SetVertices(CurrentCurve); SetVertices(CurrentCurve);
// Force the body to be the final path size to avoid excessive autosize computations // Force the body to be the final path size to avoid excessive autosize computations
@ -132,7 +140,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
SnakedStart = p0; SnakedStart = p0;
SnakedEnd = p1; SnakedEnd = p1;
slider.Path.GetPathToProgress(CurrentCurve, p0, p1); drawableSlider.HitObject.Path.GetPathToProgress(CurrentCurve, p0, p1);
SetVertices(CurrentCurve); SetVertices(CurrentCurve);

10
osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerRotationTracker.cs
View File

@ -15,13 +15,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
{ {
public class SpinnerRotationTracker : CircularContainer public class SpinnerRotationTracker : CircularContainer
{ {
private readonly Spinner spinner;
public override bool IsPresent => true; // handle input when hidden public override bool IsPresent => true; // handle input when hidden
public SpinnerRotationTracker(Spinner s) private readonly DrawableSpinner drawableSpinner;
public SpinnerRotationTracker(DrawableSpinner drawableSpinner)
{ {
spinner = s; this.drawableSpinner = drawableSpinner;
RelativeSizeAxes = Axes.Both; RelativeSizeAxes = Axes.Both;
} }
@ -64,7 +64,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
/// <summary> /// <summary>
/// Whether currently in the correct time range to allow spinning. /// Whether currently in the correct time range to allow spinning.
/// </summary> /// </summary>
private bool isSpinnableTime => spinner.StartTime <= Time.Current && spinner.EndTime > Time.Current; private bool isSpinnableTime => drawableSpinner.HitObject.StartTime <= Time.Current && drawableSpinner.HitObject.EndTime > Time.Current;
protected override bool OnMouseMove(MouseMoveEvent e) protected override bool OnMouseMove(MouseMoveEvent e)
{ {

48
osu.Game.Rulesets.Osu/Objects/Drawables/SkinnableLighting.cs Normal file
View File

@ -0,0 +1,48 @@
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
using osu.Game.Rulesets.Judgements;
using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Skinning;
using osuTK.Graphics;
namespace osu.Game.Rulesets.Osu.Objects.Drawables
{
public class SkinnableLighting : SkinnableSprite
{
private DrawableHitObject targetObject;
private JudgementResult targetResult;
public SkinnableLighting()
: base("lighting")
{
}
protected override void SkinChanged(ISkinSource skin, bool allowFallback)
{
base.SkinChanged(skin, allowFallback);
updateColour();
}
/// <summary>
/// Updates the lighting colour from a given hitobject and result.
/// </summary>
/// <param name="targetObject">The <see cref="DrawableHitObject"/> that's been judged.</param>
/// <param name="targetResult">The <see cref="JudgementResult"/> that <paramref name="targetObject"/> was judged with.</param>
public void SetColourFrom(DrawableHitObject targetObject, JudgementResult targetResult)
{
this.targetObject = targetObject;
this.targetResult = targetResult;
updateColour();
}
private void updateColour()
{
if (targetObject == null || targetResult == null)
Colour = Color4.White;
else
Colour = targetResult.IsHit ? targetObject.AccentColour.Value : Color4.Transparent;
}
}
}

5
osu.Game.Rulesets.Osu/Skinning/LegacyMainCirclePiece.cs
View File

@ -11,6 +11,7 @@ using osu.Game.Graphics;
using osu.Game.Graphics.Sprites; using osu.Game.Graphics.Sprites;
using osu.Game.Rulesets.Objects.Drawables; using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Osu.Objects; using osu.Game.Rulesets.Osu.Objects;
using osu.Game.Rulesets.Osu.Objects.Drawables;
using osu.Game.Skinning; using osu.Game.Skinning;
using osuTK; using osuTK;
using osuTK.Graphics; using osuTK.Graphics;
@ -50,7 +51,7 @@ namespace osu.Game.Rulesets.Osu.Skinning
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load() private void load()
{ {
OsuHitObject osuObject = (OsuHitObject)drawableObject.HitObject; var drawableOsuObject = (DrawableOsuHitObject)drawableObject;
bool allowFallback = false; bool allowFallback = false;
@ -114,7 +115,7 @@ namespace osu.Game.Rulesets.Osu.Skinning
state.BindTo(drawableObject.State); state.BindTo(drawableObject.State);
accentColour.BindTo(drawableObject.AccentColour); accentColour.BindTo(drawableObject.AccentColour);
indexInCurrentCombo.BindTo(osuObject.IndexInCurrentComboBindable); indexInCurrentCombo.BindTo(drawableOsuObject.IndexInCurrentComboBindable);
Texture getTextureWithFallback(string name) Texture getTextureWithFallback(string name)
{ {

143
osu.Game.Rulesets.Osu/Skinning/LegacyNewStyleSpinner.cs
View File

@ -19,98 +19,113 @@ namespace osu.Game.Rulesets.Osu.Skinning
/// Legacy skinned spinner with two main spinning layers, one fixed overlay and one final spinning overlay. /// Legacy skinned spinner with two main spinning layers, one fixed overlay and one final spinning overlay.
/// No background layer. /// No background layer.
/// </summary> /// </summary>
public class LegacyNewStyleSpinner : CompositeDrawable public class LegacyNewStyleSpinner : LegacySpinner
{ {
private Sprite glow;
private Sprite discBottom; private Sprite discBottom;
private Sprite discTop; private Sprite discTop;
private Sprite spinningMiddle; private Sprite spinningMiddle;
private Sprite fixedMiddle; private Sprite fixedMiddle;
private DrawableSpinner drawableSpinner; private readonly Color4 glowColour = new Color4(3, 151, 255, 255);
private const float final_scale = 0.625f; private Container scaleContainer;
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load(ISkinSource source, DrawableHitObject drawableObject) private void load(ISkinSource source)
{ {
drawableSpinner = (DrawableSpinner)drawableObject; AddInternal(scaleContainer = new Container
Scale = new Vector2(final_scale);
InternalChildren = new Drawable[]
{ {
discBottom = new Sprite Scale = new Vector2(SPRITE_SCALE),
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{ {
Anchor = Anchor.Centre, glow = new Sprite
Origin = Anchor.Centre, {
Texture = source.GetTexture("spinner-bottom") Anchor = Anchor.Centre,
}, Origin = Anchor.Centre,
discTop = new Sprite Texture = source.GetTexture("spinner-glow"),
{ Blending = BlendingParameters.Additive,
Anchor = Anchor.Centre, Colour = glowColour,
Origin = Anchor.Centre, },
Texture = source.GetTexture("spinner-top") discBottom = new Sprite
}, {
fixedMiddle = new Sprite Anchor = Anchor.Centre,
{ Origin = Anchor.Centre,
Anchor = Anchor.Centre, Texture = source.GetTexture("spinner-bottom")
Origin = Anchor.Centre, },
Texture = source.GetTexture("spinner-middle") discTop = new Sprite
}, {
spinningMiddle = new Sprite Anchor = Anchor.Centre,
{ Origin = Anchor.Centre,
Anchor = Anchor.Centre, Texture = source.GetTexture("spinner-top")
Origin = Anchor.Centre, },
Texture = source.GetTexture("spinner-middle2") fixedMiddle = new Sprite
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Texture = source.GetTexture("spinner-middle")
},
spinningMiddle = new Sprite
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Texture = source.GetTexture("spinner-middle2")
}
} }
}; });
} }
protected override void LoadComplete() protected override void UpdateStateTransforms(DrawableHitObject drawableHitObject, ArmedState state)
{ {
base.LoadComplete(); base.UpdateStateTransforms(drawableHitObject, state);
drawableSpinner.ApplyCustomUpdateState += updateStateTransforms; switch (drawableHitObject)
updateStateTransforms(drawableSpinner, drawableSpinner.State.Value);
}
private void updateStateTransforms(DrawableHitObject drawableHitObject, ArmedState state)
{
if (!(drawableHitObject is DrawableSpinner))
return;
var spinner = (Spinner)drawableSpinner.HitObject;
using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt, true))
this.FadeOut();
using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimeFadeIn / 2, true))
this.FadeInFromZero(spinner.TimeFadeIn / 2);
using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt, true))
{ {
fixedMiddle.FadeColour(Color4.White); case DrawableSpinner d:
Spinner spinner = d.HitObject;
using (BeginDelayedSequence(spinner.TimePreempt, true)) using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt, true))
fixedMiddle.FadeColour(Color4.Red, spinner.Duration); this.FadeOut();
using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimeFadeIn / 2, true))
this.FadeInFromZero(spinner.TimeFadeIn / 2);
using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt, true))
{
fixedMiddle.FadeColour(Color4.White);
using (BeginDelayedSequence(spinner.TimePreempt, true))
fixedMiddle.FadeColour(Color4.Red, spinner.Duration);
}
if (state == ArmedState.Hit)
{
using (BeginAbsoluteSequence(d.HitStateUpdateTime))
glow.FadeOut(300);
}
break;
case DrawableSpinnerBonusTick _:
if (state == ArmedState.Hit)
glow.FlashColour(Color4.White, 200);
break;
} }
} }
protected override void Update() protected override void Update()
{ {
base.Update(); base.Update();
spinningMiddle.Rotation = discTop.Rotation = drawableSpinner.RotationTracker.Rotation; spinningMiddle.Rotation = discTop.Rotation = DrawableSpinner.RotationTracker.Rotation;
discBottom.Rotation = discTop.Rotation / 3; discBottom.Rotation = discTop.Rotation / 3;
Scale = new Vector2(final_scale * (0.8f + (float)Interpolation.ApplyEasing(Easing.Out, drawableSpinner.Progress) * 0.2f)); glow.Alpha = DrawableSpinner.Progress;
}
protected override void Dispose(bool isDisposing) scaleContainer.Scale = new Vector2(SPRITE_SCALE * (0.8f + (float)Interpolation.ApplyEasing(Easing.Out, DrawableSpinner.Progress) * 0.2f));
{
base.Dispose(isDisposing);
if (drawableSpinner != null)
drawableSpinner.ApplyCustomUpdateState -= updateStateTransforms;
} }
} }
} }

49
osu.Game.Rulesets.Osu/Skinning/LegacyOldStyleSpinner.cs
View File

@ -8,6 +8,7 @@ using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Sprites; using osu.Framework.Graphics.Sprites;
using osu.Framework.Utils; using osu.Framework.Utils;
using osu.Game.Rulesets.Objects.Drawables; using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Osu.Objects;
using osu.Game.Rulesets.Osu.Objects.Drawables; using osu.Game.Rulesets.Osu.Objects.Drawables;
using osu.Game.Skinning; using osu.Game.Skinning;
using osuTK; using osuTK;
@ -17,28 +18,22 @@ namespace osu.Game.Rulesets.Osu.Skinning
/// <summary> /// <summary>
/// Legacy skinned spinner with one main spinning layer and a background layer. /// Legacy skinned spinner with one main spinning layer and a background layer.
/// </summary> /// </summary>
public class LegacyOldStyleSpinner : CompositeDrawable public class LegacyOldStyleSpinner : LegacySpinner
{ {
private DrawableSpinner drawableSpinner;
private Sprite disc; private Sprite disc;
private Sprite metreSprite; private Sprite metreSprite;
private Container metre; private Container metre;
private bool spinnerBlink; private bool spinnerBlink;
private const float sprite_scale = 1 / 1.6f; private const float final_metre_height = 692 * SPRITE_SCALE;
private const float final_metre_height = 692 * sprite_scale;
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load(ISkinSource source, DrawableHitObject drawableObject) private void load(ISkinSource source)
{ {
spinnerBlink = source.GetConfig<OsuSkinConfiguration, bool>(OsuSkinConfiguration.SpinnerNoBlink)?.Value != true; spinnerBlink = source.GetConfig<OsuSkinConfiguration, bool>(OsuSkinConfiguration.SpinnerNoBlink)?.Value != true;
drawableSpinner = (DrawableSpinner)drawableObject; AddInternal(new Container
RelativeSizeAxes = Axes.Both;
InternalChild = new Container
{ {
// the old-style spinner relied heavily on absolute screen-space coordinate values. // the old-style spinner relied heavily on absolute screen-space coordinate values.
// wrap everything in a container simulating absolute coords to preserve alignment // wrap everything in a container simulating absolute coords to preserve alignment
@ -54,14 +49,14 @@ namespace osu.Game.Rulesets.Osu.Skinning
Anchor = Anchor.Centre, Anchor = Anchor.Centre,
Origin = Anchor.Centre, Origin = Anchor.Centre,
Texture = source.GetTexture("spinner-background"), Texture = source.GetTexture("spinner-background"),
Scale = new Vector2(sprite_scale) Scale = new Vector2(SPRITE_SCALE)
}, },
disc = new Sprite disc = new Sprite
{ {
Anchor = Anchor.Centre, Anchor = Anchor.Centre,
Origin = Anchor.Centre, Origin = Anchor.Centre,
Texture = source.GetTexture("spinner-circle"), Texture = source.GetTexture("spinner-circle"),
Scale = new Vector2(sprite_scale) Scale = new Vector2(SPRITE_SCALE)
}, },
metre = new Container metre = new Container
{ {
@ -77,27 +72,21 @@ namespace osu.Game.Rulesets.Osu.Skinning
Texture = source.GetTexture("spinner-metre"), Texture = source.GetTexture("spinner-metre"),
Anchor = Anchor.TopLeft, Anchor = Anchor.TopLeft,
Origin = Anchor.TopLeft, Origin = Anchor.TopLeft,
Scale = new Vector2(0.625f) Scale = new Vector2(SPRITE_SCALE)
} }
} }
} }
}; });
} }
protected override void LoadComplete() protected override void UpdateStateTransforms(DrawableHitObject drawableHitObject, ArmedState state)
{ {
base.LoadComplete(); base.UpdateStateTransforms(drawableHitObject, state);
drawableSpinner.ApplyCustomUpdateState += updateStateTransforms; if (!(drawableHitObject is DrawableSpinner d))
updateStateTransforms(drawableSpinner, drawableSpinner.State.Value);
}
private void updateStateTransforms(DrawableHitObject drawableHitObject, ArmedState state)
{
if (!(drawableHitObject is DrawableSpinner))
return; return;
var spinner = drawableSpinner.HitObject; Spinner spinner = d.HitObject;
using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt, true)) using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt, true))
this.FadeOut(); this.FadeOut();
@ -109,11 +98,11 @@ namespace osu.Game.Rulesets.Osu.Skinning
protected override void Update() protected override void Update()
{ {
base.Update(); base.Update();
disc.Rotation = drawableSpinner.RotationTracker.Rotation; disc.Rotation = DrawableSpinner.RotationTracker.Rotation;
// careful: need to call this exactly once for all calculations in a frame // careful: need to call this exactly once for all calculations in a frame
// as the function has a random factor in it // as the function has a random factor in it
var metreHeight = getMetreHeight(drawableSpinner.Progress); var metreHeight = getMetreHeight(DrawableSpinner.Progress);
// hack to make the metre blink up from below than down from above. // hack to make the metre blink up from below than down from above.
// move down the container to be able to apply masking for the metre, // move down the container to be able to apply masking for the metre,
@ -139,13 +128,5 @@ namespace osu.Game.Rulesets.Osu.Skinning
return (float)barCount / total_bars * final_metre_height; return (float)barCount / total_bars * final_metre_height;
} }
protected override void Dispose(bool isDisposing)
{
base.Dispose(isDisposing);
if (drawableSpinner != null)
drawableSpinner.ApplyCustomUpdateState -= updateStateTransforms;
}
} }
} }

3
osu.Game.Rulesets.Osu/Skinning/LegacySliderBall.cs
View File

@ -5,7 +5,6 @@ using osu.Framework.Allocation;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers; using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Sprites; using osu.Framework.Graphics.Sprites;
using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Skinning; using osu.Game.Skinning;
using osuTK.Graphics; using osuTK.Graphics;
@ -26,7 +25,7 @@ namespace osu.Game.Rulesets.Osu.Skinning
} }
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load(ISkinSource skin, DrawableHitObject drawableObject) private void load(ISkinSource skin)
{ {
var ballColour = skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderBall)?.Value ?? Color4.White; var ballColour = skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderBall)?.Value ?? Color4.White;

84
osu.Game.Rulesets.Osu/Skinning/LegacySpinner.cs Normal file
View File

@ -0,0 +1,84 @@
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
using System;
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Sprites;
using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Osu.Objects.Drawables;
using osu.Game.Skinning;
using osuTK;
namespace osu.Game.Rulesets.Osu.Skinning
{
public abstract class LegacySpinner : CompositeDrawable
{
protected const float SPRITE_SCALE = 0.625f;
protected DrawableSpinner DrawableSpinner { get; private set; }
private Sprite spin;
[BackgroundDependencyLoader]
private void load(DrawableHitObject drawableHitObject, ISkinSource source)
{
RelativeSizeAxes = Axes.Both;
DrawableSpinner = (DrawableSpinner)drawableHitObject;
AddRangeInternal(new[]
{
spin = new Sprite
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Depth = float.MinValue,
Texture = source.GetTexture("spinner-spin"),
Scale = new Vector2(SPRITE_SCALE),
Y = 120 - 45 // offset temporarily to avoid overlapping default spin counter
},
});
}
protected override void LoadComplete()
{
base.LoadComplete();
DrawableSpinner.ApplyCustomUpdateState += UpdateStateTransforms;
UpdateStateTransforms(DrawableSpinner, DrawableSpinner.State.Value);
}
protected virtual void UpdateStateTransforms(DrawableHitObject drawableHitObject, ArmedState state)
{
switch (drawableHitObject)
{
case DrawableSpinner d:
double fadeOutLength = Math.Min(400, d.HitObject.Duration);
using (BeginAbsoluteSequence(drawableHitObject.HitStateUpdateTime - fadeOutLength, true))
spin.FadeOutFromOne(fadeOutLength);
break;
case DrawableSpinnerTick d:
if (state == ArmedState.Hit)
{
using (BeginAbsoluteSequence(d.HitStateUpdateTime, true))
spin.FadeOut(300);
}
break;
}
}
protected override void Dispose(bool isDisposing)
{
base.Dispose(isDisposing);
if (DrawableSpinner != null)
DrawableSpinner.ApplyCustomUpdateState -= UpdateStateTransforms;
}
}
}

15
osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs
View File

@ -4,12 +4,15 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers; using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Pooling; using osu.Framework.Graphics.Pooling;
using osu.Game.Rulesets.Judgements; using osu.Game.Rulesets.Judgements;
using osu.Game.Rulesets.Objects; using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Objects.Drawables; using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Osu.Configuration;
using osu.Game.Rulesets.Osu.Objects.Drawables; using osu.Game.Rulesets.Osu.Objects.Drawables;
using osu.Game.Rulesets.Osu.Objects.Drawables.Connections; using osu.Game.Rulesets.Osu.Objects.Drawables.Connections;
using osu.Game.Rulesets.Osu.Scoring; using osu.Game.Rulesets.Osu.Scoring;
@ -17,9 +20,6 @@ using osu.Game.Rulesets.Osu.UI.Cursor;
using osu.Game.Rulesets.Scoring; using osu.Game.Rulesets.Scoring;
using osu.Game.Rulesets.UI; using osu.Game.Rulesets.UI;
using osu.Game.Skinning; using osu.Game.Skinning;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Game.Rulesets.Osu.Configuration;
using osuTK; using osuTK;
namespace osu.Game.Rulesets.Osu.UI namespace osu.Game.Rulesets.Osu.UI
@ -95,6 +95,8 @@ namespace osu.Game.Rulesets.Osu.UI
public override void Add(DrawableHitObject h) public override void Add(DrawableHitObject h)
{ {
DrawableOsuHitObject osuHitObject = (DrawableOsuHitObject)h;
h.OnNewResult += onNewResult; h.OnNewResult += onNewResult;
h.OnLoadComplete += d => h.OnLoadComplete += d =>
{ {
@ -107,18 +109,19 @@ namespace osu.Game.Rulesets.Osu.UI
base.Add(h); base.Add(h);
DrawableOsuHitObject osuHitObject = (DrawableOsuHitObject)h;
osuHitObject.CheckHittable = hitPolicy.IsHittable; osuHitObject.CheckHittable = hitPolicy.IsHittable;
followPoints.AddFollowPoints(osuHitObject); followPoints.AddFollowPoints(osuHitObject.HitObject);
} }
public override bool Remove(DrawableHitObject h) public override bool Remove(DrawableHitObject h)
{ {
DrawableOsuHitObject osuHitObject = (DrawableOsuHitObject)h;
bool result = base.Remove(h); bool result = base.Remove(h);
if (result) if (result)
followPoints.RemoveFollowPoints((DrawableOsuHitObject)h); followPoints.RemoveFollowPoints(osuHitObject.HitObject);
return result; return result;
} }

4
osu.Game.Rulesets.Taiko/Audio/DrumSampleContainer.cs
View File

@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Taiko.Audio
private readonly ControlPointInfo controlPoints; private readonly ControlPointInfo controlPoints;
private readonly Dictionary<double, DrumSample> mappings = new Dictionary<double, DrumSample>(); private readonly Dictionary<double, DrumSample> mappings = new Dictionary<double, DrumSample>();
private IBindableList<SampleControlPoint> samplePoints; private readonly IBindableList<SampleControlPoint> samplePoints = new BindableList<SampleControlPoint>();
public DrumSampleContainer(ControlPointInfo controlPoints) public DrumSampleContainer(ControlPointInfo controlPoints)
{ {
@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Taiko.Audio
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load() private void load()
{ {
samplePoints = controlPoints.SamplePoints.GetBoundCopy(); samplePoints.BindTo(controlPoints.SamplePoints);
samplePoints.BindCollectionChanged((_, __) => recreateMappings(), true); samplePoints.BindCollectionChanged((_, __) => recreateMappings(), true);
} }

10
osu.Game.Tests/Beatmaps/BeatmapDifficultyManagerTest.cs
View File

@ -14,8 +14,8 @@ namespace osu.Game.Tests.Beatmaps
[Test] [Test]
public void TestKeyEqualsWithDifferentModInstances() public void TestKeyEqualsWithDifferentModInstances()
{ {
var key1 = new BeatmapDifficultyManager.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() }); var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
var key2 = new BeatmapDifficultyManager.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() }); var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
Assert.That(key1, Is.EqualTo(key2)); Assert.That(key1, Is.EqualTo(key2));
} }
@ -23,8 +23,8 @@ namespace osu.Game.Tests.Beatmaps
[Test] [Test]
public void TestKeyEqualsWithDifferentModOrder() public void TestKeyEqualsWithDifferentModOrder()
{ {
var key1 = new BeatmapDifficultyManager.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() }); var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
var key2 = new BeatmapDifficultyManager.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHidden(), new OsuModHardRock() }); var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHidden(), new OsuModHardRock() });
Assert.That(key1, Is.EqualTo(key2)); Assert.That(key1, Is.EqualTo(key2));
} }
@ -47,7 +47,7 @@ namespace osu.Game.Tests.Beatmaps
[TestCase(8.3, DifficultyRating.ExpertPlus)] [TestCase(8.3, DifficultyRating.ExpertPlus)]
public void TestDifficultyRatingMapping(double starRating, DifficultyRating expectedBracket) public void TestDifficultyRatingMapping(double starRating, DifficultyRating expectedBracket)
{ {
var actualBracket = BeatmapDifficultyManager.GetDifficultyRating(starRating); var actualBracket = BeatmapDifficultyCache.GetDifficultyRating(starRating);
Assert.AreEqual(expectedBracket, actualBracket); Assert.AreEqual(expectedBracket, actualBracket);
} }

6
osu.Game.Tests/Visual/Gameplay/TestSceneSpectator.cs
View File

@ -250,7 +250,7 @@ namespace osu.Game.Tests.Visual.Gameplay
public void EndPlay(int beatmapId) public void EndPlay(int beatmapId)
{ {
((ISpectatorClient)this).UserFinishedPlaying((int)StreamingUser.Id, new SpectatorState ((ISpectatorClient)this).UserFinishedPlaying(StreamingUser.Id, new SpectatorState
{ {
BeatmapID = beatmapId, BeatmapID = beatmapId,
RulesetID = 0, RulesetID = 0,
@ -273,7 +273,7 @@ namespace osu.Game.Tests.Visual.Gameplay
} }
var bundle = new FrameDataBundle(frames); var bundle = new FrameDataBundle(frames);
((ISpectatorClient)this).UserSentFrames((int)StreamingUser.Id, bundle); ((ISpectatorClient)this).UserSentFrames(StreamingUser.Id, bundle);
if (!sentState) if (!sentState)
sendState(beatmapId); sendState(beatmapId);
@ -293,7 +293,7 @@ namespace osu.Game.Tests.Visual.Gameplay
private void sendState(int beatmapId) private void sendState(int beatmapId)
{ {
sentState = true; sentState = true;
((ISpectatorClient)this).UserBeganPlaying((int)StreamingUser.Id, new SpectatorState ((ISpectatorClient)this).UserBeganPlaying(StreamingUser.Id, new SpectatorState
{ {
BeatmapID = beatmapId, BeatmapID = beatmapId,
RulesetID = 0, RulesetID = 0,

4
osu.Game.Tests/Visual/Gameplay/TestSceneSpectatorPlayback.cs
View File

@ -43,7 +43,7 @@ namespace osu.Game.Tests.Visual.Gameplay
private Replay replay; private Replay replay;
private IBindableList<int> users; private readonly IBindableList<int> users = new BindableList<int>();
private TestReplayRecorder recorder; private TestReplayRecorder recorder;
@ -67,7 +67,7 @@ namespace osu.Game.Tests.Visual.Gameplay
{ {
replay = new Replay(); replay = new Replay();
users = streamingClient.PlayingUsers.GetBoundCopy(); users.BindTo(streamingClient.PlayingUsers);
users.BindCollectionChanged((obj, args) => users.BindCollectionChanged((obj, args) =>
{ {
switch (args.Action) switch (args.Action)

2
osu.Game.Tournament/Screens/Editors/TeamEditorScreen.cs
View File

@ -277,7 +277,7 @@ namespace osu.Game.Tournament.Screens.Editors
userId.Value = user.Id.ToString(); userId.Value = user.Id.ToString();
userId.BindValueChanged(idString => userId.BindValueChanged(idString =>
{ {
long.TryParse(idString.NewValue, out var parsed); int.TryParse(idString.NewValue, out var parsed);
user.Id = parsed; user.Id = parsed;

68
osu.Game/Beatmaps/BeatmapDifficultyManager.cs → osu.Game/Beatmaps/BeatmapDifficultyCache.cs
View File

@ -2,7 +2,6 @@
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using System; using System;
using System.Collections.Concurrent;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics; using System.Diagnostics;
using System.Linq; using System.Linq;
@ -11,25 +10,25 @@ using System.Threading.Tasks;
using JetBrains.Annotations; using JetBrains.Annotations;
using osu.Framework.Allocation; using osu.Framework.Allocation;
using osu.Framework.Bindables; using osu.Framework.Bindables;
using osu.Framework.Graphics.Containers;
using osu.Framework.Lists; using osu.Framework.Lists;
using osu.Framework.Logging; using osu.Framework.Logging;
using osu.Framework.Threading; using osu.Framework.Threading;
using osu.Framework.Utils; using osu.Framework.Utils;
using osu.Game.Database;
using osu.Game.Rulesets; using osu.Game.Rulesets;
using osu.Game.Rulesets.Difficulty;
using osu.Game.Rulesets.Mods; using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.UI; using osu.Game.Rulesets.UI;
namespace osu.Game.Beatmaps namespace osu.Game.Beatmaps
{ {
public class BeatmapDifficultyManager : CompositeDrawable /// <summary>
/// A component which performs and acts as a central cache for difficulty calculations of beatmap/ruleset/mod combinations.
/// Currently not persisted between game sessions.
/// </summary>
public class BeatmapDifficultyCache : MemoryCachingComponent<BeatmapDifficultyCache.DifficultyCacheLookup, StarDifficulty>
{ {
// Too many simultaneous updates can lead to stutters. One thread seems to work fine for song select display purposes. // Too many simultaneous updates can lead to stutters. One thread seems to work fine for song select display purposes.
private readonly ThreadedTaskScheduler updateScheduler = new ThreadedTaskScheduler(1, nameof(BeatmapDifficultyManager)); private readonly ThreadedTaskScheduler updateScheduler = new ThreadedTaskScheduler(1, nameof(BeatmapDifficultyCache));
// A permanent cache to prevent re-computations.
private readonly ConcurrentDictionary<DifficultyCacheLookup, StarDifficulty> difficultyCache = new ConcurrentDictionary<DifficultyCacheLookup, StarDifficulty>();
// All bindables that should be updated along with the current ruleset + mods. // All bindables that should be updated along with the current ruleset + mods.
private readonly LockedWeakList<BindableStarDifficulty> trackedBindables = new LockedWeakList<BindableStarDifficulty>(); private readonly LockedWeakList<BindableStarDifficulty> trackedBindables = new LockedWeakList<BindableStarDifficulty>();
@ -239,7 +238,7 @@ namespace osu.Game.Beatmaps
var calculator = ruleset.CreateDifficultyCalculator(beatmapManager.GetWorkingBeatmap(beatmapInfo)); var calculator = ruleset.CreateDifficultyCalculator(beatmapManager.GetWorkingBeatmap(beatmapInfo));
var attributes = calculator.Calculate(key.Mods); var attributes = calculator.Calculate(key.Mods);
return difficultyCache[key] = new StarDifficulty(attributes); return Cache[key] = new StarDifficulty(attributes);
} }
catch (BeatmapInvalidForRulesetException e) catch (BeatmapInvalidForRulesetException e)
{ {
@ -250,7 +249,7 @@ namespace osu.Game.Beatmaps
if (rulesetInfo.Equals(beatmapInfo.Ruleset)) if (rulesetInfo.Equals(beatmapInfo.Ruleset))
{ {
Logger.Error(e, $"Failed to convert {beatmapInfo.OnlineBeatmapID} to the beatmap's default ruleset ({beatmapInfo.Ruleset})."); Logger.Error(e, $"Failed to convert {beatmapInfo.OnlineBeatmapID} to the beatmap's default ruleset ({beatmapInfo.Ruleset}).");
return difficultyCache[key] = new StarDifficulty(); return Cache[key] = new StarDifficulty();
} }
// Check the cache first because this is now a different ruleset than the one previously guarded against. // Check the cache first because this is now a different ruleset than the one previously guarded against.
@ -261,7 +260,7 @@ namespace osu.Game.Beatmaps
} }
catch catch
{ {
return difficultyCache[key] = new StarDifficulty(); return Cache[key] = new StarDifficulty();
} }
} }
@ -290,7 +289,7 @@ namespace osu.Game.Beatmaps
} }
key = new DifficultyCacheLookup(beatmapInfo.ID, rulesetInfo.ID.Value, mods); key = new DifficultyCacheLookup(beatmapInfo.ID, rulesetInfo.ID.Value, mods);
return difficultyCache.TryGetValue(key, out existingDifficulty); return Cache.TryGetValue(key, out existingDifficulty);
} }
protected override void Dispose(bool isDisposing) protected override void Dispose(bool isDisposing)
@ -344,49 +343,4 @@ namespace osu.Game.Beatmaps
} }
} }
} }
public readonly struct StarDifficulty
{
/// <summary>
/// The star difficulty rating for the given beatmap.
/// </summary>
public readonly double Stars;
/// <summary>
/// The maximum combo achievable on the given beatmap.
/// </summary>
public readonly int MaxCombo;
/// <summary>
/// The difficulty attributes computed for the given beatmap.
/// Might not be available if the star difficulty is associated with a beatmap that's not locally available.
/// </summary>
[CanBeNull]
public readonly DifficultyAttributes Attributes;
/// <summary>
/// Creates a <see cref="StarDifficulty"/> structure based on <see cref="DifficultyAttributes"/> computed
/// by a <see cref="DifficultyCalculator"/>.
/// </summary>
public StarDifficulty([NotNull] DifficultyAttributes attributes)
{
Stars = attributes.StarRating;
MaxCombo = attributes.MaxCombo;
Attributes = attributes;
// Todo: Add more members (BeatmapInfo.DifficultyRating? Attributes? Etc...)
}
/// <summary>
/// Creates a <see cref="StarDifficulty"/> structure with a pre-populated star difficulty and max combo
/// in scenarios where computing <see cref="DifficultyAttributes"/> is not feasible (i.e. when working with online sources).
/// </summary>
public StarDifficulty(double starDifficulty, int maxCombo)
{
Stars = starDifficulty;
MaxCombo = maxCombo;
Attributes = null;
}
public DifficultyRating DifficultyRating => BeatmapDifficultyManager.GetDifficultyRating(Stars);
}
} }

2
osu.Game/Beatmaps/BeatmapInfo.cs
View File

@ -136,7 +136,7 @@ namespace osu.Game.Beatmaps
public List<ScoreInfo> Scores { get; set; } public List<ScoreInfo> Scores { get; set; }
[JsonIgnore] [JsonIgnore]
public DifficultyRating DifficultyRating => BeatmapDifficultyManager.GetDifficultyRating(StarDifficulty); public DifficultyRating DifficultyRating => BeatmapDifficultyCache.GetDifficultyRating(StarDifficulty);
public string[] SearchableTerms => new[] public string[] SearchableTerms => new[]
{ {

6
osu.Game/Beatmaps/Drawables/DifficultyIcon.cs
View File

@ -142,7 +142,7 @@ namespace osu.Game.Beatmaps.Drawables
private CancellationTokenSource difficultyCancellation; private CancellationTokenSource difficultyCancellation;
[Resolved] [Resolved]
private BeatmapDifficultyManager difficultyManager { get; set; } private BeatmapDifficultyCache difficultyCache { get; set; }
public DifficultyRetriever(BeatmapInfo beatmap, RulesetInfo ruleset, IReadOnlyList<Mod> mods) public DifficultyRetriever(BeatmapInfo beatmap, RulesetInfo ruleset, IReadOnlyList<Mod> mods)
{ {
@ -158,8 +158,8 @@ namespace osu.Game.Beatmaps.Drawables
{ {
difficultyCancellation = new CancellationTokenSource(); difficultyCancellation = new CancellationTokenSource();
localStarDifficulty = ruleset != null localStarDifficulty = ruleset != null
? difficultyManager.GetBindableDifficulty(beatmap, ruleset, mods, difficultyCancellation.Token) ? difficultyCache.GetBindableDifficulty(beatmap, ruleset, mods, difficultyCancellation.Token)
: difficultyManager.GetBindableDifficulty(beatmap, difficultyCancellation.Token); : difficultyCache.GetBindableDifficulty(beatmap, difficultyCancellation.Token);
localStarDifficulty.BindValueChanged(difficulty => StarDifficulty.Value = difficulty.NewValue); localStarDifficulty.BindValueChanged(difficulty => StarDifficulty.Value = difficulty.NewValue);
} }

53
osu.Game/Beatmaps/StarDifficulty.cs Normal file
View File

@ -0,0 +1,53 @@
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
using JetBrains.Annotations;
using osu.Game.Rulesets.Difficulty;
namespace osu.Game.Beatmaps
{
public readonly struct StarDifficulty
{
/// <summary>
/// The star difficulty rating for the given beatmap.
/// </summary>
public readonly double Stars;
/// <summary>
/// The maximum combo achievable on the given beatmap.
/// </summary>
public readonly int MaxCombo;
/// <summary>
/// The difficulty attributes computed for the given beatmap.
/// Might not be available if the star difficulty is associated with a beatmap that's not locally available.
/// </summary>
[CanBeNull]
public readonly DifficultyAttributes Attributes;
/// <summary>
/// Creates a <see cref="StarDifficulty"/> structure based on <see cref="DifficultyAttributes"/> computed
/// by a <see cref="DifficultyCalculator"/>.
/// </summary>
public StarDifficulty([NotNull] DifficultyAttributes attributes)
{
Stars = attributes.StarRating;
MaxCombo = attributes.MaxCombo;
Attributes = attributes;
// Todo: Add more members (BeatmapInfo.DifficultyRating? Attributes? Etc...)
}
/// <summary>
/// Creates a <see cref="StarDifficulty"/> structure with a pre-populated star difficulty and max combo
/// in scenarios where computing <see cref="DifficultyAttributes"/> is not feasible (i.e. when working with online sources).
/// </summary>
public StarDifficulty(double starDifficulty, int maxCombo)
{
Stars = starDifficulty;
MaxCombo = maxCombo;
Attributes = null;
}
public DifficultyRating DifficultyRating => BeatmapDifficultyCache.GetDifficultyRating(Stars);
}
}

17
osu.Game/Database/MemoryCachingComponent.cs Normal file
View File

@ -0,0 +1,17 @@
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
using System.Collections.Concurrent;
using osu.Framework.Graphics;
namespace osu.Game.Database
{
/// <summary>
/// A component which performs lookups (or calculations) and caches the results.
/// Currently not persisted between game sessions.
/// </summary>
public abstract class MemoryCachingComponent<TLookup, TValue> : Component
{
protected readonly ConcurrentDictionary<TLookup, TValue> Cache = new ConcurrentDictionary<TLookup, TValue>();
}
}

2
osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs
View File

@ -61,7 +61,7 @@ namespace osu.Game.Online.API.Requests.Responses
private int[] ratings { get; set; } private int[] ratings { get; set; }
[JsonProperty(@"user_id")] [JsonProperty(@"user_id")]
private long creatorId private int creatorId
{ {
set => Author.Id = value; set => Author.Id = value;
} }

2
osu.Game/Online/API/Requests/Responses/APIChangelogUser.cs
View File

@ -20,7 +20,7 @@ namespace osu.Game.Online.API.Requests.Responses
public string OsuUsername { get; set; } public string OsuUsername { get; set; }
[JsonProperty("user_id")] [JsonProperty("user_id")]
public long? UserId { get; set; } public int? UserId { get; set; }
[JsonProperty("user_url")] [JsonProperty("user_url")]
public string UserUrl { get; set; } public string UserUrl { get; set; }

2
osu.Game/Online/Chat/Channel.cs
View File

@ -22,7 +22,7 @@ namespace osu.Game.Online.Chat
public readonly ObservableCollection<User> Users = new ObservableCollection<User>(); public readonly ObservableCollection<User> Users = new ObservableCollection<User>();
[JsonProperty(@"users")] [JsonProperty(@"users")]
private long[] userIds private int[] userIds
{ {
set set
{ {

4
osu.Game/OsuGame.cs
View File

@ -278,7 +278,7 @@ namespace osu.Game
break; break;
case LinkAction.OpenUserProfile: case LinkAction.OpenUserProfile:
if (long.TryParse(link.Argument, out long userId)) if (int.TryParse(link.Argument, out int userId))
ShowUser(userId); ShowUser(userId);
break; break;
@ -321,7 +321,7 @@ namespace osu.Game
/// Show a user's profile as an overlay. /// Show a user's profile as an overlay.
/// </summary> /// </summary>
/// <param name="userId">The user to display.</param> /// <param name="userId">The user to display.</param>
public void ShowUser(long userId) => waitForReady(() => userProfile, _ => userProfile.ShowUser(userId)); public void ShowUser(int userId) => waitForReady(() => userProfile, _ => userProfile.ShowUser(userId));
/// <summary> /// <summary>
/// Show a beatmap's set as an overlay, displaying the given beatmap. /// Show a beatmap's set as an overlay, displaying the given beatmap.

10
osu.Game/OsuGameBase.cs
View File

@ -59,7 +59,7 @@ namespace osu.Game
protected ScoreManager ScoreManager; protected ScoreManager ScoreManager;
protected BeatmapDifficultyManager DifficultyManager; protected BeatmapDifficultyCache DifficultyCache;
protected SkinManager SkinManager; protected SkinManager SkinManager;
@ -202,7 +202,7 @@ namespace osu.Game
dependencies.Cache(FileStore = new FileStore(contextFactory, Storage)); dependencies.Cache(FileStore = new FileStore(contextFactory, Storage));
// ordering is important here to ensure foreign keys rules are not broken in ModelStore.Cleanup() // ordering is important here to ensure foreign keys rules are not broken in ModelStore.Cleanup()
dependencies.Cache(ScoreManager = new ScoreManager(RulesetStore, () => BeatmapManager, Storage, API, contextFactory, Host, () => DifficultyManager, LocalConfig)); dependencies.Cache(ScoreManager = new ScoreManager(RulesetStore, () => BeatmapManager, Storage, API, contextFactory, Host, () => DifficultyCache, LocalConfig));
dependencies.Cache(BeatmapManager = new BeatmapManager(Storage, contextFactory, RulesetStore, API, Audio, Host, defaultBeatmap, true)); dependencies.Cache(BeatmapManager = new BeatmapManager(Storage, contextFactory, RulesetStore, API, Audio, Host, defaultBeatmap, true));
// this should likely be moved to ArchiveModelManager when another case appers where it is necessary // this should likely be moved to ArchiveModelManager when another case appers where it is necessary
@ -226,10 +226,10 @@ namespace osu.Game
ScoreManager.Undelete(getBeatmapScores(item), true); ScoreManager.Undelete(getBeatmapScores(item), true);
}); });
dependencies.Cache(DifficultyManager = new BeatmapDifficultyManager()); dependencies.Cache(DifficultyCache = new BeatmapDifficultyCache());
AddInternal(DifficultyManager); AddInternal(DifficultyCache);
var scorePerformanceManager = new ScorePerformanceManager(); var scorePerformanceManager = new ScorePerformanceCache();
dependencies.Cache(scorePerformanceManager); dependencies.Cache(scorePerformanceManager);
AddInternal(scorePerformanceManager); AddInternal(scorePerformanceManager);

6
osu.Game/Overlays/Dashboard/CurrentlyPlayingDisplay.cs
View File

@ -20,7 +20,7 @@ namespace osu.Game.Overlays.Dashboard
{ {
internal class CurrentlyPlayingDisplay : CompositeDrawable internal class CurrentlyPlayingDisplay : CompositeDrawable
{ {
private IBindableList<int> playingUsers; private readonly IBindableList<int> playingUsers = new BindableList<int>();
private FillFlowContainer<PlayingUserPanel> userFlow; private FillFlowContainer<PlayingUserPanel> userFlow;
@ -48,7 +48,7 @@ namespace osu.Game.Overlays.Dashboard
{ {
base.LoadComplete(); base.LoadComplete();
playingUsers = spectatorStreaming.PlayingUsers.GetBoundCopy(); playingUsers.BindTo(spectatorStreaming.PlayingUsers);
playingUsers.BindCollectionChanged((sender, e) => Schedule(() => playingUsers.BindCollectionChanged((sender, e) => Schedule(() =>
{ {
switch (e.Action) switch (e.Action)
@ -59,7 +59,7 @@ namespace osu.Game.Overlays.Dashboard
var request = new GetUserRequest(u); var request = new GetUserRequest(u);
request.Success += user => Schedule(() => request.Success += user => Schedule(() =>
{ {
if (playingUsers.Contains((int)user.Id)) if (playingUsers.Contains(user.Id))
userFlow.Add(createUserPanel(user)); userFlow.Add(createUserPanel(user));
}); });
api.Queue(request); api.Queue(request);

2
osu.Game/Overlays/UserProfileOverlay.cs
View File

@ -33,7 +33,7 @@ namespace osu.Game.Overlays
{ {
} }
public void ShowUser(long userId) => ShowUser(new User { Id = userId }); public void ShowUser(int userId) => ShowUser(new User { Id = userId });
public void ShowUser(User user, bool fetchOnline = true) public void ShowUser(User user, bool fetchOnline = true)
{ {

48
osu.Game/Rulesets/Mods/ModHidden.cs
View File

@ -1,19 +1,16 @@
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence. // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using osu.Game.Configuration; using System;
using osu.Game.Graphics; using osu.Game.Graphics;
using osu.Game.Rulesets.Objects.Drawables; using osu.Game.Rulesets.Objects.Drawables;
using System.Collections.Generic;
using System.Linq;
using osu.Framework.Bindables;
using osu.Framework.Graphics.Sprites; using osu.Framework.Graphics.Sprites;
using osu.Game.Rulesets.Scoring; using osu.Game.Rulesets.Scoring;
using osu.Game.Scoring; using osu.Game.Scoring;
namespace osu.Game.Rulesets.Mods namespace osu.Game.Rulesets.Mods
{ {
public abstract class ModHidden : Mod, IReadFromConfig, IApplicableToDrawableHitObjects, IApplicableToScoreProcessor public abstract class ModHidden : ModWithVisibilityAdjustment, IApplicableToScoreProcessor
{ {
public override string Name => "Hidden"; public override string Name => "Hidden";
public override string Acronym => "HD"; public override string Acronym => "HD";
@ -21,37 +18,14 @@ namespace osu.Game.Rulesets.Mods
public override ModType Type => ModType.DifficultyIncrease; public override ModType Type => ModType.DifficultyIncrease;
public override bool Ranked => true; public override bool Ranked => true;
protected Bindable<bool> IncreaseFirstObjectVisibility = new Bindable<bool>();
/// <summary> /// <summary>
/// Check whether the provided hitobject should be considered the "first" hideable object. /// Check whether the provided hitobject should be considered the "first" hideable object.
/// Can be used to skip spinners, for instance. /// Can be used to skip spinners, for instance.
/// </summary> /// </summary>
/// <param name="hitObject">The hitobject to check.</param> /// <param name="hitObject">The hitobject to check.</param>
[Obsolete("Use IsFirstAdjustableObject() instead.")] // Can be removed 20210506
protected virtual bool IsFirstHideableObject(DrawableHitObject hitObject) => true; protected virtual bool IsFirstHideableObject(DrawableHitObject hitObject) => true;
public void ReadFromConfig(OsuConfigManager config)
{
IncreaseFirstObjectVisibility = config.GetBindable<bool>(OsuSetting.IncreaseFirstObjectVisibility);
}
public virtual void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
{
if (IncreaseFirstObjectVisibility.Value)
{
drawables = drawables.SkipWhile(h => !IsFirstHideableObject(h));
var firstObject = drawables.FirstOrDefault();
if (firstObject != null)
firstObject.ApplyCustomUpdateState += ApplyFirstObjectIncreaseVisibilityState;
drawables = drawables.Skip(1);
}
foreach (var dho in drawables)
dho.ApplyCustomUpdateState += ApplyHiddenState;
}
public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor) public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
{ {
// Default value of ScoreProcessor's Rank in Hidden Mod should be SS+ // Default value of ScoreProcessor's Rank in Hidden Mod should be SS+
@ -73,11 +47,26 @@ namespace osu.Game.Rulesets.Mods
} }
} }
protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
{
#pragma warning disable 618
ApplyFirstObjectIncreaseVisibilityState(hitObject, state);
#pragma warning restore 618
}
protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
{
#pragma warning disable 618
ApplyHiddenState(hitObject, state);
#pragma warning restore 618
}
/// <summary> /// <summary>
/// Apply a special visibility state to the first object in a beatmap, if the user chooses to turn on the "increase first object visibility" setting. /// Apply a special visibility state to the first object in a beatmap, if the user chooses to turn on the "increase first object visibility" setting.
/// </summary> /// </summary>
/// <param name="hitObject">The hit object to apply the state change to.</param> /// <param name="hitObject">The hit object to apply the state change to.</param>
/// <param name="state">The state of the hit object.</param> /// <param name="state">The state of the hit object.</param>
[Obsolete("Use ApplyIncreasedVisibilityState() instead.")] // Can be removed 20210506
protected virtual void ApplyFirstObjectIncreaseVisibilityState(DrawableHitObject hitObject, ArmedState state) protected virtual void ApplyFirstObjectIncreaseVisibilityState(DrawableHitObject hitObject, ArmedState state)
{ {
} }
@ -87,6 +76,7 @@ namespace osu.Game.Rulesets.Mods
/// </summary> /// </summary>
/// <param name="hitObject">The hit object to apply the state change to.</param> /// <param name="hitObject">The hit object to apply the state change to.</param>
/// <param name="state">The state of the hit object.</param> /// <param name="state">The state of the hit object.</param>
[Obsolete("Use ApplyNormalVisibilityState() instead.")] // Can be removed 20210506
protected virtual void ApplyHiddenState(DrawableHitObject hitObject, ArmedState state) protected virtual void ApplyHiddenState(DrawableHitObject hitObject, ArmedState state)
{ {
} }

114
osu.Game/Rulesets/Mods/ModWithVisibilityAdjustment.cs Normal file
View File

@ -0,0 +1,114 @@
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
using System.Collections.Generic;
using osu.Framework.Bindables;
using osu.Game.Beatmaps;
using osu.Game.Configuration;
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Objects.Drawables;
namespace osu.Game.Rulesets.Mods
{
/// <summary>
/// A <see cref="Mod"/> which applies visibility adjustments to <see cref="DrawableHitObject"/>s
/// with an optional increased visibility adjustment depending on the user's "increase first object visibility" setting.
/// </summary>
public abstract class ModWithVisibilityAdjustment : Mod, IReadFromConfig, IApplicableToBeatmap, IApplicableToDrawableHitObjects
{
/// <summary>
/// The first adjustable object.
/// </summary>
protected HitObject FirstObject { get; private set; }
/// <summary>
/// Whether the visibility of <see cref="FirstObject"/> should be increased.
/// </summary>
protected readonly Bindable<bool> IncreaseFirstObjectVisibility = new Bindable<bool>();
/// <summary>
/// Check whether the provided hitobject should be considered the "first" adjustable object.
/// Can be used to skip spinners, for instance.
/// </summary>
/// <param name="hitObject">The hitobject to check.</param>
protected virtual bool IsFirstAdjustableObject(HitObject hitObject) => true;
/// <summary>
/// Apply a special increased-visibility state to the first adjustable object.
/// Only applicable if the user chooses to turn on the "increase first object visibility" setting.
/// </summary>
/// <param name="hitObject">The hit object to apply the state change to.</param>
/// <param name="state">The state of the hitobject.</param>
protected abstract void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state);
/// <summary>
/// Apply a normal visibility state adjustment to an object.
/// </summary>
/// <param name="hitObject">The hit object to apply the state change to.</param>
/// <param name="state">The state of the hitobject.</param>
protected abstract void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state);
public virtual void ReadFromConfig(OsuConfigManager config)
{
config.BindWith(OsuSetting.IncreaseFirstObjectVisibility, IncreaseFirstObjectVisibility);
}
public virtual void ApplyToBeatmap(IBeatmap beatmap)
{
FirstObject = getFirstAdjustableObjectRecursive(beatmap.HitObjects);
HitObject getFirstAdjustableObjectRecursive(IReadOnlyList<HitObject> hitObjects)
{
foreach (var h in hitObjects)
{
if (IsFirstAdjustableObject(h))
return h;
var nestedResult = getFirstAdjustableObjectRecursive(h.NestedHitObjects);
if (nestedResult != null)
return nestedResult;
}
return null;
}
}
public virtual void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
{
foreach (var dho in drawables)
{
dho.ApplyCustomUpdateState += (o, state) =>
{
// Increased visibility is applied to the entire first object, including all of its nested hitobjects.
if (IncreaseFirstObjectVisibility.Value && isObjectEqualToOrNestedIn(o.HitObject, FirstObject))
ApplyIncreasedVisibilityState(o, state);
else
ApplyNormalVisibilityState(o, state);
};
}
}
/// <summary>
/// Checks whether a given object is nested within a target.
/// </summary>
/// <param name="toCheck">The <see cref="HitObject"/> to check.</param>
/// <param name="target">The <see cref="HitObject"/> which may be equal to or contain <paramref name="toCheck"/> as a nested object.</param>
/// <returns>Whether <paramref name="toCheck"/> is equal to or nested within <paramref name="target"/>.</returns>
private bool isObjectEqualToOrNestedIn(HitObject toCheck, HitObject target)
{
if (target == null)
return false;
if (toCheck == target)
return true;
foreach (var h in target.NestedHitObjects)
{
if (isObjectEqualToOrNestedIn(toCheck, h))
return true;
}
return false;
}
}
}

10
osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
View File

@ -125,14 +125,14 @@ namespace osu.Game.Rulesets.Objects.Drawables
Result = CreateResult(judgement); Result = CreateResult(judgement);
if (Result == null) if (Result == null)
throw new InvalidOperationException($"{GetType().ReadableName()} must provide a {nameof(JudgementResult)} through {nameof(CreateResult)}."); throw new InvalidOperationException($"{GetType().ReadableName()} must provide a {nameof(JudgementResult)} through {nameof(CreateResult)}.");
LoadSamples();
} }
protected override void LoadAsyncComplete() protected override void LoadAsyncComplete()
{ {
base.LoadAsyncComplete(); base.LoadAsyncComplete();
LoadSamples();
HitObject.DefaultsApplied += onDefaultsApplied; HitObject.DefaultsApplied += onDefaultsApplied;
startTimeBindable = HitObject.StartTimeBindable.GetBoundCopy(); startTimeBindable = HitObject.StartTimeBindable.GetBoundCopy();
@ -546,7 +546,11 @@ namespace osu.Game.Rulesets.Objects.Drawables
// Ensure that the judgement is given a valid time offset, because this may not get set by the caller // Ensure that the judgement is given a valid time offset, because this may not get set by the caller
var endTime = HitObject.GetEndTime(); var endTime = HitObject.GetEndTime();
Result.TimeOffset = Math.Min(HitObject.HitWindows.WindowFor(HitResult.Miss), Time.Current - endTime); Result.TimeOffset = Time.Current - endTime;
double missWindow = HitObject.HitWindows.WindowFor(HitResult.Miss);
if (missWindow > 0)
Result.TimeOffset = Math.Min(Result.TimeOffset, missWindow);
if (Result.HasResult) if (Result.HasResult)
updateState(Result.IsHit ? ArmedState.Hit : ArmedState.Miss); updateState(Result.IsHit ? ArmedState.Hit : ArmedState.Miss);

2
osu.Game/Scoring/ScoreInfo.cs
View File

@ -123,7 +123,7 @@ namespace osu.Game.Scoring
[JsonIgnore] [JsonIgnore]
[Column("UserID")] [Column("UserID")]
public long? UserID public int? UserID
{ {
get => User?.Id ?? 1; get => User?.Id ?? 1;
set set

10
osu.Game/Scoring/ScoreManager.cs
View File

@ -37,13 +37,13 @@ namespace osu.Game.Scoring
private readonly Func<BeatmapManager> beatmaps; private readonly Func<BeatmapManager> beatmaps;
[CanBeNull] [CanBeNull]
private readonly Func<BeatmapDifficultyManager> difficulties; private readonly Func<BeatmapDifficultyCache> difficulties;
[CanBeNull] [CanBeNull]
private readonly OsuConfigManager configManager; private readonly OsuConfigManager configManager;
public ScoreManager(RulesetStore rulesets, Func<BeatmapManager> beatmaps, Storage storage, IAPIProvider api, IDatabaseContextFactory contextFactory, IIpcHost importHost = null, public ScoreManager(RulesetStore rulesets, Func<BeatmapManager> beatmaps, Storage storage, IAPIProvider api, IDatabaseContextFactory contextFactory, IIpcHost importHost = null,
Func<BeatmapDifficultyManager> difficulties = null, OsuConfigManager configManager = null) Func<BeatmapDifficultyCache> difficulties = null, OsuConfigManager configManager = null)
: base(storage, contextFactory, api, new ScoreStore(contextFactory, storage), importHost) : base(storage, contextFactory, api, new ScoreStore(contextFactory, storage), importHost)
{ {
this.rulesets = rulesets; this.rulesets = rulesets;
@ -121,14 +121,14 @@ namespace osu.Game.Scoring
public readonly Bindable<ScoringMode> ScoringMode = new Bindable<ScoringMode>(); public readonly Bindable<ScoringMode> ScoringMode = new Bindable<ScoringMode>();
private readonly ScoreInfo score; private readonly ScoreInfo score;
private readonly Func<BeatmapDifficultyManager> difficulties; private readonly Func<BeatmapDifficultyCache> difficulties;
/// <summary> /// <summary>
/// Creates a new <see cref="TotalScoreBindable"/>. /// Creates a new <see cref="TotalScoreBindable"/>.
/// </summary> /// </summary>
/// <param name="score">The <see cref="ScoreInfo"/> to provide the total score of.</param> /// <param name="score">The <see cref="ScoreInfo"/> to provide the total score of.</param>
/// <param name="difficulties">A function to retrieve the <see cref="BeatmapDifficultyManager"/>.</param> /// <param name="difficulties">A function to retrieve the <see cref="BeatmapDifficultyCache"/>.</param>
public TotalScoreBindable(ScoreInfo score, Func<BeatmapDifficultyManager> difficulties) public TotalScoreBindable(ScoreInfo score, Func<BeatmapDifficultyCache> difficulties)
{ {
this.score = score; this.score = score;
this.difficulties = difficulties; this.difficulties = difficulties;

20
osu.Game/Scoring/ScorePerformanceManager.cs → osu.Game/Scoring/ScorePerformanceCache.cs
View File

@ -2,27 +2,23 @@
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using System; using System;
using System.Collections.Concurrent;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using JetBrains.Annotations; using JetBrains.Annotations;
using osu.Framework.Allocation; using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Game.Beatmaps; using osu.Game.Beatmaps;
using osu.Game.Database;
namespace osu.Game.Scoring namespace osu.Game.Scoring
{ {
/// <summary> /// <summary>
/// A global component which calculates and caches results of performance calculations for locally databased scores. /// A component which performs and acts as a central cache for performance calculations of locally databased scores.
/// Currently not persisted between game sessions.
/// </summary> /// </summary>
public class ScorePerformanceManager : Component public class ScorePerformanceCache : MemoryCachingComponent<ScorePerformanceCache.PerformanceCacheLookup, double>
{ {
// this cache will grow indefinitely per session and should be considered temporary.
// this whole component should likely be replaced with database persistence.
private readonly ConcurrentDictionary<PerformanceCacheLookup, double> performanceCache = new ConcurrentDictionary<PerformanceCacheLookup, double>();
[Resolved] [Resolved]
private BeatmapDifficultyManager difficultyManager { get; set; } private BeatmapDifficultyCache difficultyCache { get; set; }
/// <summary> /// <summary>
/// Calculates performance for the given <see cref="ScoreInfo"/>. /// Calculates performance for the given <see cref="ScoreInfo"/>.
@ -33,7 +29,7 @@ namespace osu.Game.Scoring
{ {
var lookupKey = new PerformanceCacheLookup(score); var lookupKey = new PerformanceCacheLookup(score);
if (performanceCache.TryGetValue(lookupKey, out double performance)) if (Cache.TryGetValue(lookupKey, out double performance))
return Task.FromResult((double?)performance); return Task.FromResult((double?)performance);
return computePerformanceAsync(score, lookupKey, token); return computePerformanceAsync(score, lookupKey, token);
@ -41,7 +37,7 @@ namespace osu.Game.Scoring
private async Task<double?> computePerformanceAsync(ScoreInfo score, PerformanceCacheLookup lookupKey, CancellationToken token = default) private async Task<double?> computePerformanceAsync(ScoreInfo score, PerformanceCacheLookup lookupKey, CancellationToken token = default)
{ {
var attributes = await difficultyManager.GetDifficultyAsync(score.Beatmap, score.Ruleset, score.Mods, token); var attributes = await difficultyCache.GetDifficultyAsync(score.Beatmap, score.Ruleset, score.Mods, token);
// Performance calculation requires the beatmap and ruleset to be locally available. If not, return a default value. // Performance calculation requires the beatmap and ruleset to be locally available. If not, return a default value.
if (attributes.Attributes == null) if (attributes.Attributes == null)
@ -53,7 +49,7 @@ namespace osu.Game.Scoring
var total = calculator?.Calculate(); var total = calculator?.Calculate();
if (total.HasValue) if (total.HasValue)
performanceCache[lookupKey] = total.Value; Cache[lookupKey] = total.Value;
return total; return total;
} }

4
osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/ControlPointPart.cs
View File

@ -14,13 +14,13 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
/// </summary> /// </summary>
public class ControlPointPart : TimelinePart<GroupVisualisation> public class ControlPointPart : TimelinePart<GroupVisualisation>
{ {
private IBindableList<ControlPointGroup> controlPointGroups; private readonly IBindableList<ControlPointGroup> controlPointGroups = new BindableList<ControlPointGroup>();
protected override void LoadBeatmap(WorkingBeatmap beatmap) protected override void LoadBeatmap(WorkingBeatmap beatmap)
{ {
base.LoadBeatmap(beatmap); base.LoadBeatmap(beatmap);
controlPointGroups = beatmap.Beatmap.ControlPointInfo.Groups.GetBoundCopy(); controlPointGroups.BindTo(beatmap.Beatmap.ControlPointInfo.Groups);
controlPointGroups.BindCollectionChanged((sender, args) => controlPointGroups.BindCollectionChanged((sender, args) =>
{ {
switch (args.Action) switch (args.Action)

4
osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/GroupVisualisation.cs
View File

@ -15,7 +15,7 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
{ {
public readonly ControlPointGroup Group; public readonly ControlPointGroup Group;
private BindableList<ControlPoint> controlPoints; private readonly IBindableList<ControlPoint> controlPoints = new BindableList<ControlPoint>();
[Resolved] [Resolved]
private OsuColour colours { get; set; } private OsuColour colours { get; set; }
@ -30,7 +30,7 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
{ {
base.LoadComplete(); base.LoadComplete();
controlPoints = (BindableList<ControlPoint>)Group.ControlPoints.GetBoundCopy(); controlPoints.BindTo(Group.ControlPoints);
controlPoints.BindCollectionChanged((_, __) => controlPoints.BindCollectionChanged((_, __) =>
{ {
if (controlPoints.Count == 0) if (controlPoints.Count == 0)

4
osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineControlPointDisplay.cs
View File

@ -16,7 +16,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
/// </summary> /// </summary>
public class TimelineControlPointDisplay : TimelinePart<TimelineControlPointGroup> public class TimelineControlPointDisplay : TimelinePart<TimelineControlPointGroup>
{ {
private IBindableList<ControlPointGroup> controlPointGroups; private readonly IBindableList<ControlPointGroup> controlPointGroups = new BindableList<ControlPointGroup>();
public TimelineControlPointDisplay() public TimelineControlPointDisplay()
{ {
@ -27,7 +27,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
{ {
base.LoadBeatmap(beatmap); base.LoadBeatmap(beatmap);
controlPointGroups = beatmap.Beatmap.ControlPointInfo.Groups.GetBoundCopy(); controlPointGroups.BindTo(beatmap.Beatmap.ControlPointInfo.Groups);
controlPointGroups.BindCollectionChanged((sender, args) => controlPointGroups.BindCollectionChanged((sender, args) =>
{ {
switch (args.Action) switch (args.Action)

4
osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineControlPointGroup.cs
View File

@ -14,7 +14,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
{ {
public readonly ControlPointGroup Group; public readonly ControlPointGroup Group;
private BindableList<ControlPoint> controlPoints; private readonly IBindableList<ControlPoint> controlPoints = new BindableList<ControlPoint>();
[Resolved] [Resolved]
private OsuColour colours { get; set; } private OsuColour colours { get; set; }
@ -34,7 +34,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
{ {
base.LoadComplete(); base.LoadComplete();
controlPoints = (BindableList<ControlPoint>)Group.ControlPoints.GetBoundCopy(); controlPoints.BindTo(Group.ControlPoints);
controlPoints.BindCollectionChanged((_, __) => controlPoints.BindCollectionChanged((_, __) =>
{ {
ClearInternal(); ClearInternal();

4
osu.Game/Screens/Edit/Timing/ControlPointTable.cs
View File

@ -98,7 +98,7 @@ namespace osu.Game.Screens.Edit.Timing
private class ControlGroupAttributes : CompositeDrawable private class ControlGroupAttributes : CompositeDrawable
{ {
private readonly IBindableList<ControlPoint> controlPoints; private readonly IBindableList<ControlPoint> controlPoints = new BindableList<ControlPoint>();
private readonly FillFlowContainer fill; private readonly FillFlowContainer fill;
@ -112,7 +112,7 @@ namespace osu.Game.Screens.Edit.Timing
Spacing = new Vector2(2) Spacing = new Vector2(2)
}; };
controlPoints = group.ControlPoints.GetBoundCopy(); controlPoints.BindTo(group.ControlPoints);
} }
[Resolved] [Resolved]

9
osu.Game/Screens/Edit/Timing/TimingScreen.cs
View File

@ -56,7 +56,7 @@ namespace osu.Game.Screens.Edit.Timing
private OsuButton deleteButton; private OsuButton deleteButton;
private ControlPointTable table; private ControlPointTable table;
private IBindableList<ControlPointGroup> controlGroups; private readonly IBindableList<ControlPointGroup> controlPointGroups = new BindableList<ControlPointGroup>();
[Resolved] [Resolved]
private EditorClock clock { get; set; } private EditorClock clock { get; set; }
@ -124,11 +124,10 @@ namespace osu.Game.Screens.Edit.Timing
selectedGroup.BindValueChanged(selected => { deleteButton.Enabled.Value = selected.NewValue != null; }, true); selectedGroup.BindValueChanged(selected => { deleteButton.Enabled.Value = selected.NewValue != null; }, true);
controlGroups = Beatmap.Value.Beatmap.ControlPointInfo.Groups.GetBoundCopy(); controlPointGroups.BindTo(Beatmap.Value.Beatmap.ControlPointInfo.Groups);
controlPointGroups.BindCollectionChanged((sender, args) =>
controlGroups.BindCollectionChanged((sender, args) =>
{ {
table.ControlGroups = controlGroups; table.ControlGroups = controlPointGroups;
changeHandler.SaveState(); changeHandler.SaveState();
}, true); }, true);
} }

4
osu.Game/Screens/Play/Spectator.cs
View File

@ -182,7 +182,7 @@ namespace osu.Game.Screens.Play
spectatorStreaming.OnUserFinishedPlaying += userFinishedPlaying; spectatorStreaming.OnUserFinishedPlaying += userFinishedPlaying;
spectatorStreaming.OnNewFrames += userSentFrames; spectatorStreaming.OnNewFrames += userSentFrames;
spectatorStreaming.WatchUser((int)targetUser.Id); spectatorStreaming.WatchUser(targetUser.Id);
managerUpdated = beatmaps.ItemUpdated.GetBoundCopy(); managerUpdated = beatmaps.ItemUpdated.GetBoundCopy();
managerUpdated.BindValueChanged(beatmapUpdated); managerUpdated.BindValueChanged(beatmapUpdated);
@ -353,7 +353,7 @@ namespace osu.Game.Screens.Play
spectatorStreaming.OnUserFinishedPlaying -= userFinishedPlaying; spectatorStreaming.OnUserFinishedPlaying -= userFinishedPlaying;
spectatorStreaming.OnNewFrames -= userSentFrames; spectatorStreaming.OnNewFrames -= userSentFrames;
spectatorStreaming.StopWatchingUser((int)targetUser.Id); spectatorStreaming.StopWatchingUser(targetUser.Id);
} }
managerUpdated?.UnbindAll(); managerUpdated?.UnbindAll();

4
osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs
View File

@ -56,7 +56,7 @@ namespace osu.Game.Screens.Ranking.Expanded
} }
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load(BeatmapDifficultyManager beatmapDifficultyManager) private void load(BeatmapDifficultyCache beatmapDifficultyCache)
{ {
var beatmap = score.Beatmap; var beatmap = score.Beatmap;
var metadata = beatmap.BeatmapSet?.Metadata ?? beatmap.Metadata; var metadata = beatmap.BeatmapSet?.Metadata ?? beatmap.Metadata;
@ -143,7 +143,7 @@ namespace osu.Game.Screens.Ranking.Expanded
Spacing = new Vector2(5, 0), Spacing = new Vector2(5, 0),
Children = new Drawable[] Children = new Drawable[]
{ {
new StarRatingDisplay(beatmapDifficultyManager.GetDifficulty(beatmap, score.Ruleset, score.Mods)) new StarRatingDisplay(beatmapDifficultyCache.GetDifficulty(beatmap, score.Ruleset, score.Mods))
{ {
Anchor = Anchor.CentreLeft, Anchor = Anchor.CentreLeft,
Origin = Anchor.CentreLeft Origin = Anchor.CentreLeft

2
osu.Game/Screens/Ranking/Expanded/StarRatingDisplay.cs
View File

@ -34,7 +34,7 @@ namespace osu.Game.Screens.Ranking.Expanded
} }
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load(OsuColour colours, BeatmapDifficultyManager difficultyManager) private void load(OsuColour colours, BeatmapDifficultyCache difficultyCache)
{ {
AutoSizeAxes = Axes.Both; AutoSizeAxes = Axes.Both;

6
osu.Game/Screens/Ranking/Expanded/Statistics/PerformanceStatistic.cs
View File

@ -28,7 +28,7 @@ namespace osu.Game.Screens.Ranking.Expanded.Statistics
} }
[BackgroundDependencyLoader] [BackgroundDependencyLoader]
private void load(ScorePerformanceManager performanceManager) private void load(ScorePerformanceCache performanceCache)
{ {
if (score.PP.HasValue) if (score.PP.HasValue)
{ {
@ -36,8 +36,8 @@ namespace osu.Game.Screens.Ranking.Expanded.Statistics
} }
else else
{ {
performanceManager.CalculatePerformanceAsync(score, cancellationTokenSource.Token) performanceCache.CalculatePerformanceAsync(score, cancellationTokenSource.Token)
.ContinueWith(t => Schedule(() => setPerformanceValue(t.Result)), cancellationTokenSource.Token); .ContinueWith(t => Schedule(() => setPerformanceValue(t.Result)), cancellationTokenSource.Token);
} }
} }

4
osu.Game/Screens/Select/BeatmapInfoWedge.cs
View File

@ -41,7 +41,7 @@ namespace osu.Game.Screens.Select
private readonly IBindable<RulesetInfo> ruleset = new Bindable<RulesetInfo>(); private readonly IBindable<RulesetInfo> ruleset = new Bindable<RulesetInfo>();
[Resolved] [Resolved]
private BeatmapDifficultyManager difficultyManager { get; set; } private BeatmapDifficultyCache difficultyCache { get; set; }
private IBindable<StarDifficulty> beatmapDifficulty; private IBindable<StarDifficulty> beatmapDifficulty;
@ -100,7 +100,7 @@ namespace osu.Game.Screens.Select
cancellationSource = new CancellationTokenSource(); cancellationSource = new CancellationTokenSource();
beatmapDifficulty?.UnbindAll(); beatmapDifficulty?.UnbindAll();
beatmapDifficulty = difficultyManager.GetBindableDifficulty(beatmap.BeatmapInfo, cancellationSource.Token); beatmapDifficulty = difficultyCache.GetBindableDifficulty(beatmap.BeatmapInfo, cancellationSource.Token);
beatmapDifficulty.BindValueChanged(_ => updateDisplay()); beatmapDifficulty.BindValueChanged(_ => updateDisplay());
updateDisplay(); updateDisplay();

4
osu.Game/Screens/Select/Carousel/DrawableCarouselBeatmap.cs
View File

@ -55,7 +55,7 @@ namespace osu.Game.Screens.Select.Carousel
private BeatmapSetOverlay beatmapOverlay { get; set; } private BeatmapSetOverlay beatmapOverlay { get; set; }
[Resolved] [Resolved]
private BeatmapDifficultyManager difficultyManager { get; set; } private BeatmapDifficultyCache difficultyCache { get; set; }
[Resolved(CanBeNull = true)] [Resolved(CanBeNull = true)]
private CollectionManager collectionManager { get; set; } private CollectionManager collectionManager { get; set; }
@ -216,7 +216,7 @@ namespace osu.Game.Screens.Select.Carousel
if (Item.State.Value != CarouselItemState.Collapsed) if (Item.State.Value != CarouselItemState.Collapsed)
{ {
// We've potentially cancelled the computation above so a new bindable is required. // We've potentially cancelled the computation above so a new bindable is required.
starDifficultyBindable = difficultyManager.GetBindableDifficulty(beatmap, (starDifficultyCancellationSource = new CancellationTokenSource()).Token); starDifficultyBindable = difficultyCache.GetBindableDifficulty(beatmap, (starDifficultyCancellationSource = new CancellationTokenSource()).Token);
starDifficultyBindable.BindValueChanged(d => starCounter.Current = (float)d.NewValue.Stars, true); starDifficultyBindable.BindValueChanged(d => starCounter.Current = (float)d.NewValue.Stars, true);
} }

6
osu.Game/Screens/Select/Details/AdvancedStats.cs
View File

@ -32,7 +32,7 @@ namespace osu.Game.Screens.Select.Details
private IBindable<RulesetInfo> ruleset { get; set; } private IBindable<RulesetInfo> ruleset { get; set; }
[Resolved] [Resolved]
private BeatmapDifficultyManager difficultyManager { get; set; } private BeatmapDifficultyCache difficultyCache { get; set; }
protected readonly StatisticRow FirstValue, HpDrain, Accuracy, ApproachRate; protected readonly StatisticRow FirstValue, HpDrain, Accuracy, ApproachRate;
private readonly StatisticRow starDifficulty; private readonly StatisticRow starDifficulty;
@ -161,8 +161,8 @@ namespace osu.Game.Screens.Select.Details
starDifficultyCancellationSource = new CancellationTokenSource(); starDifficultyCancellationSource = new CancellationTokenSource();
normalStarDifficulty = difficultyManager.GetBindableDifficulty(Beatmap, ruleset.Value, null, starDifficultyCancellationSource.Token); normalStarDifficulty = difficultyCache.GetBindableDifficulty(Beatmap, ruleset.Value, null, starDifficultyCancellationSource.Token);
moddedStarDifficulty = difficultyManager.GetBindableDifficulty(Beatmap, ruleset.Value, mods.Value, starDifficultyCancellationSource.Token); moddedStarDifficulty = difficultyCache.GetBindableDifficulty(Beatmap, ruleset.Value, mods.Value, starDifficultyCancellationSource.Token);
normalStarDifficulty.BindValueChanged(_ => updateDisplay()); normalStarDifficulty.BindValueChanged(_ => updateDisplay());
moddedStarDifficulty.BindValueChanged(_ => updateDisplay(), true); moddedStarDifficulty.BindValueChanged(_ => updateDisplay(), true);

15
osu.Game/Skinning/PausableSkinnableSound.cs
View File

@ -4,6 +4,7 @@
using System.Collections.Generic; using System.Collections.Generic;
using osu.Framework.Allocation; using osu.Framework.Allocation;
using osu.Framework.Bindables; using osu.Framework.Bindables;
using osu.Framework.Threading;
using osu.Game.Audio; using osu.Game.Audio;
using osu.Game.Screens.Play; using osu.Game.Screens.Play;
@ -25,6 +26,8 @@ namespace osu.Game.Skinning
private readonly IBindable<bool> samplePlaybackDisabled = new Bindable<bool>(); private readonly IBindable<bool> samplePlaybackDisabled = new Bindable<bool>();
private ScheduledDelegate scheduledStart;
[BackgroundDependencyLoader(true)] [BackgroundDependencyLoader(true)]
private void load(ISamplePlaybackDisabler samplePlaybackDisabler) private void load(ISamplePlaybackDisabler samplePlaybackDisabler)
{ {
@ -39,12 +42,14 @@ namespace osu.Game.Skinning
// let non-looping samples that have already been started play out to completion (sounds better than abruptly cutting off). // let non-looping samples that have already been started play out to completion (sounds better than abruptly cutting off).
if (!Looping) return; if (!Looping) return;
cancelPendingStart();
if (disabled.NewValue) if (disabled.NewValue)
base.Stop(); base.Stop();
else else
{ {
// schedule so we don't start playing a sample which is no longer alive. // schedule so we don't start playing a sample which is no longer alive.
Schedule(() => scheduledStart = Schedule(() =>
{ {
if (RequestedPlaying) if (RequestedPlaying)
base.Play(); base.Play();
@ -56,6 +61,7 @@ namespace osu.Game.Skinning
public override void Play() public override void Play()
{ {
cancelPendingStart();
RequestedPlaying = true; RequestedPlaying = true;
if (samplePlaybackDisabled.Value) if (samplePlaybackDisabled.Value)
@ -66,8 +72,15 @@ namespace osu.Game.Skinning
public override void Stop() public override void Stop()
{ {
cancelPendingStart();
RequestedPlaying = false; RequestedPlaying = false;
base.Stop(); base.Stop();
} }
private void cancelPendingStart()
{
scheduledStart?.Cancel();
scheduledStart = null;
}
} }
} }

50
osu.Game/Tests/Visual/SkinnableTestScene.cs
View File

@ -65,17 +65,15 @@ namespace osu.Game.Tests.Visual
private Drawable createProvider(Skin skin, Func<Drawable> creationFunction, IBeatmap beatmap) private Drawable createProvider(Skin skin, Func<Drawable> creationFunction, IBeatmap beatmap)
{ {
var created = creationFunction(); var created = creationFunction();
createdDrawables.Add(created); createdDrawables.Add(created);
var autoSize = created.RelativeSizeAxes == Axes.None; SkinProvidingContainer mainProvider;
Container childContainer;
OutlineBox outlineBox;
SkinProvidingContainer skinProvider;
var mainProvider = new SkinProvidingContainer(skin) var children = new Container
{
RelativeSizeAxes = !autoSize ? Axes.Both : Axes.None,
AutoSizeAxes = autoSize ? Axes.Both : Axes.None,
};
return new Container
{ {
RelativeSizeAxes = Axes.Both, RelativeSizeAxes = Axes.Both,
BorderColour = Color4.White, BorderColour = Color4.White,
@ -96,27 +94,47 @@ namespace osu.Game.Tests.Visual
Scale = new Vector2(1.5f), Scale = new Vector2(1.5f),
Padding = new MarginPadding(5), Padding = new MarginPadding(5),
}, },
new Container childContainer = new Container
{ {
RelativeSizeAxes = !autoSize ? Axes.Both : Axes.None,
AutoSizeAxes = autoSize ? Axes.Both : Axes.None,
Anchor = Anchor.Centre, Anchor = Anchor.Centre,
Origin = Anchor.Centre, Origin = Anchor.Centre,
Children = new Drawable[] Children = new Drawable[]
{ {
new OutlineBox { Alpha = autoSize ? 1 : 0 }, outlineBox = new OutlineBox(),
mainProvider.WithChild( (mainProvider = new SkinProvidingContainer(skin)).WithChild(
new SkinProvidingContainer(Ruleset.Value.CreateInstance().CreateLegacySkinProvider(mainProvider, beatmap)) skinProvider = new SkinProvidingContainer(Ruleset.Value.CreateInstance().CreateLegacySkinProvider(mainProvider, beatmap))
{ {
Child = created, Child = created,
RelativeSizeAxes = !autoSize ? Axes.Both : Axes.None,
AutoSizeAxes = autoSize ? Axes.Both : Axes.None,
} }
) )
} }
}, },
} }
}; };
// run this once initially to bring things into a sane state as early as possible.
updateSizing();
// run this once after construction to handle the case the changes are made in a BDL/LoadComplete call.
Schedule(updateSizing);
return children;
void updateSizing()
{
var autoSize = created.RelativeSizeAxes == Axes.None;
foreach (var c in new[] { mainProvider, childContainer, skinProvider })
{
c.RelativeSizeAxes = Axes.None;
c.AutoSizeAxes = Axes.None;
c.RelativeSizeAxes = !autoSize ? Axes.Both : Axes.None;
c.AutoSizeAxes = autoSize ? Axes.Both : Axes.None;
}
outlineBox.Alpha = autoSize ? 1 : 0;
}
} }
/// <summary> /// <summary>

2
osu.Game/Users/User.cs
View File

@ -12,7 +12,7 @@ namespace osu.Game.Users
public class User : IEquatable<User> public class User : IEquatable<User>
{ {
[JsonProperty(@"id")] [JsonProperty(@"id")]
public long Id = 1; public int Id = 1;
[JsonProperty(@"join_date")] [JsonProperty(@"join_date")]
public DateTimeOffset JoinDate; public DateTimeOffset JoinDate;

2
osu.Game/osu.Game.csproj
View File

@ -26,7 +26,7 @@
<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" /> <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" /> <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
<PackageReference Include="Newtonsoft.Json" Version="12.0.3" /> <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
<PackageReference Include="ppy.osu.Framework" Version="2020.1029.1" /> <PackageReference Include="ppy.osu.Framework" Version="2020.1105.0" />
<PackageReference Include="ppy.osu.Game.Resources" Version="2020.1030.0" /> <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1030.0" />
<PackageReference Include="Sentry" Version="2.1.6" /> <PackageReference Include="Sentry" Version="2.1.6" />
<PackageReference Include="SharpCompress" Version="0.26.0" /> <PackageReference Include="SharpCompress" Version="0.26.0" />

12
osu.iOS.props
View File

@ -70,9 +70,17 @@
<Reference Include="System.Net.Http" /> <Reference Include="System.Net.Http" />
</ItemGroup> </ItemGroup>
<ItemGroup Label="Package References"> <ItemGroup Label="Package References">
<PackageReference Include="ppy.osu.Framework.iOS" Version="2020.1029.1" /> <PackageReference Include="ppy.osu.Framework.iOS" Version="2020.1105.0" />
<PackageReference Include="ppy.osu.Game.Resources" Version="2020.1030.0" /> <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1030.0" />
</ItemGroup> </ItemGroup>
<!-- See https://github.com/dotnet/runtime/issues/35988 (can be removed after Xamarin uses net5.0 / net6.0) -->
<PropertyGroup>
<NoWarn>$(NoWarn);NU1605</NoWarn>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.SignalR.Client" Version="3.0.3" />
<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.0.3" />
</ItemGroup>
<!-- Xamarin.iOS does not automatically handle transitive dependencies from NuGet packages. --> <!-- Xamarin.iOS does not automatically handle transitive dependencies from NuGet packages. -->
<ItemGroup Label="Transitive Dependencies"> <ItemGroup Label="Transitive Dependencies">
<PackageReference Include="DiffPlex" Version="1.6.3" /> <PackageReference Include="DiffPlex" Version="1.6.3" />
@ -80,7 +88,7 @@
<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" /> <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" /> <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
<PackageReference Include="Newtonsoft.Json" Version="12.0.3" /> <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
<PackageReference Include="ppy.osu.Framework" Version="2020.1029.1" /> <PackageReference Include="ppy.osu.Framework" Version="2020.1105.0" />
<PackageReference Include="SharpCompress" Version="0.26.0" /> <PackageReference Include="SharpCompress" Version="0.26.0" />
<PackageReference Include="NUnit" Version="3.12.0" /> <PackageReference Include="NUnit" Version="3.12.0" />
<PackageReference Include="SharpRaven" Version="2.4.0" /> <PackageReference Include="SharpRaven" Version="2.4.0" />