1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-18 07:22:57 +08:00
osu-lazer/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs

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

348 lines
11 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-21 23:24:31 +08:00
2022-06-17 15:37:17 +08:00
#nullable disable
2018-04-21 23:24:31 +08:00
using System;
using System.Linq;
2018-04-21 23:24:31 +08:00
using osu.Framework.Allocation;
2019-05-04 15:50:36 +08:00
using osu.Framework.Bindables;
2018-04-21 23:24:31 +08:00
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Shapes;
using osu.Framework.Graphics.Sprites;
2018-04-21 23:24:31 +08:00
using osu.Framework.Graphics.UserInterface;
using osu.Framework.Input.Bindings;
2018-10-02 11:02:47 +08:00
using osu.Framework.Input.Events;
using osu.Framework.Threading;
2020-01-09 12:43:44 +08:00
using osu.Framework.Utils;
using osu.Game.Configuration;
2018-04-21 23:24:31 +08:00
using osu.Game.Graphics;
using osu.Game.Graphics.Containers;
2018-04-21 23:24:31 +08:00
using osu.Game.Graphics.Sprites;
using osu.Game.Input.Bindings;
2018-11-20 15:51:59 +08:00
using osuTK;
using osuTK.Graphics;
2018-04-21 23:24:31 +08:00
namespace osu.Game.Screens.Play.HUD
{
public partial class HoldForMenuButton : FillFlowContainer
2018-04-21 23:24:31 +08:00
{
public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
public override bool PropagatePositionalInputSubTree => alwaysShow.Value || touchActive.Value;
public readonly Bindable<bool> IsPaused = new Bindable<bool>();
public readonly Bindable<bool> ReplayLoaded = new Bindable<bool>();
private HoldButton button;
2018-05-11 02:08:02 +08:00
public Action Action { get; set; }
private OsuSpriteText text;
private Bindable<bool> alwaysShow;
public HoldForMenuButton()
2018-04-21 23:24:31 +08:00
{
Direction = FillDirection.Horizontal;
Spacing = new Vector2(20, 0);
Margin = new MarginPadding(10);
AlwaysPresent = true;
}
[BackgroundDependencyLoader(true)]
private void load(Player player, OsuConfigManager config)
{
2018-04-21 23:24:31 +08:00
Children = new Drawable[]
{
text = new OsuSpriteText
{
Font = OsuFont.GetFont(weight: FontWeight.Bold),
2018-04-21 23:24:31 +08:00
Anchor = Anchor.CentreLeft,
Origin = Anchor.CentreLeft
},
button = new HoldButton(player?.Configuration.AllowRestart == false)
{
HoverGained = () => text.FadeIn(500, Easing.OutQuint),
HoverLost = () => text.FadeOut(500, Easing.OutQuint),
IsPaused = { BindTarget = IsPaused },
ReplayLoaded = { BindTarget = ReplayLoaded },
Action = () => Action(),
}
2018-04-21 23:24:31 +08:00
};
2018-04-21 23:24:31 +08:00
AutoSizeAxes = Axes.Both;
alwaysShow = config.GetBindable<bool>(OsuSetting.AlwaysShowHoldForMenuButton);
2018-04-21 23:24:31 +08:00
}
[Resolved]
private SessionStatics sessionStatics { get; set; }
private Bindable<bool> touchActive;
protected override void LoadComplete()
{
button.HoldActivationDelay.BindValueChanged(v =>
2019-09-27 07:59:42 +08:00
{
text.Text = v.NewValue > 0
? "hold for menu"
: "press for menu";
}, true);
touchActive = sessionStatics.GetBindable<bool>(Static.TouchInputActive);
if (touchActive.Value)
{
Alpha = 1f;
text.FadeInFromZero(500, Easing.OutQuint)
.Delay(1500)
.FadeOut(500, Easing.OutQuint);
}
else
{
Alpha = 0;
text.Alpha = 0f;
}
base.LoadComplete();
}
private float positionalAdjust = 1; // Start at 1 to handle the case where a user never send positional input.
2018-10-02 11:02:47 +08:00
protected override bool OnMouseMove(MouseMoveEvent e)
{
2024-02-02 18:48:13 +08:00
positionalAdjust = Vector2.Distance(e.MousePosition, button.ToSpaceOfOtherDrawable(button.DrawRectangle.Centre, Parent!)) / 100;
2018-10-02 11:02:47 +08:00
return base.OnMouseMove(e);
}
2018-05-21 23:49:33 +08:00
protected override void Update()
{
base.Update();
// While the button is hovered or still animating, keep fully visible.
if (text.Alpha > 0 || button.Progress.Value > 0 || button.IsHovered)
Alpha = 1;
// When touch input is detected, keep visible at a constant opacity.
else if (touchActive.Value)
Alpha = 0.5f;
// Otherwise, if the user chooses, show it when the mouse is nearby.
else if (alwaysShow.Value)
2019-11-11 19:53:22 +08:00
{
float minAlpha = touchActive.Value ? .08f : 0;
Alpha = Interpolation.ValueAt(
Math.Clamp(Clock.ElapsedFrameTime, 0, 200),
Alpha, Math.Clamp(1 - positionalAdjust, minAlpha, 1), 0, 200, Easing.OutQuint);
2019-11-11 19:53:22 +08:00
}
else
Alpha = 0;
2018-05-21 23:49:33 +08:00
}
private partial class HoldButton : HoldToConfirmContainer, IKeyBindingHandler<GlobalAction>
2018-04-21 23:24:31 +08:00
{
private SpriteIcon icon;
private CircularProgress circularProgress;
2018-05-22 14:59:53 +08:00
private Circle overlayCircle;
2018-05-21 23:49:33 +08:00
public readonly Bindable<bool> IsPaused = new Bindable<bool>();
public readonly Bindable<bool> ReplayLoaded = new Bindable<bool>();
protected override bool AllowMultipleFires => true;
public Action HoverGained;
public Action HoverLost;
private const double shake_duration = 20;
private bool pendingAnimation;
private ScheduledDelegate shakeOperation;
public HoldButton(bool isDangerousAction)
: base(isDangerousAction)
{
}
2018-04-21 23:24:31 +08:00
[BackgroundDependencyLoader]
2022-01-15 08:06:39 +08:00
private void load(OsuColour colours)
2018-04-21 23:24:31 +08:00
{
Size = new Vector2(60);
Child = new CircularContainer
2018-04-21 23:24:31 +08:00
{
Masking = true,
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
2018-04-21 23:24:31 +08:00
{
new Box
{
RelativeSizeAxes = Axes.Both,
Colour = colours.Gray1,
Alpha = 0.5f,
},
circularProgress = new CircularProgress
{
RelativeSizeAxes = Axes.Both,
InnerRadius = 1
},
2018-05-22 14:59:53 +08:00
overlayCircle = new Circle
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
Colour = colours.Gray1,
Size = new Vector2(0.9f),
},
icon = new SpriteIcon
{
Shadow = false,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Size = new Vector2(15),
Icon = FontAwesome.Solid.Times
},
}
};
bind();
2019-05-07 12:34:06 +08:00
}
protected override void Update()
{
base.Update();
circularProgress.Progress = Progress.Value;
}
private void bind()
{
Progress.ValueChanged += progress =>
{
icon.Scale = new Vector2(1 + (float)progress.NewValue * 0.2f);
if (IsDangerousAction)
{
Colour = Interpolation.ValueAt(progress.NewValue, Color4.White, Color4.Red, 0, 1, Easing.OutQuint);
if (progress.NewValue > 0 && progress.NewValue < 1)
{
shakeOperation ??= Scheduler.AddDelayed(shake, shake_duration, true);
}
else
{
Child.MoveTo(Vector2.Zero, shake_duration * 2, Easing.OutQuint);
shakeOperation?.Cancel();
shakeOperation = null;
}
}
};
2018-04-21 23:24:31 +08:00
}
private void shake()
{
const float shake_magnitude = 8;
Child.MoveTo(new Vector2(
RNG.NextSingle(-1, 1) * (float)Progress.Value * shake_magnitude,
RNG.NextSingle(-1, 1) * (float)Progress.Value * shake_magnitude
), shake_duration);
}
protected override void Confirm()
2018-04-21 23:24:31 +08:00
{
base.Confirm();
2018-05-22 15:04:07 +08:00
// temporarily unbind as to not look weird if releasing during confirm animation (can see the unwind of progress).
Progress.UnbindAll();
2018-05-22 14:58:00 +08:00
// avoid starting a new confirm call until we finish animating.
pendingAnimation = true;
AbortConfirm();
2018-05-22 14:59:53 +08:00
overlayCircle.ScaleTo(0, 100)
.Then().FadeOut().ScaleTo(1).FadeIn(500)
2022-06-24 20:25:23 +08:00
.OnComplete(_ =>
{
2018-05-22 15:44:37 +08:00
icon.ScaleTo(1, 100);
circularProgress.FadeOut(100).OnComplete(_ =>
{
bind();
2018-05-22 15:44:37 +08:00
circularProgress.FadeIn();
pendingAnimation = false;
});
});
}
2018-04-22 00:25:21 +08:00
2018-10-02 11:02:47 +08:00
protected override bool OnHover(HoverEvent e)
{
HoverGained?.Invoke();
return true;
}
2018-10-02 11:02:47 +08:00
protected override void OnHoverLost(HoverLostEvent e)
{
HoverLost?.Invoke();
2018-10-02 11:02:47 +08:00
base.OnHoverLost(e);
}
2021-09-16 17:26:12 +08:00
public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
{
if (e.Repeat)
return false;
2021-09-16 17:26:12 +08:00
switch (e.Action)
{
case GlobalAction.Back:
if (!pendingAnimation)
BeginConfirm();
return true;
case GlobalAction.PauseGameplay:
// handled by replay player
if (ReplayLoaded.Value) return false;
if (!pendingAnimation)
BeginConfirm();
return true;
}
return false;
}
2021-09-16 17:26:12 +08:00
public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
{
2021-09-16 17:26:12 +08:00
switch (e.Action)
{
case GlobalAction.Back:
AbortConfirm();
break;
2020-07-13 08:00:10 +08:00
case GlobalAction.PauseGameplay:
if (ReplayLoaded.Value) return;
AbortConfirm();
break;
}
}
2018-10-02 11:02:47 +08:00
protected override bool OnMouseDown(MouseDownEvent e)
{
if (!pendingAnimation && e.CurrentState.Mouse.Buttons.Count() == 1)
BeginConfirm();
return true;
2018-04-21 23:24:31 +08:00
}
protected override void OnMouseUp(MouseUpEvent e)
2018-04-21 23:24:31 +08:00
{
if (!e.HasAnyButtonPressed)
AbortConfirm();
2018-04-21 23:24:31 +08:00
}
}
}
}