1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-17 17:33:03 +08:00
osu-lazer/osu.Game.Tournament/TournamentGameBase.cs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

393 lines
14 KiB
C#
Raw Normal View History

2019-03-04 12:24:19 +08:00
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
2018-11-06 17:32:59 +08:00
using System;
2018-11-06 17:32:59 +08:00
using System.IO;
2018-11-06 19:13:04 +08:00
using System.Linq;
using System.Threading.Tasks;
2018-11-06 17:32:59 +08:00
using Newtonsoft.Json;
using osu.Framework.Allocation;
2023-07-25 19:50:55 +08:00
using osu.Framework.Extensions.ObjectExtensions;
using osu.Framework.Graphics;
2018-11-08 19:15:22 +08:00
using osu.Framework.Graphics.Textures;
2019-06-13 18:10:57 +08:00
using osu.Framework.Input;
2018-11-06 23:27:12 +08:00
using osu.Framework.IO.Stores;
using osu.Framework.Logging;
using osu.Framework.Platform;
using osu.Game.Database;
using osu.Game.Graphics;
using osu.Game.Online;
2018-11-06 17:32:59 +08:00
using osu.Game.Online.API.Requests;
using osu.Game.Tournament.IO;
using osu.Game.Tournament.IPC;
2019-06-18 13:51:48 +08:00
using osu.Game.Tournament.Models;
using osu.Game.Users;
2019-06-13 18:10:57 +08:00
using osuTK.Input;
2018-11-06 17:32:59 +08:00
namespace osu.Game.Tournament
{
[Cached(typeof(TournamentGameBase))]
2020-06-10 03:14:05 +08:00
public partial class TournamentGameBase : OsuGameBase
2018-11-06 17:32:59 +08:00
{
public const string BRACKET_FILENAME = @"bracket.json";
2023-07-30 01:31:05 +08:00
private LadderInfo ladder = new LadderInfo();
2023-07-25 19:50:55 +08:00
private TournamentStorage storage = null!;
private DependencyContainer dependencies = null!;
private FileBasedIPC ipc = null!;
private BeatmapLookupCache beatmapCache = null!;
protected Task BracketLoadTask => bracketLoadTaskCompletionSource.Task;
2021-02-12 21:38:55 +08:00
private readonly TaskCompletionSource<bool> bracketLoadTaskCompletionSource = new TaskCompletionSource<bool>();
2018-11-06 17:32:59 +08:00
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
{
return dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
}
public override EndpointConfiguration CreateEndpoints()
{
if (UseDevelopmentServer)
return base.CreateEndpoints();
return new ProductionEndpointConfiguration();
}
2023-07-25 19:50:55 +08:00
private TournamentSpriteText initialisationText = null!;
2018-11-06 17:32:59 +08:00
[BackgroundDependencyLoader]
private void load(Storage baseStorage)
2018-11-06 17:32:59 +08:00
{
Add(initialisationText = new TournamentSpriteText
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Font = OsuFont.Torus.With(size: 32),
});
Resources.AddStore(new DllResourceStore(typeof(TournamentGameBase).Assembly));
2018-11-06 23:27:12 +08:00
dependencies.CacheAs<Storage>(storage = new TournamentStorage(baseStorage));
dependencies.CacheAs(storage);
dependencies.Cache(new TournamentVideoResourceStore(storage));
2018-11-08 19:15:22 +08:00
Textures.AddTextureSource(new TextureLoaderStore(new StorageBackedResourceStore(storage)));
2018-11-06 17:32:59 +08:00
dependencies.CacheAs(new StableInfo(storage));
beatmapCache = dependencies.Get<BeatmapLookupCache>();
2019-03-04 12:13:31 +08:00
}
protected override void LoadComplete()
{
GlobalCursorDisplay.MenuCursor.AlwaysPresent = true; // required for tooltip display
// we don't want to show the menu cursor as it would appear on stream output.
GlobalCursorDisplay.MenuCursor.Alpha = 0;
base.LoadComplete();
Task.Run(readBracket);
}
private async Task readBracket()
2019-03-04 12:13:31 +08:00
{
try
2019-03-04 12:13:31 +08:00
{
if (storage.Exists(BRACKET_FILENAME))
{
using (Stream stream = storage.GetStream(BRACKET_FILENAME, FileAccess.Read, FileMode.Open))
using (var sr = new StreamReader(stream))
2023-07-25 19:50:55 +08:00
{
ladder = JsonConvert.DeserializeObject<LadderInfo>(await sr.ReadToEndAsync().ConfigureAwait(false), new JsonPointConverter()) ?? ladder;
}
}
var resolvedRuleset = ladder.Ruleset.Value != null
? RulesetStore.GetRuleset(ladder.Ruleset.Value.ShortName)
: RulesetStore.AvailableRulesets.First();
2018-11-06 17:32:59 +08:00
// Must set to null initially to avoid the following re-fetch hitting `ShortName` based equality check.
ladder.Ruleset.Value = null;
ladder.Ruleset.Value = resolvedRuleset;
bool addedInfo = false;
2018-12-01 14:32:11 +08:00
// assign teams
foreach (var match in ladder.Matches)
2018-12-01 14:32:11 +08:00
{
match.Team1.Value = ladder.Teams.FirstOrDefault(t => t.Acronym.Value == match.Team1Acronym);
match.Team2.Value = ladder.Teams.FirstOrDefault(t => t.Acronym.Value == match.Team2Acronym);
foreach (var conditional in match.ConditionalMatches)
{
conditional.Team1.Value = ladder.Teams.FirstOrDefault(t => t.Acronym.Value == conditional.Team1Acronym);
conditional.Team2.Value = ladder.Teams.FirstOrDefault(t => t.Acronym.Value == conditional.Team2Acronym);
conditional.Round.Value = match.Round.Value;
}
2018-12-01 14:32:11 +08:00
}
2018-11-06 19:18:11 +08:00
// assign progressions
foreach (var pair in ladder.Progressions)
{
var src = ladder.Matches.FirstOrDefault(p => p.ID == pair.SourceID);
var dest = ladder.Matches.FirstOrDefault(p => p.ID == pair.TargetID);
2018-11-06 19:18:11 +08:00
if (src == null)
continue;
2018-11-06 19:18:11 +08:00
if (dest != null)
{
if (pair.Losers)
src.LosersProgression.Value = dest;
else
src.Progression.Value = dest;
}
2018-11-06 19:18:11 +08:00
}
// link matches to rounds
foreach (var round in ladder.Rounds)
{
foreach (int id in round.Matches)
2019-11-11 19:53:22 +08:00
{
var found = ladder.Matches.FirstOrDefault(p => p.ID == id);
if (found != null)
{
found.Round.Value = round;
if (round.StartDate.Value > found.Date.Value)
found.Date.Value = round.StartDate.Value;
}
2019-11-11 19:53:22 +08:00
}
}
2018-11-06 19:18:11 +08:00
addedInfo |= addPlayers();
addedInfo |= await addRoundBeatmaps().ConfigureAwait(false);
addedInfo |= await addSeedingBeatmaps().ConfigureAwait(false);
2019-03-04 12:13:31 +08:00
if (addedInfo)
saveChanges();
ladder.CurrentMatch.Value = ladder.Matches.FirstOrDefault(p => p.Current.Value);
ladder.Ruleset.BindValueChanged(r =>
{
// Refetch player rank data on next startup as the ruleset has changed.
foreach (var team in ladder.Teams)
{
foreach (var player in team.Players)
player.Rank = null;
}
SaveChanges();
});
}
catch (Exception e)
{
bracketLoadTaskCompletionSource.SetException(e);
return;
}
Schedule(() =>
{
2021-02-12 21:38:55 +08:00
Ruleset.BindTo(ladder.Ruleset);
dependencies.Cache(ladder);
dependencies.CacheAs<MatchIPCInfo>(ipc = new FileBasedIPC());
Add(ipc);
2021-02-12 21:38:55 +08:00
bracketLoadTaskCompletionSource.SetResult(true);
initialisationText.Expire();
});
2019-03-04 12:13:31 +08:00
}
/// <summary>
/// Add missing player info based on user IDs.
/// </summary>
private bool addPlayers()
{
var playersRequiringPopulation = ladder.Teams
.SelectMany(t => t.Players)
.Where(p => string.IsNullOrEmpty(p.Username)
|| p.CountryCode == CountryCode.Unknown
|| p.Rank == null).ToList();
2018-11-07 00:20:32 +08:00
if (playersRequiringPopulation.Count == 0)
return false;
2018-11-07 00:20:32 +08:00
for (int i = 0; i < playersRequiringPopulation.Count; i++)
2019-11-11 19:53:22 +08:00
{
var p = playersRequiringPopulation[i];
PopulatePlayer(p, immediate: true);
updateLoadProgressMessage($"Populating user stats ({i} / {playersRequiringPopulation.Count})");
2019-11-11 19:53:22 +08:00
}
return true;
2019-03-04 12:13:31 +08:00
}
/// <summary>
/// Add missing beatmap info based on beatmap IDs
/// </summary>
private async Task<bool> addRoundBeatmaps()
2019-03-04 12:13:31 +08:00
{
var beatmapsRequiringPopulation = ladder.Rounds
.SelectMany(r => r.Beatmaps)
.Where(b => (b.Beatmap == null || b.Beatmap?.OnlineID == 0) && b.ID > 0).ToList();
if (beatmapsRequiringPopulation.Count == 0)
return false;
for (int i = 0; i < beatmapsRequiringPopulation.Count; i++)
{
var b = beatmapsRequiringPopulation[i];
2018-11-06 17:32:59 +08:00
var populated = await beatmapCache.GetBeatmapAsync(b.ID).ConfigureAwait(false);
if (populated != null)
b.Beatmap = new TournamentBeatmap(populated);
2020-01-20 10:48:56 +08:00
updateLoadProgressMessage($"Populating round beatmaps ({i} / {beatmapsRequiringPopulation.Count})");
2019-11-11 19:53:22 +08:00
}
2018-11-06 17:32:59 +08:00
return true;
}
/// <summary>
/// Add missing beatmap info based on beatmap IDs
/// </summary>
private async Task<bool> addSeedingBeatmaps()
{
var beatmapsRequiringPopulation = ladder.Teams
.SelectMany(r => r.SeedingResults)
.SelectMany(r => r.Beatmaps)
.Where(b => (b.Beatmap == null || b.Beatmap.OnlineID == 0) && b.ID > 0).ToList();
if (beatmapsRequiringPopulation.Count == 0)
return false;
for (int i = 0; i < beatmapsRequiringPopulation.Count; i++)
2020-03-03 17:12:42 +08:00
{
var b = beatmapsRequiringPopulation[i];
2020-03-03 17:12:42 +08:00
var populated = await beatmapCache.GetBeatmapAsync(b.ID).ConfigureAwait(false);
if (populated != null)
b.Beatmap = new TournamentBeatmap(populated);
updateLoadProgressMessage($"Populating seeding beatmaps ({i} / {beatmapsRequiringPopulation.Count})");
2020-03-03 17:12:42 +08:00
}
return true;
2019-03-04 12:13:31 +08:00
}
private void updateLoadProgressMessage(string s) => Schedule(() => initialisationText.Text = s);
2023-07-25 19:50:55 +08:00
public void PopulatePlayer(TournamentUser user, Action? success = null, Action? failure = null, bool immediate = false)
{
2022-06-18 07:33:26 +08:00
var req = new GetUserRequest(user.OnlineID, ladder.Ruleset.Value);
if (immediate)
{
API.Perform(req);
populate();
}
else
{
2022-06-24 20:25:23 +08:00
req.Success += _ => { populate(); };
req.Failure += _ =>
{
2022-06-18 07:33:26 +08:00
user.OnlineID = 1;
failure?.Invoke();
};
API.Queue(req);
}
void populate()
{
var res = req.Response;
if (res == null)
return;
2022-06-18 07:33:26 +08:00
user.OnlineID = res.Id;
2022-06-18 07:33:26 +08:00
user.Username = res.Username;
user.CoverUrl = res.CoverUrl;
2022-07-18 13:40:34 +08:00
user.CountryCode = res.CountryCode;
2022-06-18 07:33:26 +08:00
user.Rank = res.Statistics?.GlobalRank;
success?.Invoke();
}
}
public void SaveChanges()
2018-11-06 17:32:59 +08:00
{
if (!bracketLoadTaskCompletionSource.Task.IsCompletedSuccessfully)
{
Logger.Log("Inhibiting bracket save as bracket parsing failed");
return;
}
saveChanges();
}
private void saveChanges()
{
// Serialise before opening stream for writing, so if there's a failure it will leave the file in the previous state.
string serialisedLadder = GetSerialisedLadder();
using (var stream = storage.CreateFileSafely(BRACKET_FILENAME))
using (var sw = new StreamWriter(stream))
sw.Write(serialisedLadder);
}
public string GetSerialisedLadder()
{
foreach (var r in ladder.Rounds)
r.Matches = ladder.Matches.Where(p => p.Round.Value == r).Select(p => p.ID).ToList();
2023-07-25 19:50:55 +08:00
ladder.Progressions = ladder.Matches.Where(p => p.Progression.Value != null).Select(p => new TournamentProgression(p.ID, p.Progression.Value.AsNonNull().ID)).Concat(
ladder.Matches.Where(p => p.LosersProgression.Value != null).Select(p => new TournamentProgression(p.ID, p.LosersProgression.Value.AsNonNull().ID, true)))
.ToList();
return JsonConvert.SerializeObject(ladder,
new JsonSerializerSettings
{
Formatting = Formatting.Indented,
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Ignore,
Converters = new JsonConverter[] { new JsonPointConverter() }
});
2018-11-06 17:32:59 +08:00
}
2019-06-13 18:10:57 +08:00
protected override UserInputManager CreateUserInputManager() => new TournamentInputManager();
private partial class TournamentInputManager : UserInputManager
{
2020-01-22 22:13:21 +08:00
protected override MouseButtonEventManager CreateButtonEventManagerFor(MouseButton button)
2019-06-13 18:10:57 +08:00
{
switch (button)
{
case MouseButton.Right:
return new RightMouseManager(button);
}
2020-01-22 22:13:21 +08:00
return base.CreateButtonEventManagerFor(button);
2019-06-13 18:10:57 +08:00
}
private class RightMouseManager : MouseButtonEventManager
{
public RightMouseManager(MouseButton button)
: base(button)
{
}
public override bool EnableDrag => true; // allow right-mouse dragging for absolute scroll in scroll containers.
public override bool EnableClick => true;
public override bool ChangeFocusOnClick => false;
}
}
2018-11-06 17:32:59 +08:00
}
}