Merge pull request #25653 from EVAST9919/depth-mod

Implement `OsuModDepth`

osu.Game.Rulesets.Osu/Mods/OsuModDepth.cs

@@ -0,0 +1,162 @@
+// 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;
+using System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModDepth : ModWithVisibilityAdjustment, IUpdatableByPlayfield, IApplicableToDrawableRuleset<OsuHitObject>
+    {
+        public override string Name => "Depth";
+        public override string Acronym => "DP";
+        public override IconUsage? Icon => FontAwesome.Solid.Cube;
+        public override ModType Type => ModType.Fun;
+        public override LocalisableString Description => "3D. Almost.";
+        public override double ScoreMultiplier => 1;
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModFreezeFrame), typeof(ModWithVisibilityAdjustment) }).ToArray();
+
+        private static readonly Vector3 camera_position = new Vector3(OsuPlayfield.BASE_SIZE.X * 0.5f, OsuPlayfield.BASE_SIZE.Y * 0.5f, -200);
+        private readonly float sliderMinDepth = depthForScale(1.5f); // Depth at which slider's scale will be 1.5f
+
+        [SettingSource("Maximum depth", "How far away objects appear.", 0)]
+        public BindableFloat MaxDepth { get; } = new BindableFloat(100)
+        {
+            Precision = 10,
+            MinValue = 50,
+            MaxValue = 200
+        };
+
+        [SettingSource("Show Approach Circles", "Whether approach circles should be visible.", 1)]
+        public BindableBool ShowApproachCircles { get; } = new BindableBool(true);
+
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTransform(hitObject, state);
+
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTransform(hitObject, state);
+
+        public void ApplyToDrawableRuleset(DrawableRuleset<OsuHitObject> drawableRuleset)
+        {
+            // Hide judgment displays and follow points as they won't make any sense.
+            // Judgements can potentially be turned on in a future where they display at a position relative to their drawable counterpart.
+            drawableRuleset.Playfield.DisplayJudgements.Value = false;
+            (drawableRuleset.Playfield as OsuPlayfield)?.FollowPoints.Hide();
+        }
+
+        private void applyTransform(DrawableHitObject drawable, ArmedState state)
+        {
+            switch (drawable)
+            {
+                case DrawableHitCircle circle:
+                    if (!ShowApproachCircles.Value)
+                    {
+                        var hitObject = (OsuHitObject)drawable.HitObject;
+                        double appearTime = hitObject.StartTime - hitObject.TimePreempt;
+
+                        using (circle.BeginAbsoluteSequence(appearTime))
+                            circle.ApproachCircle.Hide();
+                    }
+
+                    break;
+            }
+        }
+
+        public void Update(Playfield playfield)
+        {
+            double time = playfield.Time.Current;
+
+            foreach (var drawable in playfield.HitObjectContainer.AliveObjects)
+            {
+                switch (drawable)
+                {
+                    case DrawableHitCircle circle:
+                        processHitObject(time, circle);
+                        break;
+
+                    case DrawableSlider slider:
+                        processSlider(time, slider);
+                        break;
+                }
+            }
+        }
+
+        private void processHitObject(double time, DrawableOsuHitObject drawable)
+        {
+            var hitObject = drawable.HitObject;
+
+            // Circles are always moving at the constant speed. They'll fade out before reaching the camera even at extreme conditions (AR 11, max depth).
+            double speed = MaxDepth.Value / hitObject.TimePreempt;
+            double appearTime = hitObject.StartTime - hitObject.TimePreempt;
+            float z = MaxDepth.Value - (float)((Math.Max(time, appearTime) - appearTime) * speed);
+
+            float scale = scaleForDepth(z);
+            drawable.Position = toPlayfieldPosition(scale, hitObject.StackedPosition);
+            drawable.Scale = new Vector2(scale);
+        }
+
+        private void processSlider(double time, DrawableSlider drawableSlider)
+        {
+            var hitObject = drawableSlider.HitObject;
+
+            double baseSpeed = MaxDepth.Value / hitObject.TimePreempt;
+            double appearTime = hitObject.StartTime - hitObject.TimePreempt;
+
+            // Allow slider to move at a constant speed if its scale at the end time will be lower than 1.5f
+            float zEnd = MaxDepth.Value - (float)((Math.Max(hitObject.StartTime + hitObject.Duration, appearTime) - appearTime) * baseSpeed);
+
+            if (zEnd > sliderMinDepth)
+            {
+                processHitObject(time, drawableSlider);
+                return;
+            }
+
+            double offsetAfterStartTime = hitObject.Duration + 500;
+            double slowSpeed = Math.Min(-sliderMinDepth / offsetAfterStartTime, baseSpeed);
+
+            double decelerationTime = hitObject.TimePreempt * 0.2;
+            float decelerationDistance = (float)(decelerationTime * (baseSpeed + slowSpeed) * 0.5);
+
+            float z;
+
+            if (time < hitObject.StartTime - decelerationTime)
+            {
+                float fullDistance = decelerationDistance + (float)(baseSpeed * (hitObject.TimePreempt - decelerationTime));
+                z = fullDistance - (float)((Math.Max(time, appearTime) - appearTime) * baseSpeed);
+            }
+            else if (time < hitObject.StartTime)
+            {
+                double timeOffset = time - (hitObject.StartTime - decelerationTime);
+                double deceleration = (slowSpeed - baseSpeed) / decelerationTime;
+                z = decelerationDistance - (float)(baseSpeed * timeOffset + deceleration * timeOffset * timeOffset * 0.5);
+            }
+            else
+            {
+                double endTime = hitObject.StartTime + offsetAfterStartTime;
+                z = -(float)((Math.Min(time, endTime) - hitObject.StartTime) * slowSpeed);
+            }
+
+            float scale = scaleForDepth(z);
+            drawableSlider.Position = toPlayfieldPosition(scale, hitObject.StackedPosition);
+            drawableSlider.Scale = new Vector2(scale);
+        }
+
+        private static float scaleForDepth(float depth) => -camera_position.Z / Math.Max(1f, depth - camera_position.Z);
+
+        private static float depthForScale(float scale) => -camera_position.Z / scale + camera_position.Z;
+
+        private static Vector2 toPlayfieldPosition(float scale, Vector2 positionAtZeroDepth)
+        {
+            return (positionAtZeroDepth - camera_position.Xy) * scale + camera_position.Xy;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Mods/OsuModFreezeFrame.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override LocalisableString Description => "Burn the notes into your memory.";
 
         //Alters the transforms of the approach circles, breaking the effects of these mods.
-        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModApproachDifferent), typeof(OsuModTransform) }).ToArray();
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModApproachDifferent), typeof(OsuModTransform), typeof(OsuModDepth) }).ToArray();
 
         public override ModType Type => ModType.Fun;
 

osu.Game.Rulesets.Osu/Mods/OsuModHidden.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override LocalisableString Description => @"Play with no approach circles and fading circles/sliders.";
         public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.06 : 1;
 
-        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn) };
+        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn), typeof(OsuModDepth) };
 
         public const double FADE_IN_DURATION_MULTIPLIER = 0.4;
         public const double FADE_OUT_DURATION_MULTIPLIER = 0.3;

osu.Game.Rulesets.Osu/Mods/OsuModMagnetised.cs

@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "No need to chase the circles – your cursor is a magnet!";
         public override double ScoreMultiplier => 0.5;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModRelax), typeof(OsuModRepel), typeof(OsuModBubbles) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModRelax), typeof(OsuModRepel), typeof(OsuModBubbles), typeof(OsuModDepth) };
 
         [SettingSource("Attraction strength", "How strong the pull is.", 0)]
         public BindableFloat AttractionStrength { get; } = new BindableFloat(0.5f)

osu.Game.Rulesets.Osu/Mods/OsuModObjectScaleTween.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         protected virtual float EndScale => 1;
 
-        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn), typeof(OsuModObjectScaleTween) };
+        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn), typeof(OsuModObjectScaleTween), typeof(OsuModDepth) };
 
         protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {

osu.Game.Rulesets.Osu/Mods/OsuModRepel.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "Hit objects run away!";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModMagnetised), typeof(OsuModBubbles) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModAutopilot), typeof(OsuModWiggle), typeof(OsuModTransform), typeof(ModAutoplay), typeof(OsuModMagnetised), typeof(OsuModBubbles), typeof(OsuModDepth) };
 
         [SettingSource("Repulsion strength", "How strong the repulsion is.", 0)]
         public BindableFloat RepulsionStrength { get; } = new BindableFloat(0.5f)

osu.Game.Rulesets.Osu/Mods/OsuModSpinIn.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         // todo: this mod needs to be incompatible with "hidden" due to forcing the circle to remain opaque,
         // further implementation will be required for supporting that.
-        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModObjectScaleTween), typeof(OsuModHidden) };
+        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModObjectScaleTween), typeof(OsuModHidden), typeof(OsuModDepth) };
 
         private const int rotate_offset = 360;
         private const float rotate_starting_width = 2;

osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs

@@ -47,7 +47,8 @@ namespace osu.Game.Rulesets.Osu.Mods
             typeof(OsuModRandom),
             typeof(OsuModSpunOut),
             typeof(OsuModStrictTracking),
-            typeof(OsuModSuddenDeath)
+            typeof(OsuModSuddenDeath),
+            typeof(OsuModDepth)
         }).ToArray();
 
         [SettingSource("Seed", "Use a custom seed instead of a random one", SettingControlType = typeof(SettingsNumberBox))]

osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override LocalisableString Description => "Put your faith in the approach circles...";
         public override double ScoreMultiplier => 1;
 
-        public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles) };
+        public override Type[] IncompatibleMods => new[] { typeof(IHidesApproachCircles), typeof(OsuModDepth) };
 
         protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {

osu.Game.Rulesets.Osu/Mods/OsuModTransform.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "Everything rotates. EVERYTHING.";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModWiggle), typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModFreezeFrame) }).ToArray();
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModWiggle), typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModFreezeFrame), typeof(OsuModDepth) }).ToArray();
 
         private float theta;
 

osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs

@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override ModType Type => ModType.Fun;
         public override LocalisableString Description => "They just won't stay still...";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => new[] { typeof(OsuModTransform), typeof(OsuModMagnetised), typeof(OsuModRepel) };
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModTransform), typeof(OsuModMagnetised), typeof(OsuModRepel), typeof(OsuModDepth) };
 
         private const int wiggle_duration = 100; // (ms) Higher = fewer wiggles
 

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -211,7 +211,8 @@ namespace osu.Game.Rulesets.Osu
                         new ModAdaptiveSpeed(),
                         new OsuModFreezeFrame(),
                         new OsuModBubbles(),
-                        new OsuModSynesthesia()
+                        new OsuModSynesthesia(),
+                        new OsuModDepth()
                     };
 
                 case ModType.System: