Add and use limited capacity queue

osu.Game.Rulesets.Taiko/Difficulty/Preprocessing/StaminaCheeseDetector.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using osu.Game.Rulesets.Difficulty.Utils;
 using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing
@@ -27,16 +28,15 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Preprocessing
 
         private void findRolls(int patternLength)
         {
-            List<TaikoDifficultyHitObject> history = new List<TaikoDifficultyHitObject>();
+            var history = new LimitedCapacityQueue<TaikoDifficultyHitObject>(2 * patternLength);
 
             int repetitionStart = 0;
 
             for (int i = 0; i < hitObjects.Count; i++)
             {
-                history.Add(hitObjects[i]);
-                if (history.Count < 2 * patternLength) continue;
-
-                if (history.Count > 2 * patternLength) history.RemoveAt(0);
+                history.Enqueue(hitObjects[i]);
+                if (!history.Full)
+                    continue;
 
                 bool isRepeat = true;
 

osu.Game.Rulesets.Taiko/Difficulty/Skills/Colour.cs

@@ -2,9 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Difficulty.Utils;
 using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Taiko.Objects;
 
@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
         /// <summary>
         /// List of the last <see cref="mono_history_max_length"/> most recent mono patterns, with the most recent at the end of the list.
         /// </summary>
-        private readonly List<int> monoHistory = new List<int>();
+        private readonly LimitedCapacityQueue<int> monoHistory = new LimitedCapacityQueue<int>(mono_history_max_length);
 
         protected override double StrainValueOf(DifficultyHitObject current)
         {
@@ -83,10 +83,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
             const int l = 2;
             double penalty = 1.0;
 
-            monoHistory.Add(currentMonoLength);
-
-            if (monoHistory.Count > mono_history_max_length)
-                monoHistory.RemoveAt(0);
+            monoHistory.Enqueue(currentMonoLength);
 
             for (int start = monoHistory.Count - l - 1; start >= 0; start--)
             {

osu.Game.Rulesets.Taiko/Difficulty/Skills/Rhythm.cs

@@ -2,9 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Difficulty.Utils;
 using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Taiko.Objects;
 
@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
         private const double strain_decay = 0.96;
         private double currentStrain;
 
-        private readonly List<TaikoDifficultyHitObject> rhythmHistory = new List<TaikoDifficultyHitObject>();
+        private readonly LimitedCapacityQueue<TaikoDifficultyHitObject> rhythmHistory = new LimitedCapacityQueue<TaikoDifficultyHitObject>(rhythm_history_max_length);
         private const int rhythm_history_max_length = 8;
 
         private int notesSinceRhythmChange;
@@ -32,10 +32,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
         {
             double penalty = 1;
 
-            rhythmHistory.Add(hitobject);
-
-            if (rhythmHistory.Count > rhythm_history_max_length)
-                rhythmHistory.RemoveAt(0);
+            rhythmHistory.Enqueue(hitobject);
 
             for (int l = 2; l <= rhythm_history_max_length / 2; l++)
             {

osu.Game.Rulesets.Taiko/Difficulty/Skills/Stamina.cs

@@ -1,10 +1,10 @@
 // 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.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Difficulty.Utils;
 using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Taiko.Objects;
 
@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
         protected override double StrainDecayBase => 0.4;
 
         private const int max_history_length = 2;
-        private readonly List<double> notePairDurationHistory = new List<double>();
+        private readonly LimitedCapacityQueue<double> notePairDurationHistory = new LimitedCapacityQueue<double>(max_history_length);
 
         private double offhandObjectDuration = double.MaxValue;
 
@@ -56,10 +56,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty.Skills
                 if (hitObject.ObjectIndex == 1)
                     return 1;
 
-                notePairDurationHistory.Add(hitObject.DeltaTime + offhandObjectDuration);
-
-                if (notePairDurationHistory.Count > max_history_length)
-                    notePairDurationHistory.RemoveAt(0);
+                notePairDurationHistory.Enqueue(hitObject.DeltaTime + offhandObjectDuration);
 
                 double shortestRecentNote = notePairDurationHistory.Min();
                 objectStrain += speedBonus(shortestRecentNote);

osu.Game.Tests/NonVisual/LimitedCapacityQueueTest.cs

@@ -0,0 +1,98 @@
+// 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 NUnit.Framework;
+using osu.Game.Rulesets.Difficulty.Utils;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [TestFixture]
+    public class LimitedCapacityQueueTest
+    {
+        private const int capacity = 3;
+
+        private LimitedCapacityQueue<int> queue;
+
+        [SetUp]
+        public void SetUp()
+        {
+            queue = new LimitedCapacityQueue<int>(capacity);
+        }
+
+        [Test]
+        public void TestEmptyQueue()
+        {
+            Assert.AreEqual(0, queue.Count);
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[0]);
+
+            Assert.Throws<InvalidOperationException>(() => _ = queue.Dequeue());
+
+            int count = 0;
+            foreach (var _ in queue)
+                count++;
+
+            Assert.AreEqual(0, count);
+        }
+
+        [TestCase(1)]
+        [TestCase(2)]
+        [TestCase(3)]
+        public void TestBelowCapacity(int count)
+        {
+            for (int i = 0; i < count; ++i)
+                queue.Enqueue(i);
+
+            Assert.AreEqual(count, queue.Count);
+
+            for (int i = 0; i < count; ++i)
+                Assert.AreEqual(i, queue[i]);
+
+            int j = 0;
+            foreach (var item in queue)
+                Assert.AreEqual(j++, item);
+
+            for (int i = queue.Count; i < queue.Count + capacity; i++)
+                Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[i]);
+        }
+
+        [TestCase(4)]
+        [TestCase(5)]
+        [TestCase(6)]
+        public void TestEnqueueAtFullCapacity(int count)
+        {
+            for (int i = 0; i < count; ++i)
+                queue.Enqueue(i);
+
+            Assert.AreEqual(capacity, queue.Count);
+
+            for (int i = 0; i < queue.Count; ++i)
+                Assert.AreEqual(count - capacity + i, queue[i]);
+
+            int j = count - capacity;
+            foreach (var item in queue)
+                Assert.AreEqual(j++, item);
+
+            for (int i = queue.Count; i < queue.Count + capacity; i++)
+                Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[i]);
+        }
+
+        [TestCase(4)]
+        [TestCase(5)]
+        [TestCase(6)]
+        public void TestDequeueAtFullCapacity(int count)
+        {
+            for (int i = 0; i < count; ++i)
+                queue.Enqueue(i);
+
+            for (int i = 0; i < capacity; ++i)
+            {
+                Assert.AreEqual(count - capacity + i, queue.Dequeue());
+                Assert.AreEqual(2 - i, queue.Count);
+            }
+
+            Assert.Throws<InvalidOperationException>(() => queue.Dequeue());
+        }
+    }
+}

osu.Game/Rulesets/Difficulty/Utils/LimitedCapacityQueue.cs

@@ -0,0 +1,114 @@
+// 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;
+using System.Collections.Generic;
+
+namespace osu.Game.Rulesets.Difficulty.Utils
+{
+    /// <summary>
+    /// An indexed queue with limited capacity.
+    /// Respects first-in-first-out insertion order.
+    /// </summary>
+    public class LimitedCapacityQueue<T> : IEnumerable<T>
+    {
+        /// <summary>
+        /// The number of elements in the queue.
+        /// </summary>
+        public int Count { get; private set; }
+
+        /// <summary>
+        /// Whether the queue is full (adding any new items will cause removing existing ones).
+        /// </summary>
+        public bool Full => Count == capacity;
+
+        private readonly T[] array;
+        private readonly int capacity;
+
+        // Markers tracking the queue's first and last element.
+        private int start, end;
+
+        /// <summary>
+        /// Constructs a new <see cref="LimitedCapacityQueue{T}"/>
+        /// </summary>
+        /// <param name="capacity">The number of items the queue can hold.</param>
+        public LimitedCapacityQueue(int capacity)
+        {
+            if (capacity < 0)
+                throw new ArgumentOutOfRangeException(nameof(capacity));
+
+            this.capacity = capacity;
+            array = new T[capacity];
+            start = 0;
+            end = -1;
+        }
+
+        /// <summary>
+        /// Removes an item from the front of the <see cref="LimitedCapacityQueue{T}"/>.
+        /// </summary>
+        /// <returns>The item removed from the front of the queue.</returns>
+        public T Dequeue()
+        {
+            if (Count == 0)
+                throw new InvalidOperationException("Queue is empty.");
+
+            var result = array[start];
+            start = (start + 1) % capacity;
+            Count--;
+            return result;
+        }
+
+        /// <summary>
+        /// Adds an item to the back of the <see cref="LimitedCapacityQueue{T}"/>.
+        /// If the queue is holding <see cref="Count"/> elements at the point of addition,
+        /// the item at the front of the queue will be removed.
+        /// </summary>
+        /// <param name="item">The item to be added to the back of the queue.</param>
+        public void Enqueue(T item)
+        {
+            end = (end + 1) % capacity;
+            if (Count == capacity)
+                start = (start + 1) % capacity;
+            else
+                Count++;
+            array[end] = item;
+        }
+
+        /// <summary>
+        /// Retrieves the item at the given index in the queue.
+        /// </summary>
+        /// <param name="index">
+        /// The index of the item to retrieve.
+        /// The item with index 0 is at the front of the queue
+        /// (it was added the earliest).
+        /// </param>
+        public T this[int index]
+        {
+            get
+            {
+                if (index < 0 || index >= Count)
+                    throw new ArgumentOutOfRangeException(nameof(index));
+
+                return array[(start + index) % capacity];
+            }
+        }
+
+        /// <summary>
+        /// Enumerates the queue from its start to its end.
+        /// </summary>
+        public IEnumerator<T> GetEnumerator()
+        {
+            if (Count == 0)
+                yield break;
+
+            for (int i = 0; i < Count; i++)
+                yield return array[(start + i) % capacity];
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}