diff --git a/osu.Android.props b/osu.Android.props
index 75ac298626..5b65670869 100644
--- a/osu.Android.props
+++ b/osu.Android.props
@@ -52,6 +52,6 @@
-
+
diff --git a/osu.Android/osu.Android.csproj b/osu.Android/osu.Android.csproj
index a2638e95c8..2051beae21 100644
--- a/osu.Android/osu.Android.csproj
+++ b/osu.Android/osu.Android.csproj
@@ -53,5 +53,10 @@
+
+
+ 5.0.0
+
+
\ No newline at end of file
diff --git a/osu.Desktop/OsuGameDesktop.cs b/osu.Desktop/OsuGameDesktop.cs
index b2487568ce..0c21c75290 100644
--- a/osu.Desktop/OsuGameDesktop.cs
+++ b/osu.Desktop/OsuGameDesktop.cs
@@ -2,6 +2,7 @@
// See the LICENCE file in the repository root for full licence text.
using System;
+using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
@@ -18,6 +19,7 @@ using osu.Framework.Screens;
using osu.Game.Screens.Menu;
using osu.Game.Updater;
using osu.Desktop.Windows;
+using osu.Framework.Threading;
using osu.Game.IO;
namespace osu.Desktop
@@ -144,13 +146,39 @@ namespace osu.Desktop
desktopWindow.DragDrop += f => fileDrop(new[] { f });
}
+ private readonly List importableFiles = new List();
+ private ScheduledDelegate importSchedule;
+
private void fileDrop(string[] filePaths)
{
- var firstExtension = Path.GetExtension(filePaths.First());
+ lock (importableFiles)
+ {
+ var firstExtension = Path.GetExtension(filePaths.First());
- if (filePaths.Any(f => Path.GetExtension(f) != firstExtension)) return;
+ if (filePaths.Any(f => Path.GetExtension(f) != firstExtension)) return;
- Task.Factory.StartNew(() => Import(filePaths), TaskCreationOptions.LongRunning);
+ importableFiles.AddRange(filePaths);
+
+ Logger.Log($"Adding {filePaths.Length} files for import");
+
+ // File drag drop operations can potentially trigger hundreds or thousands of these calls on some platforms.
+ // In order to avoid spawning multiple import tasks for a single drop operation, debounce a touch.
+ importSchedule?.Cancel();
+ importSchedule = Scheduler.AddDelayed(handlePendingImports, 100);
+ }
+ }
+
+ private void handlePendingImports()
+ {
+ lock (importableFiles)
+ {
+ Logger.Log($"Handling batch import of {importableFiles.Count} files");
+
+ var paths = importableFiles.ToArray();
+ importableFiles.Clear();
+
+ Task.Factory.StartNew(() => Import(paths), TaskCreationOptions.LongRunning);
+ }
}
}
}
diff --git a/osu.Game.Rulesets.Catch.Tests.Android/osu.Game.Rulesets.Catch.Tests.Android.csproj b/osu.Game.Rulesets.Catch.Tests.Android/osu.Game.Rulesets.Catch.Tests.Android.csproj
index 88b420ffad..2e6c10a02e 100644
--- a/osu.Game.Rulesets.Catch.Tests.Android/osu.Game.Rulesets.Catch.Tests.Android.csproj
+++ b/osu.Game.Rulesets.Catch.Tests.Android/osu.Game.Rulesets.Catch.Tests.Android.csproj
@@ -35,5 +35,10 @@
osu.Game
+
+
+ 5.0.0
+
+
\ No newline at end of file
diff --git a/osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj b/osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj
index 728af5124e..c2d9a923d9 100644
--- a/osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj
+++ b/osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj
@@ -2,7 +2,7 @@
-
+
diff --git a/osu.Game.Rulesets.Catch/Mods/CatchModHidden.cs b/osu.Game.Rulesets.Catch/Mods/CatchModHidden.cs
index 4b008d2734..bba42dea97 100644
--- a/osu.Game.Rulesets.Catch/Mods/CatchModHidden.cs
+++ b/osu.Game.Rulesets.Catch/Mods/CatchModHidden.cs
@@ -3,13 +3,16 @@
using System.Linq;
using osu.Framework.Graphics;
+using osu.Game.Rulesets.Catch.Objects;
using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.UI;
using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
namespace osu.Game.Rulesets.Catch.Mods
{
- public class CatchModHidden : ModHidden
+ public class CatchModHidden : ModHidden, IApplicableToDrawableRuleset
{
public override string Description => @"Play with fading fruits.";
public override double ScoreMultiplier => 1.06;
@@ -17,6 +20,14 @@ namespace osu.Game.Rulesets.Catch.Mods
private const double fade_out_offset_multiplier = 0.6;
private const double fade_out_duration_multiplier = 0.44;
+ public void ApplyToDrawableRuleset(DrawableRuleset drawableRuleset)
+ {
+ var drawableCatchRuleset = (DrawableCatchRuleset)drawableRuleset;
+ var catchPlayfield = (CatchPlayfield)drawableCatchRuleset.Playfield;
+
+ catchPlayfield.CatcherArea.MovableCatcher.CatchFruitOnPlate = false;
+ }
+
protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
{
base.ApplyNormalVisibilityState(hitObject, state);
diff --git a/osu.Game.Rulesets.Catch/Skinning/Legacy/CatchLegacySkinTransformer.cs b/osu.Game.Rulesets.Catch/Skinning/Legacy/CatchLegacySkinTransformer.cs
index 41fd0fe776..1b48832ed6 100644
--- a/osu.Game.Rulesets.Catch/Skinning/Legacy/CatchLegacySkinTransformer.cs
+++ b/osu.Game.Rulesets.Catch/Skinning/Legacy/CatchLegacySkinTransformer.cs
@@ -5,7 +5,6 @@ using osu.Framework.Bindables;
using osu.Framework.Graphics;
using osu.Game.Skinning;
using osuTK.Graphics;
-using static osu.Game.Skinning.LegacySkinConfiguration;
namespace osu.Game.Rulesets.Catch.Skinning.Legacy
{
@@ -14,7 +13,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
///
/// For simplicity, let's use legacy combo font texture existence as a way to identify legacy skins from default.
///
- private bool providesComboCounter => this.HasFont(GetConfig(LegacySetting.ComboPrefix)?.Value ?? "score");
+ private bool providesComboCounter => this.HasFont(LegacyFont.Combo);
public CatchLegacySkinTransformer(ISkinSource source)
: base(source)
@@ -69,7 +68,6 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
this.GetAnimation("fruit-ryuuta", true, true, true);
case CatchSkinComponents.CatchComboCounter:
-
if (providesComboCounter)
return new LegacyCatchComboCounter(Source);
diff --git a/osu.Game.Rulesets.Catch/Skinning/Legacy/LegacyCatchComboCounter.cs b/osu.Game.Rulesets.Catch/Skinning/Legacy/LegacyCatchComboCounter.cs
index f797ae75c2..28ee7bd813 100644
--- a/osu.Game.Rulesets.Catch/Skinning/Legacy/LegacyCatchComboCounter.cs
+++ b/osu.Game.Rulesets.Catch/Skinning/Legacy/LegacyCatchComboCounter.cs
@@ -7,7 +7,6 @@ using osu.Game.Rulesets.Catch.UI;
using osu.Game.Skinning;
using osuTK;
using osuTK.Graphics;
-using static osu.Game.Skinning.LegacySkinConfiguration;
namespace osu.Game.Rulesets.Catch.Skinning.Legacy
{
@@ -22,9 +21,6 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
public LegacyCatchComboCounter(ISkin skin)
{
- var fontName = skin.GetConfig(LegacySetting.ComboPrefix)?.Value ?? "score";
- var fontOverlap = skin.GetConfig(LegacySetting.ComboOverlap)?.Value ?? -2f;
-
AutoSizeAxes = Axes.Both;
Alpha = 0f;
@@ -34,7 +30,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
InternalChildren = new Drawable[]
{
- explosion = new LegacyRollingCounter(skin, fontName, fontOverlap)
+ explosion = new LegacyRollingCounter(skin, LegacyFont.Combo)
{
Alpha = 0.65f,
Blending = BlendingParameters.Additive,
@@ -42,7 +38,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
Origin = Anchor.Centre,
Scale = new Vector2(1.5f),
},
- counter = new LegacyRollingCounter(skin, fontName, fontOverlap)
+ counter = new LegacyRollingCounter(skin, LegacyFont.Combo)
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
diff --git a/osu.Game.Rulesets.Catch/UI/Catcher.cs b/osu.Game.Rulesets.Catch/UI/Catcher.cs
index ed875e7002..5d57e84b75 100644
--- a/osu.Game.Rulesets.Catch/UI/Catcher.cs
+++ b/osu.Game.Rulesets.Catch/UI/Catcher.cs
@@ -43,6 +43,11 @@ namespace osu.Game.Rulesets.Catch.UI
///
public bool HyperDashing => hyperDashModifier != 1;
+ ///
+ /// Whether fruit should appear on the plate.
+ ///
+ public bool CatchFruitOnPlate { get; set; } = true;
+
///
/// The relative space to cover in 1 millisecond. based on 1 game pixel per millisecond as in osu-stable.
///
@@ -237,7 +242,8 @@ namespace osu.Game.Rulesets.Catch.UI
{
var positionInStack = computePositionInStack(new Vector2(palpableObject.X - X, 0), palpableObject.DisplaySize.X / 2);
- placeCaughtObject(palpableObject, positionInStack);
+ if (CatchFruitOnPlate)
+ placeCaughtObject(palpableObject, positionInStack);
if (hitLighting.Value)
addLighting(hitObject, positionInStack.X, drawableObject.AccentColour.Value);
diff --git a/osu.Game.Rulesets.Mania.Tests.Android/osu.Game.Rulesets.Mania.Tests.Android.csproj b/osu.Game.Rulesets.Mania.Tests.Android/osu.Game.Rulesets.Mania.Tests.Android.csproj
index 0e557cb260..8c134c7114 100644
--- a/osu.Game.Rulesets.Mania.Tests.Android/osu.Game.Rulesets.Mania.Tests.Android.csproj
+++ b/osu.Game.Rulesets.Mania.Tests.Android/osu.Game.Rulesets.Mania.Tests.Android.csproj
@@ -35,5 +35,10 @@
osu.Game
+
+
+ 5.0.0
+
+
\ No newline at end of file
diff --git a/osu.Game.Rulesets.Mania.Tests/TestSceneHoldNoteInput.cs b/osu.Game.Rulesets.Mania.Tests/TestSceneHoldNoteInput.cs
index 7ae69bf7d7..42ea12214f 100644
--- a/osu.Game.Rulesets.Mania.Tests/TestSceneHoldNoteInput.cs
+++ b/osu.Game.Rulesets.Mania.Tests/TestSceneHoldNoteInput.cs
@@ -288,17 +288,56 @@ namespace osu.Game.Rulesets.Mania.Tests
.All(j => j.Type.IsHit()));
}
+ [Test]
+ public void TestHitTailBeforeLastTick()
+ {
+ const int tick_rate = 8;
+ const double tick_spacing = TimingControlPoint.DEFAULT_BEAT_LENGTH / tick_rate;
+ const double time_last_tick = time_head + tick_spacing * (int)((time_tail - time_head) / tick_spacing - 1);
+
+ var beatmap = new Beatmap
+ {
+ HitObjects =
+ {
+ new HoldNote
+ {
+ StartTime = time_head,
+ Duration = time_tail - time_head,
+ Column = 0,
+ }
+ },
+ BeatmapInfo =
+ {
+ BaseDifficulty = new BeatmapDifficulty { SliderTickRate = tick_rate },
+ Ruleset = new ManiaRuleset().RulesetInfo
+ },
+ };
+
+ performTest(new List
+ {
+ new ManiaReplayFrame(time_head, ManiaAction.Key1),
+ new ManiaReplayFrame(time_last_tick - 5)
+ }, beatmap);
+
+ assertHeadJudgement(HitResult.Perfect);
+ assertLastTickJudgement(HitResult.LargeTickMiss);
+ assertTailJudgement(HitResult.Ok);
+ }
+
private void assertHeadJudgement(HitResult result)
- => AddAssert($"head judged as {result}", () => judgementResults[0].Type == result);
+ => AddAssert($"head judged as {result}", () => judgementResults.First(j => j.HitObject is Note).Type == result);
private void assertTailJudgement(HitResult result)
- => AddAssert($"tail judged as {result}", () => judgementResults[^2].Type == result);
+ => AddAssert($"tail judged as {result}", () => judgementResults.Single(j => j.HitObject is TailNote).Type == result);
private void assertNoteJudgement(HitResult result)
- => AddAssert($"hold note judged as {result}", () => judgementResults[^1].Type == result);
+ => AddAssert($"hold note judged as {result}", () => judgementResults.Single(j => j.HitObject is HoldNote).Type == result);
private void assertTickJudgement(HitResult result)
- => AddAssert($"tick judged as {result}", () => judgementResults[6].Type == result); // arbitrary tick
+ => AddAssert($"any tick judged as {result}", () => judgementResults.Where(j => j.HitObject is HoldNoteTick).Any(j => j.Type == result));
+
+ private void assertLastTickJudgement(HitResult result)
+ => AddAssert($"last tick judged as {result}", () => judgementResults.Last(j => j.HitObject is HoldNoteTick).Type == result);
private ScoreAccessibleReplayPlayer currentPlayer;
diff --git a/osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj b/osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj
index af16f39563..64e934efd2 100644
--- a/osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj
+++ b/osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj
@@ -2,7 +2,7 @@
-
+
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
index 7a0e3b2b76..26393c8edb 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
if (IsForCurrentRuleset)
{
- TargetColumns = (int)Math.Max(1, roundedCircleSize);
+ TargetColumns = GetColumnCountForNonConvert(beatmap.BeatmapInfo);
if (TargetColumns > ManiaRuleset.MAX_STAGE_KEYS)
{
@@ -71,6 +71,12 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
originalTargetColumns = TargetColumns;
}
+ public static int GetColumnCountForNonConvert(BeatmapInfo beatmap)
+ {
+ var roundedCircleSize = Math.Round(beatmap.BaseDifficulty.CircleSize);
+ return (int)Math.Max(1, roundedCircleSize);
+ }
+
public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition);
protected override Beatmap ConvertBeatmap(IBeatmap original, CancellationToken cancellationToken)
diff --git a/osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs b/osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs
index 324670c4b2..d9570bf8be 100644
--- a/osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs
@@ -119,5 +119,8 @@ namespace osu.Game.Rulesets.Mania.Edit
beatSnapGrid.SelectionTimeRange = null;
}
}
+
+ public override string ConvertSelectionToString()
+ => string.Join(',', EditorBeatmap.SelectedHitObjects.Cast().OrderBy(h => h.StartTime).Select(h => $"{h.StartTime}|{h.Column}"));
}
}
diff --git a/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs b/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs
new file mode 100644
index 0000000000..d9a278ef29
--- /dev/null
+++ b/osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs
@@ -0,0 +1,33 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Filter;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Rulesets.Mania
+{
+ public class ManiaFilterCriteria : IRulesetFilterCriteria
+ {
+ private FilterCriteria.OptionalRange keys;
+
+ public bool Matches(BeatmapInfo beatmap)
+ {
+ return !keys.HasFilter || (beatmap.RulesetID == new ManiaRuleset().LegacyID && keys.IsInRange(ManiaBeatmapConverter.GetColumnCountForNonConvert(beatmap)));
+ }
+
+ public bool TryParseCustomKeywordCriteria(string key, Operator op, string value)
+ {
+ switch (key)
+ {
+ case "key":
+ case "keys":
+ return FilterQueryParser.TryUpdateCriteriaRange(ref keys, op, value);
+ }
+
+ return false;
+ }
+ }
+}
diff --git a/osu.Game.Rulesets.Mania/ManiaRuleset.cs b/osu.Game.Rulesets.Mania/ManiaRuleset.cs
index d624e094ad..88b63606b9 100644
--- a/osu.Game.Rulesets.Mania/ManiaRuleset.cs
+++ b/osu.Game.Rulesets.Mania/ManiaRuleset.cs
@@ -22,6 +22,7 @@ using osu.Game.Overlays.Settings;
using osu.Game.Rulesets.Configuration;
using osu.Game.Rulesets.Difficulty;
using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Filter;
using osu.Game.Rulesets.Mania.Beatmaps;
using osu.Game.Rulesets.Mania.Configuration;
using osu.Game.Rulesets.Mania.Difficulty;
@@ -382,6 +383,11 @@ namespace osu.Game.Rulesets.Mania
}
}
};
+
+ public override IRulesetFilterCriteria CreateRulesetFilterCriteria()
+ {
+ return new ManiaFilterCriteria();
+ }
}
public enum PlayfieldType
diff --git a/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs b/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs
index 4f062753a6..828ee7b03e 100644
--- a/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs
+++ b/osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs
@@ -233,6 +233,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
{
if (Tail.AllJudged)
{
+ foreach (var tick in tickContainer)
+ {
+ if (!tick.Judged)
+ tick.MissForcefully();
+ }
+
ApplyResult(r => r.Type = r.Judgement.MaxResult);
endHold();
}
diff --git a/osu.Game.Rulesets.Osu.Tests.Android/osu.Game.Rulesets.Osu.Tests.Android.csproj b/osu.Game.Rulesets.Osu.Tests.Android/osu.Game.Rulesets.Osu.Tests.Android.csproj
index dcf1573522..22fa605176 100644
--- a/osu.Game.Rulesets.Osu.Tests.Android/osu.Game.Rulesets.Osu.Tests.Android.csproj
+++ b/osu.Game.Rulesets.Osu.Tests.Android/osu.Game.Rulesets.Osu.Tests.Android.csproj
@@ -35,5 +35,10 @@
osu.Game
+
+
+ 5.0.0
+
+
\ No newline at end of file
diff --git a/osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj b/osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj
index 3d2d1f3fec..f743d65db3 100644
--- a/osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj
+++ b/osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj
@@ -2,7 +2,7 @@
-
+
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
index 0490e8b8ce..396fd41377 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
@@ -82,6 +82,9 @@ namespace osu.Game.Rulesets.Osu.Edit
protected override ComposeBlueprintContainer CreateBlueprintContainer()
=> new OsuBlueprintContainer(this);
+ public override string ConvertSelectionToString()
+ => string.Join(',', selectedHitObjects.Cast().OrderBy(h => h.StartTime).Select(h => (h.IndexInCurrentCombo + 1).ToString()));
+
private DistanceSnapGrid distanceSnapGrid;
private Container distanceSnapGridContainer;
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
index 871339ae7b..82301bd37f 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
@@ -35,8 +35,18 @@ namespace osu.Game.Rulesets.Osu.Edit
referenceOrigin = null;
}
- public override bool HandleMovement(MoveSelectionEvent moveEvent) =>
- moveSelection(moveEvent.InstantDelta);
+ public override bool HandleMovement(MoveSelectionEvent moveEvent)
+ {
+ var hitObjects = selectedMovableObjects;
+
+ // this will potentially move the selection out of bounds...
+ foreach (var h in hitObjects)
+ h.Position += moveEvent.InstantDelta;
+
+ // but this will be corrected.
+ moveSelectionInBounds();
+ return true;
+ }
///
/// During a transform, the initial origin is stored so it can be used throughout the operation.
@@ -140,36 +150,11 @@ namespace osu.Game.Rulesets.Osu.Edit
// the only hit object selected. with a group selection, it's likely the user
// is not looking to change the duration of the slider but expand the whole pattern.
if (hitObjects.Length == 1 && hitObjects.First() is Slider slider)
- {
- Quad quad = getSurroundingQuad(slider.Path.ControlPoints.Select(p => p.Position.Value));
- Vector2 pathRelativeDeltaScale = new Vector2(1 + scale.X / quad.Width, 1 + scale.Y / quad.Height);
-
- foreach (var point in slider.Path.ControlPoints)
- point.Position.Value *= pathRelativeDeltaScale;
- }
+ scaleSlider(slider, scale);
else
- {
- // move the selection before scaling if dragging from top or left anchors.
- if ((reference & Anchor.x0) > 0 && !moveSelection(new Vector2(-scale.X, 0))) return false;
- if ((reference & Anchor.y0) > 0 && !moveSelection(new Vector2(0, -scale.Y))) return false;
-
- Quad quad = getSurroundingQuad(hitObjects);
-
- foreach (var h in hitObjects)
- {
- var newPosition = h.Position;
-
- // guard against no-ops and NaN.
- if (scale.X != 0 && quad.Width > 0)
- newPosition.X = quad.TopLeft.X + (h.X - quad.TopLeft.X) / quad.Width * (quad.Width + scale.X);
-
- if (scale.Y != 0 && quad.Height > 0)
- newPosition.Y = quad.TopLeft.Y + (h.Y - quad.TopLeft.Y) / quad.Height * (quad.Height + scale.Y);
-
- h.Position = newPosition;
- }
- }
+ scaleHitObjects(hitObjects, reference, scale);
+ moveSelectionInBounds();
return true;
}
@@ -207,28 +192,124 @@ namespace osu.Game.Rulesets.Osu.Edit
return true;
}
- private bool moveSelection(Vector2 delta)
+ private void scaleSlider(Slider slider, Vector2 scale)
+ {
+ Quad sliderQuad = getSurroundingQuad(slider.Path.ControlPoints.Select(p => p.Position.Value));
+
+ // Limit minimum distance between control points after scaling to almost 0. Less than 0 causes the slider to flip, exactly 0 causes a crash through division by 0.
+ scale = Vector2.ComponentMax(new Vector2(Precision.FLOAT_EPSILON), sliderQuad.Size + scale) - sliderQuad.Size;
+
+ Vector2 pathRelativeDeltaScale = new Vector2(1 + scale.X / sliderQuad.Width, 1 + scale.Y / sliderQuad.Height);
+
+ Queue oldControlPoints = new Queue();
+
+ foreach (var point in slider.Path.ControlPoints)
+ {
+ oldControlPoints.Enqueue(point.Position.Value);
+ point.Position.Value *= pathRelativeDeltaScale;
+ }
+
+ //if sliderhead or sliderend end up outside playfield, revert scaling.
+ Quad scaledQuad = getSurroundingQuad(new OsuHitObject[] { slider });
+ (bool xInBounds, bool yInBounds) = isQuadInBounds(scaledQuad);
+
+ if (xInBounds && yInBounds)
+ return;
+
+ foreach (var point in slider.Path.ControlPoints)
+ point.Position.Value = oldControlPoints.Dequeue();
+ }
+
+ private void scaleHitObjects(OsuHitObject[] hitObjects, Anchor reference, Vector2 scale)
+ {
+ scale = getClampedScale(hitObjects, reference, scale);
+
+ // move the selection before scaling if dragging from top or left anchors.
+ float xOffset = ((reference & Anchor.x0) > 0) ? -scale.X : 0;
+ float yOffset = ((reference & Anchor.y0) > 0) ? -scale.Y : 0;
+
+ Quad selectionQuad = getSurroundingQuad(hitObjects);
+
+ foreach (var h in hitObjects)
+ {
+ var newPosition = h.Position;
+
+ // guard against no-ops and NaN.
+ if (scale.X != 0 && selectionQuad.Width > 0)
+ newPosition.X = selectionQuad.TopLeft.X + xOffset + (h.X - selectionQuad.TopLeft.X) / selectionQuad.Width * (selectionQuad.Width + scale.X);
+
+ if (scale.Y != 0 && selectionQuad.Height > 0)
+ newPosition.Y = selectionQuad.TopLeft.Y + yOffset + (h.Y - selectionQuad.TopLeft.Y) / selectionQuad.Height * (selectionQuad.Height + scale.Y);
+
+ h.Position = newPosition;
+ }
+ }
+
+ private (bool X, bool Y) isQuadInBounds(Quad quad)
+ {
+ bool xInBounds = (quad.TopLeft.X >= 0) && (quad.BottomRight.X <= DrawWidth);
+ bool yInBounds = (quad.TopLeft.Y >= 0) && (quad.BottomRight.Y <= DrawHeight);
+
+ return (xInBounds, yInBounds);
+ }
+
+ private void moveSelectionInBounds()
{
var hitObjects = selectedMovableObjects;
Quad quad = getSurroundingQuad(hitObjects);
- Vector2 newTopLeft = quad.TopLeft + delta;
- if (newTopLeft.X < 0)
- delta.X -= newTopLeft.X;
- if (newTopLeft.Y < 0)
- delta.Y -= newTopLeft.Y;
+ Vector2 delta = Vector2.Zero;
- Vector2 newBottomRight = quad.BottomRight + delta;
- if (newBottomRight.X > DrawWidth)
- delta.X -= newBottomRight.X - DrawWidth;
- if (newBottomRight.Y > DrawHeight)
- delta.Y -= newBottomRight.Y - DrawHeight;
+ if (quad.TopLeft.X < 0)
+ delta.X -= quad.TopLeft.X;
+ if (quad.TopLeft.Y < 0)
+ delta.Y -= quad.TopLeft.Y;
+
+ if (quad.BottomRight.X > DrawWidth)
+ delta.X -= quad.BottomRight.X - DrawWidth;
+ if (quad.BottomRight.Y > DrawHeight)
+ delta.Y -= quad.BottomRight.Y - DrawHeight;
foreach (var h in hitObjects)
h.Position += delta;
+ }
- return true;
+ ///
+ /// Clamp scale for multi-object-scaling where selection does not exceed playfield bounds or flip.
+ ///
+ /// The hitobjects to be scaled
+ /// The anchor from which the scale operation is performed
+ /// The scale to be clamped
+ /// The clamped scale vector
+ private Vector2 getClampedScale(OsuHitObject[] hitObjects, Anchor reference, Vector2 scale)
+ {
+ float xOffset = ((reference & Anchor.x0) > 0) ? -scale.X : 0;
+ float yOffset = ((reference & Anchor.y0) > 0) ? -scale.Y : 0;
+
+ Quad selectionQuad = getSurroundingQuad(hitObjects);
+
+ //todo: this is not always correct for selections involving sliders. This approximation assumes each point is scaled independently, but sliderends move with the sliderhead.
+ Quad scaledQuad = new Quad(selectionQuad.TopLeft.X + xOffset, selectionQuad.TopLeft.Y + yOffset, selectionQuad.Width + scale.X, selectionQuad.Height + scale.Y);
+
+ //max Size -> playfield bounds
+ if (scaledQuad.TopLeft.X < 0)
+ scale.X += scaledQuad.TopLeft.X;
+ if (scaledQuad.TopLeft.Y < 0)
+ scale.Y += scaledQuad.TopLeft.Y;
+
+ if (scaledQuad.BottomRight.X > DrawWidth)
+ scale.X -= scaledQuad.BottomRight.X - DrawWidth;
+ if (scaledQuad.BottomRight.Y > DrawHeight)
+ scale.Y -= scaledQuad.BottomRight.Y - DrawHeight;
+
+ //min Size -> almost 0. Less than 0 causes the quad to flip, exactly 0 causes scaling to get stuck at minimum scale.
+ Vector2 scaledSize = selectionQuad.Size + scale;
+ Vector2 minSize = new Vector2(Precision.FLOAT_EPSILON);
+
+ scale = Vector2.ComponentMax(minSize, scaledSize) - selectionQuad.Size;
+
+ return scale;
}
///
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModClassic.cs b/osu.Game.Rulesets.Osu/Mods/OsuModClassic.cs
index 5470d0fcb4..882f848190 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModClassic.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModClassic.cs
@@ -44,6 +44,9 @@ namespace osu.Game.Rulesets.Osu.Mods
[SettingSource("Use fixed slider follow circle hit area", "Makes the slider follow circle track its final size at all times.")]
public Bindable FixedFollowCircleHitArea { get; } = new BindableBool(true);
+ [SettingSource("Always play a slider's tail sample", "Always plays a slider's tail sample regardless of whether it was hit or not.")]
+ public Bindable AlwaysPlayTailSample { get; } = new BindableBool(true);
+
public void ApplyToHitObject(HitObject hitObject)
{
switch (hitObject)
@@ -79,6 +82,10 @@ namespace osu.Game.Rulesets.Osu.Mods
case DrawableSliderHead head:
head.TrackFollowCircle = !NoSliderHeadMovement.Value;
break;
+
+ case DrawableSliderTail tail:
+ tail.SamplePlaysOnlyOnHit = !AlwaysPlayTailSample.Value;
+ break;
}
}
}
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs
index 9122f347d0..04708a5ece 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs
@@ -280,7 +280,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
{
// rather than doing it this way, we should probably attach the sample to the tail circle.
// this can only be done after we stop using LegacyLastTick.
- if (TailCircle.IsHit)
+ if (!TailCircle.SamplePlaysOnlyOnHit || TailCircle.IsHit)
base.PlaySamples();
}
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs
index 6a8e02e886..87f098dd29 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTail.cs
@@ -26,6 +26,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
///
public override bool DisplayResult => false;
+ ///
+ /// Whether the hit samples only play on successful hits.
+ /// If false, the hit samples will also play on misses.
+ ///
+ public bool SamplePlaysOnlyOnHit { get; set; } = true;
+
public bool Tracking { get; set; }
private SkinnableDrawable circlePiece;
diff --git a/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySpinner.cs b/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySpinner.cs
index dd1c6cad77..064b7a4680 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySpinner.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySpinner.cs
@@ -48,9 +48,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
DrawableSpinner = (DrawableSpinner)drawableHitObject;
- Container overlayContainer;
-
- AddInternal(overlayContainer = new Container
+ AddInternal(new Container
{
Depth = float.MinValue,
RelativeSizeAxes = Axes.Both,
@@ -73,21 +71,16 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
Scale = new Vector2(SPRITE_SCALE),
Y = SPINNER_TOP_OFFSET + 115,
},
+ bonusCounter = new LegacySpriteText(source, LegacyFont.Score)
+ {
+ Alpha = 0f,
+ Anchor = Anchor.TopCentre,
+ Origin = Anchor.Centre,
+ Scale = new Vector2(SPRITE_SCALE),
+ Y = SPINNER_TOP_OFFSET + 299,
+ }.With(s => s.Font = s.Font.With(fixedWidth: false)),
}
});
-
- bonusCounter = (source.GetDrawableComponent(new HUDSkinComponent(HUDSkinComponents.ScoreText)) as LegacySpriteText)?.With(c =>
- {
- c.Alpha = 0f;
- c.Anchor = Anchor.TopCentre;
- c.Origin = Anchor.Centre;
- c.Font = c.Font.With(fixedWidth: false);
- c.Scale = new Vector2(SPRITE_SCALE);
- c.Y = SPINNER_TOP_OFFSET + 299;
- });
-
- if (bonusCounter != null)
- overlayContainer.Add(bonusCounter);
}
private IBindable gainedBonus;
@@ -98,16 +91,13 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
{
base.LoadComplete();
- if (bonusCounter != null)
+ gainedBonus = DrawableSpinner.GainedBonus.GetBoundCopy();
+ gainedBonus.BindValueChanged(bonus =>
{
- gainedBonus = DrawableSpinner.GainedBonus.GetBoundCopy();
- gainedBonus.BindValueChanged(bonus =>
- {
- bonusCounter.Text = bonus.NewValue.ToString(NumberFormatInfo.InvariantInfo);
- bonusCounter.FadeOutFromOne(800, Easing.Out);
- bonusCounter.ScaleTo(SPRITE_SCALE * 2f).Then().ScaleTo(SPRITE_SCALE * 1.28f, 800, Easing.Out);
- });
- }
+ bonusCounter.Text = bonus.NewValue.ToString(NumberFormatInfo.InvariantInfo);
+ bonusCounter.FadeOutFromOne(800, Easing.Out);
+ bonusCounter.ScaleTo(SPRITE_SCALE * 2f).Then().ScaleTo(SPRITE_SCALE * 1.28f, 800, Easing.Out);
+ });
completed.BindValueChanged(onCompletedChanged, true);
diff --git a/osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs b/osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs
index d74f885573..ffe238c507 100644
--- a/osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs
@@ -97,17 +97,14 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
return null;
case OsuSkinComponents.HitCircleText:
- var font = GetConfig(OsuSkinConfiguration.HitCirclePrefix)?.Value ?? "default";
- var overlap = GetConfig(OsuSkinConfiguration.HitCircleOverlap)?.Value ?? -2;
+ if (!this.HasFont(LegacyFont.HitCircle))
+ return null;
- return !this.HasFont(font)
- ? null
- : new LegacySpriteText(Source, font)
- {
- // stable applies a blanket 0.8x scale to hitcircle fonts
- Scale = new Vector2(0.8f),
- Spacing = new Vector2(-overlap, 0)
- };
+ return new LegacySpriteText(Source, LegacyFont.HitCircle)
+ {
+ // stable applies a blanket 0.8x scale to hitcircle fonts
+ Scale = new Vector2(0.8f),
+ };
case OsuSkinComponents.SpinnerBody:
bool hasBackground = Source.GetTexture("spinner-background") != null;
diff --git a/osu.Game.Rulesets.Osu/Skinning/OsuSkinConfiguration.cs b/osu.Game.Rulesets.Osu/Skinning/OsuSkinConfiguration.cs
index 63c9b53278..75a62a6f8e 100644
--- a/osu.Game.Rulesets.Osu/Skinning/OsuSkinConfiguration.cs
+++ b/osu.Game.Rulesets.Osu/Skinning/OsuSkinConfiguration.cs
@@ -5,8 +5,6 @@ namespace osu.Game.Rulesets.Osu.Skinning
{
public enum OsuSkinConfiguration
{
- HitCirclePrefix,
- HitCircleOverlap,
SliderBorderSize,
SliderPathRadius,
AllowSliderBallTint,
diff --git a/osu.Game.Rulesets.Taiko.Tests.Android/osu.Game.Rulesets.Taiko.Tests.Android.csproj b/osu.Game.Rulesets.Taiko.Tests.Android/osu.Game.Rulesets.Taiko.Tests.Android.csproj
index 392442b713..a48110b354 100644
--- a/osu.Game.Rulesets.Taiko.Tests.Android/osu.Game.Rulesets.Taiko.Tests.Android.csproj
+++ b/osu.Game.Rulesets.Taiko.Tests.Android/osu.Game.Rulesets.Taiko.Tests.Android.csproj
@@ -35,5 +35,10 @@
osu.Game
+
+
+ 5.0.0
+
+
\ No newline at end of file
diff --git a/osu.Game.Rulesets.Taiko.Tests/osu.Game.Rulesets.Taiko.Tests.csproj b/osu.Game.Rulesets.Taiko.Tests/osu.Game.Rulesets.Taiko.Tests.csproj
index fa00922706..eab144592f 100644
--- a/osu.Game.Rulesets.Taiko.Tests/osu.Game.Rulesets.Taiko.Tests.csproj
+++ b/osu.Game.Rulesets.Taiko.Tests/osu.Game.Rulesets.Taiko.Tests.csproj
@@ -2,7 +2,7 @@
-
+
diff --git a/osu.Game.Tests.Android/osu.Game.Tests.Android.csproj b/osu.Game.Tests.Android/osu.Game.Tests.Android.csproj
index c3d9cb5875..bf256f486c 100644
--- a/osu.Game.Tests.Android/osu.Game.Tests.Android.csproj
+++ b/osu.Game.Tests.Android/osu.Game.Tests.Android.csproj
@@ -75,6 +75,9 @@
+
+ 5.0.0
+
diff --git a/osu.Game.Tests/NonVisual/FormatUtilsTest.cs b/osu.Game.Tests/NonVisual/FormatUtilsTest.cs
new file mode 100644
index 0000000000..df095ddee3
--- /dev/null
+++ b/osu.Game.Tests/NonVisual/FormatUtilsTest.cs
@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Globalization;
+using NUnit.Framework;
+using osu.Game.Utils;
+
+namespace osu.Game.Tests.NonVisual
+{
+ [TestFixture]
+ public class FormatUtilsTest
+ {
+ [TestCase(0, "0.00%")]
+ [TestCase(0.01, "1.00%")]
+ [TestCase(0.9899, "98.99%")]
+ [TestCase(0.989999, "98.99%")]
+ [TestCase(0.99, "99.00%")]
+ [TestCase(0.9999, "99.99%")]
+ [TestCase(0.999999, "99.99%")]
+ [TestCase(1, "100.00%")]
+ public void TestAccuracyFormatting(double input, string expectedOutput)
+ {
+ Assert.AreEqual(expectedOutput, input.FormatAccuracy(CultureInfo.InvariantCulture));
+ }
+ }
+}
diff --git a/osu.Game.Tests/Online/TestAPIModJsonSerialization.cs b/osu.Game.Tests/Online/TestAPIModJsonSerialization.cs
index ab24a72a12..77f910c144 100644
--- a/osu.Game.Tests/Online/TestAPIModJsonSerialization.cs
+++ b/osu.Game.Tests/Online/TestAPIModJsonSerialization.cs
@@ -25,7 +25,7 @@ namespace osu.Game.Tests.Online
var deserialized = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(apiMod));
- Assert.That(deserialized.Acronym, Is.EqualTo(apiMod.Acronym));
+ Assert.That(deserialized?.Acronym, Is.EqualTo(apiMod.Acronym));
}
[Test]
@@ -35,7 +35,7 @@ namespace osu.Game.Tests.Online
var deserialized = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(apiMod));
- Assert.That(deserialized.Settings, Contains.Key("test_setting").With.ContainValue(2.0));
+ Assert.That(deserialized?.Settings, Contains.Key("test_setting").With.ContainValue(2.0));
}
[Test]
@@ -44,9 +44,9 @@ namespace osu.Game.Tests.Online
var apiMod = new APIMod(new TestMod { TestSetting = { Value = 2 } });
var deserialized = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(apiMod));
- var converted = (TestMod)deserialized.ToMod(new TestRuleset());
+ var converted = (TestMod)deserialized?.ToMod(new TestRuleset());
- Assert.That(converted.TestSetting.Value, Is.EqualTo(2));
+ Assert.That(converted?.TestSetting.Value, Is.EqualTo(2));
}
[Test]
@@ -61,11 +61,11 @@ namespace osu.Game.Tests.Online
});
var deserialised = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(apiMod));
- var converted = (TestModTimeRamp)deserialised.ToMod(new TestRuleset());
+ var converted = (TestModTimeRamp)deserialised?.ToMod(new TestRuleset());
- Assert.That(converted.AdjustPitch.Value, Is.EqualTo(false));
- Assert.That(converted.InitialRate.Value, Is.EqualTo(1.25));
- Assert.That(converted.FinalRate.Value, Is.EqualTo(0.25));
+ Assert.That(converted?.AdjustPitch.Value, Is.EqualTo(false));
+ Assert.That(converted?.InitialRate.Value, Is.EqualTo(1.25));
+ Assert.That(converted?.FinalRate.Value, Is.EqualTo(0.25));
}
[Test]
@@ -78,10 +78,10 @@ namespace osu.Game.Tests.Online
});
var deserialised = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(apiMod));
- var converted = (TestModDifficultyAdjust)deserialised.ToMod(new TestRuleset());
+ var converted = (TestModDifficultyAdjust)deserialised?.ToMod(new TestRuleset());
- Assert.That(converted.ExtendedLimits.Value, Is.True);
- Assert.That(converted.OverallDifficulty.Value, Is.EqualTo(11));
+ Assert.That(converted?.ExtendedLimits.Value, Is.True);
+ Assert.That(converted?.OverallDifficulty.Value, Is.EqualTo(11));
}
private class TestRuleset : Ruleset
diff --git a/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs b/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
index f2bb518b2e..3e25e22b5f 100644
--- a/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
+++ b/osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs
@@ -43,6 +43,29 @@ namespace osu.Game.Tests.Visual.Navigation
exitViaEscapeAndConfirm();
}
+ [Test]
+ public void TestRetryCountIncrements()
+ {
+ Player player = null;
+
+ PushAndConfirm(() => new TestSongSelect());
+
+ AddStep("import beatmap", () => ImportBeatmapTest.LoadQuickOszIntoOsu(Game).Wait());
+
+ AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+
+ AddStep("press enter", () => InputManager.Key(Key.Enter));
+
+ AddUntilStep("wait for player", () => (player = Game.ScreenStack.CurrentScreen as Player) != null);
+ AddAssert("retry count is 0", () => player.RestartCount == 0);
+
+ AddStep("attempt to retry", () => player.ChildrenOfType().First().Action());
+ AddUntilStep("wait for old player gone", () => Game.ScreenStack.CurrentScreen != player);
+
+ AddUntilStep("get new player", () => (player = Game.ScreenStack.CurrentScreen as Player) != null);
+ AddAssert("retry count is 1", () => player.RestartCount == 1);
+ }
+
[Test]
public void TestRetryFromResults()
{
diff --git a/osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs b/osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs
index a7f6c8c0d3..a62980addf 100644
--- a/osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs
+++ b/osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs
@@ -45,6 +45,8 @@ namespace osu.Game.Tests.Visual.Settings
public Bindable AreaOffset { get; } = new Bindable();
public Bindable AreaSize { get; } = new Bindable();
+ public Bindable Rotation { get; } = new Bindable();
+
public IBindable Tablet => tablet;
private readonly Bindable tablet = new Bindable();
diff --git a/osu.Game.Tests/osu.Game.Tests.csproj b/osu.Game.Tests/osu.Game.Tests.csproj
index e36b3cdc74..0e1f6f6b0c 100644
--- a/osu.Game.Tests/osu.Game.Tests.csproj
+++ b/osu.Game.Tests/osu.Game.Tests.csproj
@@ -3,7 +3,7 @@
-
+
diff --git a/osu.Game.Tournament.Tests/NonVisual/IPCLocationTest.cs b/osu.Game.Tournament.Tests/NonVisual/IPCLocationTest.cs
new file mode 100644
index 0000000000..4c5f5a7a1a
--- /dev/null
+++ b/osu.Game.Tournament.Tests/NonVisual/IPCLocationTest.cs
@@ -0,0 +1,73 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Platform;
+using osu.Game.Tournament.IO;
+using osu.Game.Tournament.IPC;
+
+namespace osu.Game.Tournament.Tests.NonVisual
+{
+ [TestFixture]
+ public class IPCLocationTest
+ {
+ [Test]
+ public void CheckIPCLocation()
+ {
+ // don't use clean run because files are being written before osu! launches.
+ using (HeadlessGameHost host = new HeadlessGameHost(nameof(CheckIPCLocation)))
+ {
+ string basePath = Path.Combine(RuntimeInfo.StartupDirectory, "headless", nameof(CheckIPCLocation));
+
+ // Set up a fake IPC client for the IPC Storage to switch to.
+ string testStableInstallDirectory = Path.Combine(basePath, "stable-ce");
+ Directory.CreateDirectory(testStableInstallDirectory);
+
+ string ipcFile = Path.Combine(testStableInstallDirectory, "ipc.txt");
+ File.WriteAllText(ipcFile, string.Empty);
+
+ try
+ {
+ var osu = loadOsu(host);
+ TournamentStorage storage = (TournamentStorage)osu.Dependencies.Get();
+ FileBasedIPC ipc = null;
+
+ waitForOrAssert(() => (ipc = osu.Dependencies.Get() as FileBasedIPC) != null, @"ipc could not be populated in a reasonable amount of time");
+
+ Assert.True(ipc.SetIPCLocation(testStableInstallDirectory));
+ Assert.True(storage.AllTournaments.Exists("stable.json"));
+ }
+ finally
+ {
+ host.Storage.DeleteDirectory(testStableInstallDirectory);
+ host.Storage.DeleteDirectory("tournaments");
+ host.Exit();
+ }
+ }
+ }
+
+ private TournamentGameBase loadOsu(GameHost host)
+ {
+ var osu = new TournamentGameBase();
+ Task.Run(() => host.Run(osu));
+ waitForOrAssert(() => osu.IsLoaded, @"osu! failed to start in a reasonable amount of time");
+ return osu;
+ }
+
+ private static void waitForOrAssert(Func result, string failureMessage, int timeout = 90000)
+ {
+ Task task = Task.Run(() =>
+ {
+ while (!result()) Thread.Sleep(200);
+ });
+
+ Assert.IsTrue(task.Wait(timeout), failureMessage);
+ }
+ }
+}
diff --git a/osu.Game.Tournament.Tests/osu.Game.Tournament.Tests.csproj b/osu.Game.Tournament.Tests/osu.Game.Tournament.Tests.csproj
index b20583dd7e..a4e52f8cd4 100644
--- a/osu.Game.Tournament.Tests/osu.Game.Tournament.Tests.csproj
+++ b/osu.Game.Tournament.Tests/osu.Game.Tournament.Tests.csproj
@@ -5,7 +5,7 @@
-
+
diff --git a/osu.Game.Tournament/IO/TournamentStorage.cs b/osu.Game.Tournament/IO/TournamentStorage.cs
index 5d9fed6288..044b60bbd5 100644
--- a/osu.Game.Tournament/IO/TournamentStorage.cs
+++ b/osu.Game.Tournament/IO/TournamentStorage.cs
@@ -1,12 +1,12 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
+using System.Collections.Generic;
+using System.IO;
using osu.Framework.Bindables;
using osu.Framework.Logging;
using osu.Framework.Platform;
using osu.Game.IO;
-using System.IO;
-using System.Collections.Generic;
using osu.Game.Tournament.Configuration;
namespace osu.Game.Tournament.IO
@@ -15,7 +15,12 @@ namespace osu.Game.Tournament.IO
{
private const string default_tournament = "default";
private readonly Storage storage;
- private readonly Storage allTournaments;
+
+ ///
+ /// The storage where all tournaments are located.
+ ///
+ public readonly Storage AllTournaments;
+
private readonly TournamentStorageManager storageConfig;
public readonly Bindable CurrentTournament;
@@ -23,16 +28,16 @@ namespace osu.Game.Tournament.IO
: base(storage.GetStorageForDirectory("tournaments"), string.Empty)
{
this.storage = storage;
- allTournaments = UnderlyingStorage;
+ AllTournaments = UnderlyingStorage;
storageConfig = new TournamentStorageManager(storage);
if (storage.Exists("tournament.ini"))
{
- ChangeTargetStorage(allTournaments.GetStorageForDirectory(storageConfig.Get(StorageConfig.CurrentTournament)));
+ ChangeTargetStorage(AllTournaments.GetStorageForDirectory(storageConfig.Get(StorageConfig.CurrentTournament)));
}
else
- Migrate(allTournaments.GetStorageForDirectory(default_tournament));
+ Migrate(AllTournaments.GetStorageForDirectory(default_tournament));
CurrentTournament = storageConfig.GetBindable(StorageConfig.CurrentTournament);
Logger.Log("Using tournament storage: " + GetFullPath(string.Empty));
@@ -42,11 +47,11 @@ namespace osu.Game.Tournament.IO
private void updateTournament(ValueChangedEvent newTournament)
{
- ChangeTargetStorage(allTournaments.GetStorageForDirectory(newTournament.NewValue));
+ ChangeTargetStorage(AllTournaments.GetStorageForDirectory(newTournament.NewValue));
Logger.Log("Changing tournament storage: " + GetFullPath(string.Empty));
}
- public IEnumerable ListTournaments() => allTournaments.GetDirectories(string.Empty);
+ public IEnumerable ListTournaments() => AllTournaments.GetDirectories(string.Empty);
public override void Migrate(Storage newStorage)
{
diff --git a/osu.Game.Tournament/Models/StableInfo.cs b/osu.Game.Tournament/Models/StableInfo.cs
index 0b0050a245..d390f88d59 100644
--- a/osu.Game.Tournament/Models/StableInfo.cs
+++ b/osu.Game.Tournament/Models/StableInfo.cs
@@ -5,6 +5,7 @@ using System;
using System.IO;
using Newtonsoft.Json;
using osu.Framework.Platform;
+using osu.Game.Tournament.IO;
namespace osu.Game.Tournament.Models
{
@@ -24,13 +25,14 @@ namespace osu.Game.Tournament.Models
///
public event Action OnStableInfoSaved;
- private const string config_path = "tournament/stable.json";
+ private const string config_path = "stable.json";
private readonly Storage storage;
public StableInfo(Storage storage)
{
- this.storage = storage;
+ TournamentStorage tStorage = (TournamentStorage)storage;
+ this.storage = tStorage.AllTournaments;
if (!storage.Exists(config_path))
return;
diff --git a/osu.Game.Tournament/Screens/Editors/TeamEditorScreen.cs b/osu.Game.Tournament/Screens/Editors/TeamEditorScreen.cs
index 582f72429b..aa1be143ea 100644
--- a/osu.Game.Tournament/Screens/Editors/TeamEditorScreen.cs
+++ b/osu.Game.Tournament/Screens/Editors/TeamEditorScreen.cs
@@ -2,6 +2,7 @@
// See the LICENCE file in the repository root for full licence text.
using System.Collections.Generic;
+using System.Diagnostics;
using System.IO;
using System.Linq;
using Newtonsoft.Json;
@@ -43,10 +44,13 @@ namespace osu.Game.Tournament.Screens.Editors
private void addAllCountries()
{
List countries;
+
using (Stream stream = game.Resources.GetStream("Resources/countries.json"))
using (var sr = new StreamReader(stream))
countries = JsonConvert.DeserializeObject>(sr.ReadToEnd());
+ Debug.Assert(countries != null);
+
foreach (var c in countries)
Storage.Add(c);
}
diff --git a/osu.Game/Beatmaps/BeatmapInfo.cs b/osu.Game/Beatmaps/BeatmapInfo.cs
index a898e10e4f..bf7906bd5c 100644
--- a/osu.Game/Beatmaps/BeatmapInfo.cs
+++ b/osu.Game/Beatmaps/BeatmapInfo.cs
@@ -147,7 +147,7 @@ namespace osu.Game.Beatmaps
{
string version = string.IsNullOrEmpty(Version) ? string.Empty : $"[{Version}]";
- return $"{Metadata} {version}".Trim();
+ return $"{Metadata ?? BeatmapSet?.Metadata} {version}".Trim();
}
public bool Equals(BeatmapInfo other)
diff --git a/osu.Game/Input/Handlers/ReplayInputHandler.cs b/osu.Game/Input/Handlers/ReplayInputHandler.cs
index 93ed3ca884..fba1bee0b8 100644
--- a/osu.Game/Input/Handlers/ReplayInputHandler.cs
+++ b/osu.Game/Input/Handlers/ReplayInputHandler.cs
@@ -34,8 +34,6 @@ namespace osu.Game.Input.Handlers
public override bool IsActive => true;
- public override int Priority => 0;
-
public class ReplayState : IInput
where T : struct
{
diff --git a/osu.Game/Online/DownloadTrackingComposite.cs b/osu.Game/Online/DownloadTrackingComposite.cs
index 52042c266b..d9599481e7 100644
--- a/osu.Game/Online/DownloadTrackingComposite.cs
+++ b/osu.Game/Online/DownloadTrackingComposite.cs
@@ -123,13 +123,13 @@ namespace osu.Game.Online
{
if (attachedRequest.Progress == 1)
{
- State.Value = DownloadState.Importing;
Progress.Value = 1;
+ State.Value = DownloadState.Importing;
}
else
{
- State.Value = DownloadState.Downloading;
Progress.Value = attachedRequest.Progress;
+ State.Value = DownloadState.Downloading;
attachedRequest.Failure += onRequestFailure;
attachedRequest.DownloadProgressed += onRequestProgress;
diff --git a/osu.Game/Online/Leaderboards/LeaderboardScore.cs b/osu.Game/Online/Leaderboards/LeaderboardScore.cs
index 5608002513..da1bbd18c7 100644
--- a/osu.Game/Online/Leaderboards/LeaderboardScore.cs
+++ b/osu.Game/Online/Leaderboards/LeaderboardScore.cs
@@ -61,6 +61,9 @@ namespace osu.Game.Online.Leaderboards
[Resolved(CanBeNull = true)]
private SongSelect songSelect { get; set; }
+ [Resolved]
+ private ScoreManager scoreManager { get; set; }
+
public LeaderboardScore(ScoreInfo score, int? rank, bool allowHighlight = true)
{
this.score = score;
@@ -388,6 +391,9 @@ namespace osu.Game.Online.Leaderboards
if (score.Mods.Length > 0 && modsContainer.Any(s => s.IsHovered) && songSelect != null)
items.Add(new OsuMenuItem("Use these mods", MenuItemType.Highlighted, () => songSelect.Mods.Value = score.Mods));
+ if (score.Files.Count > 0)
+ items.Add(new OsuMenuItem("Export", MenuItemType.Standard, () => scoreManager.Export(score)));
+
if (score.ID != 0)
items.Add(new OsuMenuItem("Delete", MenuItemType.Destructive, () => dialogOverlay?.Push(new LocalScoreDeleteDialog(score))));
diff --git a/osu.Game/Online/Rooms/OnlinePlayBeatmapAvailablilityTracker.cs b/osu.Game/Online/Rooms/OnlinePlayBeatmapAvailablilityTracker.cs
index d6f4c45a75..8278162353 100644
--- a/osu.Game/Online/Rooms/OnlinePlayBeatmapAvailablilityTracker.cs
+++ b/osu.Game/Online/Rooms/OnlinePlayBeatmapAvailablilityTracker.cs
@@ -45,6 +45,9 @@ namespace osu.Game.Online.Rooms
Progress.BindValueChanged(_ =>
{
+ if (State.Value != DownloadState.Downloading)
+ return;
+
// incoming progress changes are going to be at a very high rate.
// we don't want to flood the network with this, so rate limit how often we send progress updates.
if (progressUpdate?.Completed != false)
diff --git a/osu.Game/OsuGameBase.cs b/osu.Game/OsuGameBase.cs
index e1c7b67a8c..7eef0f7158 100644
--- a/osu.Game/OsuGameBase.cs
+++ b/osu.Game/OsuGameBase.cs
@@ -429,6 +429,9 @@ namespace osu.Game
public async Task Import(params string[] paths)
{
+ if (paths.Length == 0)
+ return;
+
var extension = Path.GetExtension(paths.First())?.ToLowerInvariant();
foreach (var importer in fileImporters)
diff --git a/osu.Game/Overlays/Chat/DrawableChannel.cs b/osu.Game/Overlays/Chat/DrawableChannel.cs
index 86ce724390..5f9c00b36a 100644
--- a/osu.Game/Overlays/Chat/DrawableChannel.cs
+++ b/osu.Game/Overlays/Chat/DrawableChannel.cs
@@ -275,7 +275,8 @@ namespace osu.Game.Overlays.Chat
{
if (!UserScrolling)
{
- ScrollToEnd();
+ if (Current < ScrollableExtent)
+ ScrollToEnd();
lastExtent = ScrollableExtent;
}
});
diff --git a/osu.Game/Overlays/Settings/Sections/Input/RotationPresetButtons.cs b/osu.Game/Overlays/Settings/Sections/Input/RotationPresetButtons.cs
new file mode 100644
index 0000000000..3e8da9f7d0
--- /dev/null
+++ b/osu.Game/Overlays/Settings/Sections/Input/RotationPresetButtons.cs
@@ -0,0 +1,109 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Handlers.Tablet;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+
+namespace osu.Game.Overlays.Settings.Sections.Input
+{
+ internal class RotationPresetButtons : FillFlowContainer
+ {
+ private readonly ITabletHandler tabletHandler;
+
+ private Bindable rotation;
+
+ private const int height = 50;
+
+ public RotationPresetButtons(ITabletHandler tabletHandler)
+ {
+ this.tabletHandler = tabletHandler;
+
+ RelativeSizeAxes = Axes.X;
+ Height = height;
+
+ for (int i = 0; i < 360; i += 90)
+ {
+ var presetRotation = i;
+
+ Add(new RotationButton(i)
+ {
+ RelativeSizeAxes = Axes.X,
+ Height = height,
+ Width = 0.25f,
+ Text = $"{presetRotation}ยบ",
+ Action = () => tabletHandler.Rotation.Value = presetRotation,
+ });
+ }
+ }
+
+ protected override void LoadComplete()
+ {
+ base.LoadComplete();
+
+ rotation = tabletHandler.Rotation.GetBoundCopy();
+ rotation.BindValueChanged(val =>
+ {
+ foreach (var b in Children.OfType())
+ b.IsSelected = b.Preset == val.NewValue;
+ }, true);
+ }
+
+ public class RotationButton : TriangleButton
+ {
+ [Resolved]
+ private OsuColour colours { get; set; }
+
+ public readonly int Preset;
+
+ public RotationButton(int preset)
+ {
+ Preset = preset;
+ }
+
+ private bool isSelected;
+
+ public bool IsSelected
+ {
+ get => isSelected;
+ set
+ {
+ if (value == isSelected)
+ return;
+
+ isSelected = value;
+
+ if (IsLoaded)
+ updateColour();
+ }
+ }
+
+ protected override void LoadComplete()
+ {
+ base.LoadComplete();
+ updateColour();
+ }
+
+ private void updateColour()
+ {
+ if (isSelected)
+ {
+ BackgroundColour = colours.BlueDark;
+ Triangles.ColourDark = colours.BlueDarker;
+ Triangles.ColourLight = colours.Blue;
+ }
+ else
+ {
+ BackgroundColour = colours.Gray4;
+ Triangles.ColourDark = colours.Gray5;
+ Triangles.ColourLight = colours.Gray6;
+ }
+ }
+ }
+ }
+}
diff --git a/osu.Game/Overlays/Settings/Sections/Input/TabletAreaSelection.cs b/osu.Game/Overlays/Settings/Sections/Input/TabletAreaSelection.cs
index ecb8acce54..f61742093c 100644
--- a/osu.Game/Overlays/Settings/Sections/Input/TabletAreaSelection.cs
+++ b/osu.Game/Overlays/Settings/Sections/Input/TabletAreaSelection.cs
@@ -25,6 +25,8 @@ namespace osu.Game.Overlays.Settings.Sections.Input
private readonly Bindable areaOffset = new Bindable();
private readonly Bindable areaSize = new Bindable();
+ private readonly BindableNumber rotation = new BindableNumber();
+
private readonly IBindable tablet = new Bindable();
private OsuSpriteText tabletName;
@@ -124,6 +126,13 @@ namespace osu.Game.Overlays.Settings.Sections.Input
usableAreaText.Text = $"{(float)x / commonDivider}:{(float)y / commonDivider}";
}, true);
+ rotation.BindTo(handler.Rotation);
+ rotation.BindValueChanged(val =>
+ {
+ usableAreaContainer.RotateTo(val.NewValue, 100, Easing.OutQuint)
+ .OnComplete(_ => checkBounds()); // required as we are using SSDQ.
+ });
+
tablet.BindTo(handler.Tablet);
tablet.BindValueChanged(_ => Scheduler.AddOnce(updateTabletDetails));
diff --git a/osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs b/osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs
index bd0f7ddc4c..d770c18878 100644
--- a/osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs
+++ b/osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs
@@ -27,6 +27,8 @@ namespace osu.Game.Overlays.Settings.Sections.Input
private readonly BindableNumber sizeX = new BindableNumber { MinValue = 10 };
private readonly BindableNumber sizeY = new BindableNumber { MinValue = 10 };
+ private readonly BindableNumber rotation = new BindableNumber { MinValue = 0, MaxValue = 360 };
+
[Resolved]
private GameHost host { get; set; }
@@ -110,12 +112,6 @@ namespace osu.Game.Overlays.Settings.Sections.Input
}
},
new SettingsSlider
- {
- TransferValueOnCommit = true,
- LabelText = "Aspect Ratio",
- Current = aspectRatio
- },
- new SettingsSlider
{
TransferValueOnCommit = true,
LabelText = "X Offset",
@@ -127,6 +123,19 @@ namespace osu.Game.Overlays.Settings.Sections.Input
LabelText = "Y Offset",
Current = offsetY
},
+ new SettingsSlider
+ {
+ TransferValueOnCommit = true,
+ LabelText = "Rotation",
+ Current = rotation
+ },
+ new RotationPresetButtons(tabletHandler),
+ new SettingsSlider
+ {
+ TransferValueOnCommit = true,
+ LabelText = "Aspect Ratio",
+ Current = aspectRatio
+ },
new SettingsCheckbox
{
LabelText = "Lock aspect ratio",
@@ -153,6 +162,8 @@ namespace osu.Game.Overlays.Settings.Sections.Input
{
base.LoadComplete();
+ rotation.BindTo(tabletHandler.Rotation);
+
areaOffset.BindTo(tabletHandler.AreaOffset);
areaOffset.BindValueChanged(val =>
{
diff --git a/osu.Game/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index e927951d0a..736fc47dee 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -438,6 +438,8 @@ namespace osu.Game.Rulesets.Edit
///
public abstract bool CursorInPlacementArea { get; }
+ public virtual string ConvertSelectionToString() => string.Empty;
+
#region IPositionSnapProvider
public abstract SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition);
diff --git a/osu.Game/Rulesets/RulesetStore.cs b/osu.Game/Rulesets/RulesetStore.cs
index deabea57ef..4261ee3d47 100644
--- a/osu.Game/Rulesets/RulesetStore.cs
+++ b/osu.Game/Rulesets/RulesetStore.cs
@@ -173,7 +173,7 @@ namespace osu.Game.Rulesets
{
var filename = Path.GetFileNameWithoutExtension(file);
- if (loadedAssemblies.Values.Any(t => t.Namespace == filename))
+ if (loadedAssemblies.Values.Any(t => Path.GetFileNameWithoutExtension(t.Assembly.Location) == filename))
return;
try
diff --git a/osu.Game/Rulesets/Scoring/ScoreProcessor.cs b/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
index 2024290460..b81fa79345 100644
--- a/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
+++ b/osu.Game/Rulesets/Scoring/ScoreProcessor.cs
@@ -337,7 +337,7 @@ namespace osu.Game.Rulesets.Scoring
score.TotalScore = (long)Math.Round(GetStandardisedScore());
score.Combo = Combo.Value;
score.MaxCombo = HighestCombo.Value;
- score.Accuracy = Math.Round(Accuracy.Value, 4);
+ score.Accuracy = Accuracy.Value;
score.Rank = Rank.Value;
score.Date = DateTimeOffset.Now;
diff --git a/osu.Game/Scoring/ScoreInfo.cs b/osu.Game/Scoring/ScoreInfo.cs
index f5192f3a40..ef11c19e3f 100644
--- a/osu.Game/Scoring/ScoreInfo.cs
+++ b/osu.Game/Scoring/ScoreInfo.cs
@@ -30,7 +30,7 @@ namespace osu.Game.Scoring
public long TotalScore { get; set; }
[JsonProperty("accuracy")]
- [Column(TypeName = "DECIMAL(1,4)")]
+ [Column(TypeName = "DECIMAL(1,4)")] // TODO: This data type is wrong (should contain more precision). But at the same time, we probably don't need to be storing this in the database.
public double Accuracy { get; set; }
[JsonIgnore]
diff --git a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
index 79f457c050..5ab557804e 100644
--- a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
@@ -10,6 +10,7 @@ using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Input;
+using osu.Framework.Input.Events;
using osu.Game.Audio;
using osu.Game.Graphics.UserInterface;
using osu.Game.Rulesets.Edit;
@@ -19,6 +20,7 @@ using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Objects.Types;
using osu.Game.Screens.Edit.Components.TernaryButtons;
using osuTK;
+using osuTK.Input;
namespace osu.Game.Screens.Edit.Compose.Components
{
@@ -70,6 +72,50 @@ namespace osu.Game.Screens.Edit.Compose.Components
}
}
+ protected override bool OnKeyDown(KeyDownEvent e)
+ {
+ if (e.ControlPressed)
+ {
+ switch (e.Key)
+ {
+ case Key.Left:
+ moveSelection(new Vector2(-1, 0));
+ return true;
+
+ case Key.Right:
+ moveSelection(new Vector2(1, 0));
+ return true;
+
+ case Key.Up:
+ moveSelection(new Vector2(0, -1));
+ return true;
+
+ case Key.Down:
+ moveSelection(new Vector2(0, 1));
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ ///
+ /// Move the current selection spatially by the specified delta, in gamefield coordinates (ie. the same coordinates as the blueprints).
+ ///
+ ///
+ private void moveSelection(Vector2 delta)
+ {
+ var firstBlueprint = SelectionHandler.SelectedBlueprints.FirstOrDefault();
+
+ if (firstBlueprint == null)
+ return;
+
+ // convert to game space coordinates
+ delta = firstBlueprint.ToScreenSpace(delta) - firstBlueprint.ToScreenSpace(Vector2.Zero);
+
+ SelectionHandler.HandleMovement(new MoveSelectionEvent(firstBlueprint, firstBlueprint.ScreenSpaceSelectionPoint + delta));
+ }
+
private void updatePlacementNewCombo()
{
if (currentPlacement?.HitObject is IHasComboInformation c)
diff --git a/osu.Game/Screens/Edit/Compose/Components/HitObjectOrderedSelectionContainer.cs b/osu.Game/Screens/Edit/Compose/Components/HitObjectOrderedSelectionContainer.cs
index 9e95fe4fa1..d612cf3fe0 100644
--- a/osu.Game/Screens/Edit/Compose/Components/HitObjectOrderedSelectionContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/HitObjectOrderedSelectionContainer.cs
@@ -71,7 +71,13 @@ namespace osu.Game.Screens.Edit.Compose.Components
// Put earlier blueprints towards the end of the list, so they handle input first
int i = yObj.HitObject.StartTime.CompareTo(xObj.HitObject.StartTime);
- return i == 0 ? CompareReverseChildID(x, y) : i;
+
+ if (i != 0) return i;
+
+ // Fall back to end time if the start time is equal.
+ i = yObj.HitObject.GetEndTime().CompareTo(xObj.HitObject.GetEndTime());
+
+ return i == 0 ? CompareReverseChildID(y, x) : i;
}
}
}
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs
index 1fc529910b..3623f8ad8e 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs
@@ -2,6 +2,8 @@
// See the LICENCE file in the repository root for full licence text.
using System;
+using System.Collections.Generic;
+using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics;
@@ -121,14 +123,55 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
}
base.Update();
+
+ updateStacking();
+ }
+
+ private void updateStacking()
+ {
+ // because only blueprints of objects which are alive (via pooling) are displayed in the timeline, it's feasible to do this every-update.
+
+ const int stack_offset = 5;
+
+ // after the stack gets this tall, we can presume there is space underneath to draw subsequent blueprints.
+ const int stack_reset_count = 3;
+
+ Stack currentConcurrentObjects = new Stack();
+
+ foreach (var b in SelectionBlueprints.Reverse())
+ {
+ // remove objects from the stack as long as their end time is in the past.
+ while (currentConcurrentObjects.TryPeek(out HitObject hitObject))
+ {
+ if (Precision.AlmostBigger(hitObject.GetEndTime(), b.HitObject.StartTime, 1))
+ break;
+
+ currentConcurrentObjects.Pop();
+ }
+
+ // if the stack gets too high, we should have space below it to display the next batch of objects.
+ // importantly, we only do this if time has incremented, else a stack of hitobjects all at the same time value would start to overlap themselves.
+ if (currentConcurrentObjects.TryPeek(out HitObject h) && !Precision.AlmostEquals(h.StartTime, b.HitObject.StartTime, 1))
+ {
+ if (currentConcurrentObjects.Count >= stack_reset_count)
+ currentConcurrentObjects.Clear();
+ }
+
+ b.Y = -(stack_offset * currentConcurrentObjects.Count);
+
+ currentConcurrentObjects.Push(b.HitObject);
+ }
}
protected override SelectionHandler CreateSelectionHandler() => new TimelineSelectionHandler();
- protected override SelectionBlueprint CreateBlueprintFor(HitObject hitObject) => new TimelineHitObjectBlueprint(hitObject)
+ protected override SelectionBlueprint CreateBlueprintFor(HitObject hitObject)
{
- OnDragHandled = handleScrollViaDrag
- };
+ return new TimelineHitObjectBlueprint(hitObject)
+ {
+ OnDragHandled = handleScrollViaDrag
+ };
+ }
protected override DragBox CreateDragBox(Action performSelect) => new TimelineDragBox(performSelect);
@@ -203,7 +246,13 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
Box.X = Math.Min(rescaledStart, rescaledEnd);
Box.Width = Math.Abs(rescaledStart - rescaledEnd);
- PerformSelection?.Invoke(Box.ScreenSpaceDrawQuad.AABBFloat);
+ var boxScreenRect = Box.ScreenSpaceDrawQuad.AABBFloat;
+
+ // we don't care about where the hitobjects are vertically. in cases like stacking display, they may be outside the box without this adjustment.
+ boxScreenRect.Y -= boxScreenRect.Height;
+ boxScreenRect.Height *= 2;
+
+ PerformSelection?.Invoke(boxScreenRect);
}
public override void Hide()
diff --git a/osu.Game/Screens/Edit/Compose/ComposeScreen.cs b/osu.Game/Screens/Edit/Compose/ComposeScreen.cs
index 81b1195a40..61056aeced 100644
--- a/osu.Game/Screens/Edit/Compose/ComposeScreen.cs
+++ b/osu.Game/Screens/Edit/Compose/ComposeScreen.cs
@@ -2,11 +2,16 @@
// See the LICENCE file in the repository root for full licence text.
using System.Diagnostics;
+using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
+using osu.Framework.Input;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Platform;
using osu.Game.Beatmaps;
+using osu.Game.Extensions;
using osu.Game.Rulesets;
using osu.Game.Rulesets.Edit;
using osu.Game.Screens.Edit.Compose.Components.Timeline;
@@ -14,11 +19,17 @@ using osu.Game.Skinning;
namespace osu.Game.Screens.Edit.Compose
{
- public class ComposeScreen : EditorScreenWithTimeline
+ public class ComposeScreen : EditorScreenWithTimeline, IKeyBindingHandler
{
[Resolved]
private IBindable beatmap { get; set; }
+ [Resolved]
+ private GameHost host { get; set; }
+
+ [Resolved]
+ private EditorClock clock { get; set; }
+
private HitObjectComposer composer;
public ComposeScreen()
@@ -72,5 +83,34 @@ namespace osu.Game.Screens.Edit.Compose
// this is intentionally done in two stages to ensure things are in a loaded state before exposing the ruleset to skin sources.
return beatmapSkinProvider.WithChild(rulesetSkinProvider.WithChild(content));
}
+
+ #region Input Handling
+
+ public bool OnPressed(PlatformAction action)
+ {
+ if (action.ActionType == PlatformActionType.Copy)
+ host.GetClipboard().SetText(formatSelectionAsString());
+
+ return false;
+ }
+
+ public void OnReleased(PlatformAction action)
+ {
+ }
+
+ private string formatSelectionAsString()
+ {
+ if (composer == null)
+ return string.Empty;
+
+ double displayTime = EditorBeatmap.SelectedHitObjects.OrderBy(h => h.StartTime).FirstOrDefault()?.StartTime ?? clock.CurrentTime;
+ string selectionAsString = composer.ConvertSelectionToString();
+
+ return !string.IsNullOrEmpty(selectionAsString)
+ ? $"{displayTime.ToEditorFormattedString()} ({selectionAsString}) - "
+ : $"{displayTime.ToEditorFormattedString()} - ";
+ }
+
+ #endregion
}
}
diff --git a/osu.Game/Screens/Edit/Editor.cs b/osu.Game/Screens/Edit/Editor.cs
index 0c24eb6a4d..389eb79797 100644
--- a/osu.Game/Screens/Edit/Editor.cs
+++ b/osu.Game/Screens/Edit/Editor.cs
@@ -16,7 +16,6 @@ using osu.Framework.Input;
using osu.Framework.Input.Bindings;
using osu.Framework.Input.Events;
using osu.Framework.Logging;
-using osu.Framework.Platform;
using osu.Framework.Screens;
using osu.Framework.Timing;
using osu.Game.Beatmaps;
@@ -103,7 +102,7 @@ namespace osu.Game.Screens.Edit
private MusicController music { get; set; }
[BackgroundDependencyLoader]
- private void load(OsuColour colours, GameHost host, OsuConfigManager config)
+ private void load(OsuColour colours, OsuConfigManager config)
{
var loadableBeatmap = Beatmap.Value;
diff --git a/osu.Game/Screens/Edit/Timing/DifficultySection.cs b/osu.Game/Screens/Edit/Timing/DifficultySection.cs
index 9d80ca0b14..97d110c502 100644
--- a/osu.Game/Screens/Edit/Timing/DifficultySection.cs
+++ b/osu.Game/Screens/Edit/Timing/DifficultySection.cs
@@ -28,7 +28,16 @@ namespace osu.Game.Screens.Edit.Timing
{
if (point.NewValue != null)
{
- multiplierSlider.Current = point.NewValue.SpeedMultiplierBindable;
+ var selectedPointBindable = point.NewValue.SpeedMultiplierBindable;
+
+ // there may be legacy control points, which contain infinite precision for compatibility reasons (see LegacyDifficultyControlPoint).
+ // generally that level of precision could only be set by externally editing the .osu file, so at the point
+ // a user is looking to update this within the editor it should be safe to obliterate this additional precision.
+ double expectedPrecision = new DifficultyControlPoint().SpeedMultiplierBindable.Precision;
+ if (selectedPointBindable.Precision < expectedPrecision)
+ selectedPointBindable.Precision = expectedPrecision;
+
+ multiplierSlider.Current = selectedPointBindable;
multiplierSlider.Current.BindValueChanged(_ => ChangeHandler?.SaveState());
}
}
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs b/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
index f13d623eae..f24577a8a5 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs
@@ -2,7 +2,6 @@
// See the LICENCE file in the repository root for full licence text.
using System;
-using System.Diagnostics;
using System.Linq;
using JetBrains.Annotations;
using osu.Framework.Allocation;
@@ -170,7 +169,9 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
private void joinRequested(Room room)
{
- Debug.Assert(joiningRoomOperation == null);
+ if (joiningRoomOperation != null)
+ return;
+
joiningRoomOperation = ongoingOperationTracker?.BeginOperation();
RoomManager?.JoinRoom(room, r =>
diff --git a/osu.Game/Screens/Play/HUD/LegacyComboCounter.cs b/osu.Game/Screens/Play/HUD/LegacyComboCounter.cs
index 81183a425a..b4604c0d01 100644
--- a/osu.Game/Screens/Play/HUD/LegacyComboCounter.cs
+++ b/osu.Game/Screens/Play/HUD/LegacyComboCounter.cs
@@ -6,7 +6,6 @@ using osu.Framework.Bindables;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Sprites;
-using osu.Game.Graphics.Sprites;
using osu.Game.Skinning;
using osuTK;
@@ -84,16 +83,16 @@ namespace osu.Game.Screens.Play.HUD
{
InternalChildren = new[]
{
- popOutCount = createSpriteText().With(s =>
+ popOutCount = new LegacySpriteText(skin, LegacyFont.Combo)
{
- s.Alpha = 0;
- s.Margin = new MarginPadding(0.05f);
- s.Blending = BlendingParameters.Additive;
- }),
- displayedCountSpriteText = createSpriteText().With(s =>
+ Alpha = 0,
+ Margin = new MarginPadding(0.05f),
+ Blending = BlendingParameters.Additive,
+ },
+ displayedCountSpriteText = new LegacySpriteText(skin, LegacyFont.Combo)
{
- s.Alpha = 0;
- })
+ Alpha = 0,
+ },
};
Current.ValueChanged += combo => updateCount(combo.NewValue == 0);
@@ -247,7 +246,5 @@ namespace osu.Game.Screens.Play.HUD
double difference = currentValue > newValue ? currentValue - newValue : newValue - currentValue;
return difference * rolling_duration;
}
-
- private OsuSpriteText createSpriteText() => (OsuSpriteText)skin.GetDrawableComponent(new HUDSkinComponent(HUDSkinComponents.ComboText));
}
}
diff --git a/osu.Game/Screens/Play/PlayerLoader.cs b/osu.Game/Screens/Play/PlayerLoader.cs
index 7d906cdc5b..679b3c7313 100644
--- a/osu.Game/Screens/Play/PlayerLoader.cs
+++ b/osu.Game/Screens/Play/PlayerLoader.cs
@@ -309,10 +309,8 @@ namespace osu.Game.Screens.Play
if (!this.IsCurrentScreen())
return;
- var restartCount = player?.RestartCount + 1 ?? 0;
-
player = createPlayer();
- player.RestartCount = restartCount;
+ player.RestartCount = restartCount++;
player.RestartRequested = restartRequested;
LoadTask = LoadComponentAsync(player, _ => MetadataInfo.Loading = false);
@@ -428,6 +426,8 @@ namespace osu.Game.Screens.Play
private Bindable muteWarningShownOnce;
+ private int restartCount;
+
private void showMuteWarningIfNeeded()
{
if (!muteWarningShownOnce.Value)
diff --git a/osu.Game/Skinning/HUDSkinComponents.cs b/osu.Game/Skinning/HUDSkinComponents.cs
index b01be2d5a0..a345e060e5 100644
--- a/osu.Game/Skinning/HUDSkinComponents.cs
+++ b/osu.Game/Skinning/HUDSkinComponents.cs
@@ -9,7 +9,5 @@ namespace osu.Game.Skinning
ScoreCounter,
AccuracyCounter,
HealthDisplay,
- ScoreText,
- ComboText,
}
}
diff --git a/osu.Game/Skinning/LegacyAccuracyCounter.cs b/osu.Game/Skinning/LegacyAccuracyCounter.cs
index 5eda374337..7d6f1dc916 100644
--- a/osu.Game/Skinning/LegacyAccuracyCounter.cs
+++ b/osu.Game/Skinning/LegacyAccuracyCounter.cs
@@ -29,9 +29,11 @@ namespace osu.Game.Skinning
[Resolved(canBeNull: true)]
private HUDOverlay hud { get; set; }
- protected sealed override OsuSpriteText CreateSpriteText()
- => (OsuSpriteText)skin?.GetDrawableComponent(new HUDSkinComponent(HUDSkinComponents.ScoreText))
- ?.With(s => s.Anchor = s.Origin = Anchor.TopRight);
+ protected sealed override OsuSpriteText CreateSpriteText() => new LegacySpriteText(skin, LegacyFont.Score)
+ {
+ Anchor = Anchor.TopRight,
+ Origin = Anchor.TopRight,
+ };
protected override void Update()
{
diff --git a/osu.Game/Skinning/LegacyFont.cs b/osu.Game/Skinning/LegacyFont.cs
new file mode 100644
index 0000000000..d1971cb84c
--- /dev/null
+++ b/osu.Game/Skinning/LegacyFont.cs
@@ -0,0 +1,15 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Skinning
+{
+ ///
+ /// The type of legacy font to use for s.
+ ///
+ public enum LegacyFont
+ {
+ Score,
+ Combo,
+ HitCircle,
+ }
+}
diff --git a/osu.Game/Skinning/LegacyRollingCounter.cs b/osu.Game/Skinning/LegacyRollingCounter.cs
index 8aa9d4e9af..0261db0e64 100644
--- a/osu.Game/Skinning/LegacyRollingCounter.cs
+++ b/osu.Game/Skinning/LegacyRollingCounter.cs
@@ -4,7 +4,6 @@
using System;
using osu.Game.Graphics.Sprites;
using osu.Game.Graphics.UserInterface;
-using osuTK;
namespace osu.Game.Skinning
{
@@ -14,9 +13,7 @@ namespace osu.Game.Skinning
public class LegacyRollingCounter : RollingCounter
{
private readonly ISkin skin;
-
- private readonly string fontName;
- private readonly float fontOverlap;
+ private readonly LegacyFont font;
protected override bool IsRollingProportional => true;
@@ -24,17 +21,11 @@ namespace osu.Game.Skinning
/// Creates a new .
///
/// The from which to get counter number sprites.
- /// The name of the legacy font to use.
- ///
- /// The numeric overlap of number sprites to use.
- /// A positive number will bring the number sprites closer together, while a negative number
- /// will split them apart more.
- ///
- public LegacyRollingCounter(ISkin skin, string fontName, float fontOverlap)
+ /// The legacy font to use for the counter.
+ public LegacyRollingCounter(ISkin skin, LegacyFont font)
{
this.skin = skin;
- this.fontName = fontName;
- this.fontOverlap = fontOverlap;
+ this.font = font;
}
protected override double GetProportionalDuration(int currentValue, int newValue)
@@ -42,10 +33,6 @@ namespace osu.Game.Skinning
return Math.Abs(newValue - currentValue) * 75.0;
}
- protected sealed override OsuSpriteText CreateSpriteText() =>
- new LegacySpriteText(skin, fontName)
- {
- Spacing = new Vector2(-fontOverlap, 0f)
- };
+ protected sealed override OsuSpriteText CreateSpriteText() => new LegacySpriteText(skin, font);
}
}
diff --git a/osu.Game/Skinning/LegacyScoreCounter.cs b/osu.Game/Skinning/LegacyScoreCounter.cs
index 5bffeff5a8..1d330ef495 100644
--- a/osu.Game/Skinning/LegacyScoreCounter.cs
+++ b/osu.Game/Skinning/LegacyScoreCounter.cs
@@ -33,8 +33,10 @@ namespace osu.Game.Skinning
Margin = new MarginPadding(10);
}
- protected sealed override OsuSpriteText CreateSpriteText()
- => (OsuSpriteText)skin.GetDrawableComponent(new HUDSkinComponent(HUDSkinComponents.ScoreText))
- .With(s => s.Anchor = s.Origin = Anchor.TopRight);
+ protected sealed override OsuSpriteText CreateSpriteText() => new LegacySpriteText(skin, LegacyFont.Score)
+ {
+ Anchor = Anchor.TopRight,
+ Origin = Anchor.TopRight,
+ };
}
}
diff --git a/osu.Game/Skinning/LegacySkin.cs b/osu.Game/Skinning/LegacySkin.cs
index 12abc4d867..eae3b69233 100644
--- a/osu.Game/Skinning/LegacySkin.cs
+++ b/osu.Game/Skinning/LegacySkin.cs
@@ -18,7 +18,6 @@ using osu.Game.Beatmaps.Formats;
using osu.Game.IO;
using osu.Game.Rulesets.Scoring;
using osu.Game.Screens.Play.HUD;
-using osuTK;
using osuTK.Graphics;
namespace osu.Game.Skinning
@@ -320,19 +319,13 @@ namespace osu.Game.Skinning
return null;
}
- private string scorePrefix => GetConfig(LegacySkinConfiguration.LegacySetting.ScorePrefix)?.Value ?? "score";
-
- private string comboPrefix => GetConfig(LegacySkinConfiguration.LegacySetting.ComboPrefix)?.Value ?? "score";
-
- private bool hasScoreFont => this.HasFont(scorePrefix);
-
public override Drawable GetDrawableComponent(ISkinComponent component)
{
switch (component)
{
case HUDSkinComponent hudComponent:
{
- if (!hasScoreFont)
+ if (!this.HasFont(LegacyFont.Score))
return null;
switch (hudComponent.Component)
@@ -348,18 +341,6 @@ namespace osu.Game.Skinning
case HUDSkinComponents.HealthDisplay:
return new LegacyHealthDisplay(this);
-
- case HUDSkinComponents.ComboText:
- return new LegacySpriteText(this, comboPrefix)
- {
- Spacing = new Vector2(-(GetConfig(LegacySkinConfiguration.LegacySetting.ComboOverlap)?.Value ?? -2), 0)
- };
-
- case HUDSkinComponents.ScoreText:
- return new LegacySpriteText(this, scorePrefix)
- {
- Spacing = new Vector2(-(GetConfig(LegacySkinConfiguration.LegacySetting.ScoreOverlap)?.Value ?? -2), 0)
- };
}
return null;
diff --git a/osu.Game/Skinning/LegacySkinConfiguration.cs b/osu.Game/Skinning/LegacySkinConfiguration.cs
index 84a834ec22..20d1da8aaa 100644
--- a/osu.Game/Skinning/LegacySkinConfiguration.cs
+++ b/osu.Game/Skinning/LegacySkinConfiguration.cs
@@ -19,6 +19,8 @@ namespace osu.Game.Skinning
ComboOverlap,
ScorePrefix,
ScoreOverlap,
+ HitCirclePrefix,
+ HitCircleOverlap,
AnimationFramerate,
LayeredHitSounds
}
diff --git a/osu.Game/Skinning/LegacySkinExtensions.cs b/osu.Game/Skinning/LegacySkinExtensions.cs
index a7c084998d..d8fb1fa664 100644
--- a/osu.Game/Skinning/LegacySkinExtensions.cs
+++ b/osu.Game/Skinning/LegacySkinExtensions.cs
@@ -1,6 +1,7 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
+using System;
using System.Collections.Generic;
using System.Linq;
using osu.Framework.Allocation;
@@ -63,8 +64,51 @@ namespace osu.Game.Skinning
}
}
- public static bool HasFont(this ISkin source, string fontPrefix)
- => source.GetTexture($"{fontPrefix}-0") != null;
+ public static bool HasFont(this ISkin source, LegacyFont font)
+ {
+ return source.GetTexture($"{source.GetFontPrefix(font)}-0") != null;
+ }
+
+ public static string GetFontPrefix(this ISkin source, LegacyFont font)
+ {
+ switch (font)
+ {
+ case LegacyFont.Score:
+ return source.GetConfig(LegacySetting.ScorePrefix)?.Value ?? "score";
+
+ case LegacyFont.Combo:
+ return source.GetConfig(LegacySetting.ComboPrefix)?.Value ?? "score";
+
+ case LegacyFont.HitCircle:
+ return source.GetConfig(LegacySetting.HitCirclePrefix)?.Value ?? "default";
+
+ default:
+ throw new ArgumentOutOfRangeException(nameof(font));
+ }
+ }
+
+ ///
+ /// Returns the numeric overlap of number sprites to use.
+ /// A positive number will bring the number sprites closer together, while a negative number
+ /// will split them apart more.
+ ///
+ public static float GetFontOverlap(this ISkin source, LegacyFont font)
+ {
+ switch (font)
+ {
+ case LegacyFont.Score:
+ return source.GetConfig(LegacySetting.ScoreOverlap)?.Value ?? 0f;
+
+ case LegacyFont.Combo:
+ return source.GetConfig(LegacySetting.ComboOverlap)?.Value ?? 0f;
+
+ case LegacyFont.HitCircle:
+ return source.GetConfig(LegacySetting.HitCircleOverlap)?.Value ?? -2f;
+
+ default:
+ throw new ArgumentOutOfRangeException(nameof(font));
+ }
+ }
public class SkinnableTextureAnimation : TextureAnimation
{
diff --git a/osu.Game/Skinning/LegacySpriteText.cs b/osu.Game/Skinning/LegacySpriteText.cs
index 5d0e312f7c..c55400e219 100644
--- a/osu.Game/Skinning/LegacySpriteText.cs
+++ b/osu.Game/Skinning/LegacySpriteText.cs
@@ -5,6 +5,7 @@ using System.Threading.Tasks;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Text;
using osu.Game.Graphics.Sprites;
+using osuTK;
namespace osu.Game.Skinning
{
@@ -16,12 +17,14 @@ namespace osu.Game.Skinning
protected override char[] FixedWidthExcludeCharacters => new[] { ',', '.', '%', 'x' };
- public LegacySpriteText(ISkin skin, string font = "score")
+ public LegacySpriteText(ISkin skin, LegacyFont font)
{
Shadow = false;
UseFullGlyphHeight = false;
- Font = new FontUsage(font, 1, fixedWidth: true);
+ Font = new FontUsage(skin.GetFontPrefix(font), 1, fixedWidth: true);
+ Spacing = new Vector2(-skin.GetFontOverlap(font), 0);
+
glyphStore = new LegacyGlyphStore(skin);
}
diff --git a/osu.Game/Users/UserStatistics.cs b/osu.Game/Users/UserStatistics.cs
index dc926898fc..5ddcd86d28 100644
--- a/osu.Game/Users/UserStatistics.cs
+++ b/osu.Game/Users/UserStatistics.cs
@@ -42,10 +42,10 @@ namespace osu.Game.Users
public long RankedScore;
[JsonProperty(@"hit_accuracy")]
- public decimal Accuracy;
+ public double Accuracy;
[JsonIgnore]
- public string DisplayAccuracy => Accuracy.FormatAccuracy();
+ public string DisplayAccuracy => (Accuracy / 100).FormatAccuracy();
[JsonProperty(@"play_count")]
public int PlayCount;
diff --git a/osu.Game/Utils/FormatUtils.cs b/osu.Game/Utils/FormatUtils.cs
index 2578d8d835..df1b6cf00d 100644
--- a/osu.Game/Utils/FormatUtils.cs
+++ b/osu.Game/Utils/FormatUtils.cs
@@ -1,6 +1,8 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
+using System;
+using System.Globalization;
using Humanizer;
namespace osu.Game.Utils
@@ -10,16 +12,19 @@ namespace osu.Game.Utils
///
/// Turns the provided accuracy into a percentage with 2 decimal places.
///
- /// The accuracy to be formatted
+ /// The accuracy to be formatted.
+ /// An optional format provider.
/// formatted accuracy in percentage
- public static string FormatAccuracy(this double accuracy) => $"{accuracy:0.00%}";
+ public static string FormatAccuracy(this double accuracy, IFormatProvider formatProvider = null)
+ {
+ // for the sake of display purposes, we don't want to show a user a "rounded up" percentage to the next whole number.
+ // ie. a score which gets 89.99999% shouldn't ever show as 90%.
+ // the reasoning for this is that cutoffs for grade increases are at whole numbers and displaying the required
+ // percentile with a non-matching grade is confusing.
+ accuracy = Math.Floor(accuracy * 10000) / 10000;
- ///
- /// Turns the provided accuracy into a percentage with 2 decimal places.
- ///
- /// The accuracy to be formatted
- /// formatted accuracy in percentage
- public static string FormatAccuracy(this decimal accuracy) => $"{accuracy:0.00}%";
+ return accuracy.ToString("0.00%", formatProvider ?? CultureInfo.CurrentCulture);
+ }
///
/// Formats the supplied rank/leaderboard position in a consistent, simplified way.
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index b90c938a8b..6a7f7e7026 100644
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@@ -18,20 +18,20 @@
-
+
-
-
-
+
+
+
-
-
+
+
-
+
diff --git a/osu.iOS.props b/osu.iOS.props
index ce182a3054..4aa3ad1c61 100644
--- a/osu.iOS.props
+++ b/osu.iOS.props
@@ -70,7 +70,7 @@
-
+
@@ -93,7 +93,7 @@
-
+