1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-25 00:53:22 +08:00
osu-lazer/osu.Game/Rulesets/Edit/HitObjectComposer.cs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

566 lines
21 KiB
C#
Raw Normal View History

// 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.
2018-04-13 17:19:50 +08:00
2022-06-17 15:37:17 +08:00
#nullable disable
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Extensions.EnumExtensions;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Shapes;
2018-11-14 17:34:13 +08:00
using osu.Framework.Input;
using osu.Framework.Input.Events;
using osu.Framework.Logging;
2017-11-30 18:19:34 +08:00
using osu.Game.Beatmaps;
using osu.Game.Configuration;
using osu.Game.Overlays;
using osu.Game.Rulesets.Configuration;
using osu.Game.Rulesets.Edit.Tools;
2019-04-08 17:32:05 +08:00
using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Objects;
2018-03-14 14:18:21 +08:00
using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.UI;
2020-05-25 18:21:53 +08:00
using osu.Game.Rulesets.UI.Scrolling;
2019-08-29 11:43:43 +08:00
using osu.Game.Screens.Edit;
2018-11-06 17:14:46 +08:00
using osu.Game.Screens.Edit.Components.RadioButtons;
using osu.Game.Screens.Edit.Components.TernaryButtons;
2019-08-29 15:06:40 +08:00
using osu.Game.Screens.Edit.Compose;
2018-11-06 17:28:22 +08:00
using osu.Game.Screens.Edit.Compose.Components;
using osuTK;
using osuTK.Input;
2018-04-13 17:19:50 +08:00
2017-11-29 15:22:11 +08:00
namespace osu.Game.Rulesets.Edit
{
2020-09-25 13:08:47 +08:00
/// <summary>
/// Top level container for editor compose mode.
/// Responsible for providing snapping and generally gluing components together.
/// </summary>
/// <typeparam name="TObject">The base type of supported objects.</typeparam>
2019-08-29 17:02:50 +08:00
public abstract partial class HitObjectComposer<TObject> : HitObjectComposer, IPlacementHandler
where TObject : HitObject
2017-11-29 15:22:11 +08:00
{
/// <summary>
/// Whether the playfield should be centered horizontally. Should be disabled for playfields which span the full horizontal width.
/// </summary>
protected virtual bool ApplyHorizontalCentering => true;
protected IRulesetConfigManager Config { get; private set; }
2019-12-05 19:12:25 +08:00
// Provides `Playfield`
private DependencyContainer dependencies;
2019-10-16 19:20:07 +08:00
[Resolved]
protected EditorClock EditorClock { get; private set; }
2019-10-16 19:20:07 +08:00
[Resolved]
protected EditorBeatmap EditorBeatmap { get; private set; }
[Resolved]
2020-05-20 17:40:55 +08:00
protected IBeatSnapProvider BeatSnapProvider { get; private set; }
2023-04-04 18:14:30 +08:00
[Resolved]
private OverlayColourProvider colourProvider { get; set; }
protected ComposeBlueprintContainer BlueprintContainer { get; private set; }
protected ExpandingToolboxContainer LeftToolbox { get; private set; }
protected ExpandingToolboxContainer RightToolbox { get; private set; }
2021-04-26 14:37:42 +08:00
private DrawableEditorRulesetWrapper<TObject> drawableRulesetWrapper;
protected readonly Container LayerBelowRuleset = new Container { RelativeSizeAxes = Axes.Both };
protected InputManager InputManager { get; private set; }
2018-11-14 17:34:13 +08:00
private EditorRadioButtonCollection toolboxCollection;
2020-09-25 15:44:37 +08:00
private FillFlowContainer togglesCollection;
2022-10-19 20:35:08 +08:00
private FillFlowContainer sampleBankTogglesCollection;
private IBindable<bool> hasTiming;
private Bindable<bool> autoSeekOnPlacement;
protected DrawableRuleset<TObject> DrawableRuleset { get; private set; }
2019-08-29 17:02:50 +08:00
protected HitObjectComposer(Ruleset ruleset)
: base(ruleset)
{
}
2018-04-13 17:19:50 +08:00
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
[BackgroundDependencyLoader]
2023-04-04 18:14:30 +08:00
private void load(OsuConfigManager config)
{
autoSeekOnPlacement = config.GetBindable<bool>(OsuSetting.EditorAutoSeekOnPlacement);
Config = Dependencies.Get<IRulesetConfigCache>().GetConfigFor(Ruleset);
try
{
DrawableRuleset = CreateDrawableRuleset(Ruleset, EditorBeatmap.PlayableBeatmap, new[] { Ruleset.GetAutoplayMod() });
drawableRulesetWrapper = new DrawableEditorRulesetWrapper<TObject>(DrawableRuleset)
2019-08-29 17:02:50 +08:00
{
Clock = EditorClock,
ProcessCustomClock = false
2019-08-29 17:02:50 +08:00
};
}
catch (Exception e)
{
Logger.Error(e, "Could not load beatmap successfully!");
return;
}
2018-04-13 17:19:50 +08:00
if (DrawableRuleset is IDrawableScrollingRuleset scrollingRuleset)
dependencies.CacheAs(scrollingRuleset.ScrollingInfo);
dependencies.CacheAs(Playfield);
InternalChildren = new[]
{
PlayfieldContentContainer = new Container
{
Name = "Playfield content",
RelativeSizeAxes = Axes.Y,
Children = new Drawable[]
{
// layers below playfield
drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer().WithChild(LayerBelowRuleset),
drawableRulesetWrapper,
// layers above playfield
drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer()
.WithChild(BlueprintContainer = CreateBlueprintContainer())
}
},
new Container
{
RelativeSizeAxes = Axes.Y,
AutoSizeAxes = Axes.X,
Children = new Drawable[]
{
new Box
{
Colour = colourProvider.Background5,
RelativeSizeAxes = Axes.Both,
},
LeftToolbox = new ExpandingToolboxContainer(TOOLBOX_CONTRACTED_SIZE_LEFT, 200)
{
Children = new Drawable[]
{
new EditorToolboxGroup("toolbox (1-9)")
{
Child = toolboxCollection = new EditorRadioButtonCollection { RelativeSizeAxes = Axes.X }
},
new EditorToolboxGroup("toggles (Q~P)")
{
Child = togglesCollection = new FillFlowContainer
{
RelativeSizeAxes = Axes.X,
AutoSizeAxes = Axes.Y,
Direction = FillDirection.Vertical,
Spacing = new Vector2(0, 5),
},
2022-10-19 20:35:08 +08:00
},
new EditorToolboxGroup("bank (Shift-Q~R)")
{
Child = sampleBankTogglesCollection = new FillFlowContainer
{
RelativeSizeAxes = Axes.X,
AutoSizeAxes = Axes.Y,
Direction = FillDirection.Vertical,
Spacing = new Vector2(0, 5),
},
}
}
},
}
},
new Container
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
RelativeSizeAxes = Axes.Y,
AutoSizeAxes = Axes.X,
Children = new Drawable[]
{
new Box
{
Colour = colourProvider.Background5,
RelativeSizeAxes = Axes.Both,
},
RightToolbox = new ExpandingToolboxContainer(TOOLBOX_CONTRACTED_SIZE_RIGHT, 250)
2023-04-04 18:03:45 +08:00
{
Child = new EditorToolboxGroup("inspector")
{
2023-04-04 18:17:14 +08:00
Child = new HitObjectInspector()
2023-04-04 18:03:45 +08:00
},
}
}
},
};
2018-04-13 17:19:50 +08:00
toolboxCollection.Items = CompositionTools
.Prepend(new SelectTool())
2020-09-09 17:35:25 +08:00
.Select(t => new RadioButton(t.Name, () => toolSelected(t), t.CreateIcon))
.ToList();
2018-04-13 17:19:50 +08:00
foreach (var item in toolboxCollection.Items)
{
2024-03-30 18:03:40 +08:00
item.Selected.DisabledChanged += isDisabled =>
{
2024-03-30 18:03:40 +08:00
item.TooltipText = isDisabled ? "Add at least one timing point first!" : string.Empty;
};
}
2020-09-25 16:45:19 +08:00
TernaryStates = CreateTernaryButtons().ToArray();
togglesCollection.AddRange(TernaryStates.Select(b => new DrawableTernaryButton(b)));
2022-10-19 20:35:08 +08:00
sampleBankTogglesCollection.AddRange(BlueprintContainer.SampleBankTernaryStates.Select(b => new DrawableTernaryButton(b)));
setSelectTool();
2019-10-16 19:20:07 +08:00
EditorBeatmap.SelectedHitObjects.CollectionChanged += selectionChanged;
}
2018-04-13 17:19:50 +08:00
/// <summary>
/// Houses all content relevant to the playfield.
/// </summary>
/// <remarks>
/// Generally implementations should not be adding to this directly.
/// Use <see cref="LayerBelowRuleset"/> or <see cref="BlueprintContainer"/> instead.
/// </remarks>
protected Container PlayfieldContentContainer { get; private set; }
protected override void LoadComplete()
{
base.LoadComplete();
InputManager = GetContainingInputManager();
hasTiming = EditorBeatmap.HasTiming.GetBoundCopy();
hasTiming.BindValueChanged(timing =>
{
// it's important this is performed before the similar code in EditorRadioButton disables the button.
if (!timing.NewValue)
setSelectTool();
});
EditorBeatmap.HasTiming.BindValueChanged(hasTiming =>
{
foreach (var item in toolboxCollection.Items)
{
item.Selected.Disabled = !hasTiming.NewValue;
}
}, true);
}
protected override void Update()
{
base.Update();
if (ApplyHorizontalCentering)
{
PlayfieldContentContainer.Anchor = Anchor.Centre;
PlayfieldContentContainer.Origin = Anchor.Centre;
2023-07-29 04:10:10 +08:00
// Ensure that the playfield is always centered but also doesn't get cut off by toolboxes.
PlayfieldContentContainer.Width = Math.Max(1024, DrawWidth) - TOOLBOX_CONTRACTED_SIZE_RIGHT * 2;
PlayfieldContentContainer.X = 0;
}
else
{
PlayfieldContentContainer.Anchor = Anchor.CentreLeft;
PlayfieldContentContainer.Origin = Anchor.CentreLeft;
PlayfieldContentContainer.Width = Math.Max(1024, DrawWidth) - (TOOLBOX_CONTRACTED_SIZE_LEFT + TOOLBOX_CONTRACTED_SIZE_RIGHT);
PlayfieldContentContainer.X = TOOLBOX_CONTRACTED_SIZE_LEFT;
}
}
public override Playfield Playfield => drawableRulesetWrapper.Playfield;
public override IEnumerable<DrawableHitObject> HitObjects => drawableRulesetWrapper.Playfield.AllHitObjects;
public override bool CursorInPlacementArea => drawableRulesetWrapper.Playfield.ReceivePositionalInputAt(InputManager.CurrentState.Mouse.Position);
/// <summary>
/// Defines all available composition tools, listed on the left side of the editor screen as button controls.
/// This should usually define one tool for each <see cref="HitObject"/> type used in the target ruleset.
/// </summary>
/// <remarks>
/// A "select" tool is automatically added as the first tool.
/// </remarks>
protected abstract IReadOnlyList<HitObjectCompositionTool> CompositionTools { get; }
2020-09-09 18:14:28 +08:00
/// <summary>
2020-09-25 16:45:19 +08:00
/// A collection of states which will be displayed to the user in the toolbox.
2020-09-09 18:14:28 +08:00
/// </summary>
2020-09-25 16:45:19 +08:00
public TernaryButton[] TernaryStates { get; private set; }
2020-09-25 16:45:19 +08:00
/// <summary>
/// Create all ternary states required to be displayed to the user.
/// </summary>
2022-10-19 20:35:08 +08:00
protected virtual IEnumerable<TernaryButton> CreateTernaryButtons() => BlueprintContainer.MainTernaryStates;
2020-09-09 18:14:28 +08:00
/// <summary>
/// Construct a relevant blueprint container. This will manage hitobject selection/placement input handling and display logic.
/// </summary>
protected virtual ComposeBlueprintContainer CreateBlueprintContainer() => new ComposeBlueprintContainer(this);
/// <summary>
/// Construct a drawable ruleset for the provided ruleset.
/// </summary>
/// <remarks>
/// Can be overridden to add editor-specific logical changes to a <see cref="Ruleset"/>'s standard <see cref="DrawableRuleset{TObject}"/>.
/// For example, hit animations or judgement logic may be changed to give a better editor user experience.
/// </remarks>
/// <param name="ruleset">The ruleset used to construct its drawable counterpart.</param>
/// <param name="beatmap">The loaded beatmap.</param>
/// <param name="mods">The mods to be applied.</param>
/// <returns>An editor-relevant <see cref="DrawableRuleset{TObject}"/>.</returns>
protected virtual DrawableRuleset<TObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods)
=> (DrawableRuleset<TObject>)ruleset.CreateDrawableRulesetWith(beatmap, mods);
#region Tool selection logic
protected override bool OnKeyDown(KeyDownEvent e)
{
2023-05-24 13:56:11 +08:00
if (e.ControlPressed || e.AltPressed || e.SuperPressed)
return false;
if (checkLeftToggleFromKey(e.Key, out int leftIndex))
{
var item = toolboxCollection.Items.ElementAtOrDefault(leftIndex);
if (item != null)
{
if (!item.Selected.Disabled)
item.Select();
return true;
}
}
if (checkRightToggleFromKey(e.Key, out int rightIndex))
{
2022-10-19 20:35:08 +08:00
var item = e.ShiftPressed
? sampleBankTogglesCollection.ElementAtOrDefault(rightIndex)
: togglesCollection.ElementAtOrDefault(rightIndex);
if (item is DrawableTernaryButton button)
{
button.Button.Toggle();
return true;
}
}
return base.OnKeyDown(e);
}
private bool checkLeftToggleFromKey(Key key, out int index)
{
if (key < Key.Number1 || key > Key.Number9)
{
index = -1;
return false;
}
index = key - Key.Number1;
return true;
}
private bool checkRightToggleFromKey(Key key, out int index)
{
switch (key)
{
case Key.Q:
index = 0;
break;
case Key.W:
index = 1;
break;
case Key.E:
index = 2;
break;
case Key.R:
index = 3;
break;
case Key.T:
index = 4;
break;
case Key.Y:
index = 5;
break;
case Key.U:
index = 6;
break;
case Key.I:
index = 7;
break;
case Key.O:
index = 8;
break;
case Key.P:
index = 9;
break;
default:
index = -1;
break;
}
return index >= 0;
}
private void selectionChanged(object sender, NotifyCollectionChangedEventArgs changedArgs)
2019-10-16 19:20:07 +08:00
{
if (EditorBeatmap.SelectedHitObjects.Any())
{
// ensure in selection mode if a selection is made.
setSelectTool();
}
2019-10-16 19:20:07 +08:00
}
private void setSelectTool() => toolboxCollection.Items.First().Select();
private void toolSelected(HitObjectCompositionTool tool)
2019-10-16 19:20:07 +08:00
{
BlueprintContainer.CurrentTool = tool;
2019-10-16 19:20:07 +08:00
if (!(tool is SelectTool))
EditorBeatmap.SelectedHitObjects.Clear();
2019-10-16 19:20:07 +08:00
}
#endregion
2019-08-29 17:02:50 +08:00
#region IPlacementHandler
2019-08-29 15:06:40 +08:00
public void BeginPlacement(HitObject hitObject)
{
EditorBeatmap.PlacementObject.Value = hitObject;
2019-08-29 15:06:40 +08:00
}
public void EndPlacement(HitObject hitObject, bool commit)
2019-10-18 18:04:08 +08:00
{
EditorBeatmap.PlacementObject.Value = null;
if (commit)
{
EditorBeatmap.Add(hitObject);
if (autoSeekOnPlacement.Value && EditorClock.CurrentTime < hitObject.StartTime)
EditorClock.SeekSmoothlyTo(hitObject.StartTime);
}
2019-10-18 18:04:08 +08:00
}
2019-08-29 15:06:40 +08:00
2019-10-16 19:10:03 +08:00
public void Delete(HitObject hitObject) => EditorBeatmap.Remove(hitObject);
2019-08-29 15:06:40 +08:00
#endregion
#region IPositionSnapProvider
/// <summary>
/// Retrieve the relevant <see cref="Playfield"/> at a specified screen-space position.
/// In cases where a ruleset doesn't require custom logic (due to nested playfields, for example)
/// this will return the ruleset's main playfield.
/// </summary>
/// <param name="screenSpacePosition">The screen-space position to query.</param>
/// <returns>The most relevant <see cref="Playfield"/>.</returns>
2020-05-25 18:21:53 +08:00
protected virtual Playfield PlayfieldAtScreenSpacePosition(Vector2 screenSpacePosition) => drawableRulesetWrapper.Playfield;
public override SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All)
2020-05-25 18:21:53 +08:00
{
var playfield = PlayfieldAtScreenSpacePosition(screenSpacePosition);
double? targetTime = null;
if (snapType.HasFlagFast(SnapType.GlobalGrids))
2020-05-25 18:21:53 +08:00
{
if (playfield is ScrollingPlayfield scrollingPlayfield)
{
targetTime = scrollingPlayfield.TimeAtScreenSpacePosition(screenSpacePosition);
2020-05-25 18:21:53 +08:00
// apply beat snapping
targetTime = BeatSnapProvider.SnapTime(targetTime.Value);
2020-05-25 18:21:53 +08:00
// convert back to screen space
screenSpacePosition = scrollingPlayfield.ScreenSpacePositionAtTime(targetTime.Value);
}
2020-05-25 18:21:53 +08:00
}
return new SnapResult(screenSpacePosition, targetTime, playfield);
}
#endregion
}
2019-08-29 17:02:50 +08:00
/// <summary>
/// A non-generic definition of a HitObject composer class.
/// Generally used to access certain methods without requiring a generic type for <see cref="HitObjectComposer{T}" />.
/// </summary>
[Cached]
public abstract partial class HitObjectComposer : CompositeDrawable, IPositionSnapProvider
2019-08-29 17:02:50 +08:00
{
public const float TOOLBOX_CONTRACTED_SIZE_LEFT = 60;
public const float TOOLBOX_CONTRACTED_SIZE_RIGHT = 120;
public readonly Ruleset Ruleset;
protected HitObjectComposer(Ruleset ruleset)
2019-08-29 17:02:50 +08:00
{
Ruleset = ruleset;
2019-08-29 17:02:50 +08:00
RelativeSizeAxes = Axes.Both;
}
/// <summary>
/// The target ruleset's playfield.
/// </summary>
public abstract Playfield Playfield { get; }
2019-08-29 17:02:50 +08:00
/// <summary>
/// All <see cref="DrawableHitObject"/>s in currently loaded beatmap.
2019-08-29 17:02:50 +08:00
/// </summary>
public abstract IEnumerable<DrawableHitObject> HitObjects { get; }
/// <summary>
/// Whether the user's cursor is currently in an area of the <see cref="HitObjectComposer"/> that is valid for placement.
/// </summary>
public abstract bool CursorInPlacementArea { get; }
/// <summary>
/// Returns a string representing the current selection.
/// The inverse method to <see cref="SelectFromTimestamp"/>.
/// </summary>
2021-03-29 17:29:05 +08:00
public virtual string ConvertSelectionToString() => string.Empty;
/// <summary>
/// Selects objects based on the supplied <paramref name="timestamp"/> and <paramref name="objectDescription"/>.
/// The inverse method to <see cref="ConvertSelectionToString"/>.
/// </summary>
/// <param name="timestamp">The time instant to seek to, in milliseconds.</param>
/// <param name="objectDescription">The ruleset-specific description of objects to select at the given timestamp.</param>
public virtual void SelectFromTimestamp(double timestamp, string objectDescription) { }
#region IPositionSnapProvider
public abstract SnapResult FindSnappedPositionAndTime(Vector2 screenSpacePosition, SnapType snapType = SnapType.All);
#endregion
2019-08-29 17:02:50 +08:00
}
2017-11-29 15:22:11 +08:00
}