h1or4dme8/osu-lazer
1
0
Fork 0
mirror of https://github.com/ppy/osu.git synced 2024-12-13 07:43:00 +08:00
Code Issues Releases Wiki Activity

Rename all remaining cases

Browse Source
This commit is contained in:
Dean Herbert 2021-10-03 00:55:29 +09:00
parent 973c31132b
commit ec61c3c5ee
58 changed files with 342 additions and 341 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
osu.Desktop/DiscordRichPresence.cs
View File

@ -140,10 +140,10 @@ namespace osu.Desktop
switch (activity)
{
case UserActivity.InGame game:
return game.Beatmap.ToString();
return game.BeatmapInfo.ToString();
case UserActivity.Editing edit:
return edit.Beatmap.ToString();
return edit.BeatmapInfo.ToString();
case UserActivity.InLobby lobby:
return privacyMode.Value == DiscordRichPresenceMode.Limited ? string.Empty : lobby.Room.Name.Value;

4
osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
View File

@ -71,9 +71,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
originalTargetColumns = TargetColumns;
}
public static int GetColumnCountForNonConvert(BeatmapInfo beatmap)
public static int GetColumnCountForNonConvert(BeatmapInfo beatmapInfo)
{
var roundedCircleSize = Math.Round(beatmap.BaseDifficulty.CircleSize);
var roundedCircleSize = Math.Round(beatmapInfo.BaseDifficulty.CircleSize);
return (int)Math.Max(1, roundedCircleSize);
}

4
osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs
View File

@ -13,9 +13,9 @@ namespace osu.Game.Rulesets.Mania
{
private FilterCriteria.OptionalRange<float> keys;
public bool Matches(BeatmapInfo beatmap)
public bool Matches(BeatmapInfo beatmapInfo)
{
return !keys.HasFilter || (beatmap.RulesetID == new ManiaRuleset().LegacyID && keys.IsInRange(ManiaBeatmapConverter.GetColumnCountForNonConvert(beatmap)));
return !keys.HasFilter || (beatmapInfo.RulesetID == new ManiaRuleset().LegacyID && keys.IsInRange(ManiaBeatmapConverter.GetColumnCountForNonConvert(beatmapInfo)));
}
public bool TryParseCustomKeywordCriteria(string key, Operator op, string value)

6
osu.Game.Tests/Beatmaps/IO/ImportBeatmapTest.cs
View File

@ -945,13 +945,13 @@ namespace osu.Game.Tests.Beatmaps.IO
Assert.IsTrue(manager.QueryBeatmapSets(_ => true).First().DeletePending);
}
private static Task createScoreForBeatmap(OsuGameBase osu, BeatmapInfo beatmap)
private static Task createScoreForBeatmap(OsuGameBase osu, BeatmapInfo beatmapInfo)
{
return ImportScoreTest.LoadScoreIntoOsu(osu, new ScoreInfo
{
OnlineScoreID = 2,
Beatmap = beatmap,
BeatmapInfoID = beatmap.ID
Beatmap = beatmapInfo,
BeatmapInfoID = beatmapInfo.ID
}, new ImportScoreTest.TestArchiveReader());
}

2
osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs
View File

@ -239,7 +239,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
match = shouldMatch;
}
public bool Matches(BeatmapInfo beatmap) => match;
public bool Matches(BeatmapInfo beatmapInfo) => match;
public bool TryParseCustomKeywordCriteria(string key, Operator op, string value) => false;
}
}

2
osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs
View File

@ -256,7 +256,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
{
public string CustomValue { get; set; }
public bool Matches(BeatmapInfo beatmap) => true;
public bool Matches(BeatmapInfo beatmapInfo) => true;
public bool TryParseCustomKeywordCriteria(string key, Operator op, string value)
{

2
osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
View File

@ -233,7 +233,7 @@ namespace osu.Game.Tests.Visual.Online
});
});
AddAssert("shown beatmaps of current ruleset", () => overlay.Header.HeaderContent.Picker.Difficulties.All(b => b.Beatmap.Ruleset.Equals(overlay.Header.RulesetSelector.Current.Value)));
AddAssert("shown beatmaps of current ruleset", () => overlay.Header.HeaderContent.Picker.Difficulties.All(b => b.BeatmapInfo.Ruleset.Equals(overlay.Header.RulesetSelector.Current.Value)));
AddAssert("left-most beatmap selected", () => overlay.Header.HeaderContent.Picker.Difficulties.First().State == BeatmapPicker.DifficultySelectorState.Selected);
}

8
osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlaySuccessRate.cs
View File

@ -58,10 +58,10 @@ namespace osu.Game.Tests.Visual.Online
var firstBeatmap = createBeatmap();
var secondBeatmap = createBeatmap();
AddStep("set first set", () => successRate.Beatmap = firstBeatmap);
AddStep("set first set", () => successRate.BeatmapInfo = firstBeatmap);
AddAssert("ratings set", () => successRate.Graph.Metrics == firstBeatmap.Metrics);
AddStep("set second set", () => successRate.Beatmap = secondBeatmap);
AddStep("set second set", () => successRate.BeatmapInfo = secondBeatmap);
AddAssert("ratings set", () => successRate.Graph.Metrics == secondBeatmap.Metrics);
static BeatmapInfo createBeatmap() => new BeatmapInfo
@ -77,7 +77,7 @@ namespace osu.Game.Tests.Visual.Online
[Test]
public void TestOnlyFailMetrics()
{
AddStep("set beatmap", () => successRate.Beatmap = new BeatmapInfo
AddStep("set beatmap", () => successRate.BeatmapInfo = new BeatmapInfo
{
Metrics = new BeatmapMetrics
{
@ -91,7 +91,7 @@ namespace osu.Game.Tests.Visual.Online
[Test]
public void TestEmptyMetrics()
{
AddStep("set beatmap", () => successRate.Beatmap = new BeatmapInfo
AddStep("set beatmap", () => successRate.BeatmapInfo = new BeatmapInfo
{
Metrics = new BeatmapMetrics()
});

14
osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapDetails.cs
View File

@ -30,7 +30,7 @@ namespace osu.Game.Tests.Visual.SongSelect
[Test]
public void TestAllMetrics()
{
AddStep("all metrics", () => details.Beatmap = new BeatmapInfo
AddStep("all metrics", () => details.BeatmapInfo = new BeatmapInfo
{
BeatmapSet = new BeatmapSetInfo
{
@ -61,7 +61,7 @@ namespace osu.Game.Tests.Visual.SongSelect
[Test]
public void TestAllMetricsExceptSource()
{
AddStep("all except source", () => details.Beatmap = new BeatmapInfo
AddStep("all except source", () => details.BeatmapInfo = new BeatmapInfo
{
BeatmapSet = new BeatmapSetInfo
{
@ -91,7 +91,7 @@ namespace osu.Game.Tests.Visual.SongSelect
[Test]
public void TestOnlyRatings()
{
AddStep("ratings", () => details.Beatmap = new BeatmapInfo
AddStep("ratings", () => details.BeatmapInfo = new BeatmapInfo
{
BeatmapSet = new BeatmapSetInfo
{
@ -117,7 +117,7 @@ namespace osu.Game.Tests.Visual.SongSelect
[Test]
public void TestOnlyFailsAndRetries()
{
AddStep("fails retries", () => details.Beatmap = new BeatmapInfo
AddStep("fails retries", () => details.BeatmapInfo = new BeatmapInfo
{
Version = "Only Retries and Fails",
Metadata = new BeatmapMetadata
@ -144,7 +144,7 @@ namespace osu.Game.Tests.Visual.SongSelect
[Test]
public void TestNoMetrics()
{
AddStep("no metrics", () => details.Beatmap = new BeatmapInfo
AddStep("no metrics", () => details.BeatmapInfo = new BeatmapInfo
{
Version = "No Metrics",
Metadata = new BeatmapMetadata
@ -166,13 +166,13 @@ namespace osu.Game.Tests.Visual.SongSelect
[Test]
public void TestNullBeatmap()
{
AddStep("null beatmap", () => details.Beatmap = null);
AddStep("null beatmap", () => details.BeatmapInfo = null);
}
[Test]
public void TestOnlineMetrics()
{
AddStep("online ratings/retries/fails", () => details.Beatmap = new BeatmapInfo
AddStep("online ratings/retries/fails", () => details.BeatmapInfo = new BeatmapInfo
{
OnlineBeatmapID = 162,
});

26
osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapLeaderboard.cs
View File

@ -76,7 +76,7 @@ namespace osu.Game.Tests.Visual.SongSelect
beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).Wait();
beatmapInfo = beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps.First();
leaderboard.Beatmap = beatmapInfo;
leaderboard.BeatmapInfo = beatmapInfo;
});
clearScores();
@ -186,7 +186,7 @@ namespace osu.Game.Tests.Visual.SongSelect
private void checkCount(int expected) =>
AddUntilStep("Correct count displayed", () => leaderboard.ChildrenOfType<LeaderboardScore>().Count() == expected);
private static ScoreInfo[] generateSampleScores(BeatmapInfo beatmap)
private static ScoreInfo[] generateSampleScores(BeatmapInfo beatmapInfo)
{
return new[]
{
@ -197,7 +197,7 @@ namespace osu.Game.Tests.Visual.SongSelect
MaxCombo = 244,
TotalScore = 1707827,
//Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
Beatmap = beatmap,
Beatmap = beatmapInfo,
User = new User
{
Id = 6602580,
@ -216,7 +216,7 @@ namespace osu.Game.Tests.Visual.SongSelect
MaxCombo = 244,
TotalScore = 1707827,
//Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
Beatmap = beatmap,
Beatmap = beatmapInfo,
User = new User
{
Id = 4608074,
@ -235,7 +235,7 @@ namespace osu.Game.Tests.Visual.SongSelect
MaxCombo = 244,
TotalScore = 1707827,
//Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
Beatmap = beatmap,
Beatmap = beatmapInfo,
User = new User
{
Id = 1014222,
@ -254,7 +254,7 @@ namespace osu.Game.Tests.Visual.SongSelect
MaxCombo = 244,
TotalScore = 1707827,
//Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
Beatmap = beatmap,
Beatmap = beatmapInfo,
User = new User
{
Id = 1541390,
@ -273,7 +273,7 @@ namespace osu.Game.Tests.Visual.SongSelect
MaxCombo = 244,
TotalScore = 1707827,
//Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
Beatmap = beatmap,
Beatmap = beatmapInfo,
User = new User
{
Id = 2243452,
@ -292,7 +292,7 @@ namespace osu.Game.Tests.Visual.SongSelect
MaxCombo = 244,
TotalScore = 1707827,
//Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
Beatmap = beatmap,
Beatmap = beatmapInfo,
User = new User
{
Id = 2705430,
@ -311,7 +311,7 @@ namespace osu.Game.Tests.Visual.SongSelect
MaxCombo = 244,
TotalScore = 1707827,
//Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
Beatmap = beatmap,
Beatmap = beatmapInfo,
User = new User
{
Id = 7151382,
@ -330,7 +330,7 @@ namespace osu.Game.Tests.Visual.SongSelect
MaxCombo = 244,
TotalScore = 1707827,
//Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
Beatmap = beatmap,
Beatmap = beatmapInfo,
User = new User
{
Id = 2051389,
@ -349,7 +349,7 @@ namespace osu.Game.Tests.Visual.SongSelect
MaxCombo = 244,
TotalScore = 1707827,
//Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
Beatmap = beatmap,
Beatmap = beatmapInfo,
User = new User
{
Id = 6169483,
@ -368,7 +368,7 @@ namespace osu.Game.Tests.Visual.SongSelect
MaxCombo = 244,
TotalScore = 1707827,
//Mods = new Mod[] { new OsuModHidden(), new OsuModHardRock(), },
Beatmap = beatmap,
Beatmap = beatmapInfo,
User = new User
{
Id = 6702666,
@ -385,7 +385,7 @@ namespace osu.Game.Tests.Visual.SongSelect
private void showBeatmapWithStatus(BeatmapSetOnlineStatus status)
{
leaderboard.Beatmap = new BeatmapInfo
leaderboard.BeatmapInfo = new BeatmapInfo
{
OnlineBeatmapID = 1113057,
Status = status,

13
osu.Game.Tests/Visual/UserInterface/TestSceneDeleteLocalScore.cs
View File

@ -37,7 +37,8 @@ namespace osu.Game.Tests.Visual.UserInterface
private ScoreManager scoreManager;
private readonly List<ScoreInfo> importedScores = new List<ScoreInfo>();
private BeatmapInfo beatmap;
private BeatmapInfo beatmapInfo;
[Cached]
private readonly DialogOverlay dialogOverlay;
@ -55,7 +56,7 @@ namespace osu.Game.Tests.Visual.UserInterface
Anchor = Anchor.Centre,
Size = new Vector2(550f, 450f),
Scope = BeatmapLeaderboardScope.Local,
Beatmap = new BeatmapInfo
BeatmapInfo = new BeatmapInfo
{
ID = 1,
Metadata = new BeatmapMetadata
@ -84,15 +85,15 @@ namespace osu.Game.Tests.Visual.UserInterface
dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, ContextFactory, rulesetStore, null, dependencies.Get<AudioManager>(), Resources, dependencies.Get<GameHost>(), Beatmap.Default));
dependencies.Cache(scoreManager = new ScoreManager(rulesetStore, () => beatmapManager, LocalStorage, null, ContextFactory, Scheduler));
beatmap = beatmapManager.Import(new ImportTask(TestResources.GetQuickTestBeatmapForImport())).Result.Beatmaps[0];
beatmapInfo = beatmapManager.Import(new ImportTask(TestResources.GetQuickTestBeatmapForImport())).Result.Beatmaps[0];
for (int i = 0; i < 50; i++)
{
var score = new ScoreInfo
{
OnlineScoreID = i,
Beatmap = beatmap,
BeatmapInfoID = beatmap.ID,
Beatmap = beatmapInfo,
BeatmapInfoID = beatmapInfo.ID,
Accuracy = RNG.NextDouble(),
TotalScore = RNG.Next(1, 1000000),
MaxCombo = RNG.Next(1, 1000),
@ -115,7 +116,7 @@ namespace osu.Game.Tests.Visual.UserInterface
leaderboard.Scores = null;
leaderboard.FinishTransforms(true); // After setting scores, we may be waiting for transforms to expire drawables
leaderboard.Beatmap = beatmap;
leaderboard.BeatmapInfo = beatmapInfo;
leaderboard.RefreshScores(); // Required in the case that the beatmap hasn't changed
});

2
osu.Game.Tournament.Tests/Components/TestSceneTournamentBeatmapPanel.cs
View File

@ -30,7 +30,7 @@ namespace osu.Game.Tournament.Tests.Components
private void success(APIBeatmap apiBeatmap)
{
var beatmap = apiBeatmap.ToBeatmap(rulesets);
var beatmap = apiBeatmap.ToBeatmapInfo(rulesets);
Add(new TournamentBeatmapPanel(beatmap)
{
Anchor = Anchor.Centre,

6
osu.Game.Tournament.Tests/Components/TestSceneTournamentModDisplay.cs
View File

@ -23,7 +23,7 @@ namespace osu.Game.Tournament.Tests.Components
private FillFlowContainer<TournamentBeatmapPanel> fillFlow;
private BeatmapInfo beatmap;
private BeatmapInfo beatmapInfo;
[BackgroundDependencyLoader]
private void load()
@ -44,12 +44,12 @@ namespace osu.Game.Tournament.Tests.Components
private void success(APIBeatmap apiBeatmap)
{
beatmap = apiBeatmap.ToBeatmap(rulesets);
beatmapInfo = apiBeatmap.ToBeatmapInfo(rulesets);
var mods = rulesets.GetRuleset(Ladder.Ruleset.Value.ID ?? 0).CreateInstance().AllMods;
foreach (var mod in mods)
{
fillFlow.Add(new TournamentBeatmapPanel(beatmap, mod.Acronym)
fillFlow.Add(new TournamentBeatmapPanel(beatmapInfo, mod.Acronym)
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre

20
osu.Game.Tournament/Components/TournamentBeatmapPanel.cs
View File

@ -21,7 +21,7 @@ namespace osu.Game.Tournament.Components
{
public class TournamentBeatmapPanel : CompositeDrawable
{
public readonly BeatmapInfo Beatmap;
public readonly BeatmapInfo BeatmapInfo;
private readonly string mod;
private const float horizontal_padding = 10;
@ -32,11 +32,11 @@ namespace osu.Game.Tournament.Components
private readonly Bindable<TournamentMatch> currentMatch = new Bindable<TournamentMatch>();
private Box flash;
public TournamentBeatmapPanel(BeatmapInfo beatmap, string mod = null)
public TournamentBeatmapPanel(BeatmapInfo beatmapInfo, string mod = null)
{
if (beatmap == null) throw new ArgumentNullException(nameof(beatmap));
if (beatmapInfo == null) throw new ArgumentNullException(nameof(beatmapInfo));
Beatmap = beatmap;
BeatmapInfo = beatmapInfo;
this.mod = mod;
Width = 400;
Height = HEIGHT;
@ -61,7 +61,7 @@ namespace osu.Game.Tournament.Components
{
RelativeSizeAxes = Axes.Both,
Colour = OsuColour.Gray(0.5f),
BeatmapSet = Beatmap.BeatmapSet,
BeatmapSet = BeatmapInfo.BeatmapSet,
},
new FillFlowContainer
{
@ -75,8 +75,8 @@ namespace osu.Game.Tournament.Components
new TournamentSpriteText
{
Text = new RomanisableString(
$"{Beatmap.Metadata.ArtistUnicode ?? Beatmap.Metadata.Artist} - {Beatmap.Metadata.TitleUnicode ?? Beatmap.Metadata.Title}",
$"{Beatmap.Metadata.Artist} - {Beatmap.Metadata.Title}"),
$"{BeatmapInfo.Metadata.ArtistUnicode ?? BeatmapInfo.Metadata.Artist} - {BeatmapInfo.Metadata.TitleUnicode ?? BeatmapInfo.Metadata.Title}",
$"{BeatmapInfo.Metadata.Artist} - {BeatmapInfo.Metadata.Title}"),
Font = OsuFont.Torus.With(weight: FontWeight.Bold),
},
new FillFlowContainer
@ -93,7 +93,7 @@ namespace osu.Game.Tournament.Components
},
new TournamentSpriteText
{
Text = Beatmap.Metadata.AuthorString,
Text = BeatmapInfo.Metadata.AuthorString,
Padding = new MarginPadding { Right = 20 },
Font = OsuFont.Torus.With(weight: FontWeight.Bold, size: 14)
},
@ -105,7 +105,7 @@ namespace osu.Game.Tournament.Components
},
new TournamentSpriteText
{
Text = Beatmap.Version,
Text = BeatmapInfo.Version,
Font = OsuFont.Torus.With(weight: FontWeight.Bold, size: 14)
},
}
@ -149,7 +149,7 @@ namespace osu.Game.Tournament.Components
private void updateState()
{
var found = currentMatch.Value.PicksBans.FirstOrDefault(p => p.BeatmapID == Beatmap.OnlineBeatmapID);
var found = currentMatch.Value.PicksBans.FirstOrDefault(p => p.BeatmapID == BeatmapInfo.OnlineBeatmapID);
bool doFlash = found != choice;
choice = found;

2
osu.Game.Tournament/IPC/FileBasedIPC.cs
View File

@ -94,7 +94,7 @@ namespace osu.Game.Tournament.IPC
else
{
beatmapLookupRequest = new GetBeatmapRequest(new BeatmapInfo { OnlineBeatmapID = beatmapId });
beatmapLookupRequest.Success += b => Beatmap.Value = b.ToBeatmap(Rulesets);
beatmapLookupRequest.Success += b => Beatmap.Value = b.ToBeatmapInfo(Rulesets);
API.Queue(beatmapLookupRequest);
}
}

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

@ -238,7 +238,7 @@ namespace osu.Game.Tournament.Screens.Editors
req.Success += res =>
{
Model.BeatmapInfo = res.ToBeatmap(rulesets);
Model.BeatmapInfo = res.ToBeatmapInfo(rulesets);
updatePanel();
};

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

@ -246,7 +246,7 @@ namespace osu.Game.Tournament.Screens.Editors
req.Success += res =>
{
Model.BeatmapInfo = res.ToBeatmap(rulesets);
Model.BeatmapInfo = res.ToBeatmapInfo(rulesets);
updatePanel();
};

6
osu.Game.Tournament/Screens/MapPool/MapPoolScreen.cs
View File

@ -147,11 +147,11 @@ namespace osu.Game.Tournament.Screens.MapPool
if (map != null)
{
if (e.Button == MouseButton.Left && map.Beatmap.OnlineBeatmapID != null)
addForBeatmap(map.Beatmap.OnlineBeatmapID.Value);
if (e.Button == MouseButton.Left && map.BeatmapInfo.OnlineBeatmapID != null)
addForBeatmap(map.BeatmapInfo.OnlineBeatmapID.Value);
else
{
var existing = CurrentMatch.Value.PicksBans.FirstOrDefault(p => p.BeatmapID == map.Beatmap.OnlineBeatmapID);
var existing = CurrentMatch.Value.PicksBans.FirstOrDefault(p => p.BeatmapID == map.BeatmapInfo.OnlineBeatmapID);
if (existing != null)
{

4
osu.Game.Tournament/TournamentGameBase.cs
View File

@ -182,7 +182,7 @@ namespace osu.Game.Tournament
{
var req = new GetBeatmapRequest(new BeatmapInfo { OnlineBeatmapID = b.ID });
API.Perform(req);
b.BeatmapInfo = req.Result?.ToBeatmap(RulesetStore);
b.BeatmapInfo = req.Result?.ToBeatmapInfo(RulesetStore);
addedInfo = true;
}
@ -203,7 +203,7 @@ namespace osu.Game.Tournament
{
var req = new GetBeatmapRequest(new BeatmapInfo { OnlineBeatmapID = b.ID });
req.Perform(API);
b.BeatmapInfo = req.Result?.ToBeatmap(RulesetStore);
b.BeatmapInfo = req.Result?.ToBeatmapInfo(RulesetStore);
addedInfo = true;
}

24
osu.Game/Beatmaps/BeatmapDifficultyCache.cs
View File

@ -242,7 +242,7 @@ namespace osu.Game.Beatmaps
{
// GetDifficultyAsync will fall back to existing data from BeatmapInfo if not locally available
// (contrary to GetAsync)
GetDifficultyAsync(bindable.Beatmap, rulesetInfo, mods, cancellationToken)
GetDifficultyAsync(bindable.BeatmapInfo, rulesetInfo, mods, cancellationToken)
.ContinueWith(t =>
{
// We're on a threadpool thread, but we should exit back to the update thread so consumers can safely handle value-changed events.
@ -262,7 +262,7 @@ namespace osu.Game.Beatmaps
private StarDifficulty computeDifficulty(in DifficultyCacheLookup key)
{
// In the case that the user hasn't given us a ruleset, use the beatmap's default ruleset.
var beatmapInfo = key.Beatmap;
var beatmapInfo = key.BeatmapInfo;
var rulesetInfo = key.Ruleset;
try
@ -270,7 +270,7 @@ namespace osu.Game.Beatmaps
var ruleset = rulesetInfo.CreateInstance();
Debug.Assert(ruleset != null);
var calculator = ruleset.CreateDifficultyCalculator(beatmapManager.GetWorkingBeatmap(key.Beatmap));
var calculator = ruleset.CreateDifficultyCalculator(beatmapManager.GetWorkingBeatmap(key.BeatmapInfo));
var attributes = calculator.Calculate(key.OrderedMods);
return new StarDifficulty(attributes);
@ -300,21 +300,21 @@ namespace osu.Game.Beatmaps
public readonly struct DifficultyCacheLookup : IEquatable<DifficultyCacheLookup>
{
public readonly BeatmapInfo Beatmap;
public readonly BeatmapInfo BeatmapInfo;
public readonly RulesetInfo Ruleset;
public readonly Mod[] OrderedMods;
public DifficultyCacheLookup([NotNull] BeatmapInfo beatmap, [CanBeNull] RulesetInfo ruleset, IEnumerable<Mod> mods)
public DifficultyCacheLookup([NotNull] BeatmapInfo beatmapInfo, [CanBeNull] RulesetInfo ruleset, IEnumerable<Mod> mods)
{
Beatmap = beatmap;
BeatmapInfo = beatmapInfo;
// In the case that the user hasn't given us a ruleset, use the beatmap's default ruleset.
Ruleset = ruleset ?? Beatmap.Ruleset;
Ruleset = ruleset ?? BeatmapInfo.Ruleset;
OrderedMods = mods?.OrderBy(m => m.Acronym).Select(mod => mod.DeepClone()).ToArray() ?? Array.Empty<Mod>();
}
public bool Equals(DifficultyCacheLookup other)
=> Beatmap.ID == other.Beatmap.ID
=> BeatmapInfo.ID == other.BeatmapInfo.ID
&& Ruleset.ID == other.Ruleset.ID
&& OrderedMods.SequenceEqual(other.OrderedMods);
@ -322,7 +322,7 @@ namespace osu.Game.Beatmaps
{
var hashCode = new HashCode();
hashCode.Add(Beatmap.ID);
hashCode.Add(BeatmapInfo.ID);
hashCode.Add(Ruleset.ID);
foreach (var mod in OrderedMods)
@ -334,12 +334,12 @@ namespace osu.Game.Beatmaps
private class BindableStarDifficulty : Bindable<StarDifficulty?>
{
public readonly BeatmapInfo Beatmap;
public readonly BeatmapInfo BeatmapInfo;
public readonly CancellationToken CancellationToken;
public BindableStarDifficulty(BeatmapInfo beatmap, CancellationToken cancellationToken)
public BindableStarDifficulty(BeatmapInfo beatmapInfo, CancellationToken cancellationToken)
{
Beatmap = beatmap;
BeatmapInfo = beatmapInfo;
CancellationToken = cancellationToken;
}
}

16
osu.Game/Beatmaps/BeatmapManager.cs
View File

@ -35,7 +35,7 @@ namespace osu.Game.Beatmaps
private readonly BeatmapModelDownloader beatmapModelDownloader;
private readonly WorkingBeatmapCache workingBeatmapCache;
private readonly BeatmapOnlineLookupQueue onlineBetamapLookupQueue;
private readonly BeatmapOnlineLookupQueue onlineBeatmapLookupQueue;
public BeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, [NotNull] AudioManager audioManager, IResourceStore<byte[]> resources, GameHost host = null,
WorkingBeatmap defaultBeatmap = null, bool performOnlineLookups = false)
@ -48,8 +48,8 @@ namespace osu.Game.Beatmaps
if (performOnlineLookups)
{
onlineBetamapLookupQueue = new BeatmapOnlineLookupQueue(api, storage);
beatmapModelManager.OnlineLookupQueue = onlineBetamapLookupQueue;
onlineBeatmapLookupQueue = new BeatmapOnlineLookupQueue(api, storage);
beatmapModelManager.OnlineLookupQueue = onlineBeatmapLookupQueue;
}
}
@ -182,14 +182,14 @@ namespace osu.Game.Beatmaps
/// <summary>
/// Delete a beatmap difficulty.
/// </summary>
/// <param name="beatmap">The beatmap difficulty to hide.</param>
public void Hide(BeatmapInfo beatmap) => beatmapModelManager.Hide(beatmap);
/// <param name="beatmapInfo">The beatmap difficulty to hide.</param>
public void Hide(BeatmapInfo beatmapInfo) => beatmapModelManager.Hide(beatmapInfo);
/// <summary>
/// Restore a beatmap difficulty.
/// </summary>
/// <param name="beatmap">The beatmap difficulty to restore.</param>
public void Restore(BeatmapInfo beatmap) => beatmapModelManager.Restore(beatmap);
/// <param name="beatmapInfo">The beatmap difficulty to restore.</param>
public void Restore(BeatmapInfo beatmapInfo) => beatmapModelManager.Restore(beatmapInfo);
#endregion
@ -329,7 +329,7 @@ namespace osu.Game.Beatmaps
public void Dispose()
{
onlineBetamapLookupQueue?.Dispose();
onlineBeatmapLookupQueue?.Dispose();
}
#endregion

18
osu.Game/Beatmaps/BeatmapModelManager.cs
View File

@ -173,24 +173,24 @@ namespace osu.Game.Beatmaps
/// <summary>
/// Delete a beatmap difficulty.
/// </summary>
/// <param name="beatmap">The beatmap difficulty to hide.</param>
public void Hide(BeatmapInfo beatmap) => beatmaps.Hide(beatmap);
/// <param name="beatmapInfo">The beatmap difficulty to hide.</param>
public void Hide(BeatmapInfo beatmapInfo) => beatmaps.Hide(beatmapInfo);
/// <summary>
/// Restore a beatmap difficulty.
/// </summary>
/// <param name="beatmap">The beatmap difficulty to restore.</param>
public void Restore(BeatmapInfo beatmap) => beatmaps.Restore(beatmap);
/// <param name="beatmapInfo">The beatmap difficulty to restore.</param>
public void Restore(BeatmapInfo beatmapInfo) => beatmaps.Restore(beatmapInfo);
/// <summary>
/// Saves an <see cref="IBeatmap"/> file against a given <see cref="BeatmapInfo"/>.
/// </summary>
/// <param name="info">The <see cref="BeatmapInfo"/> to save the content against. The file referenced by <see cref="BeatmapInfo.Path"/> will be replaced.</param>
/// <param name="baetmapInfo">The <see cref="BeatmapInfo"/> to save the content against. The file referenced by <see cref="BeatmapInfo.Path"/> will be replaced.</param>
/// <param name="beatmapContent">The <see cref="IBeatmap"/> content to write.</param>
/// <param name="beatmapSkin">The beatmap <see cref="ISkin"/> content to write, null if to be omitted.</param>
public virtual void Save(BeatmapInfo info, IBeatmap beatmapContent, ISkin beatmapSkin = null)
public virtual void Save(BeatmapInfo baetmapInfo, IBeatmap beatmapContent, ISkin beatmapSkin = null)
{
var setInfo = info.BeatmapSet;
var setInfo = baetmapInfo.BeatmapSet;
using (var stream = new MemoryStream())
{
@ -201,7 +201,7 @@ namespace osu.Game.Beatmaps
using (ContextFactory.GetForWrite())
{
var beatmapInfo = setInfo.Beatmaps.Single(b => b.ID == info.ID);
var beatmapInfo = setInfo.Beatmaps.Single(b => b.ID == baetmapInfo.ID);
var metadata = beatmapInfo.Metadata ?? setInfo.Metadata;
// grab the original file (or create a new one if not found).
@ -219,7 +219,7 @@ namespace osu.Game.Beatmaps
}
}
WorkingBeatmapCache?.Invalidate(info);
WorkingBeatmapCache?.Invalidate(baetmapInfo);
}
/// <summary>

66
osu.Game/Beatmaps/BeatmapOnlineLookupQueue.cs
View File

@ -58,18 +58,18 @@ namespace osu.Game.Beatmaps
}
// todo: expose this when we need to do individual difficulty lookups.
protected Task UpdateAsync(BeatmapSetInfo beatmapSet, BeatmapInfo beatmap, CancellationToken cancellationToken)
=> Task.Factory.StartNew(() => lookup(beatmapSet, beatmap), cancellationToken, TaskCreationOptions.HideScheduler | TaskCreationOptions.RunContinuationsAsynchronously, updateScheduler);
protected Task UpdateAsync(BeatmapSetInfo beatmapSet, BeatmapInfo beatmapInfo, CancellationToken cancellationToken)
=> Task.Factory.StartNew(() => lookup(beatmapSet, beatmapInfo), cancellationToken, TaskCreationOptions.HideScheduler | TaskCreationOptions.RunContinuationsAsynchronously, updateScheduler);
private void lookup(BeatmapSetInfo set, BeatmapInfo beatmap)
private void lookup(BeatmapSetInfo set, BeatmapInfo beatmapInfo)
{
if (checkLocalCache(set, beatmap))
if (checkLocalCache(set, beatmapInfo))
return;
if (api?.State.Value != APIState.Online)
return;
var req = new GetBeatmapRequest(beatmap);
var req = new GetBeatmapRequest(beatmapInfo);
req.Failure += fail;
@ -82,18 +82,18 @@ namespace osu.Game.Beatmaps
if (res != null)
{
beatmap.Status = res.Status;
beatmap.BeatmapSet.Status = res.BeatmapSet.Status;
beatmap.BeatmapSet.OnlineBeatmapSetID = res.OnlineBeatmapSetID;
beatmap.OnlineBeatmapID = res.OnlineBeatmapID;
beatmapInfo.Status = res.Status;
beatmapInfo.BeatmapSet.Status = res.BeatmapSet.Status;
beatmapInfo.BeatmapSet.OnlineBeatmapSetID = res.OnlineBeatmapSetID;
beatmapInfo.OnlineBeatmapID = res.OnlineBeatmapID;
if (beatmap.Metadata != null)
beatmap.Metadata.AuthorID = res.AuthorID;
if (beatmapInfo.Metadata != null)
beatmapInfo.Metadata.AuthorID = res.AuthorID;
if (beatmap.BeatmapSet.Metadata != null)
beatmap.BeatmapSet.Metadata.AuthorID = res.AuthorID;
if (beatmapInfo.BeatmapSet.Metadata != null)
beatmapInfo.BeatmapSet.Metadata.AuthorID = res.AuthorID;
logForModel(set, $"Online retrieval mapped {beatmap} to {res.OnlineBeatmapSetID} / {res.OnlineBeatmapID}.");
logForModel(set, $"Online retrieval mapped {beatmapInfo} to {res.OnlineBeatmapSetID} / {res.OnlineBeatmapID}.");
}
}
catch (Exception e)
@ -103,8 +103,8 @@ namespace osu.Game.Beatmaps
void fail(Exception e)
{
beatmap.OnlineBeatmapID = null;
logForModel(set, $"Online retrieval failed for {beatmap} ({e.Message})");
beatmapInfo.OnlineBeatmapID = null;
logForModel(set, $"Online retrieval failed for {beatmapInfo} ({e.Message})");
}
}
@ -149,7 +149,7 @@ namespace osu.Game.Beatmaps
cacheDownloadRequest.PerformAsync();
}
private bool checkLocalCache(BeatmapSetInfo set, BeatmapInfo beatmap)
private bool checkLocalCache(BeatmapSetInfo set, BeatmapInfo beatmapInfo)
{
// download is in progress (or was, and failed).
if (cacheDownloadRequest != null)
@ -159,9 +159,9 @@ namespace osu.Game.Beatmaps
if (!storage.Exists(cache_database_name))
return false;
if (string.IsNullOrEmpty(beatmap.MD5Hash)
&& string.IsNullOrEmpty(beatmap.Path)
&& beatmap.OnlineBeatmapID == null)
if (string.IsNullOrEmpty(beatmapInfo.MD5Hash)
&& string.IsNullOrEmpty(beatmapInfo.Path)
&& beatmapInfo.OnlineBeatmapID == null)
return false;
try
@ -174,9 +174,9 @@ namespace osu.Game.Beatmaps
{
cmd.CommandText = "SELECT beatmapset_id, beatmap_id, approved, user_id FROM osu_beatmaps WHERE checksum = @MD5Hash OR beatmap_id = @OnlineBeatmapID OR filename = @Path";
cmd.Parameters.Add(new SqliteParameter("@MD5Hash", beatmap.MD5Hash));
cmd.Parameters.Add(new SqliteParameter("@OnlineBeatmapID", beatmap.OnlineBeatmapID ?? (object)DBNull.Value));
cmd.Parameters.Add(new SqliteParameter("@Path", beatmap.Path));
cmd.Parameters.Add(new SqliteParameter("@MD5Hash", beatmapInfo.MD5Hash));
cmd.Parameters.Add(new SqliteParameter("@OnlineBeatmapID", beatmapInfo.OnlineBeatmapID ?? (object)DBNull.Value));
cmd.Parameters.Add(new SqliteParameter("@Path", beatmapInfo.Path));
using (var reader = cmd.ExecuteReader())
{
@ -184,18 +184,18 @@ namespace osu.Game.Beatmaps
{
var status = (BeatmapSetOnlineStatus)reader.GetByte(2);
beatmap.Status = status;
beatmap.BeatmapSet.Status = status;
beatmap.BeatmapSet.OnlineBeatmapSetID = reader.GetInt32(0);
beatmap.OnlineBeatmapID = reader.GetInt32(1);
beatmapInfo.Status = status;
beatmapInfo.BeatmapSet.Status = status;
beatmapInfo.BeatmapSet.OnlineBeatmapSetID = reader.GetInt32(0);
beatmapInfo.OnlineBeatmapID = reader.GetInt32(1);
if (beatmap.Metadata != null)
beatmap.Metadata.AuthorID = reader.GetInt32(3);
if (beatmapInfo.Metadata != null)
beatmapInfo.Metadata.AuthorID = reader.GetInt32(3);
if (beatmap.BeatmapSet.Metadata != null)
beatmap.BeatmapSet.Metadata.AuthorID = reader.GetInt32(3);
if (beatmapInfo.BeatmapSet.Metadata != null)
beatmapInfo.BeatmapSet.Metadata.AuthorID = reader.GetInt32(3);
logForModel(set, $"Cached local retrieval for {beatmap}.");
logForModel(set, $"Cached local retrieval for {beatmapInfo}.");
return true;
}
}
@ -204,7 +204,7 @@ namespace osu.Game.Beatmaps
}
catch (Exception ex)
{
logForModel(set, $"Cached local retrieval for {beatmap} failed with {ex}.");
logForModel(set, $"Cached local retrieval for {beatmapInfo} failed with {ex}.");
}
return false;

24
osu.Game/Beatmaps/BeatmapStore.cs
View File

@ -25,40 +25,40 @@ namespace osu.Game.Beatmaps
/// <summary>
/// Hide a <see cref="BeatmapInfo"/> in the database.
/// </summary>
/// <param name="beatmap">The beatmap to hide.</param>
/// <param name="beatmapInfo">The beatmap to hide.</param>
/// <returns>Whether the beatmap's <see cref="BeatmapInfo.Hidden"/> was changed.</returns>
public bool Hide(BeatmapInfo beatmap)
public bool Hide(BeatmapInfo beatmapInfo)
{
using (ContextFactory.GetForWrite())
{
Refresh(ref beatmap, Beatmaps);
Refresh(ref beatmapInfo, Beatmaps);
if (beatmap.Hidden) return false;
if (beatmapInfo.Hidden) return false;
beatmap.Hidden = true;
beatmapInfo.Hidden = true;
}
BeatmapHidden?.Invoke(beatmap);
BeatmapHidden?.Invoke(beatmapInfo);
return true;
}
/// <summary>
/// Restore a previously hidden <see cref="BeatmapInfo"/>.
/// </summary>
/// <param name="beatmap">The beatmap to restore.</param>
/// <param name="beatmapInfo">The beatmap to restore.</param>
/// <returns>Whether the beatmap's <see cref="BeatmapInfo.Hidden"/> was changed.</returns>
public bool Restore(BeatmapInfo beatmap)
public bool Restore(BeatmapInfo beatmapInfo)
{
using (ContextFactory.GetForWrite())
{
Refresh(ref beatmap, Beatmaps);
Refresh(ref beatmapInfo, Beatmaps);
if (!beatmap.Hidden) return false;
if (!beatmapInfo.Hidden) return false;
beatmap.Hidden = false;
beatmapInfo.Hidden = false;
}
BeatmapRestored?.Invoke(beatmap);
BeatmapRestored?.Invoke(beatmapInfo);
return true;
}

6
osu.Game/Beatmaps/DifficultyRecommender.cs
View File

@ -62,14 +62,14 @@ namespace osu.Game.Beatmaps
if (!recommendedDifficultyMapping.TryGetValue(r, out var recommendation))
continue;
BeatmapInfo beatmap = beatmaps.Where(b => b.Ruleset.Equals(r)).OrderBy(b =>
BeatmapInfo beatmapInfo = beatmaps.Where(b => b.Ruleset.Equals(r)).OrderBy(b =>
{
var difference = b.StarDifficulty - recommendation;
return difference >= 0 ? difference * 2 : difference * -1; // prefer easier over harder
}).FirstOrDefault();
if (beatmap != null)
return beatmap;
if (beatmapInfo != null)
return beatmapInfo;
}
return null;

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

@ -37,7 +37,7 @@ namespace osu.Game.Beatmaps.Drawables
}
[NotNull]
private readonly BeatmapInfo beatmap;
private readonly BeatmapInfo beatmapInfo;
[CanBeNull]
private readonly RulesetInfo ruleset;
@ -56,26 +56,26 @@ namespace osu.Game.Beatmaps.Drawables
/// <summary>
/// Creates a new <see cref="DifficultyIcon"/> with a given <see cref="RulesetInfo"/> and <see cref="Mod"/> combination.
/// </summary>
/// <param name="beatmap">The beatmap to show the difficulty of.</param>
/// <param name="beatmapInfo">The beatmap to show the difficulty of.</param>
/// <param name="ruleset">The ruleset to show the difficulty with.</param>
/// <param name="mods">The mods to show the difficulty with.</param>
/// <param name="shouldShowTooltip">Whether to display a tooltip when hovered.</param>
public DifficultyIcon([NotNull] BeatmapInfo beatmap, [CanBeNull] RulesetInfo ruleset, [CanBeNull] IReadOnlyList<Mod> mods, bool shouldShowTooltip = true)
: this(beatmap, shouldShowTooltip)
public DifficultyIcon([NotNull] BeatmapInfo beatmapInfo, [CanBeNull] RulesetInfo ruleset, [CanBeNull] IReadOnlyList<Mod> mods, bool shouldShowTooltip = true)
: this(beatmapInfo, shouldShowTooltip)
{
this.ruleset = ruleset ?? beatmap.Ruleset;
this.ruleset = ruleset ?? beatmapInfo.Ruleset;
this.mods = mods ?? Array.Empty<Mod>();
}
/// <summary>
/// Creates a new <see cref="DifficultyIcon"/> that follows the currently-selected ruleset and mods.
/// </summary>
/// <param name="beatmap">The beatmap to show the difficulty of.</param>
/// <param name="beatmapInfo">The beatmap to show the difficulty of.</param>
/// <param name="shouldShowTooltip">Whether to display a tooltip when hovered.</param>
/// <param name="performBackgroundDifficultyLookup">Whether to perform difficulty lookup (including calculation if necessary).</param>
public DifficultyIcon([NotNull] BeatmapInfo beatmap, bool shouldShowTooltip = true, bool performBackgroundDifficultyLookup = true)
public DifficultyIcon([NotNull] BeatmapInfo beatmapInfo, bool shouldShowTooltip = true, bool performBackgroundDifficultyLookup = true)
{
this.beatmap = beatmap ?? throw new ArgumentNullException(nameof(beatmap));
this.beatmapInfo = beatmapInfo ?? throw new ArgumentNullException(nameof(beatmapInfo));
this.shouldShowTooltip = shouldShowTooltip;
this.performBackgroundDifficultyLookup = performBackgroundDifficultyLookup;
@ -105,7 +105,7 @@ namespace osu.Game.Beatmaps.Drawables
Child = background = new Box
{
RelativeSizeAxes = Axes.Both,
Colour = colours.ForStarDifficulty(beatmap.StarDifficulty) // Default value that will be re-populated once difficulty calculation completes
Colour = colours.ForStarDifficulty(beatmapInfo.StarDifficulty) // Default value that will be re-populated once difficulty calculation completes
},
},
new ConstrainedIconContainer
@ -114,27 +114,27 @@ namespace osu.Game.Beatmaps.Drawables
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
// the null coalesce here is only present to make unit tests work (ruleset dlls aren't copied correctly for testing at the moment)
Icon = (ruleset ?? beatmap.Ruleset)?.CreateInstance()?.CreateIcon() ?? new SpriteIcon { Icon = FontAwesome.Regular.QuestionCircle }
Icon = (ruleset ?? beatmapInfo.Ruleset)?.CreateInstance()?.CreateIcon() ?? new SpriteIcon { Icon = FontAwesome.Regular.QuestionCircle }
},
};
if (performBackgroundDifficultyLookup)
iconContainer.Add(new DelayedLoadUnloadWrapper(() => new DifficultyRetriever(beatmap, ruleset, mods) { StarDifficulty = { BindTarget = difficultyBindable } }, 0));
iconContainer.Add(new DelayedLoadUnloadWrapper(() => new DifficultyRetriever(beatmapInfo, ruleset, mods) { StarDifficulty = { BindTarget = difficultyBindable } }, 0));
else
difficultyBindable.Value = new StarDifficulty(beatmap.StarDifficulty, 0);
difficultyBindable.Value = new StarDifficulty(beatmapInfo.StarDifficulty, 0);
difficultyBindable.BindValueChanged(difficulty => background.Colour = colours.ForStarDifficulty(difficulty.NewValue.Stars));
}
ITooltip<DifficultyIconTooltipContent> IHasCustomTooltip<DifficultyIconTooltipContent>.GetCustomTooltip() => new DifficultyIconTooltip();
DifficultyIconTooltipContent IHasCustomTooltip<DifficultyIconTooltipContent>.TooltipContent => shouldShowTooltip ? new DifficultyIconTooltipContent(beatmap, difficultyBindable) : null;
DifficultyIconTooltipContent IHasCustomTooltip<DifficultyIconTooltipContent>.TooltipContent => shouldShowTooltip ? new DifficultyIconTooltipContent(beatmapInfo, difficultyBindable) : null;
private class DifficultyRetriever : Component
{
public readonly Bindable<StarDifficulty> StarDifficulty = new Bindable<StarDifficulty>();
private readonly BeatmapInfo beatmap;
private readonly BeatmapInfo beatmapInfo;
private readonly RulesetInfo ruleset;
private readonly IReadOnlyList<Mod> mods;
@ -143,9 +143,9 @@ namespace osu.Game.Beatmaps.Drawables
[Resolved]
private BeatmapDifficultyCache difficultyCache { get; set; }
public DifficultyRetriever(BeatmapInfo beatmap, RulesetInfo ruleset, IReadOnlyList<Mod> mods)
public DifficultyRetriever(BeatmapInfo beatmapInfo, RulesetInfo ruleset, IReadOnlyList<Mod> mods)
{
this.beatmap = beatmap;
this.beatmapInfo = beatmapInfo;
this.ruleset = ruleset;
this.mods = mods;
}
@ -157,8 +157,8 @@ namespace osu.Game.Beatmaps.Drawables
{
difficultyCancellation = new CancellationTokenSource();
localStarDifficulty = ruleset != null
? difficultyCache.GetBindableDifficulty(beatmap, ruleset, mods, difficultyCancellation.Token)
: difficultyCache.GetBindableDifficulty(beatmap, difficultyCancellation.Token);
? difficultyCache.GetBindableDifficulty(beatmapInfo, ruleset, mods, difficultyCancellation.Token)
: difficultyCache.GetBindableDifficulty(beatmapInfo, difficultyCancellation.Token);
localStarDifficulty.BindValueChanged(d =>
{
if (d.NewValue is StarDifficulty diff)

8
osu.Game/Beatmaps/Drawables/DifficultyIconTooltip.cs
View File

@ -89,7 +89,7 @@ namespace osu.Game.Beatmaps.Drawables
public void SetContent(DifficultyIconTooltipContent content)
{
difficultyName.Text = content.Beatmap.Version;
difficultyName.Text = content.BeatmapInfo.Version;
starDifficulty.UnbindAll();
starDifficulty.BindTo(content.Difficulty);
@ -109,12 +109,12 @@ namespace osu.Game.Beatmaps.Drawables
internal class DifficultyIconTooltipContent
{
public readonly BeatmapInfo Beatmap;
public readonly BeatmapInfo BeatmapInfo;
public readonly IBindable<StarDifficulty> Difficulty;
public DifficultyIconTooltipContent(BeatmapInfo beatmap, IBindable<StarDifficulty> difficulty)
public DifficultyIconTooltipContent(BeatmapInfo beatmapInfo, IBindable<StarDifficulty> difficulty)
{
Beatmap = beatmap;
BeatmapInfo = beatmapInfo;
Difficulty = difficulty;
}
}

8
osu.Game/Online/API/Requests/GetBeatmapRequest.cs
View File

@ -8,13 +8,13 @@ namespace osu.Game.Online.API.Requests
{
public class GetBeatmapRequest : APIRequest<APIBeatmap>
{
private readonly BeatmapInfo beatmap;
private readonly BeatmapInfo beatmapInfo;
public GetBeatmapRequest(BeatmapInfo beatmap)
public GetBeatmapRequest(BeatmapInfo beatmapInfo)
{
this.beatmap = beatmap;
this.beatmapInfo = beatmapInfo;
}
protected override string Target => $@"beatmaps/lookup?id={beatmap.OnlineBeatmapID}&checksum={beatmap.MD5Hash}&filename={System.Uri.EscapeUriString(beatmap.Path ?? string.Empty)}";
protected override string Target => $@"beatmaps/lookup?id={beatmapInfo.OnlineBeatmapID}&checksum={beatmapInfo.MD5Hash}&filename={System.Uri.EscapeUriString(beatmapInfo.Path ?? string.Empty)}";
}
}

14
osu.Game/Online/API/Requests/GetScoresRequest.cs
View File

@ -15,20 +15,20 @@ namespace osu.Game.Online.API.Requests
{
public class GetScoresRequest : APIRequest<APILegacyScores>
{
private readonly BeatmapInfo beatmap;
private readonly BeatmapInfo beatmapInfo;
private readonly BeatmapLeaderboardScope scope;
private readonly RulesetInfo ruleset;
private readonly IEnumerable<IMod> mods;
public GetScoresRequest(BeatmapInfo beatmap, RulesetInfo ruleset, BeatmapLeaderboardScope scope = BeatmapLeaderboardScope.Global, IEnumerable<IMod> mods = null)
public GetScoresRequest(BeatmapInfo beatmapInfo, RulesetInfo ruleset, BeatmapLeaderboardScope scope = BeatmapLeaderboardScope.Global, IEnumerable<IMod> mods = null)
{
if (!beatmap.OnlineBeatmapID.HasValue)
if (!beatmapInfo.OnlineBeatmapID.HasValue)
throw new InvalidOperationException($"Cannot lookup a beatmap's scores without having a populated {nameof(BeatmapInfo.OnlineBeatmapID)}.");
if (scope == BeatmapLeaderboardScope.Local)
throw new InvalidOperationException("Should not attempt to request online scores for a local scoped leaderboard");
this.beatmap = beatmap;
this.beatmapInfo = beatmapInfo;
this.scope = scope;
this.ruleset = ruleset ?? throw new ArgumentNullException(nameof(ruleset));
this.mods = mods ?? Array.Empty<IMod>();
@ -42,7 +42,7 @@ namespace osu.Game.Online.API.Requests
foreach (APILegacyScoreInfo score in r.Scores)
{
score.Beatmap = beatmap;
score.BeatmapInfo = beatmapInfo;
score.OnlineRulesetID = ruleset.ID.Value;
}
@ -50,12 +50,12 @@ namespace osu.Game.Online.API.Requests
if (userScore != null)
{
userScore.Score.Beatmap = beatmap;
userScore.Score.BeatmapInfo = beatmapInfo;
userScore.Score.OnlineRulesetID = ruleset.ID.Value;
}
}
protected override string Target => $@"beatmaps/{beatmap.OnlineBeatmapID}/scores{createQueryParameters()}";
protected override string Target => $@"beatmaps/{beatmapInfo.OnlineBeatmapID}/scores{createQueryParameters()}";
private string createQueryParameters()
{

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

@ -64,7 +64,7 @@ namespace osu.Game.Online.API.Requests.Responses
[JsonProperty(@"max_combo")]
private int? maxCombo { get; set; }
public virtual BeatmapInfo ToBeatmap(RulesetStore rulesets)
public virtual BeatmapInfo ToBeatmapInfo(RulesetStore rulesets)
{
var set = BeatmapSet?.ToBeatmapSet(rulesets);

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

@ -116,7 +116,7 @@ namespace osu.Game.Online.API.Requests.Responses
beatmapSet.Beatmaps = beatmaps?.Select(b =>
{
var beatmap = b.ToBeatmap(rulesets);
var beatmap = b.ToBeatmapInfo(rulesets);
beatmap.BeatmapSet = beatmapSet;
beatmap.Metadata = beatmapSet.Metadata;
return beatmap;

8
osu.Game/Online/API/Requests/Responses/APILegacyScoreInfo.cs
View File

@ -37,7 +37,7 @@ namespace osu.Game.Online.API.Requests.Responses
OnlineScoreID = OnlineScoreID,
Date = Date,
PP = PP,
Beatmap = Beatmap,
Beatmap = BeatmapInfo,
RulesetID = OnlineRulesetID,
Hash = Replay ? "online" : string.Empty, // todo: temporary?
Rank = Rank,
@ -100,7 +100,7 @@ namespace osu.Game.Online.API.Requests.Responses
public DateTimeOffset Date { get; set; }
[JsonProperty(@"beatmap")]
public BeatmapInfo Beatmap { get; set; }
public BeatmapInfo BeatmapInfo { get; set; }
[JsonProperty("accuracy")]
public double Accuracy { get; set; }
@ -114,10 +114,10 @@ namespace osu.Game.Online.API.Requests.Responses
set
{
// extract the set ID to its correct place.
Beatmap.BeatmapSet = new BeatmapSetInfo { OnlineBeatmapSetID = value.ID };
BeatmapInfo.BeatmapSet = new BeatmapSetInfo { OnlineBeatmapSetID = value.ID };
value.ID = 0;
Beatmap.Metadata = value;
BeatmapInfo.Metadata = value;
}
}

8
osu.Game/Online/API/Requests/Responses/APIUserMostPlayedBeatmap.cs
View File

@ -16,7 +16,7 @@ namespace osu.Game.Online.API.Requests.Responses
public int PlayCount { get; set; }
[JsonProperty]
private BeatmapInfo beatmap { get; set; }
private BeatmapInfo beatmapInfo { get; set; }
[JsonProperty]
private APIBeatmapSet beatmapSet { get; set; }
@ -24,9 +24,9 @@ namespace osu.Game.Online.API.Requests.Responses
public BeatmapInfo GetBeatmapInfo(RulesetStore rulesets)
{
BeatmapSetInfo setInfo = beatmapSet.ToBeatmapSet(rulesets);
beatmap.BeatmapSet = setInfo;
beatmap.Metadata = setInfo.Metadata;
return beatmap;
beatmapInfo.BeatmapSet = setInfo;
beatmapInfo.Metadata = setInfo.Metadata;
return beatmapInfo;
}
}
}

10
osu.Game/Online/Chat/NowPlayingCommand.cs
View File

@ -37,27 +37,27 @@ namespace osu.Game.Online.Chat
base.LoadComplete();
string verb;
BeatmapInfo beatmap;
BeatmapInfo beatmapInfo;
switch (api.Activity.Value)
{
case UserActivity.InGame game:
verb = "playing";
beatmap = game.Beatmap;
beatmapInfo = game.BeatmapInfo;
break;
case UserActivity.Editing edit:
verb = "editing";
beatmap = edit.Beatmap;
beatmapInfo = edit.BeatmapInfo;
break;
default:
verb = "listening to";
beatmap = currentBeatmap.Value.BeatmapInfo;
beatmapInfo = currentBeatmap.Value.BeatmapInfo;
break;
}
var beatmapString = beatmap.OnlineBeatmapID.HasValue ? $"[{api.WebsiteRootUrl}/b/{beatmap.OnlineBeatmapID} {beatmap}]" : beatmap.ToString();
var beatmapString = beatmapInfo.OnlineBeatmapID.HasValue ? $"[{api.WebsiteRootUrl}/b/{beatmapInfo.OnlineBeatmapID} {beatmapInfo}]" : beatmapInfo.ToString();
channelManager.PostMessage($"is {verb} {beatmapString}", true, target);
Expire();

4
osu.Game/Online/Rooms/APIPlaylistBeatmap.cs
View File

@ -13,9 +13,9 @@ namespace osu.Game.Online.Rooms
[JsonProperty("checksum")]
public string Checksum { get; set; }
public override BeatmapInfo ToBeatmap(RulesetStore rulesets)
public override BeatmapInfo ToBeatmapInfo(RulesetStore rulesets)
{
var b = base.ToBeatmap(rulesets);
var b = base.ToBeatmapInfo(rulesets);
b.MD5Hash = Checksum;
return b;
}

2
osu.Game/Online/Rooms/PlaylistItem.cs
View File

@ -70,7 +70,7 @@ namespace osu.Game.Online.Rooms
public void MapObjects(BeatmapManager beatmaps, RulesetStore rulesets)
{
Beatmap.Value ??= apiBeatmap.ToBeatmap(rulesets);
Beatmap.Value ??= apiBeatmap.ToBeatmapInfo(rulesets);
Ruleset.Value ??= rulesets.GetRuleset(RulesetID);
Ruleset rulesetInstance = Ruleset.Value.CreateInstance();

20
osu.Game/Overlays/BeatmapSet/BeatmapPicker.cs
View File

@ -178,21 +178,21 @@ namespace osu.Game.Overlays.BeatmapSet
}
starRatingContainer.FadeOut(100);
Beatmap.Value = Difficulties.FirstOrDefault()?.Beatmap;
Beatmap.Value = Difficulties.FirstOrDefault()?.BeatmapInfo;
plays.Value = BeatmapSet?.OnlineInfo.PlayCount ?? 0;
favourites.Value = BeatmapSet?.OnlineInfo.FavouriteCount ?? 0;
updateDifficultyButtons();
}
private void showBeatmap(BeatmapInfo beatmap)
private void showBeatmap(BeatmapInfo beatmapInfo)
{
version.Text = beatmap?.Version;
version.Text = beatmapInfo?.Version;
}
private void updateDifficultyButtons()
{
Difficulties.Children.ToList().ForEach(diff => diff.State = diff.Beatmap == Beatmap.Value ? DifficultySelectorState.Selected : DifficultySelectorState.NotSelected);
Difficulties.Children.ToList().ForEach(diff => diff.State = diff.BeatmapInfo == Beatmap.Value ? DifficultySelectorState.Selected : DifficultySelectorState.NotSelected);
}
public class DifficultiesContainer : FillFlowContainer<DifficultySelectorButton>
@ -216,7 +216,7 @@ namespace osu.Game.Overlays.BeatmapSet
private readonly Box backgroundBox;
private readonly DifficultyIcon icon;
public readonly BeatmapInfo Beatmap;
public readonly BeatmapInfo BeatmapInfo;
public Action<BeatmapInfo> OnHovered;
public Action<BeatmapInfo> OnClicked;
@ -241,9 +241,9 @@ namespace osu.Game.Overlays.BeatmapSet
}
}
public DifficultySelectorButton(BeatmapInfo beatmap)
public DifficultySelectorButton(BeatmapInfo beatmapInfo)
{
Beatmap = beatmap;
BeatmapInfo = beatmapInfo;
Size = new Vector2(size);
Margin = new MarginPadding { Horizontal = tile_spacing / 2 };
@ -260,7 +260,7 @@ namespace osu.Game.Overlays.BeatmapSet
Alpha = 0.5f
}
},
icon = new DifficultyIcon(beatmap, shouldShowTooltip: false)
icon = new DifficultyIcon(beatmapInfo, shouldShowTooltip: false)
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
@ -273,7 +273,7 @@ namespace osu.Game.Overlays.BeatmapSet
protected override bool OnHover(HoverEvent e)
{
fadeIn();
OnHovered?.Invoke(Beatmap);
OnHovered?.Invoke(BeatmapInfo);
return base.OnHover(e);
}
@ -286,7 +286,7 @@ namespace osu.Game.Overlays.BeatmapSet
protected override bool OnClick(ClickEvent e)
{
OnClicked?.Invoke(Beatmap);
OnClicked?.Invoke(BeatmapInfo);
return base.OnClick(e);
}

6
osu.Game/Overlays/BeatmapSet/Info.cs
View File

@ -24,10 +24,10 @@ namespace osu.Game.Overlays.BeatmapSet
public readonly Bindable<BeatmapSetInfo> BeatmapSet = new Bindable<BeatmapSetInfo>();
public BeatmapInfo Beatmap
public BeatmapInfo BeatmapInfo
{
get => successRate.Beatmap;
set => successRate.Beatmap = value;
get => successRate.BeatmapInfo;
set => successRate.BeatmapInfo = value;
}
public Info()

16
osu.Game/Overlays/BeatmapSet/SuccessRate.cs
View File

@ -23,16 +23,16 @@ namespace osu.Game.Overlays.BeatmapSet
private readonly Bar successRate;
private readonly Container percentContainer;
private BeatmapInfo beatmap;
private BeatmapInfo beatmapInfo;
public BeatmapInfo Beatmap
public BeatmapInfo BeatmapInfo
{
get => beatmap;
get => beatmapInfo;
set
{
if (value == beatmap) return;
if (value == beatmapInfo) return;
beatmap = value;
beatmapInfo = value;
updateDisplay();
}
@ -40,15 +40,15 @@ namespace osu.Game.Overlays.BeatmapSet
private void updateDisplay()
{
int passCount = beatmap?.OnlineInfo?.PassCount ?? 0;
int playCount = beatmap?.OnlineInfo?.PlayCount ?? 0;
int passCount = beatmapInfo?.OnlineInfo?.PassCount ?? 0;
int playCount = beatmapInfo?.OnlineInfo?.PlayCount ?? 0;
var rate = playCount != 0 ? (float)passCount / playCount : 0;
successPercent.Text = rate.ToLocalisableString(@"0.#%");
successRate.Length = rate;
percentContainer.ResizeWidthTo(successRate.Length, 250, Easing.InOutCubic);
Graph.Metrics = beatmap?.Metrics;
Graph.Metrics = beatmapInfo?.Metrics;
}
public SuccessRate()

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

@ -61,7 +61,7 @@ namespace osu.Game.Overlays
Header.HeaderContent.Picker.Beatmap.ValueChanged += b =>
{
info.Beatmap = b.NewValue;
info.BeatmapInfo = b.NewValue;
ScrollFlow.ScrollToStart();
};
}

18
osu.Game/Overlays/Profile/Sections/BeatmapMetadataContainer.cs
View File

@ -15,12 +15,12 @@ namespace osu.Game.Overlays.Profile.Sections
/// </summary>
public abstract class BeatmapMetadataContainer : OsuHoverContainer
{
private readonly BeatmapInfo beatmap;
private readonly BeatmapInfo beatmapInfo;
protected BeatmapMetadataContainer(BeatmapInfo beatmap)
protected BeatmapMetadataContainer(BeatmapInfo beatmapInfo)
: base(HoverSampleSet.Submit)
{
this.beatmap = beatmap;
this.beatmapInfo = beatmapInfo;
AutoSizeAxes = Axes.Both;
}
@ -30,19 +30,19 @@ namespace osu.Game.Overlays.Profile.Sections
{
Action = () =>
{
if (beatmap.OnlineBeatmapID != null)
beatmapSetOverlay?.FetchAndShowBeatmap(beatmap.OnlineBeatmapID.Value);
else if (beatmap.BeatmapSet?.OnlineBeatmapSetID != null)
beatmapSetOverlay?.FetchAndShowBeatmapSet(beatmap.BeatmapSet.OnlineBeatmapSetID.Value);
if (beatmapInfo.OnlineBeatmapID != null)
beatmapSetOverlay?.FetchAndShowBeatmap(beatmapInfo.OnlineBeatmapID.Value);
else if (beatmapInfo.BeatmapSet?.OnlineBeatmapSetID != null)
beatmapSetOverlay?.FetchAndShowBeatmapSet(beatmapInfo.BeatmapSet.OnlineBeatmapSetID.Value);
};
Child = new FillFlowContainer
{
AutoSizeAxes = Axes.Both,
Children = CreateText(beatmap),
Children = CreateText(beatmapInfo),
};
}
protected abstract Drawable[] CreateText(BeatmapInfo beatmap);
protected abstract Drawable[] CreateText(BeatmapInfo beatmapInfo);
}
}

24
osu.Game/Overlays/Profile/Sections/Historical/DrawableMostPlayedBeatmap.cs
View File

@ -22,12 +22,12 @@ namespace osu.Game.Overlays.Profile.Sections.Historical
private const int cover_width = 100;
private const int corner_radius = 6;
private readonly BeatmapInfo beatmap;
private readonly BeatmapInfo beatmapInfo;
private readonly int playCount;
public DrawableMostPlayedBeatmap(BeatmapInfo beatmap, int playCount)
public DrawableMostPlayedBeatmap(BeatmapInfo beatmapInfo, int playCount)
{
this.beatmap = beatmap;
this.beatmapInfo = beatmapInfo;
this.playCount = playCount;
RelativeSizeAxes = Axes.X;
@ -46,7 +46,7 @@ namespace osu.Game.Overlays.Profile.Sections.Historical
{
RelativeSizeAxes = Axes.Y,
Width = cover_width,
BeatmapSet = beatmap.BeatmapSet,
BeatmapSet = beatmapInfo.BeatmapSet,
},
new Container
{
@ -77,7 +77,7 @@ namespace osu.Game.Overlays.Profile.Sections.Historical
Direction = FillDirection.Vertical,
Children = new Drawable[]
{
new MostPlayedBeatmapMetadataContainer(beatmap),
new MostPlayedBeatmapMetadataContainer(beatmapInfo),
new LinkFlowContainer(t =>
{
t.Font = OsuFont.GetFont(size: 12, weight: FontWeight.Regular);
@ -89,7 +89,7 @@ namespace osu.Game.Overlays.Profile.Sections.Historical
}.With(d =>
{
d.AddText("mapped by ");
d.AddUserLink(beatmap.Metadata.Author);
d.AddUserLink(beatmapInfo.Metadata.Author);
}),
}
},
@ -120,23 +120,23 @@ namespace osu.Game.Overlays.Profile.Sections.Historical
private class MostPlayedBeatmapMetadataContainer : BeatmapMetadataContainer
{
public MostPlayedBeatmapMetadataContainer(BeatmapInfo beatmap)
: base(beatmap)
public MostPlayedBeatmapMetadataContainer(BeatmapInfo beatmapInfo)
: base(beatmapInfo)
{
}
protected override Drawable[] CreateText(BeatmapInfo beatmap) => new Drawable[]
protected override Drawable[] CreateText(BeatmapInfo beatmapInfo) => new Drawable[]
{
new OsuSpriteText
{
Text = new RomanisableString(
$"{beatmap.Metadata.TitleUnicode ?? beatmap.Metadata.Title} [{beatmap.Version}] ",
$"{beatmap.Metadata.Title ?? beatmap.Metadata.TitleUnicode} [{beatmap.Version}] "),
$"{beatmapInfo.Metadata.TitleUnicode ?? beatmapInfo.Metadata.Title} [{beatmapInfo.Version}] ",
$"{beatmapInfo.Metadata.Title ?? beatmapInfo.Metadata.TitleUnicode} [{beatmapInfo.Version}] "),
Font = OsuFont.GetFont(weight: FontWeight.Bold)
},
new OsuSpriteText
{
Text = "by " + new RomanisableString(beatmap.Metadata.ArtistUnicode, beatmap.Metadata.Artist),
Text = "by " + new RomanisableString(beatmapInfo.Metadata.ArtistUnicode, beatmapInfo.Metadata.Artist),
Font = OsuFont.GetFont(weight: FontWeight.Regular)
},
};

12
osu.Game/Overlays/Profile/Sections/Ranks/DrawableProfileScore.cs
View File

@ -245,27 +245,27 @@ namespace osu.Game.Overlays.Profile.Sections.Ranks
private class ScoreBeatmapMetadataContainer : BeatmapMetadataContainer
{
public ScoreBeatmapMetadataContainer(BeatmapInfo beatmap)
: base(beatmap)
public ScoreBeatmapMetadataContainer(BeatmapInfo beatmapInfo)
: base(beatmapInfo)
{
}
protected override Drawable[] CreateText(BeatmapInfo beatmap) => new Drawable[]
protected override Drawable[] CreateText(BeatmapInfo beatmapInfo) => new Drawable[]
{
new OsuSpriteText
{
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft,
Text = new RomanisableString(
$"{beatmap.Metadata.TitleUnicode ?? beatmap.Metadata.Title} ",
$"{beatmap.Metadata.Title ?? beatmap.Metadata.TitleUnicode} "),
$"{beatmapInfo.Metadata.TitleUnicode ?? beatmapInfo.Metadata.Title} ",
$"{beatmapInfo.Metadata.Title ?? beatmapInfo.Metadata.TitleUnicode} "),
Font = OsuFont.GetFont(size: 14, weight: FontWeight.SemiBold, italics: true)
},
new OsuSpriteText
{
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft,
Text = "by " + new RomanisableString(beatmap.Metadata.ArtistUnicode, beatmap.Metadata.Artist),
Text = "by " + new RomanisableString(beatmapInfo.Metadata.ArtistUnicode, beatmapInfo.Metadata.Artist),
Font = OsuFont.GetFont(size: 12, italics: true)
},
};

6
osu.Game/Rulesets/Filter/IRulesetFilterCriteria.cs
View File

@ -14,15 +14,15 @@ namespace osu.Game.Rulesets.Filter
public interface IRulesetFilterCriteria
{
/// <summary>
/// Checks whether the supplied <paramref name="beatmap"/> satisfies ruleset-specific custom criteria,
/// Checks whether the supplied <paramref name="beatmapInfo"/> satisfies ruleset-specific custom criteria,
/// in addition to the ones mandated by song select.
/// </summary>
/// <param name="beatmap">The beatmap to test the criteria against.</param>
/// <param name="beatmapInfo">The beatmap to test the criteria against.</param>
/// <returns>
/// <c>true</c> if the beatmap matches the ruleset-specific custom filtering criteria,
/// <c>false</c> otherwise.
/// </returns>
bool Matches(BeatmapInfo beatmap);
bool Matches(BeatmapInfo beatmapInfo);
/// <summary>
/// Attempts to parse a single custom keyword criterion, given by the user via the song select search box.

4
osu.Game/Screens/Edit/Components/Menus/DifficultyMenuItem.cs
View File

@ -10,12 +10,12 @@ namespace osu.Game.Screens.Edit.Components.Menus
{
public class DifficultyMenuItem : StatefulMenuItem<bool>
{
public BeatmapInfo Beatmap { get; }
public BeatmapInfo BeatmapInfo { get; }
public DifficultyMenuItem(BeatmapInfo beatmapInfo, bool selected, Action<BeatmapInfo> difficultyChangeFunc)
: base(beatmapInfo.Version ?? "(unnamed)", null)
{
Beatmap = beatmapInfo;
BeatmapInfo = beatmapInfo;
State.Value = selected;
if (!selected)

8
osu.Game/Screens/Select/BeatmapCarousel.cs
View File

@ -242,15 +242,15 @@ namespace osu.Game.Screens.Select
/// <summary>
/// Selects a given beatmap on the carousel.
/// </summary>
/// <param name="beatmap">The beatmap to select.</param>
/// <param name="beatmapInfo">The beatmap to select.</param>
/// <param name="bypassFilters">Whether to select the beatmap even if it is filtered (i.e., not visible on carousel).</param>
/// <returns>True if a selection was made, False if it wasn't.</returns>
public bool SelectBeatmap(BeatmapInfo beatmap, bool bypassFilters = true)
public bool SelectBeatmap(BeatmapInfo beatmapInfo, bool bypassFilters = true)
{
// ensure that any pending events from BeatmapManager have been run before attempting a selection.
Scheduler.Update();
if (beatmap?.Hidden != false)
if (beatmapInfo?.Hidden != false)
return false;
foreach (CarouselBeatmapSet set in beatmapSets)
@ -258,7 +258,7 @@ namespace osu.Game.Screens.Select
if (!bypassFilters && set.Filtered.Value)
continue;
var item = set.Beatmaps.FirstOrDefault(p => p.BeatmapInfo.Equals(beatmap));
var item = set.Beatmaps.FirstOrDefault(p => p.BeatmapInfo.Equals(beatmapInfo));
if (item == null)
// The beatmap that needs to be selected doesn't exist in this set

6
osu.Game/Screens/Select/BeatmapClearScoresDialog.cs
View File

@ -17,9 +17,9 @@ namespace osu.Game.Screens.Select
[Resolved]
private ScoreManager scoreManager { get; set; }
public BeatmapClearScoresDialog(BeatmapInfo beatmap, Action onCompletion)
public BeatmapClearScoresDialog(BeatmapInfo beatmapInfo, Action onCompletion)
{
BodyText = $@"{beatmap.Metadata?.Artist} - {beatmap.Metadata?.Title}";
BodyText = $@"{beatmapInfo.Metadata?.Artist} - {beatmapInfo.Metadata?.Title}";
Icon = FontAwesome.Solid.Eraser;
HeaderText = @"Clearing all local scores. Are you sure?";
Buttons = new PopupDialogButton[]
@ -29,7 +29,7 @@ namespace osu.Game.Screens.Select
Text = @"Yes. Please.",
Action = () =>
{
Task.Run(() => scoreManager.Delete(scoreManager.QueryScores(s => !s.DeletePending && s.Beatmap.ID == beatmap.ID).ToList()))
Task.Run(() => scoreManager.Delete(scoreManager.QueryScores(s => !s.DeletePending && s.Beatmap.ID == beatmapInfo.ID).ToList()))
.ContinueWith(_ => onCompletion);
}
},

2
osu.Game/Screens/Select/BeatmapDetailArea.cs
View File

@ -22,7 +22,7 @@ namespace osu.Game.Screens.Select
{
beatmap = value;
Details.Beatmap = value?.BeatmapInfo;
Details.BeatmapInfo = value?.BeatmapInfo;
}
}

38
osu.Game/Screens/Select/BeatmapDetails.cs
View File

@ -41,16 +41,16 @@ namespace osu.Game.Screens.Select
[Resolved]
private RulesetStore rulesets { get; set; }
private BeatmapInfo beatmap;
private BeatmapInfo beatmapInfo;
public BeatmapInfo Beatmap
public BeatmapInfo BeatmapInfo
{
get => beatmap;
get => beatmapInfo;
set
{
if (value == beatmap) return;
if (value == beatmapInfo) return;
beatmap = value;
beatmapInfo = value;
Scheduler.AddOnce(updateStatistics);
}
@ -170,26 +170,26 @@ namespace osu.Game.Screens.Select
private void updateStatistics()
{
advanced.BeatmapInfo = Beatmap;
description.Text = Beatmap?.Version;
source.Text = Beatmap?.Metadata?.Source;
tags.Text = Beatmap?.Metadata?.Tags;
advanced.BeatmapInfo = BeatmapInfo;
description.Text = BeatmapInfo?.Version;
source.Text = BeatmapInfo?.Metadata?.Source;
tags.Text = BeatmapInfo?.Metadata?.Tags;
// metrics may have been previously fetched
if (Beatmap?.BeatmapSet?.Metrics != null && Beatmap?.Metrics != null)
if (BeatmapInfo?.BeatmapSet?.Metrics != null && BeatmapInfo?.Metrics != null)
{
updateMetrics();
return;
}
// for now, let's early abort if an OnlineBeatmapID is not present (should have been populated at import time).
if (Beatmap?.OnlineBeatmapID == null || api.State.Value == APIState.Offline)
if (BeatmapInfo?.OnlineBeatmapID == null || api.State.Value == APIState.Offline)
{
updateMetrics();
return;
}
var requestedBeatmap = Beatmap;
var requestedBeatmap = BeatmapInfo;
var lookup = new GetBeatmapRequest(requestedBeatmap);
@ -197,11 +197,11 @@ namespace osu.Game.Screens.Select
{
Schedule(() =>
{
if (beatmap != requestedBeatmap)
if (beatmapInfo != requestedBeatmap)
// the beatmap has been changed since we started the lookup.
return;
var b = res.ToBeatmap(rulesets);
var b = res.ToBeatmapInfo(rulesets);
if (requestedBeatmap.BeatmapSet == null)
requestedBeatmap.BeatmapSet = b.BeatmapSet;
@ -218,7 +218,7 @@ namespace osu.Game.Screens.Select
{
Schedule(() =>
{
if (beatmap != requestedBeatmap)
if (beatmapInfo != requestedBeatmap)
// the beatmap has been changed since we started the lookup.
return;
@ -232,12 +232,12 @@ namespace osu.Game.Screens.Select
private void updateMetrics()
{
var hasRatings = beatmap?.BeatmapSet?.Metrics?.Ratings?.Any() ?? false;
var hasRetriesFails = (beatmap?.Metrics?.Retries?.Any() ?? false) || (beatmap?.Metrics?.Fails?.Any() ?? false);
var hasRatings = beatmapInfo?.BeatmapSet?.Metrics?.Ratings?.Any() ?? false;
var hasRetriesFails = (beatmapInfo?.Metrics?.Retries?.Any() ?? false) || (beatmapInfo?.Metrics?.Fails?.Any() ?? false);
if (hasRatings)
{
ratings.Metrics = beatmap.BeatmapSet.Metrics;
ratings.Metrics = beatmapInfo.BeatmapSet.Metrics;
ratings.FadeIn(transition_duration);
}
else
@ -249,7 +249,7 @@ namespace osu.Game.Screens.Select
if (hasRetriesFails)
{
failRetryGraph.Metrics = beatmap.Metrics;
failRetryGraph.Metrics = beatmapInfo.Metrics;
failRetryContainer.FadeIn(transition_duration);
}
else

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

@ -40,7 +40,7 @@ namespace osu.Game.Screens.Select.Carousel
private const float height = MAX_HEIGHT * 0.6f;
private readonly BeatmapInfo beatmap;
private readonly BeatmapInfo beatmapInfo;
private Sprite background;
@ -68,7 +68,7 @@ namespace osu.Game.Screens.Select.Carousel
public DrawableCarouselBeatmap(CarouselBeatmap panel)
{
beatmap = panel.BeatmapInfo;
beatmapInfo = panel.BeatmapInfo;
Item = panel;
}
@ -109,7 +109,7 @@ namespace osu.Game.Screens.Select.Carousel
Origin = Anchor.CentreLeft,
Children = new Drawable[]
{
new DifficultyIcon(beatmap, shouldShowTooltip: false)
new DifficultyIcon(beatmapInfo, shouldShowTooltip: false)
{
Scale = new Vector2(1.8f),
},
@ -129,7 +129,7 @@ namespace osu.Game.Screens.Select.Carousel
{
new OsuSpriteText
{
Text = beatmap.Version,
Text = beatmapInfo.Version,
Font = OsuFont.GetFont(size: 20),
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft
@ -142,7 +142,7 @@ namespace osu.Game.Screens.Select.Carousel
},
new OsuSpriteText
{
Text = $"{(beatmap.Metadata ?? beatmap.BeatmapSet.Metadata).Author.Username}",
Text = $"{(beatmapInfo.Metadata ?? beatmapInfo.BeatmapSet.Metadata).Author.Username}",
Font = OsuFont.GetFont(italics: true),
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft
@ -156,7 +156,7 @@ namespace osu.Game.Screens.Select.Carousel
AutoSizeAxes = Axes.Both,
Children = new Drawable[]
{
new TopLocalRank(beatmap)
new TopLocalRank(beatmapInfo)
{
Scale = new Vector2(0.8f),
Size = new Vector2(40, 20)
@ -200,7 +200,7 @@ namespace osu.Game.Screens.Select.Carousel
protected override bool OnClick(ClickEvent e)
{
if (Item.State.Value == CarouselItemState.Selected)
startRequested?.Invoke(beatmap);
startRequested?.Invoke(beatmapInfo);
return base.OnClick(e);
}
@ -216,7 +216,7 @@ namespace osu.Game.Screens.Select.Carousel
if (Item.State.Value != CarouselItemState.Collapsed)
{
// We've potentially cancelled the computation above so a new bindable is required.
starDifficultyBindable = difficultyCache.GetBindableDifficulty(beatmap, (starDifficultyCancellationSource = new CancellationTokenSource()).Token);
starDifficultyBindable = difficultyCache.GetBindableDifficulty(beatmapInfo, (starDifficultyCancellationSource = new CancellationTokenSource()).Token);
starDifficultyBindable.BindValueChanged(d =>
{
starCounter.Current = (float)(d.NewValue?.Stars ?? 0);
@ -233,13 +233,13 @@ namespace osu.Game.Screens.Select.Carousel
List<MenuItem> items = new List<MenuItem>();
if (startRequested != null)
items.Add(new OsuMenuItem("Play", MenuItemType.Highlighted, () => startRequested(beatmap)));
items.Add(new OsuMenuItem("Play", MenuItemType.Highlighted, () => startRequested(beatmapInfo)));
if (editRequested != null)
items.Add(new OsuMenuItem("Edit", MenuItemType.Standard, () => editRequested(beatmap)));
items.Add(new OsuMenuItem("Edit", MenuItemType.Standard, () => editRequested(beatmapInfo)));
if (beatmap.OnlineBeatmapID.HasValue && beatmapOverlay != null)
items.Add(new OsuMenuItem("Details...", MenuItemType.Standard, () => beatmapOverlay.FetchAndShowBeatmap(beatmap.OnlineBeatmapID.Value)));
if (beatmapInfo.OnlineBeatmapID.HasValue && beatmapOverlay != null)
items.Add(new OsuMenuItem("Details...", MenuItemType.Standard, () => beatmapOverlay.FetchAndShowBeatmap(beatmapInfo.OnlineBeatmapID.Value)));
if (collectionManager != null)
{
@ -251,7 +251,7 @@ namespace osu.Game.Screens.Select.Carousel
}
if (hideRequested != null)
items.Add(new OsuMenuItem("Hide", MenuItemType.Destructive, () => hideRequested(beatmap)));
items.Add(new OsuMenuItem("Hide", MenuItemType.Destructive, () => hideRequested(beatmapInfo)));
return items.ToArray();
}
@ -262,12 +262,12 @@ namespace osu.Game.Screens.Select.Carousel
return new ToggleMenuItem(collection.Name.Value, MenuItemType.Standard, s =>
{
if (s)
collection.Beatmaps.Add(beatmap);
collection.Beatmaps.Add(beatmapInfo);
else
collection.Beatmaps.Remove(beatmap);
collection.Beatmaps.Remove(beatmapInfo);
})
{
State = { Value = collection.Beatmaps.Contains(beatmap) }
State = { Value = collection.Beatmaps.Contains(beatmapInfo) }
};
}

12
osu.Game/Screens/Select/Carousel/TopLocalRank.cs
View File

@ -17,7 +17,7 @@ namespace osu.Game.Screens.Select.Carousel
{
public class TopLocalRank : UpdateableRank
{
private readonly BeatmapInfo beatmap;
private readonly BeatmapInfo beatmapInfo;
[Resolved]
private ScoreManager scores { get; set; }
@ -31,10 +31,10 @@ namespace osu.Game.Screens.Select.Carousel
private IBindable<WeakReference<ScoreInfo>> itemUpdated;
private IBindable<WeakReference<ScoreInfo>> itemRemoved;
public TopLocalRank(BeatmapInfo beatmap)
public TopLocalRank(BeatmapInfo beatmapInfo)
: base(null)
{
this.beatmap = beatmap;
this.beatmapInfo = beatmapInfo;
}
[BackgroundDependencyLoader]
@ -55,7 +55,7 @@ namespace osu.Game.Screens.Select.Carousel
{
if (weakScore.NewValue.TryGetTarget(out var score))
{
if (score.BeatmapInfoID == beatmap.ID)
if (score.BeatmapInfoID == beatmapInfo.ID)
fetchAndLoadTopScore();
}
}
@ -79,10 +79,10 @@ namespace osu.Game.Screens.Select.Carousel
private ScoreInfo fetchTopScore()
{
if (scores == null || beatmap == null || ruleset?.Value == null || api?.LocalUser.Value == null)
if (scores == null || beatmapInfo == null || ruleset?.Value == null || api?.LocalUser.Value == null)
return null;
return scores.QueryScores(s => s.UserID == api.LocalUser.Value.Id && s.BeatmapInfoID == beatmap.ID && s.RulesetID == ruleset.Value.ID && !s.DeletePending)
return scores.QueryScores(s => s.UserID == api.LocalUser.Value.Id && s.BeatmapInfoID == beatmapInfo.ID && s.RulesetID == ruleset.Value.ID && !s.DeletePending)
.OrderByDescending(s => s.TotalScore)
.FirstOrDefault();
}

20
osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboard.cs
View File

@ -25,17 +25,17 @@ namespace osu.Game.Screens.Select.Leaderboards
[Resolved]
private RulesetStore rulesets { get; set; }
private BeatmapInfo beatmap;
private BeatmapInfo beatmapInfo;
public BeatmapInfo Beatmap
public BeatmapInfo BeatmapInfo
{
get => beatmap;
get => beatmapInfo;
set
{
if (beatmap == value)
if (beatmapInfo == value)
return;
beatmap = value;
beatmapInfo = value;
Scores = null;
UpdateScores();
@ -116,7 +116,7 @@ namespace osu.Game.Screens.Select.Leaderboards
if (score.NewValue.TryGetTarget(out var scoreInfo))
{
if (Beatmap?.ID != scoreInfo.BeatmapInfoID)
if (BeatmapInfo?.ID != scoreInfo.BeatmapInfoID)
return;
}
@ -132,7 +132,7 @@ namespace osu.Game.Screens.Select.Leaderboards
loadCancellationSource?.Cancel();
loadCancellationSource = new CancellationTokenSource();
if (Beatmap == null)
if (BeatmapInfo == null)
{
PlaceholderState = PlaceholderState.NoneSelected;
return null;
@ -141,7 +141,7 @@ namespace osu.Game.Screens.Select.Leaderboards
if (Scope == BeatmapLeaderboardScope.Local)
{
var scores = scoreManager
.QueryScores(s => !s.DeletePending && s.Beatmap.ID == Beatmap.ID && s.Ruleset.ID == ruleset.Value.ID);
.QueryScores(s => !s.DeletePending && s.Beatmap.ID == BeatmapInfo.ID && s.Ruleset.ID == ruleset.Value.ID);
if (filterMods && !mods.Value.Any())
{
@ -168,7 +168,7 @@ namespace osu.Game.Screens.Select.Leaderboards
return null;
}
if (Beatmap.OnlineBeatmapID == null || Beatmap?.Status <= BeatmapSetOnlineStatus.Pending)
if (BeatmapInfo.OnlineBeatmapID == null || BeatmapInfo?.Status <= BeatmapSetOnlineStatus.Pending)
{
PlaceholderState = PlaceholderState.Unavailable;
return null;
@ -188,7 +188,7 @@ namespace osu.Game.Screens.Select.Leaderboards
else if (filterMods)
requestMods = mods.Value;
var req = new GetScoresRequest(Beatmap, ruleset.Value ?? Beatmap.Ruleset, Scope, requestMods);
var req = new GetScoresRequest(BeatmapInfo, ruleset.Value ?? BeatmapInfo.Ruleset, Scope, requestMods);
req.Success += r =>
{

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

@ -29,8 +29,8 @@ namespace osu.Game.Screens.Select
[BackgroundDependencyLoader]
private void load()
{
BeatmapInfo beatmap = beatmapManager.QueryBeatmap(b => b.ID == score.BeatmapInfoID);
Debug.Assert(beatmap != null);
BeatmapInfo beatmapInfo = beatmapManager.QueryBeatmap(b => b.ID == score.BeatmapInfoID);
Debug.Assert(beatmapInfo != null);
BodyText = $"{score.User} ({score.DisplayAccuracy}, {score.Rank})";

2
osu.Game/Screens/Select/PlayBeatmapDetailArea.cs
View File

@ -23,7 +23,7 @@ namespace osu.Game.Screens.Select
{
base.Beatmap = value;
Leaderboard.Beatmap = value is DummyWorkingBeatmap ? null : value?.BeatmapInfo;
Leaderboard.BeatmapInfo = value is DummyWorkingBeatmap ? null : value?.BeatmapInfo;
}
}

32
osu.Game/Screens/Select/SongSelect.cs
View File

@ -345,22 +345,22 @@ namespace osu.Game.Screens.Select
/// </summary>
protected abstract BeatmapDetailArea CreateBeatmapDetailArea();
public void Edit(BeatmapInfo beatmap = null)
public void Edit(BeatmapInfo beatmapInfo = null)
{
if (!AllowEditing)
throw new InvalidOperationException($"Attempted to edit when {nameof(AllowEditing)} is disabled");
Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmap ?? beatmapNoDebounce);
Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmapInfo ?? beatmapInfoNoDebounce);
this.Push(new EditorLoader());
}
/// <summary>
/// Call to make a selection and perform the default action for this SongSelect.
/// </summary>
/// <param name="beatmap">An optional beatmap to override the current carousel selection.</param>
/// <param name="beatmapInfo">An optional beatmap to override the current carousel selection.</param>
/// <param name="ruleset">An optional ruleset to override the current carousel selection.</param>
/// <param name="customStartAction">An optional custom action to perform instead of <see cref="OnStart"/>.</param>
public void FinaliseSelection(BeatmapInfo beatmap = null, RulesetInfo ruleset = null, Action customStartAction = null)
public void FinaliseSelection(BeatmapInfo beatmapInfo = null, RulesetInfo ruleset = null, Action customStartAction = null)
{
// This is very important as we have not yet bound to screen-level bindables before the carousel load is completed.
if (!Carousel.BeatmapSetsLoaded)
@ -379,8 +379,8 @@ namespace osu.Game.Screens.Select
// this could happen via a user interaction while the carousel is still in a loading state.
if (Carousel.SelectedBeatmapInfo == null) return;
if (beatmap != null)
Carousel.SelectBeatmap(beatmap);
if (beatmapInfo != null)
Carousel.SelectBeatmap(beatmapInfo);
if (selectionChangedDebounce?.Completed == false)
{
@ -435,18 +435,18 @@ namespace osu.Game.Screens.Select
}
// We need to keep track of the last selected beatmap ignoring debounce to play the correct selection sounds.
private BeatmapInfo beatmapNoDebounce;
private BeatmapInfo beatmapInfoNoDebounce;
private RulesetInfo rulesetNoDebounce;
private void updateSelectedBeatmap(BeatmapInfo beatmap)
private void updateSelectedBeatmap(BeatmapInfo beatmapInfo)
{
if (beatmap == null && beatmapNoDebounce == null)
if (beatmapInfo == null && beatmapInfoNoDebounce == null)
return;
if (beatmap?.Equals(beatmapNoDebounce) == true)
if (beatmapInfo?.Equals(beatmapInfoNoDebounce) == true)
return;
beatmapNoDebounce = beatmap;
beatmapInfoNoDebounce = beatmapInfo;
performUpdateSelected();
}
@ -467,12 +467,12 @@ namespace osu.Game.Screens.Select
/// </summary>
private void performUpdateSelected()
{
var beatmap = beatmapNoDebounce;
var beatmap = beatmapInfoNoDebounce;
var ruleset = rulesetNoDebounce;
selectionChangedDebounce?.Cancel();
if (beatmapNoDebounce == null)
if (beatmapInfoNoDebounce == null)
run();
else
selectionChangedDebounce = Scheduler.AddDelayed(run, 200);
@ -803,11 +803,11 @@ namespace osu.Game.Screens.Select
dialogOverlay?.Push(new BeatmapDeleteDialog(beatmap));
}
private void clearScores(BeatmapInfo beatmap)
private void clearScores(BeatmapInfo beatmapInfo)
{
if (beatmap == null || beatmap.ID <= 0) return;
if (beatmapInfo == null || beatmapInfo.ID <= 0) return;
dialogOverlay?.Push(new BeatmapClearScoresDialog(beatmap, () =>
dialogOverlay?.Push(new BeatmapClearScoresDialog(beatmapInfo, () =>
// schedule done here rather than inside the dialog as the dialog may fade out and never callback.
Schedule(() => BeatmapDetails.Refresh())));
}

8
osu.Game/Skinning/LegacyBeatmapSkin.cs
View File

@ -20,8 +20,8 @@ namespace osu.Game.Skinning
protected override bool AllowManiaSkin => false;
protected override bool UseCustomSampleBanks => true;
public LegacyBeatmapSkin(BeatmapInfo beatmap, IResourceStore<byte[]> storage, IStorageResourceProvider resources)
: base(createSkinInfo(beatmap), new LegacySkinResourceStore<BeatmapSetFileInfo>(beatmap.BeatmapSet, storage), resources, beatmap.Path)
public LegacyBeatmapSkin(BeatmapInfo beatmapInfo, IResourceStore<byte[]> storage, IStorageResourceProvider resources)
: base(createSkinInfo(beatmapInfo), new LegacySkinResourceStore<BeatmapSetFileInfo>(beatmapInfo.BeatmapSet, storage), resources, beatmapInfo.Path)
{
// Disallow default colours fallback on beatmap skins to allow using parent skin combo colours. (via SkinProvidingContainer)
Configuration.AllowDefaultComboColoursFallback = false;
@ -76,7 +76,7 @@ namespace osu.Game.Skinning
return base.GetSample(sampleInfo);
}
private static SkinInfo createSkinInfo(BeatmapInfo beatmap) =>
new SkinInfo { Name = beatmap.ToString(), Creator = beatmap.Metadata?.AuthorString };
private static SkinInfo createSkinInfo(BeatmapInfo beatmapInfo) =>
new SkinInfo { Name = beatmapInfo.ToString(), Creator = beatmapInfo.Metadata?.AuthorString };
}
}

4
osu.Game/Tests/Beatmaps/LegacyBeatmapSkinColourTest.cs
View File

@ -111,8 +111,8 @@ namespace osu.Game.Tests.Beatmaps
public static readonly Color4 HYPER_DASH_FRUIT_COLOUR = Color4.DarkGoldenrod;
public TestBeatmapSkin(BeatmapInfo beatmap, bool hasColours)
: base(beatmap, new ResourceStore<byte[]>(), null)
public TestBeatmapSkin(BeatmapInfo beatmapInfo, bool hasColours)
: base(beatmapInfo, new ResourceStore<byte[]>(), null)
{
if (hasColours)
{

22
osu.Game/Users/UserActivity.cs
View File

@ -27,13 +27,13 @@ namespace osu.Game.Users
public abstract class InGame : UserActivity
{
public BeatmapInfo Beatmap { get; }
public BeatmapInfo BeatmapInfo { get; }
public RulesetInfo Ruleset { get; }
protected InGame(BeatmapInfo info, RulesetInfo ruleset)
protected InGame(BeatmapInfo beatmapInfo, RulesetInfo ruleset)
{
Beatmap = info;
BeatmapInfo = beatmapInfo;
Ruleset = ruleset;
}
@ -42,8 +42,8 @@ namespace osu.Game.Users
public class InMultiplayerGame : InGame
{
public InMultiplayerGame(BeatmapInfo beatmap, RulesetInfo ruleset)
: base(beatmap, ruleset)
public InMultiplayerGame(BeatmapInfo beatmapInfo, RulesetInfo ruleset)
: base(beatmapInfo, ruleset)
{
}
@ -52,27 +52,27 @@ namespace osu.Game.Users
public class InPlaylistGame : InGame
{
public InPlaylistGame(BeatmapInfo beatmap, RulesetInfo ruleset)
: base(beatmap, ruleset)
public InPlaylistGame(BeatmapInfo beatmapInfo, RulesetInfo ruleset)
: base(beatmapInfo, ruleset)
{
}
}
public class InSoloGame : InGame
{
public InSoloGame(BeatmapInfo info, RulesetInfo ruleset)
: base(info, ruleset)
public InSoloGame(BeatmapInfo beatmapInfo, RulesetInfo ruleset)
: base(beatmapInfo, ruleset)
{
}
}
public class Editing : UserActivity
{
public BeatmapInfo Beatmap { get; }
public BeatmapInfo BeatmapInfo { get; }
public Editing(BeatmapInfo info)
{
Beatmap = info;
BeatmapInfo = info;
}
public override string Status => @"Editing a beatmap";