1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-17 05:13:21 +08:00
osu-lazer/osu.Game/Screens/Play/HUDOverlay.cs

411 lines
15 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;
2019-04-08 17:32:05 +08:00
using System.Collections.Generic;
using System.Linq;
2018-04-13 17:19:50 +08:00
using osu.Framework.Allocation;
2019-02-21 18:04:31 +08:00
using osu.Framework.Bindables;
using osu.Framework.Extensions.EnumExtensions;
2018-04-13 17:19:50 +08:00
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
2020-10-30 13:19:40 +08:00
using osu.Framework.Input.Bindings;
2021-09-16 17:26:12 +08:00
using osu.Framework.Input.Events;
2018-04-13 17:19:50 +08:00
using osu.Game.Configuration;
2020-10-30 13:19:40 +08:00
using osu.Game.Input.Bindings;
2018-04-13 17:19:50 +08:00
using osu.Game.Overlays;
using osu.Game.Overlays.Notifications;
2019-04-08 17:32:05 +08:00
using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Scoring;
2018-04-13 17:19:50 +08:00
using osu.Game.Rulesets.UI;
using osu.Game.Screens.Play.HUD;
using osu.Game.Screens.Play.HUD.ClicksPerSecond;
using osu.Game.Skinning;
2018-11-20 15:51:59 +08:00
using osuTK;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Screens.Play
{
[Cached]
2022-11-24 13:32:20 +08:00
public partial class HUDOverlay : Container, IKeyBindingHandler<GlobalAction>
2018-04-13 17:19:50 +08:00
{
2021-04-14 13:25:16 +08:00
public const float FADE_DURATION = 300;
2021-04-14 13:25:16 +08:00
public const Easing FADE_EASING = Easing.OutQuint;
2018-04-13 17:19:50 +08:00
/// <summary>
/// The total height of all the bottom of screen scoring elements.
/// </summary>
public float BottomScoringElementsHeight { get; private set; }
protected override bool ShouldBeConsideredForInput(Drawable child)
{
// HUD uses AlwaysVisible on child components so they can be in an updated state for next display.
// Without blocking input, this would also allow them to be interacted with in such a state.
if (ShowHud.Value)
return base.ShouldBeConsideredForInput(child);
// hold to quit button should always be interactive.
return child == bottomRightElements;
}
public readonly KeyCounterDisplay KeyCounter;
2018-04-13 17:19:50 +08:00
public readonly ModDisplay ModDisplay;
public readonly HoldForMenuButton HoldToQuit;
2018-04-13 17:19:50 +08:00
public readonly PlayerSettingsOverlay PlayerSettingsOverlay;
[Cached]
private readonly ClicksPerSecondCalculator clicksPerSecondCalculator;
public Bindable<bool> ShowHealthBar = new Bindable<bool>(true);
private readonly DrawableRuleset drawableRuleset;
private readonly IReadOnlyList<Mod> mods;
/// <summary>
/// Whether the elements that can optionally be hidden should be visible.
/// </summary>
public Bindable<bool> ShowHud { get; } = new BindableBool();
private Bindable<HUDVisibilityMode> configVisibilityMode;
2018-04-13 17:19:50 +08:00
private readonly BindableBool replayLoaded = new BindableBool();
private static bool hasShownNotificationOnce;
2020-10-14 18:16:25 +08:00
private readonly FillFlowContainer bottomRightElements;
private readonly FillFlowContainer topRightElements;
internal readonly IBindable<bool> IsPlaying = new Bindable<bool>();
public IBindable<bool> HoldingForHUD => holdingForHUD;
private readonly BindableBool holdingForHUD = new BindableBool();
2020-10-30 13:19:40 +08:00
private readonly SkinnableTargetContainer mainComponents;
/// <summary>
/// A flow which sits at the left side of the screen to house leaderboard (and related) components.
/// Will automatically be positioned to avoid colliding with top scoring elements.
/// </summary>
public readonly FillFlowContainer LeaderboardFlow;
private readonly List<Drawable> hideTargets;
public HUDOverlay(DrawableRuleset drawableRuleset, IReadOnlyList<Mod> mods, bool alwaysShowLeaderboard = true)
2018-04-13 17:19:50 +08:00
{
this.drawableRuleset = drawableRuleset;
this.mods = mods;
2018-04-13 17:19:50 +08:00
RelativeSizeAxes = Axes.Both;
Children = new Drawable[]
2018-04-13 17:19:50 +08:00
{
CreateFailingLayer(),
mainComponents = new MainComponentsContainer
{
AlwaysPresent = true,
},
topRightElements = new FillFlowContainer
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
AlwaysPresent = true,
Margin = new MarginPadding(10),
Spacing = new Vector2(10),
AutoSizeAxes = Axes.Both,
Direction = FillDirection.Vertical,
Children = new Drawable[]
{
ModDisplay = CreateModsContainer(),
PlayerSettingsOverlay = CreatePlayerSettingsOverlay(),
}
},
bottomRightElements = new FillFlowContainer
2018-04-13 17:19:50 +08:00
{
Anchor = Anchor.BottomRight,
Origin = Anchor.BottomRight,
Margin = new MarginPadding(10),
Spacing = new Vector2(10),
AutoSizeAxes = Axes.Both,
LayoutDuration = FADE_DURATION / 2,
LayoutEasing = FADE_EASING,
Direction = FillDirection.Vertical,
Children = new Drawable[]
{
KeyCounter = CreateKeyCounter(),
HoldToQuit = CreateHoldForMenuButton(),
}
},
LeaderboardFlow = new FillFlowContainer
{
AutoSizeAxes = Axes.Both,
Direction = FillDirection.Vertical,
Padding = new MarginPadding(44), // enough margin to avoid the hit error display
Spacing = new Vector2(5)
},
clicksPerSecondCalculator = new ClicksPerSecondCalculator(),
};
hideTargets = new List<Drawable> { mainComponents, KeyCounter, topRightElements };
if (!alwaysShowLeaderboard)
hideTargets.Add(LeaderboardFlow);
}
2018-04-13 17:19:50 +08:00
[BackgroundDependencyLoader(true)]
private void load(OsuConfigManager config, INotificationOverlay notificationOverlay)
{
2019-12-12 15:09:42 +08:00
if (drawableRuleset != null)
{
BindDrawableRuleset(drawableRuleset);
}
2018-04-13 17:19:50 +08:00
2019-04-08 17:32:05 +08:00
ModDisplay.Current.Value = mods;
2018-04-13 17:19:50 +08:00
configVisibilityMode = config.GetBindable<HUDVisibilityMode>(OsuSetting.HUDVisibilityMode);
if (configVisibilityMode.Value == HUDVisibilityMode.Never && !hasShownNotificationOnce)
{
hasShownNotificationOnce = true;
notificationOverlay?.Post(new SimpleNotification
{
Text = $"The score overlay is currently disabled. You can toggle this by pressing {config.LookupKeyBindings(GlobalAction.ToggleInGameInterface)}."
});
}
// start all elements hidden
hideTargets.ForEach(d => d.Hide());
}
public override void Hide() =>
throw new InvalidOperationException($"{nameof(HUDOverlay)} should not be hidden as it will remove the ability of a user to quit. Use {nameof(ShowHud)} instead.");
protected override void LoadComplete()
{
base.LoadComplete();
ShowHud.BindValueChanged(visible => hideTargets.ForEach(d => d.FadeTo(visible.NewValue ? 1 : 0, FADE_DURATION, FADE_EASING)));
2018-04-13 17:19:50 +08:00
holdingForHUD.BindValueChanged(_ => updateVisibility());
IsPlaying.BindValueChanged(_ => updateVisibility());
configVisibilityMode.BindValueChanged(_ => updateVisibility(), true);
2018-04-13 17:19:50 +08:00
replayLoaded.BindValueChanged(replayLoadedValueChanged, true);
2018-04-13 17:19:50 +08:00
}
protected override void Update()
{
base.Update();
float? lowestTopScreenSpaceLeft = null;
float? lowestTopScreenSpaceRight = null;
Vector2? highestBottomScreenSpace = null;
// LINQ cast can be removed when IDrawable interface includes Anchor / RelativeSizeAxes.
foreach (var element in mainComponents.Components.Cast<Drawable>())
{
// for now align some top components with the bottom-edge of the lowest top-anchored hud element.
if (element.Anchor.HasFlagFast(Anchor.y0))
{
// health bars are excluded for the sake of hacky legacy skins which extend the health bar to take up the full screen area.
if (element is LegacyHealthDisplay)
continue;
float bottom = element.ScreenSpaceDrawQuad.BottomRight.Y;
bool isRelativeX = element.RelativeSizeAxes == Axes.X;
if (element.Anchor.HasFlagFast(Anchor.TopRight) || isRelativeX)
{
if (lowestTopScreenSpaceRight == null || bottom > lowestTopScreenSpaceRight.Value)
lowestTopScreenSpaceRight = bottom;
}
if (element.Anchor.HasFlagFast(Anchor.TopLeft) || isRelativeX)
{
if (lowestTopScreenSpaceLeft == null || bottom > lowestTopScreenSpaceLeft.Value)
lowestTopScreenSpaceLeft = bottom;
}
}
// and align bottom-right components with the top-edge of the highest bottom-anchored hud element.
else if (element.Anchor.HasFlagFast(Anchor.BottomRight) || (element.Anchor.HasFlagFast(Anchor.y2) && element.RelativeSizeAxes == Axes.X))
{
var topLeft = element.ScreenSpaceDrawQuad.TopLeft;
if (highestBottomScreenSpace == null || topLeft.Y < highestBottomScreenSpace.Value.Y)
highestBottomScreenSpace = topLeft;
}
}
if (lowestTopScreenSpaceRight.HasValue)
topRightElements.Y = MathHelper.Clamp(ToLocalSpace(new Vector2(0, lowestTopScreenSpaceRight.Value)).Y, 0, DrawHeight - topRightElements.DrawHeight);
else
topRightElements.Y = 0;
if (lowestTopScreenSpaceLeft.HasValue)
LeaderboardFlow.Y = MathHelper.Clamp(ToLocalSpace(new Vector2(0, lowestTopScreenSpaceLeft.Value)).Y, 0, DrawHeight - LeaderboardFlow.DrawHeight);
else
LeaderboardFlow.Y = 0;
if (highestBottomScreenSpace.HasValue)
bottomRightElements.Y = BottomScoringElementsHeight = -MathHelper.Clamp(DrawHeight - ToLocalSpace(highestBottomScreenSpace.Value).Y, 0, DrawHeight - bottomRightElements.DrawHeight);
else
bottomRightElements.Y = 0;
}
private void updateVisibility()
{
if (ShowHud.Disabled)
return;
if (holdingForHUD.Value)
2020-10-30 13:19:40 +08:00
{
ShowHud.Value = true;
return;
}
switch (configVisibilityMode.Value)
{
case HUDVisibilityMode.Never:
ShowHud.Value = false;
break;
case HUDVisibilityMode.HideDuringGameplay:
// always show during replay as we want the seek bar to be visible.
ShowHud.Value = replayLoaded.Value || !IsPlaying.Value;
break;
case HUDVisibilityMode.Always:
ShowHud.Value = true;
break;
}
}
2019-02-21 17:56:34 +08:00
private void replayLoadedValueChanged(ValueChangedEvent<bool> e)
2018-04-13 17:19:50 +08:00
{
2019-02-21 17:56:34 +08:00
PlayerSettingsOverlay.ReplayLoaded = e.NewValue;
2018-04-13 17:19:50 +08:00
2019-02-21 17:56:34 +08:00
if (e.NewValue)
2018-04-13 17:19:50 +08:00
{
PlayerSettingsOverlay.Show();
ModDisplay.FadeIn(200);
2018-10-30 20:32:12 +08:00
KeyCounter.Margin = new MarginPadding(10) { Bottom = 30 };
2018-04-13 17:19:50 +08:00
}
else
{
PlayerSettingsOverlay.Hide();
ModDisplay.Delay(2000).FadeOut(200);
2018-10-30 20:32:12 +08:00
KeyCounter.Margin = new MarginPadding(10);
2018-04-13 17:19:50 +08:00
}
updateVisibility();
2018-04-13 17:19:50 +08:00
}
protected virtual void BindDrawableRuleset(DrawableRuleset drawableRuleset)
2018-04-13 17:19:50 +08:00
{
2022-08-24 18:36:01 +08:00
if (drawableRuleset is ICanAttachHUDPieces attachTarget)
{
attachTarget.Attach(KeyCounter);
attachTarget.Attach(clicksPerSecondCalculator);
}
2018-04-13 17:19:50 +08:00
replayLoaded.BindTo(drawableRuleset.HasReplayLoaded);
2018-04-13 17:19:50 +08:00
}
protected FailingLayer CreateFailingLayer() => new FailingLayer
2020-06-27 01:22:30 +08:00
{
ShowHealth = { BindTarget = ShowHealthBar }
2020-06-27 01:22:30 +08:00
};
2020-04-09 13:31:25 +08:00
protected KeyCounterDisplay CreateKeyCounter() => new KeyCounterDisplay
2018-04-13 17:19:50 +08:00
{
Anchor = Anchor.BottomRight,
Origin = Anchor.BottomRight,
};
protected HoldForMenuButton CreateHoldForMenuButton() => new HoldForMenuButton
2018-04-21 23:24:31 +08:00
{
Anchor = Anchor.BottomRight,
Origin = Anchor.BottomRight,
};
protected ModDisplay CreateModsContainer() => new ModDisplay
2018-04-13 17:19:50 +08:00
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
};
protected PlayerSettingsOverlay CreatePlayerSettingsOverlay() => new PlayerSettingsOverlay();
2018-04-13 17:19:50 +08:00
2021-09-16 17:26:12 +08:00
public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
2020-10-30 13:19:40 +08:00
{
if (e.Repeat)
return false;
2021-09-16 17:26:12 +08:00
switch (e.Action)
2020-10-30 13:19:40 +08:00
{
case GlobalAction.HoldForHUD:
holdingForHUD.Value = true;
2020-10-30 13:19:40 +08:00
return true;
2020-11-30 09:59:02 +08:00
case GlobalAction.ToggleInGameInterface:
switch (configVisibilityMode.Value)
{
case HUDVisibilityMode.Never:
configVisibilityMode.Value = HUDVisibilityMode.HideDuringGameplay;
break;
case HUDVisibilityMode.HideDuringGameplay:
configVisibilityMode.Value = HUDVisibilityMode.Always;
break;
case HUDVisibilityMode.Always:
configVisibilityMode.Value = HUDVisibilityMode.Never;
break;
}
2020-12-01 13:00:54 +08:00
2020-11-30 09:59:02 +08:00
return true;
2020-10-30 13:19:40 +08:00
}
return false;
}
2021-09-16 17:26:12 +08:00
public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
2020-10-30 13:19:40 +08:00
{
2021-09-16 17:26:12 +08:00
switch (e.Action)
2020-10-30 13:19:40 +08:00
{
case GlobalAction.HoldForHUD:
holdingForHUD.Value = false;
2020-10-30 13:19:40 +08:00
break;
}
}
2022-11-24 13:32:20 +08:00
private partial class MainComponentsContainer : SkinnableTargetContainer
{
private Bindable<ScoringMode> scoringMode;
[Resolved]
private OsuConfigManager config { get; set; }
public MainComponentsContainer()
: base(GlobalSkinComponentLookup.LookupType.MainHUDComponents)
{
RelativeSizeAxes = Axes.Both;
}
protected override void LoadComplete()
{
base.LoadComplete();
// When the scoring mode changes, relative positions of elements may change (see DefaultSkin.GetDrawableComponent).
// This is a best effort implementation for cases where users haven't customised layouts.
scoringMode = config.GetBindable<ScoringMode>(OsuSetting.ScoreDisplayMode);
2022-06-24 20:25:23 +08:00
scoringMode.BindValueChanged(_ => Reload());
}
}
2018-04-13 17:19:50 +08:00
}
}