Implement Sentakki editor

osu.Game.Rulesets.Sentakki.Tests/TestSceneSentakkiEditor.cs

@@ -0,0 +1,11 @@
+using NUnit.Framework;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Sentakki.Tests
+{
+    [TestFixture]
+    public partial class TestSceneSentakkiEditor : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new SentakkiRuleset();
+    }
+}

osu.Game.Rulesets.Sentakki/Beatmaps/SentakkiBeatmapConverterOld.cs

@@ -251,6 +251,7 @@ private SentakkiHitObject createHoldNote(HitObject original, IList<IList<HitSamp
                 Break = !ClassicMode && isBreak,
                 Lane = patternGenerator.GetNextLane(twin),
                 NodeSamples = samples,
+                Samples = original.Samples,
                 StartTime = original.StartTime,
                 EndTime = original.GetEndTime()
             };

osu.Game.Rulesets.Sentakki/Edit/Blueprints/Holds/HoldHighlight.cs

@@ -0,0 +1,57 @@
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Game.Rulesets.Sentakki.Objects.Drawables.Pieces;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Sentakki.Edit.Blueprints.Holds
+{
+    public partial class HoldHighlight : CompositeDrawable
+    {
+        public readonly Container Note;
+
+        // This drawable is zero width
+        // We should use the quad of the note container
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => ring.ReceivePositionalInputAt(screenSpacePos);
+        public override Quad ScreenSpaceDrawQuad => ring.ScreenSpaceDrawQuad;
+
+        private readonly RingPiece ring;
+
+        public HoldHighlight()
+        {
+            Anchor = Origin = Anchor.Centre;
+            Colour = Color4.YellowGreen;
+            Alpha = 0.5f;
+            InternalChildren = new Drawable[]
+            {
+                Note = new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.TopCentre,
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding(-75 / 2f),
+                            Child = ring = new RingPiece()
+                        },
+                        new DotPiece(squared: true)
+                        {
+                            Anchor = Anchor.TopCentre,
+                            Rotation = 45,
+                        },
+                        new DotPiece(squared: true)
+                        {
+                            Anchor = Anchor.BottomCentre,
+                            Rotation = 45,
+                        },
+                    }
+                }
+            };
+        }
+    }
+}

osu.Game.Rulesets.Sentakki/Edit/Blueprints/Holds/HoldPlacementBlueprint.cs

@@ -0,0 +1,80 @@
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Sentakki.Objects;
+using osu.Game.Rulesets.Sentakki.UI;
+using osu.Game.Screens.Edit;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Sentakki.Edit.Blueprints.Holds
+{
+    public partial class HoldPlacementBlueprint : SentakkiPlacementBlueprint<Hold>
+    {
+        private readonly HoldHighlight highlight;
+
+        public HoldPlacementBlueprint()
+        {
+            InternalChild = highlight = new HoldHighlight();
+            highlight.Note.Y = -SentakkiPlayfield.INTERSECTDISTANCE;
+        }
+
+        [Resolved]
+        private SentakkiSnapProvider snapProvider { get; set; } = null!;
+
+        protected override void Update()
+        {
+            highlight.Rotation = HitObject.Lane.GetRotationForLane();
+            highlight.Note.Y = -snapProvider.GetDistanceRelativeToCurrentTime(HitObject.StartTime, SentakkiPlayfield.NOTESTARTDISTANCE);
+            highlight.Note.Height = -snapProvider.GetDistanceRelativeToCurrentTime(HitObject.EndTime, SentakkiPlayfield.NOTESTARTDISTANCE) - highlight.Note.Y;
+        }
+
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            if (e.Button != MouseButton.Left)
+                return false;
+
+            if (PlacementActive == PlacementState.Active)
+                return false;
+
+            BeginPlacement(true);
+            EditorClock.SeekSmoothlyTo(HitObject.StartTime);
+
+            return true;
+        }
+
+        protected override void OnMouseUp(MouseUpEvent e)
+        {
+            if (e.Button != MouseButton.Right)
+                return;
+
+            if (PlacementActive == PlacementState.Active)
+                EndPlacement(HitObject.Duration > 0);
+        }
+
+        private double originalStartTime;
+
+        public override void UpdateTimeAndPosition(SnapResult result)
+        {
+            base.UpdateTimeAndPosition(result);
+
+            if (result is not SentakkiLanedSnapResult senRes)
+                return;
+
+            if (PlacementActive == PlacementState.Active)
+            {
+                if (result.Time is double endTime)
+                {
+                    HitObject.StartTime = endTime < originalStartTime ? endTime : originalStartTime;
+                    HitObject.Duration = Math.Abs(endTime - originalStartTime);
+                }
+            }
+            else
+            {
+                HitObject.Lane = senRes.Lane;
+                if (result.Time is double startTime)
+                    originalStartTime = HitObject.StartTime = startTime;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Sentakki/Edit/Blueprints/Holds/HoldSelectionBlueprint.cs

@@ -0,0 +1,41 @@
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Primitives;
+using osu.Game.Rulesets.Sentakki.Objects;
+using osu.Game.Rulesets.Sentakki.Objects.Drawables;
+using osu.Game.Rulesets.Sentakki.UI;
+using osuTK;
+
+namespace osu.Game.Rulesets.Sentakki.Edit.Blueprints.Holds
+{
+    public partial class HoldSelectionBlueprint : SentakkiSelectionBlueprint<Hold>
+    {
+        public new DrawableHold DrawableObject => (DrawableHold)base.DrawableObject;
+
+        private readonly HoldHighlight highlight;
+
+        public HoldSelectionBlueprint(Hold hitObject)
+            : base(hitObject)
+        {
+            InternalChild = highlight = new HoldHighlight();
+        }
+
+        [Resolved]
+        private SentakkiSnapProvider snapProvider { get; set; } = null!;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            highlight.Rotation = DrawableObject.HitObject.Lane.GetRotationForLane();
+            highlight.Note.Y = -snapProvider.GetDistanceRelativeToCurrentTime(HitObject.StartTime, SentakkiPlayfield.NOTESTARTDISTANCE);
+            highlight.Note.Height = -snapProvider.GetDistanceRelativeToCurrentTime(HitObject.EndTime, SentakkiPlayfield.NOTESTARTDISTANCE) - highlight.Note.Y;
+            highlight.Note.Scale = DrawableObject.NoteBody.Scale;
+        }
+
+        public override Vector2 ScreenSpaceSelectionPoint => highlight.ScreenSpaceDrawQuad.Centre;
+
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => highlight.ReceivePositionalInputAt(screenSpacePos);
+
+        public override Quad SelectionQuad => highlight.ScreenSpaceDrawQuad;
+    }
+}

osu.Game.Rulesets.Sentakki/Edit/Blueprints/SentakkiPlacementBlueprint.cs

@@ -0,0 +1,20 @@
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Sentakki.Edit.Blueprints
+{
+    public partial class SentakkiPlacementBlueprint<T> : PlacementBlueprint where T : HitObject, new()
+    {
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
+
+        public new T HitObject => (T)base.HitObject;
+
+        public SentakkiPlacementBlueprint()
+            : base(new T())
+        {
+            Anchor = Origin = Anchor.Centre;
+        }
+    }
+}

osu.Game.Rulesets.Sentakki/Edit/Blueprints/SentakkiSelectionBlueprint.cs

@@ -0,0 +1,15 @@
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Sentakki.Objects;
+
+namespace osu.Game.Rulesets.Sentakki.Edit.Blueprints
+{
+    public partial class SentakkiSelectionBlueprint<T> : HitObjectSelectionBlueprint<T> where T : SentakkiHitObject
+    {
+        protected override bool AlwaysShowWhenSelected => true;
+
+        public SentakkiSelectionBlueprint(T hitObject)
+            : base(hitObject)
+        {
+        }
+    }
+}

osu.Game.Rulesets.Sentakki/Edit/Blueprints/Slides/SlideBodyHighlight.cs

@@ -0,0 +1,59 @@
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Sentakki.Objects;
+using osu.Game.Rulesets.Sentakki.Objects.Drawables;
+using osu.Game.Rulesets.Sentakki.Objects.Drawables.Pieces.Slides;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Sentakki.Edit.Blueprints.Slides
+{
+    public partial class SlideBodyHighlight : CompositeDrawable
+    {
+        private readonly Container<StarPiece> stars;
+
+        private readonly SlideVisual slideBody;
+
+        private readonly SlideBodyInfo slideBodyInfo;
+
+        // This drawable is zero width
+        // We should use the quad of the note container
+        //public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => SlideTapPiece.ReceivePositionalInputAt(screenSpacePos);
+        //public override Quad ScreenSpaceDrawQuad => SlideTapPiece.ScreenSpaceDrawQuad;
+
+        public SlideBodyHighlight(SlideBodyInfo slideBodyInfo)
+        {
+            Anchor = Origin = Anchor.Centre;
+            Colour = Color4.YellowGreen;
+            Alpha = 1;
+
+            InternalChildren = new Drawable[]
+            {
+                slideBody = new SlideVisual(),
+                stars = new Container<StarPiece>(),
+            };
+
+            const int number_of_stars = 3;
+
+            for (int i = 0; i < number_of_stars; ++i)
+                stars.Add(new StarPiece());
+
+            this.slideBodyInfo = slideBodyInfo;
+        }
+
+        public void OnSelected() => slideBody.Path = slideBodyInfo.SlidePath;
+
+        public void OnDeselected() => slideBody.Free();
+
+        public void UpdateFrom(DrawableSlideBody body)
+        {
+            for (int i = 0; i < body.SlideStars.Count; ++i)
+            {
+                stars[i].Position = body.SlideStars[i].Position;
+                stars[i].Rotation = body.SlideStars[i].Rotation;
+                stars[i].Scale = body.SlideStars[i].Scale;
+                stars[i].Alpha = body.SlideStars[i].Alpha;
+            }
+        }
+    }
+}