Implement HitObjectContainerEventQueue

osu.Game/Screens/Edit/Compose/HitObjectContainerEventQueue.cs

@@ -0,0 +1,102 @@
+// 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.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Screens.Edit.Compose
+{
+    /// <summary>
+    /// A queue which processes events from the many <see cref="HitObjectContainer"/>s in a nested <see cref="Playfield"/> hierarchy.
+    /// </summary>
+    internal class HitObjectContainerEventQueue : Component
+    {
+        /// <summary>
+        /// Invoked when a <see cref="HitObject"/> becomes used by a <see cref="DrawableHitObject"/>.
+        /// </summary>
+        /// <remarks>
+        /// If the ruleset uses pooled objects, this represents the time when the <see cref="HitObject"/>s become alive.
+        /// </remarks>
+        public event Action<HitObject, DrawableHitObject> HitObjectUsageBegan;
+
+        /// <summary>
+        /// Invoked when a <see cref="HitObject"/> becomes unused by a <see cref="DrawableHitObject"/>.
+        /// </summary>
+        /// <remarks>
+        /// If the ruleset uses pooled objects, this represents the time when the <see cref="HitObject"/>s become dead.
+        /// </remarks>
+        public event Action<HitObject> HitObjectUsageFinished;
+
+        /// <summary>
+        /// Invoked when a <see cref="HitObject"/> has been transferred to another <see cref="DrawableHitObject"/>.
+        /// </summary>
+        public event Action<HitObject, DrawableHitObject> HitObjectUsageTransferred;
+
+        private readonly Playfield playfield;
+
+        /// <summary>
+        /// Creates a new <see cref="HitObjectContainerEventQueue"/>.
+        /// </summary>
+        /// <param name="playfield">The most top-level <see cref="Playfield"/>.</param>
+        public HitObjectContainerEventQueue(Playfield playfield)
+        {
+            this.playfield = playfield;
+
+            bindPlayfieldRecursive(playfield);
+        }
+
+        private void bindPlayfieldRecursive(Playfield p)
+        {
+            p.HitObjectContainer.HitObjectUsageBegan += onHitObjectUsageBegan;
+            p.HitObjectContainer.HitObjectUsageFinished += onHitObjectUsageFinished;
+
+            foreach (var nested in p.NestedPlayfields)
+                bindPlayfieldRecursive(nested);
+        }
+
+        private readonly Dictionary<HitObject, int> pendingUsagesBegan = new Dictionary<HitObject, int>();
+        private readonly Dictionary<HitObject, int> pendingUsagesFinished = new Dictionary<HitObject, int>();
+
+        private void onHitObjectUsageBegan(HitObject hitObject) => pendingUsagesBegan[hitObject] = pendingUsagesBegan.GetValueOrDefault(hitObject, 0) + 1;
+
+        private void onHitObjectUsageFinished(HitObject hitObject) => pendingUsagesFinished[hitObject] = pendingUsagesFinished.GetValueOrDefault(hitObject, 0) + 1;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            foreach (var (hitObject, countBegan) in pendingUsagesBegan)
+            {
+                if (pendingUsagesFinished.TryGetValue(hitObject, out int countFinished))
+                {
+                    Debug.Assert(countFinished > 0);
+
+                    if (countBegan > countFinished)
+                    {
+                        // The hitobject is still in use, but transferred to a different HOC.
+                        HitObjectUsageTransferred?.Invoke(hitObject, playfield.AllHitObjects.Single(d => d.HitObject == hitObject));
+                        pendingUsagesFinished.Remove(hitObject);
+                    }
+                }
+                else
+                {
+                    // This is a new usage of the hitobject.
+                    HitObjectUsageBegan?.Invoke(hitObject, playfield.AllHitObjects.Single(d => d.HitObject == hitObject));
+                }
+            }
+
+            // Go through any remaining pending finished usages.
+            foreach (var (hitObject, _) in pendingUsagesFinished)
+                HitObjectUsageFinished?.Invoke(hitObject);
+
+            pendingUsagesBegan.Clear();
+            pendingUsagesFinished.Clear();
+        }
+    }
+}