OsuObjectInspectorRuleset.cs

// 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.Collections.Generic;
using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics;
using osu.Game.Beatmaps;
using osu.Game.Rulesets;
using osu.Game.Rulesets.Difficulty;
using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
using osu.Game.Rulesets.Osu.Edit;
using osu.Game.Rulesets.Osu.Objects.Drawables;
using osu.Game.Rulesets.Osu.UI;
using osu.Game.Rulesets.UI;

namespace PerformanceCalculatorGUI.Screens.ObjectInspection
{
    public partial class OsuObjectInspectorRuleset : DrawableOsuEditorRuleset
    {
        private OsuDifficultyHitObject[] difficultyHitObjects = [];

        [Resolved]
        private ObjectDifficultyValuesContainer objectDifficultyValuesContainer { get; set; } = null!;

        [Resolved]
        private Bindable<DifficultyCalculator?> difficultyCalculator { get; set; } = null!;

        public OsuObjectInspectorRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods)
            : base(ruleset, beatmap, mods)
        {
        }

        protected override void LoadComplete()
        {
            var extendedDifficultyCalculator = (IExtendedDifficultyCalculator?)difficultyCalculator.Value;

            if (extendedDifficultyCalculator != null)
            {
                difficultyHitObjects = extendedDifficultyCalculator.GetDifficultyHitObjects().Cast<OsuDifficultyHitObject>().ToArray();
            }

            base.LoadComplete();
        }

        protected override void Update()
        {
            base.Update();
            objectDifficultyValuesContainer.CurrentDifficultyHitObject.Value = difficultyHitObjects.LastOrDefault(x => x.BaseObject.StartTime <= Clock.CurrentTime);
        }

        public override bool PropagatePositionalInputSubTree => false;

        public override bool PropagateNonPositionalInputSubTree => false;

        protected override Playfield CreatePlayfield() => new OsuObjectInspectorPlayfield(difficultyHitObjects);

        private partial class OsuObjectInspectorPlayfield : OsuPlayfield
        {
            private readonly IReadOnlyList<OsuDifficultyHitObject> difficultyHitObjects;
            protected override GameplayCursorContainer? CreateCursor() => null;

            public OsuObjectInspectorPlayfield(IReadOnlyList<OsuDifficultyHitObject> difficultyHitObjects)
            {
                this.difficultyHitObjects = difficultyHitObjects;
                HitPolicy = new AnyOrderHitPolicy();
                DisplayJudgements.Value = false;
            }

            protected override void OnNewDrawableHitObject(DrawableHitObject d)
            {
                base.OnNewDrawableHitObject(d);
                d.ApplyCustomUpdateState += updateState;
            }

            private void updateState(DrawableHitObject hitObject, ArmedState state)
            {
                if (hitObject is DrawableSliderRepeat repeat)
                {
                    repeat.Arrow.ApplyTransformsAt(hitObject.StateUpdateTime, true);
                    repeat.Arrow.ClearTransformsAfter(hitObject.StateUpdateTime, true);
                }

                // adjust the visuals of top-level object types to make them stay on screen for longer than usual.
                switch (hitObject)
                {
                    case DrawableSlider:
                    case DrawableHitCircle:
                        var nextHitObject = difficultyHitObjects.FirstOrDefault(x => x.BaseObject.StartTime > hitObject.StartTimeBindable.Value)?.BaseObject;

                        if (nextHitObject != null)
                        {
                            // Get the existing fade out transform
                            var existing = hitObject.Transforms.LastOrDefault(t => t.TargetMember == nameof(Alpha));

                            if (existing == null)
                                return;

                            hitObject.RemoveTransform(existing);

                            using (hitObject.BeginAbsoluteSequence(hitObject.StartTimeBindable.Value))
                            {
                                double hitObjectDuration = hitObject.HitObject.GetEndTime() - hitObject.StartTimeBindable.Value;

                                hitObject.Delay(hitObjectDuration)
                                         .FadeTo(0.25f, 200f, Easing.Out)
                                         .Delay(nextHitObject.StartTimeBindable.Value - hitObject.StartTimeBindable.Value - hitObjectDuration)
                                         .FadeOut(100f, Easing.Out)
                                         .Expire();
                            }
                        }

                        break;
                }
            }
        }
    }
}