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;
+ }
+ }
+ }
+}