2019-03-26 12:31:49 +08:00
|
|
|
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
|
2019-01-24 16:43:03 +08:00
|
|
|
// See the LICENCE file in the repository root for full licence text.
|
2018-04-13 17:19:50 +08: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;
|
|
|
|
using System.Linq;
|
2019-05-10 15:31:09 +08:00
|
|
|
using System.Threading;
|
2019-09-03 12:05:03 +08:00
|
|
|
using JetBrains.Annotations;
|
2019-09-04 19:28:21 +08:00
|
|
|
using osu.Framework.Audio;
|
|
|
|
using osu.Framework.Audio.Track;
|
2019-02-21 18:04:31 +08:00
|
|
|
using osu.Framework.Bindables;
|
2018-04-13 17:19:50 +08:00
|
|
|
using osu.Framework.Graphics.Cursor;
|
2019-09-04 19:28:21 +08:00
|
|
|
using osu.Framework.Graphics.Textures;
|
2018-04-13 17:19:50 +08:00
|
|
|
using osu.Framework.Input;
|
2019-03-05 17:06:24 +08:00
|
|
|
using osu.Framework.Input.Events;
|
2019-09-04 19:28:21 +08:00
|
|
|
using osu.Framework.IO.Stores;
|
2018-04-13 17:19:50 +08:00
|
|
|
using osu.Game.Configuration;
|
2019-03-05 17:06:24 +08:00
|
|
|
using osu.Game.Graphics.Cursor;
|
2018-04-13 17:19:50 +08:00
|
|
|
using osu.Game.Input.Handlers;
|
|
|
|
using osu.Game.Overlays;
|
2018-11-28 16:20:37 +08:00
|
|
|
using osu.Game.Replays;
|
2018-04-13 17:19:50 +08:00
|
|
|
using osu.Game.Rulesets.Configuration;
|
|
|
|
using osu.Game.Rulesets.Scoring;
|
2018-12-04 03:37:26 +08:00
|
|
|
using osu.Game.Scoring;
|
2019-03-19 19:21:31 +08:00
|
|
|
using osu.Game.Screens.Play;
|
2018-04-13 17:19:50 +08:00
|
|
|
|
|
|
|
namespace osu.Game.Rulesets.UI
|
|
|
|
{
|
|
|
|
/// <summary>
|
2019-03-20 10:31:03 +08:00
|
|
|
/// Displays an interactive ruleset gameplay instance.
|
2018-04-13 17:19:50 +08:00
|
|
|
/// </summary>
|
2019-03-19 22:44:15 +08:00
|
|
|
/// <typeparam name="TObject">The type of HitObject contained by this DrawableRuleset.</typeparam>
|
|
|
|
public abstract class DrawableRuleset<TObject> : DrawableRuleset, IProvideCursor, ICanAttachKeyCounter
|
2019-03-19 19:21:31 +08:00
|
|
|
where TObject : HitObject
|
2018-04-13 17:19:50 +08:00
|
|
|
{
|
|
|
|
/// <summary>
|
|
|
|
/// The selected variant.
|
|
|
|
/// </summary>
|
|
|
|
public virtual int Variant => 0;
|
|
|
|
|
|
|
|
/// <summary>
|
2019-03-19 22:44:15 +08:00
|
|
|
/// The key conversion input manager for this DrawableRuleset.
|
2018-04-13 17:19:50 +08:00
|
|
|
/// </summary>
|
|
|
|
public PassThroughInputManager KeyBindingInputManager;
|
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
public override double GameplayStartTime => Objects.First().StartTime - 2000;
|
2018-07-17 13:29:22 +08:00
|
|
|
|
2018-04-13 17:19:50 +08:00
|
|
|
private readonly Lazy<Playfield> playfield;
|
2018-06-06 13:20:51 +08:00
|
|
|
|
2019-09-04 19:28:21 +08:00
|
|
|
private TextureStore textureStore;
|
|
|
|
|
|
|
|
private ISampleStore sampleStore;
|
|
|
|
|
2018-04-13 17:19:50 +08:00
|
|
|
/// <summary>
|
|
|
|
/// The playfield.
|
|
|
|
/// </summary>
|
2019-06-04 15:13:16 +08:00
|
|
|
public override Playfield Playfield => playfield.Value;
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2018-08-05 19:12:31 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Place to put drawables above hit objects but below UI.
|
|
|
|
/// </summary>
|
2019-03-20 13:55:38 +08:00
|
|
|
public Container Overlays { get; private set; }
|
2018-08-05 19:12:31 +08:00
|
|
|
|
2019-05-09 17:06:11 +08:00
|
|
|
public override GameplayClock FrameStableClock => frameStabilityContainer.GameplayClock;
|
|
|
|
|
2019-08-26 15:33:24 +08:00
|
|
|
private bool frameStablePlayback = true;
|
|
|
|
|
2019-08-15 17:25:31 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Whether to enable frame-stable playback.
|
|
|
|
/// </summary>
|
|
|
|
internal bool FrameStablePlayback
|
|
|
|
{
|
2019-08-26 15:33:24 +08:00
|
|
|
get => frameStablePlayback;
|
|
|
|
set
|
|
|
|
{
|
|
|
|
frameStablePlayback = false;
|
|
|
|
if (frameStabilityContainer != null)
|
|
|
|
frameStabilityContainer.FrameStablePlayback = value;
|
|
|
|
}
|
2019-08-15 17:25:31 +08:00
|
|
|
}
|
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Invoked when a <see cref="JudgementResult"/> has been applied by a <see cref="DrawableHitObject"/>.
|
|
|
|
/// </summary>
|
|
|
|
public event Action<JudgementResult> OnNewResult;
|
2019-03-05 17:06:24 +08:00
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Invoked when a <see cref="JudgementResult"/> is being reverted by a <see cref="DrawableHitObject"/>.
|
|
|
|
/// </summary>
|
|
|
|
public event Action<JudgementResult> OnRevertResult;
|
2019-03-05 17:06:24 +08:00
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
/// <summary>
|
|
|
|
/// The beatmap.
|
|
|
|
/// </summary>
|
|
|
|
public Beatmap<TObject> Beatmap;
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
public override IEnumerable<HitObject> Objects => Beatmap.HitObjects;
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2018-07-11 16:25:57 +08:00
|
|
|
protected IRulesetConfigManager Config { get; private set; }
|
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
/// <summary>
|
|
|
|
/// The mods which are to be applied.
|
|
|
|
/// </summary>
|
2019-04-10 16:11:17 +08:00
|
|
|
[Cached(typeof(IReadOnlyList<Mod>))]
|
|
|
|
private readonly IReadOnlyList<Mod> mods;
|
2019-03-20 13:55:38 +08:00
|
|
|
|
|
|
|
private FrameStabilityContainer frameStabilityContainer;
|
|
|
|
|
2018-04-13 17:19:50 +08:00
|
|
|
private OnScreenDisplay onScreenDisplay;
|
|
|
|
|
|
|
|
/// <summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// Creates a ruleset visualisation for the provided ruleset and beatmap.
|
2018-04-13 17:19:50 +08:00
|
|
|
/// </summary>
|
2019-03-20 13:55:38 +08:00
|
|
|
/// <param name="ruleset">The ruleset being represented.</param>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// <param name="workingBeatmap">The beatmap to create the hit renderer for.</param>
|
2019-04-25 16:36:17 +08:00
|
|
|
/// <param name="mods">The <see cref="Mod"/>s to apply.</param>
|
2019-08-29 18:38:44 +08:00
|
|
|
protected DrawableRuleset(Ruleset ruleset, IWorkingBeatmap workingBeatmap, IReadOnlyList<Mod> mods)
|
2019-03-19 19:21:31 +08:00
|
|
|
: base(ruleset)
|
2018-04-13 17:19:50 +08:00
|
|
|
{
|
2019-04-08 17:32:05 +08:00
|
|
|
if (workingBeatmap == null)
|
|
|
|
throw new ArgumentException("Beatmap cannot be null.", nameof(workingBeatmap));
|
|
|
|
|
2019-04-10 16:11:17 +08:00
|
|
|
this.mods = mods.ToArray();
|
2019-03-19 19:21:31 +08:00
|
|
|
|
|
|
|
RelativeSizeAxes = Axes.Both;
|
|
|
|
|
2019-04-08 17:32:05 +08:00
|
|
|
Beatmap = (Beatmap<TObject>)workingBeatmap.GetPlayableBeatmap(ruleset.RulesetInfo, mods);
|
2019-03-19 19:21:31 +08:00
|
|
|
|
|
|
|
KeyBindingInputManager = CreateInputManager();
|
2018-04-13 17:19:50 +08:00
|
|
|
playfield = new Lazy<Playfield>(CreatePlayfield);
|
|
|
|
|
2019-02-22 16:51:39 +08:00
|
|
|
IsPaused.ValueChanged += paused =>
|
2018-07-11 16:01:27 +08:00
|
|
|
{
|
2019-02-21 17:56:34 +08:00
|
|
|
if (HasReplayLoaded.Value)
|
2018-07-11 16:01:27 +08:00
|
|
|
return;
|
|
|
|
|
2019-02-22 16:51:39 +08:00
|
|
|
KeyBindingInputManager.UseParentInput = !paused.NewValue;
|
2018-07-11 16:01:27 +08:00
|
|
|
};
|
2018-04-13 17:19:50 +08:00
|
|
|
}
|
2018-05-06 18:57:52 +08:00
|
|
|
|
2018-07-11 16:07:14 +08:00
|
|
|
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
|
2018-04-13 17:19:50 +08:00
|
|
|
{
|
2018-07-11 16:07:14 +08:00
|
|
|
var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
|
2018-06-11 13:36:56 +08:00
|
|
|
|
2019-09-04 19:28:21 +08:00
|
|
|
var resources = Ruleset.CreateReourceStore();
|
|
|
|
|
|
|
|
if (resources != null)
|
|
|
|
{
|
|
|
|
textureStore = new TextureStore(new TextureLoaderStore(new NamespacedResourceStore<byte[]>(resources, "Textures")));
|
|
|
|
textureStore.AddStore(dependencies.Get<TextureStore>());
|
|
|
|
dependencies.Cache(textureStore);
|
|
|
|
|
|
|
|
sampleStore = dependencies.Get<AudioManager>().GetSampleStore(new NamespacedResourceStore<byte[]>(resources, "Samples"));
|
|
|
|
dependencies.CacheAs(sampleStore);
|
|
|
|
}
|
|
|
|
|
2018-06-11 13:36:56 +08:00
|
|
|
onScreenDisplay = dependencies.Get<OnScreenDisplay>();
|
2018-05-21 14:56:02 +08:00
|
|
|
|
2018-07-11 16:25:57 +08:00
|
|
|
Config = dependencies.Get<RulesetConfigCache>().GetConfigFor(Ruleset);
|
2019-04-01 11:16:05 +08:00
|
|
|
|
2018-07-11 16:25:57 +08:00
|
|
|
if (Config != null)
|
2018-04-13 17:19:50 +08:00
|
|
|
{
|
2018-07-11 16:25:57 +08:00
|
|
|
dependencies.Cache(Config);
|
|
|
|
onScreenDisplay?.BeginTracking(this, Config);
|
2018-04-13 17:19:50 +08:00
|
|
|
}
|
|
|
|
|
2018-06-11 13:36:56 +08:00
|
|
|
return dependencies;
|
|
|
|
}
|
2018-06-11 11:57:26 +08:00
|
|
|
|
2019-03-31 00:29:37 +08:00
|
|
|
public virtual PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new PlayfieldAdjustmentContainer();
|
2019-03-26 12:31:49 +08:00
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
[BackgroundDependencyLoader]
|
2019-05-10 16:42:45 +08:00
|
|
|
private void load(OsuConfigManager config, CancellationToken? cancellationToken)
|
2019-03-20 13:55:38 +08:00
|
|
|
{
|
|
|
|
InternalChildren = new Drawable[]
|
|
|
|
{
|
2019-05-09 15:36:47 +08:00
|
|
|
frameStabilityContainer = new FrameStabilityContainer(GameplayStartTime)
|
2019-03-20 13:55:38 +08:00
|
|
|
{
|
2019-08-26 15:33:24 +08:00
|
|
|
FrameStablePlayback = FrameStablePlayback,
|
2019-03-26 12:31:49 +08:00
|
|
|
Child = KeyBindingInputManager
|
|
|
|
.WithChild(CreatePlayfieldAdjustmentContainer()
|
|
|
|
.WithChild(Playfield)
|
|
|
|
)
|
2019-03-20 13:55:38 +08:00
|
|
|
},
|
|
|
|
Overlays = new Container { RelativeSizeAxes = Axes.Both }
|
|
|
|
};
|
|
|
|
|
2019-03-25 18:21:25 +08:00
|
|
|
if ((ResumeOverlay = CreateResumeOverlay()) != null)
|
|
|
|
{
|
|
|
|
AddInternal(CreateInputManager()
|
|
|
|
.WithChild(CreatePlayfieldAdjustmentContainer()
|
|
|
|
.WithChild(ResumeOverlay)));
|
|
|
|
}
|
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
applyRulesetMods(mods, config);
|
|
|
|
|
2019-05-10 15:31:09 +08:00
|
|
|
loadObjects(cancellationToken);
|
2019-03-19 19:21:31 +08:00
|
|
|
}
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-18 13:40:53 +08:00
|
|
|
/// <summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// Creates and adds drawable representations of hit objects to the play field.
|
2019-03-18 13:40:53 +08:00
|
|
|
/// </summary>
|
2019-05-10 16:42:45 +08:00
|
|
|
private void loadObjects(CancellationToken? cancellationToken)
|
2019-03-19 19:21:31 +08:00
|
|
|
{
|
|
|
|
foreach (TObject h in Beatmap.HitObjects)
|
2019-05-10 15:31:09 +08:00
|
|
|
{
|
2019-05-10 16:42:45 +08:00
|
|
|
cancellationToken?.ThrowIfCancellationRequested();
|
2019-03-24 22:40:43 +08:00
|
|
|
addHitObject(h);
|
2019-05-10 15:31:09 +08:00
|
|
|
}
|
|
|
|
|
2019-05-10 16:42:45 +08:00
|
|
|
cancellationToken?.ThrowIfCancellationRequested();
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
Playfield.PostProcess();
|
2019-03-16 12:47:11 +08:00
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
foreach (var mod in mods.OfType<IApplicableToDrawableHitObjects>())
|
|
|
|
mod.ApplyToDrawableHitObjects(Playfield.HitObjectContainer.Objects);
|
|
|
|
}
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-21 15:57:40 +08:00
|
|
|
public override void RequestResume(Action continueResume)
|
|
|
|
{
|
2019-03-25 21:00:33 +08:00
|
|
|
if (ResumeOverlay != null && (Cursor == null || (Cursor.LastFrameState == Visibility.Visible && Contains(Cursor.ActiveCursor.ScreenSpaceDrawQuad.Centre))))
|
2019-03-21 15:57:40 +08:00
|
|
|
{
|
2019-03-25 18:21:25 +08:00
|
|
|
ResumeOverlay.GameplayCursor = Cursor;
|
2019-03-21 15:57:40 +08:00
|
|
|
ResumeOverlay.ResumeAction = continueResume;
|
|
|
|
ResumeOverlay.Show();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
continueResume();
|
|
|
|
}
|
|
|
|
|
2018-04-13 17:19:50 +08:00
|
|
|
/// <summary>
|
2019-03-19 22:44:15 +08:00
|
|
|
/// Creates and adds the visual representation of a <see cref="TObject"/> to this <see cref="DrawableRuleset{TObject}"/>.
|
2018-04-13 17:19:50 +08:00
|
|
|
/// </summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// <param name="hitObject">The <see cref="TObject"/> to add the visual representation for.</param>
|
2019-03-24 22:40:43 +08:00
|
|
|
private void addHitObject(TObject hitObject)
|
2018-04-13 17:19:50 +08:00
|
|
|
{
|
2019-03-24 22:40:43 +08:00
|
|
|
var drawableObject = CreateDrawableRepresentation(hitObject);
|
2019-03-16 12:47:11 +08:00
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
if (drawableObject == null)
|
|
|
|
return;
|
2019-03-16 12:47:11 +08:00
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
drawableObject.OnNewResult += (_, r) => OnNewResult?.Invoke(r);
|
|
|
|
drawableObject.OnRevertResult += (_, r) => OnRevertResult?.Invoke(r);
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
Playfield.Add(drawableObject);
|
2018-04-13 17:19:50 +08:00
|
|
|
}
|
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
public override void SetReplayScore(Score replayScore)
|
2018-04-13 17:19:50 +08:00
|
|
|
{
|
2019-03-20 13:55:38 +08:00
|
|
|
if (!(KeyBindingInputManager is IHasReplayHandler replayInputManager))
|
|
|
|
throw new InvalidOperationException($"A {nameof(KeyBindingInputManager)} which supports replay loading is not available");
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
var handler = (ReplayScore = replayScore) != null ? CreateReplayInputHandler(replayScore.Replay) : null;
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
replayInputManager.ReplayInputHandler = handler;
|
|
|
|
frameStabilityContainer.ReplayInputHandler = handler;
|
2018-08-06 09:54:16 +08:00
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
HasReplayLoaded.Value = replayInputManager.ReplayInputHandler != null;
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
if (replayInputManager.ReplayInputHandler != null)
|
|
|
|
replayInputManager.ReplayInputHandler.GamefieldToScreenSpace = Playfield.GamefieldToScreenSpace;
|
2019-04-23 12:32:44 +08:00
|
|
|
|
|
|
|
if (!ProvidingUserCursor)
|
2019-04-23 12:45:51 +08:00
|
|
|
{
|
|
|
|
// The cursor is hidden by default (see Playfield.load()), but should be shown when there's a replay
|
2019-04-23 12:32:44 +08:00
|
|
|
Playfield.Cursor?.Show();
|
2019-04-23 12:45:51 +08:00
|
|
|
}
|
2019-03-20 13:55:38 +08:00
|
|
|
}
|
2018-04-13 17:19:50 +08:00
|
|
|
|
|
|
|
/// <summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// Creates a DrawableHitObject from a HitObject.
|
2018-04-13 17:19:50 +08:00
|
|
|
/// </summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// <param name="h">The HitObject to make drawable.</param>
|
|
|
|
/// <returns>The DrawableHitObject.</returns>
|
2019-03-24 22:40:43 +08:00
|
|
|
public abstract DrawableHitObject<TObject> CreateDrawableRepresentation(TObject h);
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-26 10:28:43 +08:00
|
|
|
public void Attach(KeyCounterDisplay keyCounter) =>
|
2019-03-19 19:21:31 +08:00
|
|
|
(KeyBindingInputManager as ICanAttachKeyCounter)?.Attach(keyCounter);
|
2018-04-13 17:19:50 +08:00
|
|
|
|
|
|
|
/// <summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// Creates a key conversion input manager. An exception will be thrown if a valid <see cref="RulesetInputManager{T}"/> is not returned.
|
2018-04-13 17:19:50 +08:00
|
|
|
/// </summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// <returns>The input manager.</returns>
|
|
|
|
protected abstract PassThroughInputManager CreateInputManager();
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
protected virtual ReplayInputHandler CreateReplayInputHandler(Replay replay) => null;
|
2018-04-25 16:15:53 +08:00
|
|
|
|
2018-04-13 17:19:50 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Creates a Playfield.
|
|
|
|
/// </summary>
|
|
|
|
/// <returns>The Playfield.</returns>
|
|
|
|
protected abstract Playfield CreatePlayfield();
|
2018-05-21 14:59:33 +08:00
|
|
|
|
2018-04-13 17:19:50 +08:00
|
|
|
public override ScoreProcessor CreateScoreProcessor() => new ScoreProcessor<TObject>(this);
|
|
|
|
|
|
|
|
/// <summary>
|
2019-03-19 22:44:15 +08:00
|
|
|
/// Applies the active mods to this DrawableRuleset.
|
2018-04-13 17:19:50 +08:00
|
|
|
/// </summary>
|
2019-04-25 16:36:17 +08:00
|
|
|
/// <param name="mods">The <see cref="Mod"/>s to apply.</param>
|
|
|
|
/// <param name="config">The <see cref="OsuConfigManager"/> to apply.</param>
|
2019-04-10 16:13:12 +08:00
|
|
|
private void applyRulesetMods(IReadOnlyList<Mod> mods, OsuConfigManager config)
|
2018-04-13 17:19:50 +08:00
|
|
|
{
|
|
|
|
if (mods == null)
|
|
|
|
return;
|
|
|
|
|
2019-03-19 22:44:15 +08:00
|
|
|
foreach (var mod in mods.OfType<IApplicableToDrawableRuleset<TObject>>())
|
|
|
|
mod.ApplyToDrawableRuleset(this);
|
2018-05-06 19:09:46 +08:00
|
|
|
|
2018-06-06 13:20:51 +08:00
|
|
|
foreach (var mod in mods.OfType<IReadFromConfig>())
|
|
|
|
mod.ReadFromConfig(config);
|
2018-04-13 17:19:50 +08:00
|
|
|
}
|
|
|
|
|
2019-03-20 13:55:38 +08:00
|
|
|
#region IProvideCursor
|
|
|
|
|
|
|
|
protected override bool OnHover(HoverEvent e) => true; // required for IProvideCursor
|
|
|
|
|
2019-03-26 12:39:19 +08:00
|
|
|
CursorContainer IProvideCursor.Cursor => Playfield.Cursor;
|
|
|
|
|
|
|
|
public override GameplayCursorContainer Cursor => Playfield.Cursor;
|
2019-03-20 13:55:38 +08:00
|
|
|
|
|
|
|
public bool ProvidingUserCursor => Playfield.Cursor != null && !HasReplayLoaded.Value;
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
protected override void Dispose(bool isDisposing)
|
2018-04-13 17:19:50 +08:00
|
|
|
{
|
2019-03-19 19:21:31 +08:00
|
|
|
base.Dispose(isDisposing);
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
if (Config != null)
|
|
|
|
{
|
|
|
|
onScreenDisplay?.StopTracking(this, Config);
|
|
|
|
Config = null;
|
|
|
|
}
|
2018-04-13 17:19:50 +08:00
|
|
|
}
|
2019-03-19 19:21:31 +08:00
|
|
|
}
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
/// <summary>
|
2019-03-20 10:31:03 +08:00
|
|
|
/// 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>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// </summary>
|
2019-03-19 22:44:15 +08:00
|
|
|
public abstract class DrawableRuleset : CompositeDrawable
|
2019-03-19 19:21:31 +08:00
|
|
|
{
|
2018-04-13 17:19:50 +08:00
|
|
|
/// <summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// Whether a replay is currently loaded.
|
2018-04-13 17:19:50 +08:00
|
|
|
/// </summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
public readonly BindableBool HasReplayLoaded = new BindableBool();
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Whether the game is paused. Used to block user input.
|
|
|
|
/// </summary>
|
|
|
|
public readonly BindableBool IsPaused = new BindableBool();
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-06-04 15:13:16 +08:00
|
|
|
/// <summary>
|
|
|
|
/// The playfield.
|
|
|
|
/// </summary>
|
|
|
|
public abstract Playfield Playfield { get; }
|
|
|
|
|
2019-05-09 17:06:11 +08:00
|
|
|
/// <summary>
|
|
|
|
/// The frame-stable clock which is being used for playfield display.
|
|
|
|
/// </summary>
|
|
|
|
public abstract GameplayClock FrameStableClock { get; }
|
|
|
|
|
2019-03-20 10:31:03 +08:00
|
|
|
/// <summary>~
|
2019-03-19 19:21:31 +08:00
|
|
|
/// The associated ruleset.
|
|
|
|
/// </summary>
|
|
|
|
public readonly Ruleset Ruleset;
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2018-10-03 14:36:14 +08:00
|
|
|
/// <summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// Creates a ruleset visualisation for the provided ruleset.
|
2018-10-03 14:36:14 +08:00
|
|
|
/// </summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// <param name="ruleset">The ruleset.</param>
|
2019-03-20 10:31:03 +08:00
|
|
|
internal DrawableRuleset(Ruleset ruleset)
|
2018-10-03 14:36:14 +08:00
|
|
|
{
|
2019-03-19 19:21:31 +08:00
|
|
|
Ruleset = ruleset;
|
|
|
|
}
|
2018-10-03 14:36:14 +08:00
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
/// <summary>
|
|
|
|
/// All the converted hit objects contained by this hit renderer.
|
|
|
|
/// </summary>
|
|
|
|
public abstract IEnumerable<HitObject> Objects { get; }
|
2018-10-03 14:36:14 +08:00
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
/// <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; }
|
2018-10-03 14:36:14 +08:00
|
|
|
|
2019-03-19 19:21:31 +08:00
|
|
|
/// <summary>
|
|
|
|
/// The currently loaded replay. Usually null in the case of a local player.
|
|
|
|
/// </summary>
|
|
|
|
public Score ReplayScore { get; protected set; }
|
2018-10-03 14:36:14 +08:00
|
|
|
|
2018-04-13 17:19:50 +08:00
|
|
|
/// <summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// The cursor being displayed by the <see cref="Playfield"/>. May be null if no cursor is provided.
|
2018-04-13 17:19:50 +08:00
|
|
|
/// </summary>
|
2019-03-26 12:39:19 +08:00
|
|
|
public abstract GameplayCursorContainer Cursor { get; }
|
2018-04-13 17:19:50 +08:00
|
|
|
|
2019-09-02 10:20:50 +08:00
|
|
|
/// <summary>
|
|
|
|
/// An optional overlay used when resuming gameplay from a paused state.
|
|
|
|
/// </summary>
|
|
|
|
public ResumeOverlay ResumeOverlay { get; protected set; }
|
|
|
|
|
2019-09-03 12:05:03 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Returns first available <see cref="HitWindows"/> provided by a <see cref="HitObject"/>.
|
|
|
|
/// </summary>
|
|
|
|
[CanBeNull]
|
|
|
|
public HitWindows FirstAvailableHitWindows
|
|
|
|
{
|
|
|
|
get
|
|
|
|
{
|
|
|
|
foreach (var h in Objects)
|
|
|
|
{
|
|
|
|
if (h.HitWindows != null)
|
|
|
|
return h.HitWindows;
|
|
|
|
|
|
|
|
foreach (var n in h.NestedHitObjects)
|
|
|
|
if (n.HitWindows != null)
|
|
|
|
return n.HitWindows;
|
|
|
|
}
|
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-02 10:20:50 +08:00
|
|
|
protected virtual ResumeOverlay CreateResumeOverlay() => null;
|
|
|
|
|
2018-04-13 17:19:50 +08:00
|
|
|
/// <summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// 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);
|
|
|
|
|
2019-03-20 14:27:06 +08:00
|
|
|
/// <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 17:19:50 +08:00
|
|
|
/// </summary>
|
2019-03-20 14:27:06 +08:00
|
|
|
/// <param name="continueResume">The action to run when resuming is to be completed.</param>
|
|
|
|
public abstract void RequestResume(Action continueResume);
|
2018-04-13 17:19:50 +08:00
|
|
|
|
|
|
|
/// <summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// Create a <see cref="ScoreProcessor"/> for the associated ruleset and link with this
|
2019-03-19 22:44:15 +08:00
|
|
|
/// <see cref="DrawableRuleset"/>.
|
2018-04-13 17:19:50 +08:00
|
|
|
/// </summary>
|
2019-03-19 19:21:31 +08:00
|
|
|
/// <returns>A score processor.</returns>
|
|
|
|
public abstract ScoreProcessor CreateScoreProcessor();
|
2018-04-13 17:19:50 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
public class BeatmapInvalidForRulesetException : ArgumentException
|
|
|
|
{
|
|
|
|
public BeatmapInvalidForRulesetException(string text)
|
|
|
|
: base(text)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|