// Copyright (c) 2007-2017 ppy Pty Ltd . // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE 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 osu.Game.Screens.Play; using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; using osu.Framework.Input; using osu.Game.Rulesets.Replays; using osu.Game.Rulesets.Scoring; using OpenTK; using osu.Game.Rulesets.Beatmaps; namespace osu.Game.Rulesets.UI { /// /// Base RulesetContainer. Doesn't hold objects. /// /// Should not be derived - derive instead. /// /// public abstract class RulesetContainer : Container { /// /// Invoked when all the judgeable HitObjects have been judged. /// public event Action OnAllJudged; /// /// Whether to apply adjustments to the child based on our own size. /// public bool AspectAdjust = true; /// /// The input manager for this RulesetContainer. /// internal readonly PlayerInputManager InputManager = new PlayerInputManager(); /// /// The key conversion input manager for this RulesetContainer. /// protected readonly PassThroughInputManager KeyConversionInputManager; /// /// Whether we are currently providing the local user a gameplay cursor. /// public virtual bool ProvidingUserCursor => false; /// /// Whether we have a replay loaded currently. /// public bool HasReplayLoaded => InputManager.ReplayInputHandler != null; public abstract IEnumerable Objects { get; } /// /// Whether all the HitObjects have been judged. /// protected abstract bool AllObjectsJudged { get; } protected readonly Ruleset Ruleset; /// /// A visual representation of a . /// /// The ruleset being repesented. internal RulesetContainer(Ruleset ruleset) { Ruleset = ruleset; KeyConversionInputManager = CreateKeyBindingInputManager(); KeyConversionInputManager.RelativeSizeAxes = Axes.Both; } /// /// Checks whether all HitObjects have been judged, and invokes OnAllJudged. /// protected void CheckAllJudged() { if (AllObjectsJudged) OnAllJudged?.Invoke(); } public abstract ScoreProcessor CreateScoreProcessor(); /// /// Creates a key conversion input manager. /// /// The input manager. public virtual PassThroughInputManager CreateKeyBindingInputManager() => new PassThroughInputManager(); protected virtual FramedReplayInputHandler CreateReplayInputHandler(Replay replay) => new FramedReplayInputHandler(replay); public Replay Replay { get; private set; } /// /// Sets a replay to be used, overriding local input. /// /// The replay, null for local input. public void SetReplay(Replay replay) { Replay = replay; InputManager.ReplayInputHandler = replay != null ? CreateReplayInputHandler(replay) : null; } } /// /// RulesetContainer that applies conversion to Beatmaps. Does not contain a Playfield /// and does not load drawable hit objects. /// /// Should not be derived - derive instead. /// /// /// The type of HitObject contained by this RulesetContainer. public abstract class RulesetContainer : RulesetContainer where TObject : HitObject { /// /// The Beatmap /// public Beatmap Beatmap; /// /// All the converted hit objects contained by this hit renderer. /// public override IEnumerable Objects => Beatmap.HitObjects; /// /// The mods which are to be applied. /// protected IEnumerable Mods; /// /// Creates a hit renderer for a beatmap. /// /// The ruleset being repesented. /// The beatmap to create the hit renderer for. /// Whether to assume the beatmap is for the current ruleset. internal RulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset) : base(ruleset) { Debug.Assert(beatmap != null, "RulesetContainer initialized with a null beatmap."); Mods = beatmap.Mods.Value; RelativeSizeAxes = Axes.Both; BeatmapConverter converter = CreateBeatmapConverter(); BeatmapProcessor processor = CreateBeatmapProcessor(); // Check if the beatmap can be converted if (!converter.CanConvert(beatmap.Beatmap)) throw new BeatmapInvalidForRulesetException($"{nameof(Beatmap)} can not be converted for the current ruleset (converter: {converter})."); // Convert the beatmap Beatmap = converter.Convert(beatmap.Beatmap, isForCurrentRuleset); // Apply difficulty adjustments from mods before using Difficulty. foreach (var mod in Mods.OfType()) mod.ApplyToDifficulty(Beatmap.BeatmapInfo.Difficulty); // Apply defaults foreach (var h in Beatmap.HitObjects) h.ApplyDefaults(Beatmap.ControlPointInfo, Beatmap.BeatmapInfo.Difficulty); // Post-process the beatmap processor.PostProcess(Beatmap); ApplyBeatmap(); // Add mods, should always be the last thing applied to give full control to mods applyMods(Mods); } /// /// Applies the active mods to this RulesetContainer. /// /// private void applyMods(IEnumerable mods) { if (mods == null) return; foreach (var mod in mods.OfType>()) mod.ApplyToRulesetContainer(this); } /// /// Called when the beatmap of this hit renderer has been set. Used to apply any default values from the beatmap. /// protected virtual void ApplyBeatmap() { } /// /// Creates a processor to perform post-processing operations /// on HitObjects in converted Beatmaps. /// /// The Beatmap processor. protected virtual BeatmapProcessor CreateBeatmapProcessor() => new BeatmapProcessor(); /// /// Creates a converter to convert Beatmap to a specific mode. /// /// The Beatmap converter. protected abstract BeatmapConverter CreateBeatmapConverter(); } /// /// A derivable RulesetContainer that manages the Playfield and HitObjects. /// /// The type of HitObject contained by this RulesetContainer. /// The type of Judgement of DrawableHitObjects contained by this RulesetContainer. public abstract class RulesetContainer : RulesetContainer where TObject : HitObject where TJudgement : Judgement { public event Action OnJudgement; public sealed override bool ProvidingUserCursor => !HasReplayLoaded && Playfield.ProvidingUserCursor; /// /// All the converted hit objects contained by this hit renderer. /// public new IEnumerable Objects => Beatmap.HitObjects; protected override bool AllObjectsJudged => drawableObjects.All(h => h.Judged); /// /// The playfield. /// public Playfield Playfield { get; private set; } protected override Container Content => content; private readonly Container content; private readonly List> drawableObjects = new List>(); /// /// Creates a hit renderer for a beatmap. /// /// The ruleset being repesented. /// The beatmap to create the hit renderer for. /// Whether to assume the beatmap is for the current ruleset. protected RulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset) : base(ruleset, beatmap, isForCurrentRuleset) { InputManager.Add(content = new Container { RelativeSizeAxes = Axes.Both, Children = new[] { KeyConversionInputManager } }); AddInternal(InputManager); } [BackgroundDependencyLoader] private void load() { KeyConversionInputManager.Add(Playfield = CreatePlayfield()); loadObjects(); if (InputManager?.ReplayInputHandler != null) InputManager.ReplayInputHandler.ToScreenSpace = Playfield.ScaledContent.ToScreenSpace; } /// /// Creates and adds drawable representations of hit objects to the play field. /// private void loadObjects() { drawableObjects.Capacity = Beatmap.HitObjects.Count; foreach (TObject h in Beatmap.HitObjects) { var drawableObject = GetVisualRepresentation(h); if (drawableObject == null) continue; drawableObject.OnJudgement += onJudgement; drawableObjects.Add(drawableObject); Playfield.Add(drawableObject); } Playfield.PostProcess(); } protected override void Update() { base.Update(); Playfield.Size = AspectAdjust ? GetPlayfieldAspectAdjust() : Vector2.One; } /// /// In some cases we want to apply changes to the relative size of our contained based on custom conditions. /// /// protected virtual Vector2 GetPlayfieldAspectAdjust() => new Vector2(0.75f); //a sane default /// /// Triggered when an object's Judgement is updated. /// /// The object that Judgement has been updated for. private void onJudgement(DrawableHitObject judgedObject) { Playfield.OnJudgement(judgedObject); OnJudgement?.Invoke(judgedObject.Judgement); CheckAllJudged(); } /// /// Creates a DrawableHitObject from a HitObject. /// /// The HitObject to make drawable. /// The DrawableHitObject. protected abstract DrawableHitObject GetVisualRepresentation(TObject h); /// /// Creates a Playfield. /// /// The Playfield. protected abstract Playfield CreatePlayfield(); } /// /// A derivable RulesetContainer that manages the Playfield and HitObjects. /// /// The type of Playfield contained by this RulesetContainer. /// The type of HitObject contained by this RulesetContainer. /// The type of Judgement of DrawableHitObjects contained by this RulesetContainer. public abstract class RulesetContainer : RulesetContainer where TObject : HitObject where TJudgement : Judgement where TPlayfield : Playfield { /// /// The playfield. /// protected new TPlayfield Playfield => (TPlayfield)base.Playfield; /// /// Creates a hit renderer for a beatmap. /// /// The ruleset being repesented. /// The beatmap to create the hit renderer for. /// Whether to assume the beatmap is for the current ruleset. protected RulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset) : base(ruleset, beatmap, isForCurrentRuleset) { } } public class BeatmapInvalidForRulesetException : ArgumentException { public BeatmapInvalidForRulesetException(string text) : base(text) { } } }