// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence. // See the LICENCE file in the repository root for full licence text. 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.IO; using System.Linq; using System.Threading; using System.Threading.Tasks; using JetBrains.Annotations; using osu.Framework.Audio; using osu.Framework.Audio.Sample; using osu.Framework.Audio.Track; using osu.Framework.Bindables; using osu.Framework.Graphics.Cursor; using osu.Framework.Graphics.Textures; using osu.Framework.Input; using osu.Framework.Input.Events; using osu.Framework.IO.Stores; using osu.Game.Configuration; using osu.Game.Graphics.Cursor; using osu.Game.Input.Handlers; using osu.Game.Overlays; using osu.Game.Replays; using osu.Game.Rulesets.Configuration; using osu.Game.Rulesets.Scoring; using osu.Game.Scoring; using osu.Game.Screens.Play; using osuTK; namespace osu.Game.Rulesets.UI { /// /// Displays an interactive ruleset gameplay instance. /// /// The type of HitObject contained by this DrawableRuleset. public abstract class DrawableRuleset : DrawableRuleset, IProvideCursor, ICanAttachKeyCounter where TObject : HitObject { public override event Action OnNewResult; public override event Action OnRevertResult; /// /// The selected variant. /// public virtual int Variant => 0; /// /// The key conversion input manager for this DrawableRuleset. /// public PassThroughInputManager KeyBindingInputManager; public override double GameplayStartTime => Objects.First().StartTime - 2000; private readonly Lazy playfield; private TextureStore textureStore; private ISampleStore localSampleStore; /// /// The playfield. /// public override Playfield Playfield => playfield.Value; private Container overlays; public override Container Overlays => overlays; public override GameplayClock FrameStableClock => frameStabilityContainer.GameplayClock; private bool frameStablePlayback = true; /// /// Whether to enable frame-stable playback. /// internal bool FrameStablePlayback { get => frameStablePlayback; set { frameStablePlayback = false; if (frameStabilityContainer != null) frameStabilityContainer.FrameStablePlayback = value; } } /// /// The beatmap. /// public readonly Beatmap Beatmap; public override IEnumerable Objects => Beatmap.HitObjects; protected IRulesetConfigManager Config { get; private set; } /// /// The mods which are to be applied. /// [Cached(typeof(IReadOnlyList))] private readonly IReadOnlyList mods; private FrameStabilityContainer frameStabilityContainer; private OnScreenDisplay onScreenDisplay; /// /// Creates a ruleset visualisation for the provided ruleset and beatmap. /// /// The ruleset being represented. /// The beatmap to create the hit renderer for. /// The s to apply. protected DrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList mods = null) : base(ruleset) { if (beatmap == null) throw new ArgumentNullException(nameof(beatmap), "Beatmap cannot be null."); if (!(beatmap is Beatmap 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(); RelativeSizeAxes = Axes.Both; KeyBindingInputManager = CreateInputManager(); playfield = new Lazy(CreatePlayfield); IsPaused.ValueChanged += paused => { if (HasReplayLoaded.Value) return; KeyBindingInputManager.UseParentInput = !paused.NewValue; }; } protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) { var dependencies = new DependencyContainer(base.CreateChildDependencies(parent)); var resources = Ruleset.CreateResourceStore(); if (resources != null) { textureStore = new TextureStore(new TextureLoaderStore(new NamespacedResourceStore(resources, "Textures"))); textureStore.AddStore(dependencies.Get()); dependencies.Cache(textureStore); localSampleStore = dependencies.Get().GetSampleStore(new NamespacedResourceStore(resources, "Samples")); localSampleStore.PlaybackConcurrency = OsuGameBase.SAMPLE_CONCURRENCY; dependencies.CacheAs(new FallbackSampleStore(localSampleStore, dependencies.Get())); } onScreenDisplay = dependencies.Get(); Config = dependencies.Get().GetConfigFor(Ruleset); if (Config != null) { dependencies.Cache(Config); onScreenDisplay?.BeginTracking(this, Config); } return dependencies; } public virtual PlayfieldAdjustmentContainer CreatePlayfieldAdjustmentContainer() => new PlayfieldAdjustmentContainer(); [BackgroundDependencyLoader] private void load(OsuConfigManager config, CancellationToken? cancellationToken) { InternalChildren = new Drawable[] { frameStabilityContainer = new FrameStabilityContainer(GameplayStartTime) { FrameStablePlayback = FrameStablePlayback, Children = new Drawable[] { KeyBindingInputManager .WithChild(CreatePlayfieldAdjustmentContainer() .WithChild(Playfield) ), overlays = new Container { RelativeSizeAxes = Axes.Both } } }, }; if ((ResumeOverlay = CreateResumeOverlay()) != null) { AddInternal(CreateInputManager() .WithChild(CreatePlayfieldAdjustmentContainer() .WithChild(ResumeOverlay))); } applyRulesetMods(mods, config); loadObjects(cancellationToken); } /// /// Creates and adds drawable representations of hit objects to the play field. /// private void loadObjects(CancellationToken? cancellationToken) { foreach (TObject h in Beatmap.HitObjects) { cancellationToken?.ThrowIfCancellationRequested(); addHitObject(h); } cancellationToken?.ThrowIfCancellationRequested(); Playfield.PostProcess(); foreach (var mod in mods.OfType()) mod.ApplyToDrawableHitObjects(Playfield.AllHitObjects); } public override void RequestResume(Action continueResume) { if (ResumeOverlay != null && (Cursor == null || (Cursor.LastFrameState == Visibility.Visible && Contains(Cursor.ActiveCursor.ScreenSpaceDrawQuad.Centre)))) { ResumeOverlay.GameplayCursor = Cursor; ResumeOverlay.ResumeAction = continueResume; ResumeOverlay.Show(); } else continueResume(); } public override void CancelResume() { // called if the user pauses while the resume overlay is open ResumeOverlay?.Hide(); } /// /// Creates and adds the visual representation of a to this . /// /// The to add the visual representation for. private void addHitObject(TObject hitObject) { var drawableObject = CreateDrawableRepresentation(hitObject); if (drawableObject == null) return; drawableObject.OnNewResult += (_, r) => OnNewResult?.Invoke(r); drawableObject.OnRevertResult += (_, r) => OnRevertResult?.Invoke(r); Playfield.Add(drawableObject); } public override void SetReplayScore(Score replayScore) { if (!(KeyBindingInputManager is IHasReplayHandler replayInputManager)) throw new InvalidOperationException($"A {nameof(KeyBindingInputManager)} which supports replay loading is not available"); var handler = (ReplayScore = replayScore) != null ? CreateReplayInputHandler(replayScore.Replay) : null; replayInputManager.ReplayInputHandler = handler; frameStabilityContainer.ReplayInputHandler = handler; HasReplayLoaded.Value = replayInputManager.ReplayInputHandler != null; if (replayInputManager.ReplayInputHandler != null) replayInputManager.ReplayInputHandler.GamefieldToScreenSpace = Playfield.GamefieldToScreenSpace; if (!ProvidingUserCursor) { // The cursor is hidden by default (see Playfield.load()), but should be shown when there's a replay Playfield.Cursor?.Show(); } } /// /// Creates a DrawableHitObject from a HitObject. /// /// The HitObject to make drawable. /// The DrawableHitObject. public abstract DrawableHitObject CreateDrawableRepresentation(TObject h); public void Attach(KeyCounterDisplay keyCounter) => (KeyBindingInputManager as ICanAttachKeyCounter)?.Attach(keyCounter); /// /// Creates a key conversion input manager. An exception will be thrown if a valid is not returned. /// /// The input manager. protected abstract PassThroughInputManager CreateInputManager(); protected virtual ReplayInputHandler CreateReplayInputHandler(Replay replay) => null; protected virtual ReplayRecorder CreateReplayRecorder(Replay replay) => null; /// /// Creates a Playfield. /// /// The Playfield. protected abstract Playfield CreatePlayfield(); /// /// Applies the active mods to this DrawableRuleset. /// /// The s to apply. /// The to apply. private void applyRulesetMods(IReadOnlyList mods, OsuConfigManager config) { if (mods == null) return; foreach (var mod in mods.OfType>()) mod.ApplyToDrawableRuleset(this); foreach (var mod in mods.OfType()) mod.ReadFromConfig(config); } #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; public bool ProvidingUserCursor => Playfield.Cursor != null && !HasReplayLoaded.Value; #endregion protected override void Dispose(bool isDisposing) { base.Dispose(isDisposing); localSampleStore?.Dispose(); if (Config != null) { onScreenDisplay?.StopTracking(this, Config); Config = null; } } } /// /// Displays an interactive ruleset gameplay instance. /// /// 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. /// /// public abstract class DrawableRuleset : CompositeDrawable { /// /// Invoked when a has been applied by a . /// public abstract event Action OnNewResult; /// /// Invoked when a is being reverted by a . /// public abstract event Action OnRevertResult; /// /// Whether a replay is currently loaded. /// public readonly BindableBool HasReplayLoaded = new BindableBool(); /// /// Whether the game is paused. Used to block user input. /// public readonly BindableBool IsPaused = new BindableBool(); /// /// The playfield. /// public abstract Playfield Playfield { get; } /// /// Place to put drawables above hit objects but below UI. /// public abstract Container Overlays { get; } /// /// The frame-stable clock which is being used for playfield display. /// public abstract GameplayClock FrameStableClock { get; } /// ~ /// The associated ruleset. /// public readonly Ruleset Ruleset; /// /// Creates a ruleset visualisation for the provided ruleset. /// /// The ruleset. internal DrawableRuleset(Ruleset ruleset) { Ruleset = ruleset; } /// /// All the converted hit objects contained by this hit renderer. /// public abstract IEnumerable Objects { get; } /// /// The point in time at which gameplay starts, including any required lead-in for display purposes. /// Defaults to two seconds before the first . Override as necessary. /// public abstract double GameplayStartTime { get; } /// /// The currently loaded replay. Usually null in the case of a local player. /// public Score ReplayScore { get; protected set; } /// /// The cursor being displayed by the . May be null if no cursor is provided. /// public abstract GameplayCursorContainer Cursor { get; } /// /// An optional overlay used when resuming gameplay from a paused state. /// public ResumeOverlay ResumeOverlay { get; protected set; } /// /// Returns first available provided by a . /// [CanBeNull] public HitWindows FirstAvailableHitWindows { get { foreach (var h in Objects) { if (h.HitWindows.WindowFor(HitResult.Miss) > 0) return h.HitWindows; foreach (var n in h.NestedHitObjects) { if (h.HitWindows.WindowFor(HitResult.Miss) > 0) return n.HitWindows; } } return null; } } protected virtual ResumeOverlay CreateResumeOverlay() => null; /// /// Sets a replay to be used, overriding local input. /// /// The replay, null for local input. public abstract void SetReplayScore(Score replayScore); /// /// Invoked when the interactive user requests resuming from a paused state. /// Allows potentially delaying the resume process until an interaction is performed. /// /// The action to run when resuming is to be completed. public abstract void RequestResume(Action continueResume); /// /// Invoked when the user requests to pause while the resume overlay is active. /// public abstract void CancelResume(); } public class BeatmapInvalidForRulesetException : ArgumentException { public BeatmapInvalidForRulesetException(string text) : base(text) { } } /// /// A sample store which adds a fallback source. /// /// /// This is a temporary implementation to workaround ISampleStore limitations. /// 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 GetAsync(string name) => primary.GetAsync(name) ?? secondary.GetAsync(name); public Stream GetStream(string name) => primary.GetStream(name) ?? secondary.GetStream(name); public IEnumerable GetAvailableResources() => throw new NotSupportedException(); public void AddAdjustment(AdjustableProperty type, BindableNumber adjustBindable) => throw new NotSupportedException(); public void RemoveAdjustment(AdjustableProperty type, BindableNumber adjustBindable) => throw new NotSupportedException(); public BindableNumber Volume => throw new NotSupportedException(); public BindableNumber Balance => throw new NotSupportedException(); public BindableNumber Frequency => throw new NotSupportedException(); public BindableNumber Tempo => throw new NotSupportedException(); public IBindable GetAggregate(AdjustableProperty type) => throw new NotSupportedException(); public IBindable AggregateVolume => throw new NotSupportedException(); public IBindable AggregateBalance => throw new NotSupportedException(); public IBindable AggregateFrequency => throw new NotSupportedException(); public IBindable AggregateTempo => throw new NotSupportedException(); public int PlaybackConcurrency { get => throw new NotSupportedException(); set => throw new NotSupportedException(); } public void Dispose() { } } }