osu/osu.Game/Rulesets/UI/DrawableRuleset.cs

554 lines
20 KiB
C#
Raw Normal View History

// 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-04-13 09:19:50 +00:00
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Game.Beatmaps;
using osu.Game.Rulesets.Judgements;
using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Objects.Drawables;
using System;
using System.Collections.Generic;
2019-09-06 03:12:27 +00:00
using System.IO;
2018-04-13 09:19:50 +00:00
using System.Linq;
using System.Threading;
2019-09-06 03:12:27 +00:00
using System.Threading.Tasks;
using JetBrains.Annotations;
using osu.Framework.Audio;
2019-09-06 03:12:27 +00:00
using osu.Framework.Audio.Sample;
using osu.Framework.Audio.Track;
2019-02-21 10:04:31 +00:00
using osu.Framework.Bindables;
2018-04-13 09:19:50 +00:00
using osu.Framework.Graphics.Cursor;
using osu.Framework.Graphics.Textures;
2018-04-13 09:19:50 +00:00
using osu.Framework.Input;
using osu.Framework.Input.Events;
using osu.Framework.IO.Stores;
2018-04-13 09:19:50 +00:00
using osu.Game.Configuration;
using osu.Game.Graphics.Cursor;
2018-04-13 09:19:50 +00:00
using osu.Game.Input.Handlers;
using osu.Game.Overlays;
2018-11-28 08:20:37 +00:00
using osu.Game.Replays;
2018-04-13 09:19:50 +00:00
using osu.Game.Rulesets.Configuration;
using osu.Game.Rulesets.Scoring;
using osu.Game.Scoring;
using osu.Game.Screens.Play;
using osuTK;
2018-04-13 09:19:50 +00:00
namespace osu.Game.Rulesets.UI
{
/// <summary>
/// Displays an interactive ruleset gameplay instance.
2018-04-13 09:19:50 +00:00
/// </summary>
/// <typeparam name="TObject">The type of HitObject contained by this DrawableRuleset.</typeparam>
public abstract class DrawableRuleset<TObject> : DrawableRuleset, IProvideCursor, ICanAttachKeyCounter
where TObject : HitObject
2018-04-13 09:19:50 +00:00
{
2019-12-11 08:25:06 +00:00
public override event Action<JudgementResult> OnNewResult;
public override event Action<JudgementResult> OnRevertResult;
2018-04-13 09:19:50 +00:00
/// <summary>
/// The selected variant.
/// </summary>
public virtual int Variant => 0;
/// <summary>
/// The key conversion input manager for this DrawableRuleset.
2018-04-13 09:19:50 +00:00
/// </summary>
public PassThroughInputManager KeyBindingInputManager;
public override double GameplayStartTime => Objects.First().StartTime - 2000;
2018-04-13 09:19:50 +00:00
private readonly Lazy<Playfield> playfield;
2018-06-06 05:20:51 +00:00
private TextureStore textureStore;
private ISampleStore localSampleStore;
2018-04-13 09:19:50 +00:00
/// <summary>
/// The playfield.
/// </summary>
2019-06-04 07:13:16 +00:00
public override Playfield Playfield => playfield.Value;
2018-04-13 09:19:50 +00:00
private Container overlays;
public override Container Overlays => overlays;
public override GameplayClock FrameStableClock => frameStabilityContainer.GameplayClock;
private bool frameStablePlayback = true;
/// <summary>
/// Whether to enable frame-stable playback.
/// </summary>
internal bool FrameStablePlayback
{
get => frameStablePlayback;
set
{
frameStablePlayback = false;
if (frameStabilityContainer != null)
frameStabilityContainer.FrameStablePlayback = value;
}
}
2019-03-20 05:55:38 +00:00
/// <summary>
/// The beatmap.
/// </summary>
public readonly Beatmap<TObject> Beatmap;
2018-04-13 09:19:50 +00:00
2019-03-20 05:55:38 +00:00
public override IEnumerable<HitObject> Objects => Beatmap.HitObjects;
2018-04-13 09:19:50 +00:00
2018-07-11 08:25:57 +00:00
protected IRulesetConfigManager Config { get; private set; }
2019-03-20 05:55:38 +00:00
/// <summary>
/// The mods which are to be applied.
/// </summary>
2019-04-10 08:11:17 +00:00
[Cached(typeof(IReadOnlyList<Mod>))]
private readonly IReadOnlyList<Mod> mods;
2019-03-20 05:55:38 +00:00
private FrameStabilityContainer frameStabilityContainer;
2018-04-13 09:19:50 +00:00
private OnScreenDisplay onScreenDisplay;
/// <summary>
/// Creates a ruleset visualisation for the provided ruleset and beatmap.
2018-04-13 09:19:50 +00:00
/// </summary>
2019-03-20 05:55:38 +00:00
/// <param name="ruleset">The ruleset being represented.</param>
/// <param name="beatmap">The beatmap to create the hit renderer for.</param>
2019-04-25 08:36:17 +00:00
/// <param name="mods">The <see cref="Mod"/>s to apply.</param>
protected DrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null)
: base(ruleset)
2018-04-13 09:19:50 +00:00
{
if (beatmap == null)
throw new ArgumentNullException(nameof(beatmap), "Beatmap cannot be null.");
2019-04-08 09:32:05 +00:00
if (!(beatmap is Beatmap<TObject> tBeatmap))
throw new ArgumentException($"{GetType()} expected the beatmap to contain hitobjects of type {typeof(TObject)}.", nameof(beatmap));
Beatmap = tBeatmap;
this.mods = mods?.ToArray() ?? Array.Empty<Mod>();
RelativeSizeAxes = Axes.Both;
KeyBindingInputManager = CreateInputManager();
2018-04-13 09:19:50 +00:00
playfield = new Lazy<Playfield>(CreatePlayfield);
IsPaused.ValueChanged += paused =>
2018-07-11 08:01:27 +00:00
{
2019-02-21 09:56:34 +00:00
if (HasReplayLoaded.Value)
2018-07-11 08:01:27 +00:00
return;
KeyBindingInputManager.UseParentInput = !paused.NewValue;
2018-07-11 08:01:27 +00:00
};
2018-04-13 09:19:50 +00:00
}
2018-05-06 10:57:52 +00:00
2018-07-11 08:07:14 +00:00
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
2018-04-13 09:19:50 +00:00
{
2018-07-11 08:07:14 +00:00
var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
var resources = Ruleset.CreateResourceStore();
if (resources != null)
{
textureStore = new TextureStore(new TextureLoaderStore(new NamespacedResourceStore<byte[]>(resources, "Textures")));
textureStore.AddStore(dependencies.Get<TextureStore>());
dependencies.Cache(textureStore);
localSampleStore = dependencies.Get<AudioManager>().GetSampleStore(new NamespacedResourceStore<byte[]>(resources, "Samples"));
localSampleStore.PlaybackConcurrency = OsuGameBase.SAMPLE_CONCURRENCY;
dependencies.CacheAs<ISampleStore>(new FallbackSampleStore(localSampleStore, dependencies.Get<ISampleStore>()));
}
onScreenDisplay = dependencies.Get<OnScreenDisplay>();
2018-05-21 06:56:02 +00:00
2018-07-11 08:25:57 +00:00
Config = dependencies.Get<RulesetConfigCache>().GetConfigFor(Ruleset);
2019-04-01 03:16:05 +00:00
2018-07-11 08:25:57 +00:00
if (Config != null)
2018-04-13 09:19:50 +00:00
{
2018-07-11 08:25:57 +00:00
dependencies.Cache(Config);
onScreenDisplay?.BeginTracking(this, Config);
2018-04-13 09:19:50 +00:00
}
return dependencies;
}
2018-06-11 03:57:26 +00:00
public virtual PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new PlayfieldAdjustmentContainer();
2019-03-20 05:55:38 +00:00
[BackgroundDependencyLoader]
2019-05-10 08:42:45 +00:00
private void load(OsuConfigManager config, CancellationToken? cancellationToken)
2019-03-20 05:55:38 +00:00
{
InternalChildren = new Drawable[]
{
frameStabilityContainer = new FrameStabilityContainer(GameplayStartTime)
2019-03-20 05:55:38 +00:00
{
FrameStablePlayback = FrameStablePlayback,
Children = new Drawable[]
{
KeyBindingInputManager
.WithChild(CreatePlayfieldAdjustmentContainer()
.WithChild(Playfield)
),
overlays = new Container { RelativeSizeAxes = Axes.Both }
}
2019-03-20 05:55:38 +00:00
},
};
if ((ResumeOverlay = CreateResumeOverlay()) != null)
{
AddInternal(CreateInputManager()
.WithChild(CreatePlayfieldAdjustmentContainer()
.WithChild(ResumeOverlay)));
}
2019-03-20 05:55:38 +00:00
applyRulesetMods(mods, config);
loadObjects(cancellationToken);
}
2018-04-13 09:19:50 +00:00
/// <summary>
/// Creates and adds drawable representations of hit objects to the play field.
/// </summary>
2019-05-10 08:42:45 +00:00
private void loadObjects(CancellationToken? cancellationToken)
{
foreach (TObject h in Beatmap.HitObjects)
{
2019-05-10 08:42:45 +00:00
cancellationToken?.ThrowIfCancellationRequested();
addHitObject(h);
}
2019-05-10 08:42:45 +00:00
cancellationToken?.ThrowIfCancellationRequested();
2018-04-13 09:19:50 +00:00
Playfield.PostProcess();
foreach (var mod in mods.OfType<IApplicableToDrawableHitObjects>())
mod.ApplyToDrawableHitObjects(Playfield.AllHitObjects);
}
2018-04-13 09:19:50 +00:00
2019-03-21 07:57:40 +00:00
public override void RequestResume(Action continueResume)
{
2019-03-25 13:00:33 +00:00
if (ResumeOverlay != null && (Cursor == null || (Cursor.LastFrameState == Visibility.Visible && Contains(Cursor.ActiveCursor.ScreenSpaceDrawQuad.Centre))))
2019-03-21 07:57:40 +00:00
{
ResumeOverlay.GameplayCursor = Cursor;
2019-03-21 07:57:40 +00:00
ResumeOverlay.ResumeAction = continueResume;
ResumeOverlay.Show();
}
else
continueResume();
}
2019-10-25 19:57:49 +00:00
public override void CancelResume()
{
// called if the user pauses while the resume overlay is open
ResumeOverlay?.Hide();
2019-10-25 19:57:49 +00:00
}
2018-04-13 09:19:50 +00:00
/// <summary>
2019-11-17 12:48:23 +00:00
/// Creates and adds the visual representation of a <typeparamref name="TObject"/> to this <see cref="DrawableRuleset{TObject}"/>.
2018-04-13 09:19:50 +00:00
/// </summary>
2019-11-17 12:48:23 +00:00
/// <param name="hitObject">The <typeparamref name="TObject"/> to add the visual representation for.</param>
private void addHitObject(TObject hitObject)
2018-04-13 09:19:50 +00:00
{
var drawableObject = CreateDrawableRepresentation(hitObject);
if (drawableObject == null)
return;
drawableObject.OnNewResult += (_, r) => OnNewResult?.Invoke(r);
drawableObject.OnRevertResult += (_, r) => OnRevertResult?.Invoke(r);
2018-04-13 09:19:50 +00:00
Playfield.Add(drawableObject);
2018-04-13 09:19:50 +00:00
}
2019-03-20 05:55:38 +00:00
public override void SetReplayScore(Score replayScore)
2018-04-13 09:19:50 +00:00
{
2019-03-20 05:55:38 +00:00
if (!(KeyBindingInputManager is IHasReplayHandler replayInputManager))
throw new InvalidOperationException($"A {nameof(KeyBindingInputManager)} which supports replay loading is not available");
2018-04-13 09:19:50 +00:00
2019-03-20 05:55:38 +00:00
var handler = (ReplayScore = replayScore) != null ? CreateReplayInputHandler(replayScore.Replay) : null;
2018-04-13 09:19:50 +00:00
2019-03-20 05:55:38 +00:00
replayInputManager.ReplayInputHandler = handler;
frameStabilityContainer.ReplayInputHandler = handler;
2019-03-20 05:55:38 +00:00
HasReplayLoaded.Value = replayInputManager.ReplayInputHandler != null;
2018-04-13 09:19:50 +00:00
2019-03-20 05:55:38 +00:00
if (replayInputManager.ReplayInputHandler != null)
replayInputManager.ReplayInputHandler.GamefieldToScreenSpace = Playfield.GamefieldToScreenSpace;
if (!ProvidingUserCursor)
2019-04-23 04:45:51 +00:00
{
// The cursor is hidden by default (see Playfield.load()), but should be shown when there's a replay
Playfield.Cursor?.Show();
2019-04-23 04:45:51 +00:00
}
2019-03-20 05:55:38 +00:00
}
2018-04-13 09:19:50 +00:00
/// <summary>
/// Creates a DrawableHitObject from a HitObject.
2018-04-13 09:19:50 +00:00
/// </summary>
/// <param name="h">The HitObject to make drawable.</param>
/// <returns>The DrawableHitObject.</returns>
public abstract DrawableHitObject<TObject> CreateDrawableRepresentation(TObject h);
2018-04-13 09:19:50 +00:00
public void Attach(KeyCounterDisplay keyCounter) =>
(KeyBindingInputManager as ICanAttachKeyCounter)?.Attach(keyCounter);
2018-04-13 09:19:50 +00:00
/// <summary>
/// Creates a key conversion input manager. An exception will be thrown if a valid <see cref="RulesetInputManager{T}"/> is not returned.
2018-04-13 09:19:50 +00:00
/// </summary>
/// <returns>The input manager.</returns>
protected abstract PassThroughInputManager CreateInputManager();
2018-04-13 09:19:50 +00:00
protected virtual ReplayInputHandler CreateReplayInputHandler(Replay replay) => null;
2020-03-23 10:03:42 +00:00
protected virtual ReplayRecorder CreateReplayRecorder(Replay replay) => null;
2018-04-13 09:19:50 +00:00
/// <summary>
/// Creates a Playfield.
/// </summary>
/// <returns>The Playfield.</returns>
protected abstract Playfield CreatePlayfield();
2018-04-13 09:19:50 +00:00
/// <summary>
/// Applies the active mods to this DrawableRuleset.
2018-04-13 09:19:50 +00:00
/// </summary>
2019-04-25 08:36:17 +00:00
/// <param name="mods">The <see cref="Mod"/>s to apply.</param>
/// <param name="config">The <see cref="OsuConfigManager"/> to apply.</param>
private void applyRulesetMods(IReadOnlyList<Mod> mods, OsuConfigManager config)
2018-04-13 09:19:50 +00:00
{
if (mods == null)
return;
foreach (var mod in mods.OfType<IApplicableToDrawableRuleset<TObject>>())
mod.ApplyToDrawableRuleset(this);
2018-06-06 05:20:51 +00:00
foreach (var mod in mods.OfType<IReadFromConfig>())
mod.ReadFromConfig(config);
2018-04-13 09:19:50 +00:00
}
2019-03-20 05:55:38 +00:00
#region IProvideCursor
protected override bool OnHover(HoverEvent e) => true; // required for IProvideCursor
// only show the cursor when within the playfield, by default.
public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Playfield.ReceivePositionalInputAt(screenSpacePos);
CursorContainer IProvideCursor.Cursor => Playfield.Cursor;
public override GameplayCursorContainer Cursor => Playfield.Cursor;
2019-03-20 05:55:38 +00:00
public bool ProvidingUserCursor => Playfield.Cursor != null && !HasReplayLoaded.Value;
#endregion
protected override void Dispose(bool isDisposing)
2018-04-13 09:19:50 +00:00
{
base.Dispose(isDisposing);
2018-04-13 09:19:50 +00:00
localSampleStore?.Dispose();
if (Config != null)
{
onScreenDisplay?.StopTracking(this, Config);
Config = null;
}
2018-04-13 09:19:50 +00:00
}
}
2018-04-13 09:19:50 +00:00
/// <summary>
/// Displays an interactive ruleset gameplay instance.
/// <remarks>
/// This type is required only for adding non-generic type to the draw hierarchy.
/// Once IDrawable is a thing, this can also become an interface.
/// </remarks>
/// </summary>
public abstract class DrawableRuleset : CompositeDrawable
{
2019-12-11 08:25:06 +00:00
/// <summary>
/// Invoked when a <see cref="JudgementResult"/> has been applied by a <see cref="DrawableHitObject"/>.
/// </summary>
public abstract event Action<JudgementResult> OnNewResult;
/// <summary>
/// Invoked when a <see cref="JudgementResult"/> is being reverted by a <see cref="DrawableHitObject"/>.
/// </summary>
public abstract event Action<JudgementResult> OnRevertResult;
2018-04-13 09:19:50 +00:00
/// <summary>
/// Whether a replay is currently loaded.
2018-04-13 09:19:50 +00:00
/// </summary>
public readonly BindableBool HasReplayLoaded = new BindableBool();
2018-04-13 09:19:50 +00:00
/// <summary>
/// Whether the game is paused. Used to block user input.
/// </summary>
public readonly BindableBool IsPaused = new BindableBool();
2018-04-13 09:19:50 +00:00
2019-06-04 07:13:16 +00:00
/// <summary>
/// The playfield.
/// </summary>
public abstract Playfield Playfield { get; }
/// <summary>
/// Place to put drawables above hit objects but below UI.
/// </summary>
public abstract Container Overlays { get; }
/// <summary>
/// The frame-stable clock which is being used for playfield display.
/// </summary>
public abstract GameplayClock FrameStableClock { get; }
/// <summary>~
/// The associated ruleset.
/// </summary>
public readonly Ruleset Ruleset;
2018-04-13 09:19:50 +00:00
/// <summary>
/// Creates a ruleset visualisation for the provided ruleset.
/// </summary>
/// <param name="ruleset">The ruleset.</param>
internal DrawableRuleset(Ruleset ruleset)
{
Ruleset = ruleset;
}
/// <summary>
/// All the converted hit objects contained by this hit renderer.
/// </summary>
public abstract IEnumerable<HitObject> Objects { get; }
/// <summary>
/// The point in time at which gameplay starts, including any required lead-in for display purposes.
/// Defaults to two seconds before the first <see cref="HitObject"/>. Override as necessary.
/// </summary>
public abstract double GameplayStartTime { get; }
/// <summary>
/// The currently loaded replay. Usually null in the case of a local player.
/// </summary>
public Score ReplayScore { get; protected set; }
2018-04-13 09:19:50 +00:00
/// <summary>
/// The cursor being displayed by the <see cref="Playfield"/>. May be null if no cursor is provided.
2018-04-13 09:19:50 +00:00
/// </summary>
public abstract GameplayCursorContainer Cursor { get; }
2018-04-13 09:19:50 +00:00
/// <summary>
/// An optional overlay used when resuming gameplay from a paused state.
/// </summary>
public ResumeOverlay ResumeOverlay { get; protected set; }
/// <summary>
/// Returns first available <see cref="HitWindows"/> provided by a <see cref="HitObject"/>.
/// </summary>
[CanBeNull]
public HitWindows FirstAvailableHitWindows
{
get
{
foreach (var h in Objects)
{
2019-10-09 10:08:31 +00:00
if (h.HitWindows.WindowFor(HitResult.Miss) > 0)
return h.HitWindows;
foreach (var n in h.NestedHitObjects)
2019-11-11 11:53:22 +00:00
{
2019-10-09 10:08:31 +00:00
if (h.HitWindows.WindowFor(HitResult.Miss) > 0)
return n.HitWindows;
2019-11-11 11:53:22 +00:00
}
}
return null;
}
}
protected virtual ResumeOverlay CreateResumeOverlay() => null;
2018-04-13 09:19:50 +00:00
/// <summary>
/// Sets a replay to be used, overriding local input.
/// </summary>
/// <param name="replayScore">The replay, null for local input.</param>
public abstract void SetReplayScore(Score replayScore);
/// <summary>
/// Invoked when the interactive user requests resuming from a paused state.
/// Allows potentially delaying the resume process until an interaction is performed.
2018-04-13 09:19:50 +00:00
/// </summary>
/// <param name="continueResume">The action to run when resuming is to be completed.</param>
public abstract void RequestResume(Action continueResume);
2018-04-13 09:19:50 +00:00
/// <summary>
/// Invoked when the user requests to pause while the resume overlay is active.
/// </summary>
2019-10-25 19:57:49 +00:00
public abstract void CancelResume();
2018-04-13 09:19:50 +00:00
}
public class BeatmapInvalidForRulesetException : ArgumentException
{
public BeatmapInvalidForRulesetException(string text)
: base(text)
{
}
}
2019-09-06 03:12:27 +00:00
/// <summary>
/// A sample store which adds a fallback source.
/// </summary>
/// <remarks>
/// This is a temporary implementation to workaround ISampleStore limitations.
/// </remarks>
public class FallbackSampleStore : ISampleStore
{
private readonly ISampleStore primary;
private readonly ISampleStore secondary;
public FallbackSampleStore(ISampleStore primary, ISampleStore secondary)
{
this.primary = primary;
this.secondary = secondary;
}
public SampleChannel Get(string name) => primary.Get(name) ?? secondary.Get(name);
public Task<SampleChannel> GetAsync(string name) => primary.GetAsync(name) ?? secondary.GetAsync(name);
public Stream GetStream(string name) => primary.GetStream(name) ?? secondary.GetStream(name);
public IEnumerable<string> GetAvailableResources() => throw new NotSupportedException();
2019-09-06 03:12:27 +00:00
public void AddAdjustment(AdjustableProperty type, BindableNumber<double> adjustBindable) => throw new NotSupportedException();
2019-09-06 03:12:27 +00:00
public void RemoveAdjustment(AdjustableProperty type, BindableNumber<double> adjustBindable) => throw new NotSupportedException();
2019-09-06 03:12:27 +00:00
public BindableNumber<double> Volume => throw new NotSupportedException();
2019-09-06 03:12:27 +00:00
public BindableNumber<double> Balance => throw new NotSupportedException();
2019-09-06 03:12:27 +00:00
public BindableNumber<double> Frequency => throw new NotSupportedException();
public BindableNumber<double> Tempo => throw new NotSupportedException();
public IBindable<double> GetAggregate(AdjustableProperty type) => throw new NotSupportedException();
2019-09-06 03:12:27 +00:00
public IBindable<double> AggregateVolume => throw new NotSupportedException();
public IBindable<double> AggregateBalance => throw new NotSupportedException();
public IBindable<double> AggregateFrequency => throw new NotSupportedException();
public IBindable<double> AggregateTempo => throw new NotSupportedException();
2019-09-06 03:12:27 +00:00
public int PlaybackConcurrency
{
get => throw new NotSupportedException();
set => throw new NotSupportedException();
2019-09-06 03:12:27 +00:00
}
public void Dispose()
{
}
}
2018-04-13 09:19:50 +00:00
}