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

212 lines
7.4 KiB
C#
Raw Normal View History

2018-01-05 11:21:19 +00:00
// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
2017-03-11 05:27:18 +00:00
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Allocation;
using osu.Framework.Configuration;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Input;
2017-03-11 05:27:18 +00:00
using osu.Game.Configuration;
using osu.Game.Graphics;
2017-03-11 05:27:18 +00:00
using osu.Game.Graphics.UserInterface;
using osu.Game.Overlays;
using osu.Game.Overlays.Notifications;
using osu.Game.Rulesets.Scoring;
using osu.Game.Rulesets.UI;
using osu.Game.Screens.Play.HUD;
using OpenTK;
using OpenTK.Input;
2017-03-11 05:27:18 +00:00
namespace osu.Game.Screens.Play
2017-03-11 05:27:18 +00:00
{
public class HUDOverlay : Container
2017-03-11 05:27:18 +00:00
{
2017-04-03 09:17:53 +00:00
private const int duration = 100;
2017-04-04 14:47:41 +00:00
private readonly Container content;
2017-03-11 05:27:18 +00:00
public readonly KeyCounterCollection KeyCounter;
2017-04-07 12:20:31 +00:00
public readonly RollingCounter<int> ComboCounter;
2017-03-11 05:27:18 +00:00
public readonly ScoreCounter ScoreCounter;
2017-04-07 12:20:31 +00:00
public readonly RollingCounter<double> AccuracyCounter;
2017-03-11 05:27:18 +00:00
public readonly HealthDisplay HealthDisplay;
2017-03-22 12:27:04 +00:00
public readonly SongProgress Progress;
public readonly ModDisplay ModDisplay;
2017-10-02 01:42:38 +00:00
public readonly ReplaySettingsOverlay ReplaySettingsOverlay;
2017-03-11 05:27:18 +00:00
2017-03-31 13:43:31 +00:00
private Bindable<bool> showHud;
private readonly BindableBool replayLoaded = new BindableBool();
2017-03-31 13:43:31 +00:00
2017-04-03 11:58:38 +00:00
private static bool hasShownNotificationOnce;
2017-03-11 05:27:18 +00:00
public HUDOverlay()
2017-03-11 05:27:18 +00:00
{
RelativeSizeAxes = Axes.Both;
2017-04-04 14:47:41 +00:00
Add(content = new Container
2017-03-11 05:27:18 +00:00
{
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
KeyCounter = CreateKeyCounter(),
ComboCounter = CreateComboCounter(),
ScoreCounter = CreateScoreCounter(),
AccuracyCounter = CreateAccuracyCounter(),
HealthDisplay = CreateHealthDisplay(),
Progress = CreateProgress(),
ModDisplay = CreateModsContainer(),
2017-10-02 01:42:38 +00:00
ReplaySettingsOverlay = CreateReplaySettingsOverlay(),
}
});
replayLoaded.ValueChanged += replayLoadedValueChanged;
}
private void replayLoadedValueChanged(bool loaded)
{
ReplaySettingsOverlay.ReplayLoaded = loaded;
if (loaded)
{
ReplaySettingsOverlay.Show();
ModDisplay.FadeIn(200);
}
else
{
ReplaySettingsOverlay.Hide();
ModDisplay.Delay(2000).FadeOut(200);
}
2017-03-11 05:27:18 +00:00
}
[BackgroundDependencyLoader(true)]
private void load(OsuConfigManager config, NotificationOverlay notificationOverlay, OsuColour colours)
2017-03-11 05:27:18 +00:00
{
2017-05-15 01:56:27 +00:00
showHud = config.GetBindable<bool>(OsuSetting.ShowInterface);
2017-05-23 09:24:16 +00:00
showHud.ValueChanged += hudVisibility => content.FadeTo(hudVisibility ? 1 : 0, duration);
2017-03-31 13:43:31 +00:00
showHud.TriggerChange();
2017-04-03 11:58:38 +00:00
if (!showHud && !hasShownNotificationOnce)
{
2017-04-03 11:58:38 +00:00
hasShownNotificationOnce = true;
notificationOverlay?.Post(new SimpleNotification
{
2017-04-06 05:27:23 +00:00
Text = @"The score overlay is currently disabled. You can toggle this by pressing Shift+Tab."
});
}
2017-03-11 05:27:18 +00:00
// todo: the stuff below should probably not be in this base implementation, but in each individual class.
ComboCounter.AccentColour = colours.BlueLighter;
AccuracyCounter.AccentColour = colours.BlueLighter;
ScoreCounter.AccentColour = colours.BlueLighter;
var shd = HealthDisplay as StandardHealthDisplay;
if (shd != null)
{
shd.AccentColour = colours.BlueLighter;
shd.GlowColour = colours.BlueDarker;
}
2017-03-11 05:27:18 +00:00
}
2017-08-09 04:28:29 +00:00
public virtual void BindRulesetContainer(RulesetContainer rulesetContainer)
2017-03-11 05:27:18 +00:00
{
(rulesetContainer.KeyBindingInputManager as ICanAttachKeyCounter)?.Attach(KeyCounter);
replayLoaded.BindTo(rulesetContainer.HasReplayLoaded);
replayLoaded.TriggerChange();
Progress.BindRulestContainer(rulesetContainer);
2017-03-11 05:27:18 +00:00
}
2017-04-01 11:46:45 +00:00
protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
{
if (args.Repeat) return false;
if (state.Keyboard.ShiftPressed)
{
switch (args.Key)
{
case Key.Tab:
showHud.Value = !showHud.Value;
return true;
}
}
return base.OnKeyDown(state, args);
}
protected virtual RollingCounter<double> CreateAccuracyCounter() => new PercentageCounter
{
Anchor = Anchor.TopCentre,
Origin = Anchor.TopRight,
Position = new Vector2(0, 35),
TextSize = 20,
Margin = new MarginPadding { Right = 140 },
};
protected virtual RollingCounter<int> CreateComboCounter() => new SimpleComboCounter
{
Anchor = Anchor.TopCentre,
Origin = Anchor.TopLeft,
Position = new Vector2(0, 35),
Margin = new MarginPadding { Left = 140 },
TextSize = 20,
};
protected virtual HealthDisplay CreateHealthDisplay() => new StandardHealthDisplay
{
Size = new Vector2(1, 5),
RelativeSizeAxes = Axes.X,
Margin = new MarginPadding { Top = 20 }
};
protected virtual KeyCounterCollection CreateKeyCounter() => new KeyCounterCollection
{
IsCounting = true,
FadeTime = 50,
Anchor = Anchor.BottomRight,
Origin = Anchor.BottomRight,
Margin = new MarginPadding(10),
Y = -TwoLayerButton.SIZE_RETRACTED.Y,
};
protected virtual ScoreCounter CreateScoreCounter() => new ScoreCounter(6)
{
Anchor = Anchor.TopCentre,
Origin = Anchor.TopCentre,
TextSize = 40,
Position = new Vector2(0, 30),
};
protected virtual SongProgress CreateProgress() => new SongProgress
{
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft,
RelativeSizeAxes = Axes.X,
};
protected virtual ModDisplay CreateModsContainer() => new ModDisplay
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
AutoSizeAxes = Axes.Both,
Margin = new MarginPadding { Top = 20, Right = 10 },
};
protected virtual ReplaySettingsOverlay CreateReplaySettingsOverlay() => new ReplaySettingsOverlay();
public virtual void BindProcessor(ScoreProcessor processor)
{
ScoreCounter?.Current.BindTo(processor.TotalScore);
AccuracyCounter?.Current.BindTo(processor.Accuracy);
ComboCounter?.Current.BindTo(processor.Combo);
HealthDisplay?.Current.BindTo(processor.Health);
var shd = HealthDisplay as StandardHealthDisplay;
if (shd != null)
processor.NewJudgement += shd.Flash;
}
2017-03-11 05:27:18 +00:00
}
}