mirror of https://github.com/ppy/osu
426 lines
18 KiB
C#
426 lines
18 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.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Linq.Expressions;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using osu.Framework.Audio;
|
|
using osu.Framework.Audio.Track;
|
|
using osu.Framework.Extensions;
|
|
using osu.Framework.Graphics.Textures;
|
|
using osu.Framework.Graphics.Video;
|
|
using osu.Framework.Lists;
|
|
using osu.Framework.Logging;
|
|
using osu.Framework.Platform;
|
|
using osu.Framework.Threading;
|
|
using osu.Game.Beatmaps.Formats;
|
|
using osu.Game.Database;
|
|
using osu.Game.IO;
|
|
using osu.Game.IO.Archives;
|
|
using osu.Game.Online.API;
|
|
using osu.Game.Online.API.Requests;
|
|
using osu.Game.Rulesets;
|
|
using osu.Game.Rulesets.Objects;
|
|
|
|
namespace osu.Game.Beatmaps
|
|
{
|
|
/// <summary>
|
|
/// Handles the storage and retrieval of Beatmaps/WorkingBeatmaps.
|
|
/// </summary>
|
|
public partial class BeatmapManager : DownloadableArchiveModelManager<BeatmapSetInfo, BeatmapSetFileInfo>
|
|
{
|
|
/// <summary>
|
|
/// Fired when a single difficulty has been hidden.
|
|
/// </summary>
|
|
public event Action<BeatmapInfo> BeatmapHidden;
|
|
|
|
/// <summary>
|
|
/// Fired when a single difficulty has been restored.
|
|
/// </summary>
|
|
public event Action<BeatmapInfo> BeatmapRestored;
|
|
|
|
/// <summary>
|
|
/// A default representation of a WorkingBeatmap to use when no beatmap is available.
|
|
/// </summary>
|
|
public readonly WorkingBeatmap DefaultBeatmap;
|
|
|
|
public override string[] HandledExtensions => new[] { ".osz" };
|
|
|
|
protected override string[] HashableFileTypes => new[] { ".osu" };
|
|
|
|
protected override string ImportFromStablePath => "Songs";
|
|
|
|
private readonly RulesetStore rulesets;
|
|
|
|
private readonly BeatmapStore beatmaps;
|
|
|
|
private readonly AudioManager audioManager;
|
|
|
|
private readonly GameHost host;
|
|
|
|
private readonly BeatmapUpdateQueue updateQueue;
|
|
|
|
public BeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, AudioManager audioManager, GameHost host = null,
|
|
WorkingBeatmap defaultBeatmap = null)
|
|
: base(storage, contextFactory, api, new BeatmapStore(contextFactory), host)
|
|
{
|
|
this.rulesets = rulesets;
|
|
this.audioManager = audioManager;
|
|
this.host = host;
|
|
|
|
DefaultBeatmap = defaultBeatmap;
|
|
|
|
beatmaps = (BeatmapStore)ModelStore;
|
|
beatmaps.BeatmapHidden += b => BeatmapHidden?.Invoke(b);
|
|
beatmaps.BeatmapRestored += b => BeatmapRestored?.Invoke(b);
|
|
|
|
updateQueue = new BeatmapUpdateQueue(api);
|
|
}
|
|
|
|
protected override ArchiveDownloadRequest<BeatmapSetInfo> CreateDownloadRequest(BeatmapSetInfo set, bool minimiseDownloadSize) =>
|
|
new DownloadBeatmapSetRequest(set, minimiseDownloadSize);
|
|
|
|
protected override bool ShouldDeleteArchive(string path) => Path.GetExtension(path)?.ToLowerInvariant() == ".osz";
|
|
|
|
protected override Task Populate(BeatmapSetInfo beatmapSet, ArchiveReader archive, CancellationToken cancellationToken = default)
|
|
{
|
|
if (archive != null)
|
|
beatmapSet.Beatmaps = createBeatmapDifficulties(beatmapSet.Files);
|
|
|
|
foreach (BeatmapInfo b in beatmapSet.Beatmaps)
|
|
{
|
|
// remove metadata from difficulties where it matches the set
|
|
if (beatmapSet.Metadata.Equals(b.Metadata))
|
|
b.Metadata = null;
|
|
|
|
b.BeatmapSet = beatmapSet;
|
|
}
|
|
|
|
validateOnlineIds(beatmapSet);
|
|
|
|
return updateQueue.UpdateAsync(beatmapSet, cancellationToken);
|
|
}
|
|
|
|
protected override void PreImport(BeatmapSetInfo beatmapSet)
|
|
{
|
|
if (beatmapSet.Beatmaps.Any(b => b.BaseDifficulty == null))
|
|
throw new InvalidOperationException($"Cannot import {nameof(BeatmapInfo)} with null {nameof(BeatmapInfo.BaseDifficulty)}.");
|
|
|
|
// check if a set already exists with the same online id, delete if it does.
|
|
if (beatmapSet.OnlineBeatmapSetID != null)
|
|
{
|
|
var existingOnlineId = beatmaps.ConsumableItems.FirstOrDefault(b => b.OnlineBeatmapSetID == beatmapSet.OnlineBeatmapSetID);
|
|
|
|
if (existingOnlineId != null)
|
|
{
|
|
Delete(existingOnlineId);
|
|
beatmaps.PurgeDeletable(s => s.ID == existingOnlineId.ID);
|
|
LogForModel(beatmapSet, $"Found existing beatmap set with same OnlineBeatmapSetID ({beatmapSet.OnlineBeatmapSetID}). It has been purged.");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void validateOnlineIds(BeatmapSetInfo beatmapSet)
|
|
{
|
|
var beatmapIds = beatmapSet.Beatmaps.Where(b => b.OnlineBeatmapID.HasValue).Select(b => b.OnlineBeatmapID).ToList();
|
|
|
|
LogForModel(beatmapSet, "Validating online IDs...");
|
|
|
|
// ensure all IDs are unique
|
|
if (beatmapIds.GroupBy(b => b).Any(g => g.Count() > 1))
|
|
{
|
|
LogForModel(beatmapSet, "Found non-unique IDs, resetting...");
|
|
resetIds();
|
|
return;
|
|
}
|
|
|
|
// find any existing beatmaps in the database that have matching online ids
|
|
var existingBeatmaps = QueryBeatmaps(b => beatmapIds.Contains(b.OnlineBeatmapID)).ToList();
|
|
|
|
if (existingBeatmaps.Count > 0)
|
|
{
|
|
// reset the import ids (to force a re-fetch) *unless* they match the candidate CheckForExisting set.
|
|
// we can ignore the case where the new ids are contained by the CheckForExisting set as it will either be used (import skipped) or deleted.
|
|
var existing = CheckForExisting(beatmapSet);
|
|
|
|
if (existing == null || existingBeatmaps.Any(b => !existing.Beatmaps.Contains(b)))
|
|
{
|
|
LogForModel(beatmapSet, "Found existing import with IDs already, resetting...");
|
|
resetIds();
|
|
}
|
|
}
|
|
|
|
void resetIds() => beatmapSet.Beatmaps.ForEach(b => b.OnlineBeatmapID = null);
|
|
}
|
|
|
|
protected override bool CheckLocalAvailability(BeatmapSetInfo model, IQueryable<BeatmapSetInfo> items) => items.Any(b => b.OnlineBeatmapSetID == model.OnlineBeatmapSetID);
|
|
|
|
/// <summary>
|
|
/// Delete a beatmap difficulty.
|
|
/// </summary>
|
|
/// <param name="beatmap">The beatmap difficulty to hide.</param>
|
|
public void Hide(BeatmapInfo beatmap) => beatmaps.Hide(beatmap);
|
|
|
|
/// <summary>
|
|
/// Restore a beatmap difficulty.
|
|
/// </summary>
|
|
/// <param name="beatmap">The beatmap difficulty to restore.</param>
|
|
public void Restore(BeatmapInfo beatmap) => beatmaps.Restore(beatmap);
|
|
|
|
private readonly WeakList<WorkingBeatmap> workingCache = new WeakList<WorkingBeatmap>();
|
|
|
|
/// <summary>
|
|
/// Retrieve a <see cref="WorkingBeatmap"/> instance for the provided <see cref="BeatmapInfo"/>
|
|
/// </summary>
|
|
/// <param name="beatmapInfo">The beatmap to lookup.</param>
|
|
/// <param name="previous">The currently loaded <see cref="WorkingBeatmap"/>. Allows for optimisation where elements are shared with the new beatmap. May be returned if beatmapInfo requested matches</param>
|
|
/// <returns>A <see cref="WorkingBeatmap"/> instance correlating to the provided <see cref="BeatmapInfo"/>.</returns>
|
|
public WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo, WorkingBeatmap previous = null)
|
|
{
|
|
if (beatmapInfo?.ID > 0 && previous != null && previous.BeatmapInfo?.ID == beatmapInfo.ID)
|
|
return previous;
|
|
|
|
if (beatmapInfo?.BeatmapSet == null || beatmapInfo == DefaultBeatmap?.BeatmapInfo)
|
|
return DefaultBeatmap;
|
|
|
|
lock (workingCache)
|
|
{
|
|
var working = workingCache.FirstOrDefault(w => w.BeatmapInfo?.ID == beatmapInfo.ID);
|
|
|
|
if (working == null)
|
|
{
|
|
if (beatmapInfo.Metadata == null)
|
|
beatmapInfo.Metadata = beatmapInfo.BeatmapSet.Metadata;
|
|
|
|
workingCache.Add(working = new BeatmapManagerWorkingBeatmap(Files.Store,
|
|
new LargeTextureStore(host?.CreateTextureLoaderStore(Files.Store)), beatmapInfo, audioManager));
|
|
}
|
|
|
|
previous?.TransferTo(working);
|
|
return working;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Perform a lookup query on available <see cref="BeatmapSetInfo"/>s.
|
|
/// </summary>
|
|
/// <param name="query">The query.</param>
|
|
/// <returns>The first result for the provided query, or null if no results were found.</returns>
|
|
public BeatmapSetInfo QueryBeatmapSet(Expression<Func<BeatmapSetInfo, bool>> query) => beatmaps.ConsumableItems.AsNoTracking().FirstOrDefault(query);
|
|
|
|
protected override bool CanUndelete(BeatmapSetInfo existing, BeatmapSetInfo import)
|
|
{
|
|
if (!base.CanUndelete(existing, import))
|
|
return false;
|
|
|
|
var existingIds = existing.Beatmaps.Select(b => b.OnlineBeatmapID).OrderBy(i => i);
|
|
var importIds = import.Beatmaps.Select(b => b.OnlineBeatmapID).OrderBy(i => i);
|
|
|
|
// force re-import if we are not in a sane state.
|
|
return existing.OnlineBeatmapSetID == import.OnlineBeatmapSetID && existingIds.SequenceEqual(importIds);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a list of all usable <see cref="BeatmapSetInfo"/>s.
|
|
/// </summary>
|
|
/// <returns>A list of available <see cref="BeatmapSetInfo"/>.</returns>
|
|
public List<BeatmapSetInfo> GetAllUsableBeatmapSets() => GetAllUsableBeatmapSetsEnumerable().ToList();
|
|
|
|
/// <summary>
|
|
/// Returns a list of all usable <see cref="BeatmapSetInfo"/>s.
|
|
/// </summary>
|
|
/// <returns>A list of available <see cref="BeatmapSetInfo"/>.</returns>
|
|
public IQueryable<BeatmapSetInfo> GetAllUsableBeatmapSetsEnumerable() => beatmaps.ConsumableItems.Where(s => !s.DeletePending && !s.Protected);
|
|
|
|
/// <summary>
|
|
/// Perform a lookup query on available <see cref="BeatmapSetInfo"/>s.
|
|
/// </summary>
|
|
/// <param name="query">The query.</param>
|
|
/// <returns>Results from the provided query.</returns>
|
|
public IEnumerable<BeatmapSetInfo> QueryBeatmapSets(Expression<Func<BeatmapSetInfo, bool>> query) => beatmaps.ConsumableItems.AsNoTracking().Where(query);
|
|
|
|
/// <summary>
|
|
/// Perform a lookup query on available <see cref="BeatmapInfo"/>s.
|
|
/// </summary>
|
|
/// <param name="query">The query.</param>
|
|
/// <returns>The first result for the provided query, or null if no results were found.</returns>
|
|
public BeatmapInfo QueryBeatmap(Expression<Func<BeatmapInfo, bool>> query) => beatmaps.Beatmaps.AsNoTracking().FirstOrDefault(query);
|
|
|
|
/// <summary>
|
|
/// Perform a lookup query on available <see cref="BeatmapInfo"/>s.
|
|
/// </summary>
|
|
/// <param name="query">The query.</param>
|
|
/// <returns>Results from the provided query.</returns>
|
|
public IQueryable<BeatmapInfo> QueryBeatmaps(Expression<Func<BeatmapInfo, bool>> query) => beatmaps.Beatmaps.AsNoTracking().Where(query);
|
|
|
|
protected override string HumanisedModelName => "beatmap";
|
|
|
|
protected override BeatmapSetInfo CreateModel(ArchiveReader reader)
|
|
{
|
|
// let's make sure there are actually .osu files to import.
|
|
string mapName = reader.Filenames.FirstOrDefault(f => f.EndsWith(".osu"));
|
|
|
|
if (string.IsNullOrEmpty(mapName))
|
|
{
|
|
Logger.Log($"No beatmap files found in the beatmap archive ({reader.Name}).", LoggingTarget.Database);
|
|
return null;
|
|
}
|
|
|
|
Beatmap beatmap;
|
|
using (var stream = new LineBufferedReader(reader.GetStream(mapName)))
|
|
beatmap = Decoder.GetDecoder<Beatmap>(stream).Decode(stream);
|
|
|
|
return new BeatmapSetInfo
|
|
{
|
|
OnlineBeatmapSetID = beatmap.BeatmapInfo.BeatmapSet?.OnlineBeatmapSetID,
|
|
Beatmaps = new List<BeatmapInfo>(),
|
|
Metadata = beatmap.Metadata,
|
|
DateAdded = DateTimeOffset.UtcNow
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create all required <see cref="BeatmapInfo"/>s for the provided archive.
|
|
/// </summary>
|
|
private List<BeatmapInfo> createBeatmapDifficulties(List<BeatmapSetFileInfo> files)
|
|
{
|
|
var beatmapInfos = new List<BeatmapInfo>();
|
|
|
|
foreach (var file in files.Where(f => f.Filename.EndsWith(".osu")))
|
|
{
|
|
using (var raw = Files.Store.GetStream(file.FileInfo.StoragePath))
|
|
using (var ms = new MemoryStream()) //we need a memory stream so we can seek
|
|
using (var sr = new LineBufferedReader(ms))
|
|
{
|
|
raw.CopyTo(ms);
|
|
ms.Position = 0;
|
|
|
|
var decoder = Decoder.GetDecoder<Beatmap>(sr);
|
|
IBeatmap beatmap = decoder.Decode(sr);
|
|
|
|
string hash = ms.ComputeSHA2Hash();
|
|
|
|
if (beatmapInfos.Any(b => b.Hash == hash))
|
|
continue;
|
|
|
|
beatmap.BeatmapInfo.Path = file.Filename;
|
|
beatmap.BeatmapInfo.Hash = hash;
|
|
beatmap.BeatmapInfo.MD5Hash = ms.ComputeMD5Hash();
|
|
|
|
var ruleset = rulesets.GetRuleset(beatmap.BeatmapInfo.RulesetID);
|
|
beatmap.BeatmapInfo.Ruleset = ruleset;
|
|
|
|
// TODO: this should be done in a better place once we actually need to dynamically update it.
|
|
beatmap.BeatmapInfo.StarDifficulty = ruleset?.CreateInstance().CreateDifficultyCalculator(new DummyConversionBeatmap(beatmap)).Calculate().StarRating ?? 0;
|
|
beatmap.BeatmapInfo.Length = calculateLength(beatmap);
|
|
beatmap.BeatmapInfo.BPM = beatmap.ControlPointInfo.BPMMode;
|
|
|
|
beatmapInfos.Add(beatmap.BeatmapInfo);
|
|
}
|
|
}
|
|
|
|
return beatmapInfos;
|
|
}
|
|
|
|
private double calculateLength(IBeatmap b)
|
|
{
|
|
if (!b.HitObjects.Any())
|
|
return 0;
|
|
|
|
var lastObject = b.HitObjects.Last();
|
|
|
|
//TODO: this isn't always correct (consider mania where a non-last object may last for longer than the last in the list).
|
|
double endTime = lastObject.GetEndTime();
|
|
double startTime = b.HitObjects.First().StartTime;
|
|
|
|
return endTime - startTime;
|
|
}
|
|
|
|
/// <summary>
|
|
/// A dummy WorkingBeatmap for the purpose of retrieving a beatmap for star difficulty calculation.
|
|
/// </summary>
|
|
private class DummyConversionBeatmap : WorkingBeatmap
|
|
{
|
|
private readonly IBeatmap beatmap;
|
|
|
|
public DummyConversionBeatmap(IBeatmap beatmap)
|
|
: base(beatmap.BeatmapInfo, null)
|
|
{
|
|
this.beatmap = beatmap;
|
|
}
|
|
|
|
protected override IBeatmap GetBeatmap() => beatmap;
|
|
protected override Texture GetBackground() => null;
|
|
protected override VideoSprite GetVideo() => null;
|
|
protected override Track GetTrack() => null;
|
|
}
|
|
|
|
private class BeatmapUpdateQueue
|
|
{
|
|
private readonly IAPIProvider api;
|
|
|
|
private const int update_queue_request_concurrency = 4;
|
|
|
|
private readonly ThreadedTaskScheduler updateScheduler = new ThreadedTaskScheduler(update_queue_request_concurrency, nameof(BeatmapUpdateQueue));
|
|
|
|
public BeatmapUpdateQueue(IAPIProvider api)
|
|
{
|
|
this.api = api;
|
|
}
|
|
|
|
public Task UpdateAsync(BeatmapSetInfo beatmapSet, CancellationToken cancellationToken)
|
|
{
|
|
if (api?.State != APIState.Online)
|
|
return Task.CompletedTask;
|
|
|
|
LogForModel(beatmapSet, "Performing online lookups...");
|
|
return Task.WhenAll(beatmapSet.Beatmaps.Select(b => UpdateAsync(beatmapSet, b, cancellationToken)).ToArray());
|
|
}
|
|
|
|
// todo: expose this when we need to do individual difficulty lookups.
|
|
protected Task UpdateAsync(BeatmapSetInfo beatmapSet, BeatmapInfo beatmap, CancellationToken cancellationToken)
|
|
=> Task.Factory.StartNew(() => update(beatmapSet, beatmap), cancellationToken, TaskCreationOptions.HideScheduler, updateScheduler);
|
|
|
|
private void update(BeatmapSetInfo set, BeatmapInfo beatmap)
|
|
{
|
|
if (api?.State != APIState.Online)
|
|
return;
|
|
|
|
var req = new GetBeatmapRequest(beatmap);
|
|
|
|
req.Failure += fail;
|
|
|
|
try
|
|
{
|
|
// intentionally blocking to limit web request concurrency
|
|
api.Perform(req);
|
|
|
|
var res = req.Result;
|
|
|
|
beatmap.Status = res.Status;
|
|
beatmap.BeatmapSet.Status = res.BeatmapSet.Status;
|
|
beatmap.BeatmapSet.OnlineBeatmapSetID = res.OnlineBeatmapSetID;
|
|
beatmap.OnlineBeatmapID = res.OnlineBeatmapID;
|
|
|
|
LogForModel(set, $"Online retrieval mapped {beatmap} to {res.OnlineBeatmapSetID} / {res.OnlineBeatmapID}.");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
fail(e);
|
|
}
|
|
|
|
void fail(Exception e)
|
|
{
|
|
beatmap.OnlineBeatmapID = null;
|
|
LogForModel(set, $"Online retrieval failed for {beatmap} ({e.Message})");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|