Merge branch 'master' into action-key-counter

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs

@@ -39,10 +39,14 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
         /// </summary>
         private const float taiko_base_distance = 100;
 
+        private bool isForCurrentRuleset;
+
         protected override IEnumerable<Type> ValidConversionTypes { get; } = new[] { typeof(HitObject) };
 
         protected override Beatmap<TaikoHitObject> ConvertBeatmap(Beatmap original, bool isForCurrentRuleset)
         {
+            this.isForCurrentRuleset = isForCurrentRuleset;
+
             // Rewrite the beatmap info to add the slider velocity multiplier
             BeatmapInfo info = original.BeatmapInfo.DeepClone();
             info.Difficulty.SliderMultiplier *= legacy_velocity_multiplier;
@@ -104,7 +108,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 // If the drum roll is to be split into hit circles, assume the ticks are 1/8 spaced within the duration of one beat
                 double tickSpacing = Math.Min(speedAdjustedBeatLength / beatmap.BeatmapInfo.Difficulty.SliderTickRate, taikoDuration / repeats);
 
-                if (tickSpacing > 0 && osuDuration < 2 * speedAdjustedBeatLength)
+                if (!isForCurrentRuleset && tickSpacing > 0 && osuDuration < 2 * speedAdjustedBeatLength)
                 {
                     List<SampleInfoList> allSamples = curveData != null ? curveData.RepeatSamples : new List<SampleInfoList>(new[] { samples });
 

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableBarLine.cs

@@ -58,10 +58,10 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             };
         }
 
-        protected override TaikoJudgement CreateJudgement() => new TaikoJudgement();
+        protected override TaikoJudgement CreateJudgement() => null;
 
         protected override void UpdateState(ArmedState state)
         {
         }
     }
-}
+}

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableBarLineMajor.cs

@@ -20,10 +20,12 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         /// </summary>
         private const float triangle_size = 20f;
 
+        private readonly Container triangleContainer;
+
         public DrawableBarLineMajor(BarLine barLine)
             : base(barLine)
         {
-            Add(new Container
+            Add(triangleContainer = new Container
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
@@ -53,5 +55,13 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
             Tracker.Alpha = 1f;
         }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            using (triangleContainer.BeginAbsoluteSequence(HitObject.StartTime))
+                triangleContainer.FadeOut(150);
+        }
     }
-}
+}

osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs

@@ -45,6 +45,8 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         private readonly Container topLevelHitContainer;
 
+        private readonly Container barlineContainer;
+
         private readonly Container overlayBackgroundContainer;
         private readonly Container backgroundContainer;
 
@@ -85,7 +87,7 @@ namespace osu.Game.Rulesets.Taiko.UI
                     {
                         new Container
                         {
-                            Name = "Masked elements",
+                            Name = "Masked elements before hit objects",
                             RelativeSizeAxes = Axes.Both,
                             Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
                             Masking = true,
@@ -103,13 +105,21 @@ namespace osu.Game.Rulesets.Taiko.UI
                                     Origin = Anchor.Centre,
                                     RelativeSizeAxes = Axes.Both,
                                     FillMode = FillMode.Fit
-                                },
+                                }
-                                content = new Container
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                },
                             }
                         },
+                        barlineContainer = new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET }
+                        },
+                        content = new Container
+                        {
+                            Name = "Hit objects",
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
+                            Masking = true
+                        },
                         kiaiExplosionContainer = new Container<KiaiHitExplosion>
                         {
                             Name = "Kiai hit explosions",
@@ -198,6 +208,10 @@ namespace osu.Game.Rulesets.Taiko.UI
 
             base.Add(h);
 
+            var barline = h as DrawableBarLine;
+            if (barline != null)
+                barlineContainer.Add(barline.CreateProxy());
+
             // Swells should be moved at the very top of the playfield when they reach the hit target
             var swell = h as DrawableSwell;
             if (swell != null)
@@ -239,4 +253,4 @@ namespace osu.Game.Rulesets.Taiko.UI
                 hitExplosionContainer.Children.FirstOrDefault(e => e.Judgement == judgedObject.Judgement)?.VisualiseSecondHit();
         }
     }
-}
+}

osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs

@@ -106,6 +106,9 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// <returns>Whether a hit was processed.</returns>
         protected bool UpdateJudgement(bool userTriggered)
         {
+            if (Judgement == null)
+                return false;
+
             var partial = Judgement as IPartialJudgement;
 
             // Never re-process non-partial hits

osu.Game/Rulesets/UI/ScrollingPlayfield.cs

@@ -151,10 +151,6 @@ namespace osu.Game.Rulesets.UI
             /// </summary>
             public readonly BindableBool Reversed = new BindableBool();
 
-            /// <summary>
-            /// Hit objects that are to be re-processed on the next update.
-            /// </summary>
-            private readonly List<DrawableHitObject> queuedHitObjects = new List<DrawableHitObject>();
             private readonly Container<SpeedAdjustmentContainer> speedAdjustments;
 
             private readonly Axes scrollingAxes;
@@ -168,6 +164,9 @@ namespace osu.Game.Rulesets.UI
                 this.scrollingAxes = scrollingAxes;
 
                 AddInternal(speedAdjustments = new Container<SpeedAdjustmentContainer> { RelativeSizeAxes = Axes.Both });
+
+                // Default speed adjustment
+                AddSpeedAdjustment(new SpeedAdjustmentContainer(new MultiplierControlPoint(0)));
             }
 
             /// <summary>
@@ -180,6 +179,21 @@ namespace osu.Game.Rulesets.UI
                 speedAdjustment.VisibleTimeRange.BindTo(VisibleTimeRange);
                 speedAdjustment.Reversed.BindTo(Reversed);
                 speedAdjustments.Add(speedAdjustment);
+
+                // We now need to re-sort the hit objects in the last speed adjustment prior to this one, to see if they need a new parent
+                var previousSpeedAdjustment = speedAdjustments.LastOrDefault(s => s.ControlPoint.StartTime < speedAdjustment.ControlPoint.StartTime);
+                if (previousSpeedAdjustment == null)
+                    return;
+
+                foreach (DrawableHitObject h in previousSpeedAdjustment.Children)
+                {
+                    var newSpeedAdjustment = adjustmentContainerFor(h);
+                    if (newSpeedAdjustment == previousSpeedAdjustment)
+                        continue;
+
+                    previousSpeedAdjustment.Remove(h);
+                    newSpeedAdjustment.Add(h);
+                }
             }
 
             public override IEnumerable<DrawableHitObject> Objects => speedAdjustments.SelectMany(s => s.Children);
@@ -194,30 +208,14 @@ namespace osu.Game.Rulesets.UI
                 if (!(hitObject is IScrollingHitObject))
                     throw new InvalidOperationException($"Hit objects added to a {nameof(ScrollingHitObjectContainer)} must implement {nameof(IScrollingHitObject)}.");
 
-                queuedHitObjects.Add(hitObject);
+                var target = adjustmentContainerFor(hitObject);
+                if (target == null)
+                    throw new InvalidOperationException($"A {nameof(SpeedAdjustmentContainer)} to container {hitObject} could not be found.");
+
+                target.Add(hitObject);
             }
 
-            public override bool Remove(DrawableHitObject hitObject) => speedAdjustments.Any(s => s.Remove(hitObject)) || queuedHitObjects.Remove(hitObject);
+            public override bool Remove(DrawableHitObject hitObject) => speedAdjustments.Any(s => s.Remove(hitObject));
-
-            protected override void Update()
-            {
-                base.Update();
-
-                // Todo: At the moment this is going to re-process every single Update, however this will only be a null-op
-                // when there are no SpeedAdjustmentContainers available. This should probably error or something, but it's okay for now.
-
-                for (int i = queuedHitObjects.Count - 1; i >= 0; i--)
-                {
-                    var hitObject = queuedHitObjects[i];
-
-                    var target = adjustmentContainerFor(hitObject);
-                    if (target == null)
-                        continue;
-
-                    target.Add(hitObject);
-                    queuedHitObjects.RemoveAt(i);
-                }
-            }
 
             /// <summary>
             /// Finds the <see cref="SpeedAdjustmentContainer"/> which provides the speed adjustment active at the start time
@@ -237,4 +235,4 @@ namespace osu.Game.Rulesets.UI
             private SpeedAdjustmentContainer adjustmentContainerAt(double time) => speedAdjustments.FirstOrDefault(c => c.CanContain(time)) ?? speedAdjustments.LastOrDefault();
         }
     }
-}
+}