osu/osu.Game/Screens/Play/HUDOverlay.cs

387 lines
14 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 09:19:50 +00:00
using System;
2019-04-08 09:32:05 +00:00
using System.Collections.Generic;
2018-04-13 09:19:50 +00:00
using osu.Framework.Allocation;
2019-02-21 10:04:31 +00:00
using osu.Framework.Bindables;
using osu.Framework.Extensions.IEnumerableExtensions;
2018-04-13 09:19:50 +00:00
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
2020-10-30 05:19:40 +00:00
using osu.Framework.Input.Bindings;
2018-04-13 09:19:50 +00:00
using osu.Game.Configuration;
2020-10-30 05:19:40 +00:00
using osu.Game.Input.Bindings;
2018-04-13 09:19:50 +00:00
using osu.Game.Overlays;
using osu.Game.Overlays.Notifications;
2019-04-08 09:32:05 +00:00
using osu.Game.Rulesets.Mods;
2018-04-13 09:19:50 +00:00
using osu.Game.Rulesets.Scoring;
using osu.Game.Rulesets.UI;
using osu.Game.Screens.Play.HUD;
2018-11-20 07:51:59 +00:00
using osuTK;
2018-04-13 09:19:50 +00:00
namespace osu.Game.Screens.Play
{
[Cached]
2020-10-30 05:19:40 +00:00
public class HUDOverlay : Container, IKeyBindingHandler<GlobalAction>
2018-04-13 09:19:50 +00:00
{
public const float FADE_DURATION = 400;
public const Easing FADE_EASING = Easing.Out;
2018-04-13 09:19:50 +00:00
/// <summary>
/// The total height of all the top of screen scoring elements.
/// </summary>
public float TopScoringElementsHeight { get; private set; }
public readonly KeyCounterDisplay KeyCounter;
public readonly SkinnableComboCounter ComboCounter;
public readonly SkinnableScoreCounter ScoreCounter;
public readonly SkinnableAccuracyCounter AccuracyCounter;
public readonly SkinnableHealthDisplay HealthDisplay;
2018-04-13 09:19:50 +00:00
public readonly SongProgress Progress;
public readonly ModDisplay ModDisplay;
2019-08-30 09:46:42 +00:00
public readonly HitErrorDisplay HitErrorDisplay;
public readonly HoldForMenuButton HoldToQuit;
2018-04-13 09:19:50 +00:00
public readonly PlayerSettingsOverlay PlayerSettingsOverlay;
2020-04-09 05:31:25 +00:00
public readonly FailingLayer FailingLayer;
2018-04-13 09:19:50 +00:00
public Bindable<bool> ShowHealthbar = new Bindable<bool>(true);
private readonly ScoreProcessor scoreProcessor;
private readonly HealthProcessor healthProcessor;
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;
private readonly Container visibilityContainer;
2018-04-13 09:19:50 +00:00
private readonly BindableBool replayLoaded = new BindableBool();
private static bool hasShownNotificationOnce;
public Action<double> RequestSeek;
2020-10-14 10:16:25 +00:00
private readonly FillFlowContainer bottomRightElements;
private readonly FillFlowContainer topRightElements;
internal readonly IBindable<bool> IsBreakTime = new Bindable<bool>();
2020-10-30 05:19:40 +00:00
private bool holdingForHUD;
private IEnumerable<Drawable> hideTargets => new Drawable[] { visibilityContainer, KeyCounter };
public HUDOverlay(ScoreProcessor scoreProcessor, HealthProcessor healthProcessor, DrawableRuleset drawableRuleset, IReadOnlyList<Mod> mods)
2018-04-13 09:19:50 +00:00
{
this.scoreProcessor = scoreProcessor;
this.healthProcessor = healthProcessor;
this.drawableRuleset = drawableRuleset;
this.mods = mods;
2018-04-13 09:19:50 +00:00
RelativeSizeAxes = Axes.Both;
Children = new Drawable[]
2018-04-13 09:19:50 +00:00
{
2020-04-09 05:31:25 +00:00
FailingLayer = CreateFailingLayer(),
2019-01-23 05:51:13 +00:00
visibilityContainer = new Container
{
RelativeSizeAxes = Axes.Both,
Child = new GridContainer
2019-01-23 05:51:13 +00:00
{
RelativeSizeAxes = Axes.Both,
Content = new[]
2019-01-23 05:51:13 +00:00
{
new Drawable[]
2019-01-23 05:51:13 +00:00
{
2020-10-19 19:32:16 +00:00
new Container
{
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
HealthDisplay = CreateHealthDisplay(),
AccuracyCounter = CreateAccuracyCounter(),
ScoreCounter = CreateScoreCounter(),
ComboCounter = CreateComboCounter(),
HitErrorDisplay = CreateHitErrorDisplayOverlay(),
}
},
},
new Drawable[]
{
Progress = CreateProgress(),
}
},
RowDimensions = new[]
{
new Dimension(),
new Dimension(GridSizeMode.AutoSize)
}
},
},
topRightElements = new FillFlowContainer
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
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 09:19:50 +00: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(),
}
2018-04-13 09:19:50 +00:00
}
};
}
2018-04-13 09:19:50 +00:00
[BackgroundDependencyLoader(true)]
private void load(OsuConfigManager config, NotificationOverlay notificationOverlay)
{
2019-12-12 07:09:42 +00:00
if (scoreProcessor != null)
BindScoreProcessor(scoreProcessor);
if (healthProcessor != null)
BindHealthProcessor(healthProcessor);
2018-04-13 09:19:50 +00:00
2019-12-12 07:09:42 +00:00
if (drawableRuleset != null)
{
BindDrawableRuleset(drawableRuleset);
Progress.Objects = drawableRuleset.Objects;
Progress.RequestSeek = time => RequestSeek(time);
Progress.ReferenceClock = drawableRuleset.FrameStableClock;
}
2018-04-13 09:19:50 +00:00
2019-04-08 09:32:05 +00:00
ModDisplay.Current.Value = mods;
2018-04-13 09:19:50 +00: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();
ShowHealthbar.BindValueChanged(healthBar => HealthDisplay.FadeTo(healthBar.NewValue ? 1 : 0, FADE_DURATION, FADE_EASING), true);
ShowHud.BindValueChanged(visible => hideTargets.ForEach(d => d.FadeTo(visible.NewValue ? 1 : 0, FADE_DURATION, FADE_EASING)));
2018-04-13 09:19:50 +00:00
IsBreakTime.BindValueChanged(_ => updateVisibility());
configVisibilityMode.BindValueChanged(_ => updateVisibility(), true);
2018-04-13 09:19:50 +00:00
replayLoaded.BindValueChanged(replayLoadedValueChanged, true);
2018-04-13 09:19:50 +00:00
}
protected override void Update()
{
base.Update();
// HACK: for now align with the accuracy counter.
// this is done for the sake of hacky legacy skins which extend the health bar to take up the full screen area.
// it only works with the default skin due to padding offsetting it *just enough* to coexist.
topRightElements.Y = TopScoringElementsHeight = ToLocalSpace(AccuracyCounter.Drawable.ScreenSpaceDrawQuad.BottomRight).Y;
bottomRightElements.Y = -Progress.Height;
}
private void updateVisibility()
{
if (ShowHud.Disabled)
return;
2020-10-30 05:19:40 +00:00
if (holdingForHUD)
{
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 || IsBreakTime.Value;
break;
case HUDVisibilityMode.Always:
ShowHud.Value = true;
break;
}
}
2019-02-21 09:56:34 +00:00
private void replayLoadedValueChanged(ValueChangedEvent<bool> e)
2018-04-13 09:19:50 +00:00
{
2019-02-21 09:56:34 +00:00
PlayerSettingsOverlay.ReplayLoaded = e.NewValue;
2018-04-13 09:19:50 +00:00
2019-02-21 09:56:34 +00:00
if (e.NewValue)
2018-04-13 09:19:50 +00:00
{
PlayerSettingsOverlay.Show();
ModDisplay.FadeIn(200);
2018-10-30 12:32:12 +00:00
KeyCounter.Margin = new MarginPadding(10) { Bottom = 30 };
2018-04-13 09:19:50 +00:00
}
else
{
PlayerSettingsOverlay.Hide();
ModDisplay.Delay(2000).FadeOut(200);
2018-10-30 12:32:12 +00:00
KeyCounter.Margin = new MarginPadding(10);
2018-04-13 09:19:50 +00:00
}
updateVisibility();
2018-04-13 09:19:50 +00:00
}
protected virtual void BindDrawableRuleset(DrawableRuleset drawableRuleset)
2018-04-13 09:19:50 +00:00
{
(drawableRuleset as ICanAttachKeyCounter)?.Attach(KeyCounter);
2018-04-13 09:19:50 +00:00
replayLoaded.BindTo(drawableRuleset.HasReplayLoaded);
2018-04-13 09:19:50 +00:00
2019-03-20 05:49:33 +00:00
Progress.BindDrawableRuleset(drawableRuleset);
2018-04-13 09:19:50 +00:00
}
protected virtual SkinnableAccuracyCounter CreateAccuracyCounter() => new SkinnableAccuracyCounter();
2018-04-13 09:19:50 +00:00
protected virtual SkinnableScoreCounter CreateScoreCounter() => new SkinnableScoreCounter();
protected virtual SkinnableComboCounter CreateComboCounter() => new SkinnableComboCounter();
2018-04-13 09:19:50 +00:00
protected virtual SkinnableHealthDisplay CreateHealthDisplay() => new SkinnableHealthDisplay();
2018-04-13 09:19:50 +00:00
2020-06-26 17:22:30 +00:00
protected virtual FailingLayer CreateFailingLayer() => new FailingLayer
{
ShowHealth = { BindTarget = ShowHealthbar }
};
2020-04-09 05:31:25 +00:00
protected virtual KeyCounterDisplay CreateKeyCounter() => new KeyCounterDisplay
2018-04-13 09:19:50 +00:00
{
Anchor = Anchor.BottomRight,
Origin = Anchor.BottomRight,
};
protected virtual SongProgress CreateProgress() => new SongProgress
{
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft,
RelativeSizeAxes = Axes.X,
};
protected virtual HoldForMenuButton CreateHoldForMenuButton() => new HoldForMenuButton
2018-04-21 15:24:31 +00:00
{
Anchor = Anchor.BottomRight,
Origin = Anchor.BottomRight,
};
2018-04-13 09:19:50 +00:00
protected virtual ModDisplay CreateModsContainer() => new ModDisplay
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
AutoSizeAxes = Axes.Both,
};
2019-12-12 07:09:42 +00:00
protected virtual HitErrorDisplay CreateHitErrorDisplayOverlay() => new HitErrorDisplay(scoreProcessor, drawableRuleset?.FirstAvailableHitWindows);
2018-04-13 09:19:50 +00:00
protected virtual PlayerSettingsOverlay CreatePlayerSettingsOverlay() => new PlayerSettingsOverlay();
protected virtual void BindScoreProcessor(ScoreProcessor processor)
2018-04-13 09:19:50 +00:00
{
ScoreCounter?.Current.BindTo(processor.TotalScore);
AccuracyCounter?.Current.BindTo(processor.Accuracy);
ComboCounter?.Current.BindTo(processor.Combo);
if (HealthDisplay is IHealthDisplay shd)
{
processor.NewJudgement += judgement =>
{
2020-10-16 08:24:43 +00:00
if (judgement.IsHit && judgement.Type != HitResult.IgnoreHit)
shd.Flash(judgement);
};
}
2018-04-13 09:19:50 +00:00
}
protected virtual void BindHealthProcessor(HealthProcessor processor)
{
2020-04-09 05:31:25 +00:00
HealthDisplay?.BindHealthProcessor(processor);
FailingLayer?.BindHealthProcessor(processor);
}
2020-10-30 05:19:40 +00:00
public bool OnPressed(GlobalAction action)
{
switch (action)
{
case GlobalAction.HoldForHUD:
holdingForHUD = true;
updateVisibility();
return true;
2020-11-30 01:59:02 +00: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 05:00:54 +00:00
2020-11-30 01:59:02 +00:00
return true;
2020-10-30 05:19:40 +00:00
}
return false;
}
public void OnReleased(GlobalAction action)
{
switch (action)
{
case GlobalAction.HoldForHUD:
holdingForHUD = false;
updateVisibility();
break;
}
}
2018-04-13 09:19:50 +00:00
}
}