Merge pull request #98 from swoolcock/rename-sheets

Rename note sheet to star sheet

Author: swoolcock

osu.Game.Rulesets.Rush.Tests/Beatmaps/CraftedBeatmapConversionTest.cs

@@ -27,7 +27,7 @@ protected override IEnumerable<ConvertValue> CreateConvertValue(HitObject hitObj
                 EndTime = hitObject.GetEndTime(),
                 Lane = (hitObject as LanedHit)?.Lane,
                 IsMinion = hitObject is Minion,
-                IsNoteSheet = hitObject is NoteSheet,
+                IsStarSheet = hitObject is StarSheet,
                 IsMiniBoss = hitObject is MiniBoss,
                 IsSawblade = hitObject is Sawblade,
                 HasHeart = hitObject is Heart /*|| (hitObject is LanedHit)?.HasHeart*/,
@@ -50,7 +50,7 @@ public struct ConvertValue : IEquatable<ConvertValue>
         public double EndTime;
         public LanedHitLane? Lane;
         public bool IsMinion;
-        public bool IsNoteSheet;
+        public bool IsStarSheet;
         public bool IsMiniBoss;
         public bool IsSawblade;
         public bool IsHammer;
@@ -62,7 +62,7 @@ public bool Equals(ConvertValue other)
                && Precision.AlmostEquals(EndTime, other.EndTime, conversion_lenience)
                && Lane == other.Lane
                && IsMinion == other.IsMinion
-               && IsNoteSheet == other.IsNoteSheet
+               && IsStarSheet == other.IsStarSheet
                && IsSawblade == other.IsSawblade
                && IsHammer == other.IsHammer
                && HasHeart == other.HasHeart

osu.Game.Rulesets.Rush/Beatmaps/RushBeatmap.cs

@@ -16,7 +16,7 @@ public class RushBeatmap : Beatmap<RushHitObject>
         public override IEnumerable<BeatmapStatistic> GetStatistics()
         {
             int minions = HitObjects.Count(s => s is Minion);
-            int notesheets = HitObjects.Count(s => s is NoteSheet);
+            int starsheets = HitObjects.Count(s => s is StarSheet);
             int sawblades = HitObjects.Count(s => s is Sawblade);
             int dualhits = HitObjects.Count(s => s is DualHit);
             int minibosses = HitObjects.Count(s => s is MiniBoss);
@@ -32,8 +32,8 @@ public override IEnumerable<BeatmapStatistic> GetStatistics()
                 },
                 new BeatmapStatistic
                 {
-                    Name = @"Notesheet Count",
-                    Content = notesheets.ToString(),
+                    Name = @"Star Sheet Count",
+                    Content = starsheets.ToString(),
                     CreateIcon = () => createIcon(FontAwesome.Regular.Star),
                 },
                 new BeatmapStatistic

osu.Game.Rulesets.Rush/Beatmaps/RushCraftedBeatmapConverter.cs

@@ -56,9 +56,9 @@ namespace osu.Game.Rulesets.Rush.Beatmaps
     /// 1) The "finish" hitsound will be converted to hearts rather than sawblades.
     ///
     /// Sliders:
-    /// 1) Sliders that start in section A or C are by default "air" or "ground" notesheets respectively
-    /// 2) Sliders that start in section B will add equal length notesheets to both air and ground
-    /// 3) The slider head indicates in which lane the notesheet will appear
+    /// 1) Sliders that start in section A or C are by default "air" or "ground" starsheets respectively
+    /// 2) Sliders that start in section B will add equal length starsheets to both air and ground
+    /// 3) The slider head indicates in which lane the starsheet will appear
     /// 4) Slider distance and repeats are ignored, only the final end time is used
     ///
     /// Spinners:
@@ -97,11 +97,11 @@ protected override IEnumerable<RushHitObject> ConvertHitObject(HitObject origina
 
                     break;
 
-                case HitObjectType.DualNoteSheet:
-                case HitObjectType.NoteSheet:
-                    if (hitObjectType == HitObjectType.DualNoteSheet || lane == LanedHitLane.Air)
+                case HitObjectType.DualStarSheet:
+                case HitObjectType.StarSheet:
+                    if (hitObjectType == HitObjectType.DualStarSheet || lane == LanedHitLane.Air)
                     {
-                        yield return new NoteSheet
+                        yield return new StarSheet
                         {
                             StartTime = original.StartTime,
                             EndTime = original.GetEndTime(),
@@ -110,9 +110,9 @@ protected override IEnumerable<RushHitObject> ConvertHitObject(HitObject origina
                         };
                     }
 
-                    if (hitObjectType == HitObjectType.DualNoteSheet || lane == LanedHitLane.Ground)
+                    if (hitObjectType == HitObjectType.DualStarSheet || lane == LanedHitLane.Ground)
                     {
-                        yield return new NoteSheet
+                        yield return new StarSheet
                         {
                             StartTime = original.StartTime,
                             EndTime = original.GetEndTime(),
@@ -193,14 +193,14 @@ private bool typeForObject(HitObject hitObject, out HitObjectType hitObjectType,
             {
                 if (position.Y >= horizontal_top && position.Y < horizontal_bottom)
                 {
-                    hitObjectType = hitObject is IHasDuration ? HitObjectType.DualNoteSheet : HitObjectType.DualHit;
+                    hitObjectType = hitObject is IHasDuration ? HitObjectType.DualStarSheet : HitObjectType.DualHit;
                     return true;
                 }
 
                 lane = position.Y < horizontal_top ? LanedHitLane.Air : LanedHitLane.Ground;
 
                 if (hitObject is IHasDuration)
-                    hitObjectType = HitObjectType.NoteSheet;
+                    hitObjectType = HitObjectType.StarSheet;
                 else
                 {
                     hitObjectType = HitObjectType.Minion;
@@ -230,8 +230,8 @@ private bool typeForObject(HitObject hitObject, out HitObjectType hitObjectType,
         private enum HitObjectType
         {
             Minion,
-            NoteSheet,
-            DualNoteSheet, // helper to save on double sliders
+            StarSheet,
+            DualStarSheet, // helper to save on double sliders
             DualHit,
             MiniBoss,
             Sawblade,

osu.Game.Rulesets.Rush/Beatmaps/RushGeneratedBeatmapConverter.cs

@@ -22,9 +22,9 @@ public class RushGeneratedBeatmapConverter : BeatmapConverter<RushHitObject>
         private const double sawblade_probability = 0.1;
         private const double dualhit_probability = 0.2;
         private const double suggest_probability = 0.1;
-        private const double notesheet_start_probability = 0.5;
-        private const double notesheet_end_probability = 0.2;
-        private const double notesheet_dual_probability = 0.1;
+        private const double starsheet_start_probability = 0.5;
+        private const double starsheet_end_probability = 0.2;
+        private const double starsheet_dual_probability = 0.1;
         private const double kiai_multiplier = 4;
 
         private const double sawblade_same_lane_safety_time = 90;
@@ -48,7 +48,7 @@ public class RushGeneratedBeatmapConverter : BeatmapConverter<RushHitObject>
         private double previousSourceTime;
         private HitObjectFlags previousFlags;
 
-        private readonly Dictionary<LanedHitLane, NoteSheet> currentNoteSheets = new Dictionary<LanedHitLane, NoteSheet>();
+        private readonly Dictionary<LanedHitLane, StarSheet> currentStarSheets = new Dictionary<LanedHitLane, StarSheet>();
 
         public RushGeneratedBeatmapConverter(IBeatmap beatmap, Ruleset ruleset)
             : base(beatmap, ruleset)
@@ -76,7 +76,7 @@ private void reset()
             previousLane = null;
             previousSourcePosition = null;
             previousSourceTime = 0;
-            currentNoteSheets.Clear();
+            currentStarSheets.Clear();
         }
 
         // todo: Check for conversion types that should be supported (ie. Beatmap.HitObjects.Any(h => h is IHasXPosition))
@@ -127,23 +127,23 @@ void updatePrevious(LanedHitLane? newLane, HitObjectFlags newFlags)
             lane ??= laneForHitObject(original);
 
             // if we should end a sheet, try to
-            if (currentNoteSheets.Count > 0 && (flags.HasFlag(HitObjectFlags.ForceEndNotesheet) || flags.HasFlag(HitObjectFlags.SuggestEndNotesheet) && random.NextDouble() < notesheet_end_probability))
+            if (currentStarSheets.Count > 0 && (flags.HasFlag(HitObjectFlags.ForceEndStarSheet) || flags.HasFlag(HitObjectFlags.SuggestEndStarSheet) && random.NextDouble() < starsheet_end_probability))
             {
                 // TODO: for now we'll end both sheets where they are and ignore snapping logic
-                currentNoteSheets.Clear();
+                currentStarSheets.Clear();
             }
 
-            // if we should start a notesheet...
-            if (flags.HasFlag(HitObjectFlags.ForceStartNotesheet) || flags.HasFlag(HitObjectFlags.SuggestStartNotesheet) && random.NextDouble() < notesheet_start_probability)
+            // if we should start a starsheet...
+            if (flags.HasFlag(HitObjectFlags.ForceStartStarSheet) || flags.HasFlag(HitObjectFlags.SuggestStartStarSheet) && random.NextDouble() < starsheet_start_probability)
             {
                 // TODO: for now, end all existing sheets
-                currentNoteSheets.Clear();
+                currentStarSheets.Clear();
 
                 // use the suggested lane or randomly select one
                 LanedHitLane sheetLane = lane ?? (random.NextDouble() < 0.5 ? LanedHitLane.Ground : LanedHitLane.Air);
 
                 // create a sheet
-                NoteSheet sheet = currentNoteSheets[sheetLane] = createNoteSheet(original, sheetLane, original.Samples);
+                StarSheet sheet = currentStarSheets[sheetLane] = createStarSheet(original, sheetLane, original.Samples);
                 LanedHitLane otherLane = sheetLane.Opposite();
 
                 // FIXME: surely this is bad, altering the hit object after it's been returned???
@@ -185,22 +185,22 @@ void updatePrevious(LanedHitLane? newLane, HitObjectFlags newFlags)
                     }
                 }
                 // otherwise we have a chance to make a dual sheet
-                else if (random.NextDouble() < notesheet_dual_probability)
+                else if (random.NextDouble() < starsheet_dual_probability)
                 {
-                    currentNoteSheets[otherLane] = createNoteSheet(original, otherLane, null);
-                    yield return currentNoteSheets[otherLane];
+                    currentStarSheets[otherLane] = createStarSheet(original, otherLane, null);
+                    yield return currentStarSheets[otherLane];
                 }
 
                 updatePrevious(sheetLane, flags);
                 yield break;
             }
 
             // if either of the sheets are too long, end them where they are
-            if (currentNoteSheets.ContainsKey(LanedHitLane.Air) && currentNoteSheets[LanedHitLane.Air].Duration >= max_sheet_length)
-                currentNoteSheets.Remove(LanedHitLane.Air);
+            if (currentStarSheets.ContainsKey(LanedHitLane.Air) && currentStarSheets[LanedHitLane.Air].Duration >= max_sheet_length)
+                currentStarSheets.Remove(LanedHitLane.Air);
 
-            if (currentNoteSheets.ContainsKey(LanedHitLane.Ground) && currentNoteSheets[LanedHitLane.Ground].Duration >= max_sheet_length)
-                currentNoteSheets.Remove(LanedHitLane.Ground);
+            if (currentStarSheets.ContainsKey(LanedHitLane.Ground) && currentStarSheets[LanedHitLane.Ground].Duration >= max_sheet_length)
+                currentStarSheets.Remove(LanedHitLane.Ground);
 
             // if it's low probability, potentially skip this object
             if (flags.HasFlag(HitObjectFlags.LowProbability) && random.NextDouble() < skip_probability)
@@ -225,10 +225,10 @@ void updatePrevious(LanedHitLane? newLane, HitObjectFlags newFlags)
             // if we still haven't selected a lane at this point, pick a random one
             var finalLane = lane ?? (random.NextDouble() < 0.5 ? LanedHitLane.Ground : LanedHitLane.Air);
 
-            // check if a lane is blocked by a notesheet
-            LanedHitLane? blockedLane = currentNoteSheets.ContainsKey(LanedHitLane.Air)
+            // check if a lane is blocked by a starsheet
+            LanedHitLane? blockedLane = currentStarSheets.ContainsKey(LanedHitLane.Air)
                 ? LanedHitLane.Air
-                : currentNoteSheets.ContainsKey(LanedHitLane.Ground)
+                : currentStarSheets.ContainsKey(LanedHitLane.Ground)
                     ? LanedHitLane.Ground
                     : (LanedHitLane?)null;
 
@@ -323,8 +323,8 @@ private MiniBoss createMiniBoss(HitObject original) =>
                 Samples = original.Samples
             };
 
-        private NoteSheet createNoteSheet(HitObject original, LanedHitLane lane, IList<HitSampleInfo> samples) =>
-            new NoteSheet
+        private StarSheet createStarSheet(HitObject original, LanedHitLane lane, IList<HitSampleInfo> samples) =>
+            new StarSheet
             {
                 StartTime = original.StartTime,
                 EndTime = original.GetEndTime(),
@@ -353,13 +353,13 @@ private HitObjectFlags flagsForHitObject(HitObject hitObject, IBeatmap beatmap)
         {
             HitObjectFlags flags = HitObjectFlags.None;
 
-            // sliders should force a notesheet to start or end
+            // sliders should force a starsheet to start or end
             if (hitObject is IHasDuration hasDuration && hitObject is IHasDistance && hasDuration.Duration >= min_sheet_length)
             {
-                // if (currentNoteSheets.Count == 2)
-                //     flags |= HitObjectFlags.ForceStartNotesheet | HitObjectFlags.ForceEndNotesheet;
+                // if (currentStarSheets.Count == 2)
+                //     flags |= HitObjectFlags.ForceStartStarSheet | HitObjectFlags.ForceEndStarSheet;
                 // else
-                flags |= HitObjectFlags.ForceStartNotesheet | HitObjectFlags.ForceEndNotesheet;
+                flags |= HitObjectFlags.ForceStartStarSheet | HitObjectFlags.ForceEndStarSheet;
             }
 
             // TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
@@ -383,37 +383,37 @@ private HitObjectFlags flagsForHitObject(HitObject hitObject, IBeatmap beatmap)
                 flags |= newCombo ? HitObjectFlags.ForceNotSameLane : HitObjectFlags.SuggestNotSameLane;
                 // flags |= HitObjectFlags.LowProbability;
                 flags |= HitObjectFlags.AllowSawbladeAdd;
-                flags |= HitObjectFlags.ForceEndNotesheet;
+                flags |= HitObjectFlags.ForceEndStarSheet;
             }
             else if (timeSeparation <= 125)
             {
                 // more than 120 bpm
                 flags |= newCombo ? HitObjectFlags.ForceNotSameLane : HitObjectFlags.SuggestNotSameLane;
                 flags |= HitObjectFlags.AllowSawbladeAdd;
-                flags |= HitObjectFlags.ForceEndNotesheet;
+                flags |= HitObjectFlags.ForceEndStarSheet;
             }
             else if (timeSeparation <= 135 && positionSeparation < 20)
             {
                 // more than 111 bpm stream
                 flags |= newCombo ? HitObjectFlags.ForceNotSameLane : HitObjectFlags.ForceSameLane;
                 flags |= HitObjectFlags.AllowSawbladeAdd;
-                flags |= HitObjectFlags.ForceEndNotesheet;
+                flags |= HitObjectFlags.ForceEndStarSheet;
             }
             else
             {
                 flags |= newCombo ? HitObjectFlags.ForceNotSameLane : HitObjectFlags.ForceSameLane;
                 // flags |= HitObjectFlags.LowProbability;
                 flags |= HitObjectFlags.AllowDoubleHit;
                 flags |= HitObjectFlags.AllowSawbladeAdd;
-                flags |= HitObjectFlags.ForceEndNotesheet;
+                flags |= HitObjectFlags.ForceEndStarSheet;
                 // flags |= HitObjectFlags.AllowSawbladeReplace; FIXME: for now, always add rather than replace
             }
 
             // new combo should never be low probability
             if (newCombo) flags &= ~HitObjectFlags.LowProbability;
 
-            // new combo should force note sheets to end
-            if (newCombo) flags |= HitObjectFlags.ForceEndNotesheet;
+            // new combo should force star sheets to end
+            if (newCombo) flags |= HitObjectFlags.ForceEndStarSheet;
 
             return flags;
         }
@@ -463,10 +463,10 @@ private enum HitObjectFlags
             /// </summary>
             AllowSawbladeAdd = 1 << 7,
 
-            ForceStartNotesheet = 1 << 8,
-            ForceEndNotesheet = 1 << 9,
-            SuggestStartNotesheet = 1 << 10,
-            SuggestEndNotesheet = 1 << 11,
+            ForceStartStarSheet = 1 << 8,
+            ForceEndStarSheet = 1 << 9,
+            SuggestStartStarSheet = 1 << 10,
+            SuggestEndStarSheet = 1 << 11,
 
             AllowSawbladeAddOrReplace = AllowSawbladeAdd | AllowSawbladeReplace,
         }