mirror of https://github.com/ppy/osu
375 lines
13 KiB
C#
375 lines
13 KiB
C#
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
|
|
// See the LICENCE file in the repository root for full licence text.
|
|
|
|
using System;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using Newtonsoft.Json;
|
|
using osu.Framework.Allocation;
|
|
using osu.Framework.Bindables;
|
|
using osu.Framework.Configuration;
|
|
using osu.Framework.Graphics;
|
|
using osu.Framework.Graphics.Containers;
|
|
using osu.Framework.Graphics.Shapes;
|
|
using osu.Framework.Graphics.Textures;
|
|
using osu.Framework.Input;
|
|
using osu.Framework.IO.Stores;
|
|
using osu.Framework.Platform;
|
|
using osu.Game.Beatmaps;
|
|
using osu.Game.Graphics;
|
|
using osu.Game.Online.API.Requests;
|
|
using osu.Game.Tournament.IPC;
|
|
using osu.Game.Tournament.Models;
|
|
using osu.Game.Users;
|
|
using osuTK;
|
|
using osuTK.Graphics;
|
|
using osuTK.Input;
|
|
|
|
namespace osu.Game.Tournament
|
|
{
|
|
[Cached(typeof(TournamentGameBase))]
|
|
public abstract class TournamentGameBase : OsuGameBase
|
|
{
|
|
private const string bracket_filename = "bracket.json";
|
|
|
|
private LadderInfo ladder;
|
|
|
|
private Storage storage;
|
|
|
|
private TournamentStorage tournamentStorage;
|
|
|
|
private DependencyContainer dependencies;
|
|
|
|
private Bindable<Size> windowSize;
|
|
private FileBasedIPC ipc;
|
|
|
|
private Drawable heightWarning;
|
|
|
|
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
|
|
{
|
|
return dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
|
|
}
|
|
|
|
[BackgroundDependencyLoader]
|
|
private void load(Storage storage, FrameworkConfigManager frameworkConfig)
|
|
{
|
|
Resources.AddStore(new DllResourceStore(typeof(TournamentGameBase).Assembly));
|
|
|
|
dependencies.CacheAs(tournamentStorage = new TournamentStorage(storage));
|
|
|
|
Textures.AddStore(new TextureLoaderStore(tournamentStorage));
|
|
|
|
this.storage = storage;
|
|
|
|
windowSize = frameworkConfig.GetBindable<Size>(FrameworkSetting.WindowedSize);
|
|
windowSize.BindValueChanged(size => ScheduleAfterChildren(() =>
|
|
{
|
|
var minWidth = (int)(size.NewValue.Height / 768f * TournamentSceneManager.REQUIRED_WIDTH) - 1;
|
|
|
|
heightWarning.Alpha = size.NewValue.Width < minWidth ? 1 : 0;
|
|
}), true);
|
|
|
|
readBracket();
|
|
|
|
ladder.CurrentMatch.Value = ladder.Matches.FirstOrDefault(p => p.Current.Value);
|
|
|
|
dependencies.CacheAs<MatchIPCInfo>(ipc = new FileBasedIPC());
|
|
Add(ipc);
|
|
|
|
AddRange(new[]
|
|
{
|
|
new Container
|
|
{
|
|
CornerRadius = 10,
|
|
Depth = float.MinValue,
|
|
Position = new Vector2(5),
|
|
Masking = true,
|
|
AutoSizeAxes = Axes.Both,
|
|
Anchor = Anchor.BottomRight,
|
|
Origin = Anchor.BottomRight,
|
|
Children = new Drawable[]
|
|
{
|
|
new Box
|
|
{
|
|
Colour = OsuColour.Gray(0.2f),
|
|
RelativeSizeAxes = Axes.Both,
|
|
},
|
|
new TourneyButton
|
|
{
|
|
Text = "Save Changes",
|
|
Width = 140,
|
|
Height = 50,
|
|
Padding = new MarginPadding
|
|
{
|
|
Top = 10,
|
|
Left = 10,
|
|
},
|
|
Margin = new MarginPadding
|
|
{
|
|
Right = 10,
|
|
Bottom = 10,
|
|
},
|
|
Action = SaveChanges,
|
|
},
|
|
}
|
|
},
|
|
heightWarning = new Container
|
|
{
|
|
Masking = true,
|
|
CornerRadius = 5,
|
|
Depth = float.MinValue,
|
|
Anchor = Anchor.Centre,
|
|
Origin = Anchor.Centre,
|
|
AutoSizeAxes = Axes.Both,
|
|
Children = new Drawable[]
|
|
{
|
|
new Box
|
|
{
|
|
Colour = Color4.Red,
|
|
RelativeSizeAxes = Axes.Both,
|
|
},
|
|
new TournamentSpriteText
|
|
{
|
|
Text = "Please make the window wider",
|
|
Font = OsuFont.Torus.With(weight: FontWeight.Bold),
|
|
Colour = Color4.White,
|
|
Padding = new MarginPadding(20)
|
|
}
|
|
}
|
|
},
|
|
});
|
|
}
|
|
|
|
private void readBracket()
|
|
{
|
|
if (storage.Exists(bracket_filename))
|
|
{
|
|
using (Stream stream = storage.GetStream(bracket_filename, FileAccess.Read, FileMode.Open))
|
|
using (var sr = new StreamReader(stream))
|
|
ladder = JsonConvert.DeserializeObject<LadderInfo>(sr.ReadToEnd());
|
|
}
|
|
|
|
if (ladder == null)
|
|
ladder = new LadderInfo();
|
|
|
|
if (ladder.Ruleset.Value == null)
|
|
ladder.Ruleset.Value = RulesetStore.AvailableRulesets.First();
|
|
|
|
Ruleset.BindTo(ladder.Ruleset);
|
|
|
|
dependencies.Cache(ladder);
|
|
|
|
bool addedInfo = false;
|
|
|
|
// assign teams
|
|
foreach (var match in ladder.Matches)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
// 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);
|
|
|
|
if (src == null)
|
|
continue;
|
|
|
|
if (dest != null)
|
|
{
|
|
if (pair.Losers)
|
|
src.LosersProgression.Value = dest;
|
|
else
|
|
src.Progression.Value = dest;
|
|
}
|
|
}
|
|
|
|
// link matches to rounds
|
|
foreach (var round in ladder.Rounds)
|
|
{
|
|
foreach (var id in round.Matches)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
addedInfo |= addPlayers();
|
|
addedInfo |= addBeatmaps();
|
|
|
|
if (addedInfo)
|
|
SaveChanges();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add missing player info based on user IDs.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private bool addPlayers()
|
|
{
|
|
bool addedInfo = false;
|
|
|
|
foreach (var t in ladder.Teams)
|
|
{
|
|
foreach (var p in t.Players)
|
|
{
|
|
if (string.IsNullOrEmpty(p.Username) || p.Statistics == null)
|
|
{
|
|
PopulateUser(p);
|
|
addedInfo = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return addedInfo;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add missing beatmap info based on beatmap IDs
|
|
/// </summary>
|
|
private bool addBeatmaps()
|
|
{
|
|
bool addedInfo = false;
|
|
|
|
foreach (var r in ladder.Rounds)
|
|
{
|
|
foreach (var b in r.Beatmaps.ToList())
|
|
{
|
|
if (b.BeatmapInfo != null)
|
|
continue;
|
|
|
|
if (b.ID > 0)
|
|
{
|
|
var req = new GetBeatmapRequest(new BeatmapInfo { OnlineBeatmapID = b.ID });
|
|
API.Perform(req);
|
|
b.BeatmapInfo = req.Result?.ToBeatmap(RulesetStore);
|
|
|
|
addedInfo = true;
|
|
}
|
|
|
|
if (b.BeatmapInfo == null)
|
|
// if online population couldn't be performed, ensure we don't leave a null value behind
|
|
r.Beatmaps.Remove(b);
|
|
}
|
|
}
|
|
|
|
foreach (var t in ladder.Teams)
|
|
{
|
|
foreach (var s in t.SeedingResults)
|
|
{
|
|
foreach (var b in s.Beatmaps)
|
|
{
|
|
if (b.BeatmapInfo == null && b.ID > 0)
|
|
{
|
|
var req = new GetBeatmapRequest(new BeatmapInfo { OnlineBeatmapID = b.ID });
|
|
req.Perform(API);
|
|
b.BeatmapInfo = req.Result?.ToBeatmap(RulesetStore);
|
|
|
|
addedInfo = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return addedInfo;
|
|
}
|
|
|
|
public void PopulateUser(User user, Action success = null, Action failure = null)
|
|
{
|
|
var req = new GetUserRequest(user.Id, Ruleset.Value);
|
|
|
|
req.Success += res =>
|
|
{
|
|
user.Username = res.Username;
|
|
user.Statistics = res.Statistics;
|
|
user.Country = res.Country;
|
|
user.Cover = res.Cover;
|
|
|
|
success?.Invoke();
|
|
};
|
|
|
|
req.Failure += _ =>
|
|
{
|
|
user.Id = 1;
|
|
failure?.Invoke();
|
|
};
|
|
|
|
API.Queue(req);
|
|
}
|
|
|
|
protected override void LoadComplete()
|
|
{
|
|
MenuCursorContainer.Cursor.AlwaysPresent = true; // required for tooltip display
|
|
MenuCursorContainer.Cursor.Alpha = 0;
|
|
|
|
base.LoadComplete();
|
|
}
|
|
|
|
protected virtual void SaveChanges()
|
|
{
|
|
foreach (var r in ladder.Rounds)
|
|
r.Matches = ladder.Matches.Where(p => p.Round.Value == r).Select(p => p.ID).ToList();
|
|
|
|
ladder.Progressions = ladder.Matches.Where(p => p.Progression.Value != null).Select(p => new TournamentProgression(p.ID, p.Progression.Value.ID)).Concat(
|
|
ladder.Matches.Where(p => p.LosersProgression.Value != null).Select(p => new TournamentProgression(p.ID, p.LosersProgression.Value.ID, true)))
|
|
.ToList();
|
|
|
|
using (var stream = storage.GetStream(bracket_filename, FileAccess.Write, FileMode.Create))
|
|
using (var sw = new StreamWriter(stream))
|
|
{
|
|
sw.Write(JsonConvert.SerializeObject(ladder,
|
|
new JsonSerializerSettings
|
|
{
|
|
Formatting = Formatting.Indented,
|
|
NullValueHandling = NullValueHandling.Ignore,
|
|
DefaultValueHandling = DefaultValueHandling.Ignore,
|
|
}));
|
|
}
|
|
}
|
|
|
|
protected override UserInputManager CreateUserInputManager() => new TournamentInputManager();
|
|
|
|
private class TournamentInputManager : UserInputManager
|
|
{
|
|
protected override MouseButtonEventManager CreateButtonEventManagerFor(MouseButton button)
|
|
{
|
|
switch (button)
|
|
{
|
|
case MouseButton.Right:
|
|
return new RightMouseManager(button);
|
|
}
|
|
|
|
return base.CreateButtonEventManagerFor(button);
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
}
|