1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-17 19:02:56 +08:00
osu-lazer/osu.Game/Screens/Select/BeatmapInfoWedge.cs

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

523 lines
20 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
2016-12-06 17:56:20 +08:00
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
2018-11-20 15:51:59 +08:00
using osuTK;
using osuTK.Graphics;
using osu.Framework.Allocation;
2019-02-21 18:04:31 +08:00
using osu.Framework.Bindables;
using osu.Framework.Extensions.Color4Extensions;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Game.Beatmaps;
2016-11-24 12:48:48 +08:00
using osu.Game.Beatmaps.Drawables;
2016-12-16 11:25:28 +08:00
using osu.Game.Graphics;
using osu.Game.Graphics.Sprites;
using osu.Framework.Graphics.Shapes;
using osu.Framework.Graphics.Cursor;
2019-04-02 13:51:28 +08:00
using osu.Framework.Graphics.Effects;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Localisation;
using osu.Framework.Logging;
using osu.Game.Configuration;
using osu.Game.Extensions;
using osu.Game.Rulesets;
2019-04-08 17:32:05 +08:00
using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.UI;
2021-04-19 22:53:44 +08:00
using osu.Game.Graphics.Containers;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Screens.Select
{
public partial class BeatmapInfoWedge : VisibilityContainer
{
2021-08-13 21:29:22 +08:00
public const float BORDER_THICKNESS = 2.5f;
private const float shear_width = 36.75f;
private const float transition_duration = 250;
private static readonly Vector2 wedged_container_shear = new Vector2(shear_width / SongSelect.WEDGE_HEIGHT, 0);
2018-04-13 17:19:50 +08:00
2021-02-25 21:01:53 +08:00
[Resolved]
private IBindable<RulesetInfo> ruleset { get; set; }
protected Container DisplayedContent { get; private set; }
2021-05-06 01:14:04 +08:00
protected WedgeInfoText Info { get; private set; }
2018-04-13 17:19:50 +08:00
public BeatmapInfoWedge()
{
Shear = wedged_container_shear;
Masking = true;
BorderColour = new Color4(221, 255, 255, 255);
2021-08-13 21:29:22 +08:00
BorderThickness = BORDER_THICKNESS;
2017-12-26 19:18:47 +08:00
Alpha = 0;
2017-06-12 11:48:47 +08:00
EdgeEffect = new EdgeEffectParameters
{
Type = EdgeEffectType.Glow,
Colour = new Color4(130, 204, 255, 150),
Radius = 20,
Roundness = 15,
};
}
2018-04-13 17:19:50 +08:00
2021-02-25 21:09:41 +08:00
[BackgroundDependencyLoader]
private void load()
{
2021-02-25 21:09:41 +08:00
ruleset.BindValueChanged(_ => updateDisplay());
}
2021-08-19 18:19:46 +08:00
private const double animation_duration = 800;
protected override void PopIn()
{
2021-08-19 18:19:46 +08:00
this.MoveToX(0, animation_duration, Easing.OutQuint);
this.RotateTo(0, animation_duration, Easing.OutQuint);
this.FadeIn(transition_duration);
}
2018-04-13 17:19:50 +08:00
protected override void PopOut()
{
2021-08-19 18:19:46 +08:00
this.MoveToX(-100, animation_duration, Easing.In);
this.RotateTo(10, animation_duration, Easing.In);
this.FadeOut(transition_duration * 2, Easing.In);
}
2018-04-13 17:19:50 +08:00
private WorkingBeatmap beatmap;
public WorkingBeatmap Beatmap
{
get => beatmap;
set
{
if (beatmap == value) return;
beatmap = value;
updateDisplay();
}
}
2021-05-06 01:14:04 +08:00
public override bool IsPresent => base.IsPresent || DisplayedContent == null; // Visibility is updated in the LoadComponentAsync callback
2021-05-06 00:50:49 +08:00
private Container loadingInfo;
private void updateDisplay()
{
Scheduler.AddOnce(perform);
void perform()
{
void removeOldInfo()
{
State.Value = beatmap == null ? Visibility.Hidden : Visibility.Visible;
DisplayedContent?.FadeOut(transition_duration);
2021-05-06 01:14:04 +08:00
DisplayedContent?.Expire();
DisplayedContent = null;
}
if (beatmap == null)
{
removeOldInfo();
return;
}
2021-05-06 00:50:49 +08:00
LoadComponentAsync(loadingInfo = new Container
{
2021-05-06 00:50:49 +08:00
RelativeSizeAxes = Axes.Both,
Shear = -Shear,
2021-05-06 01:14:04 +08:00
Depth = DisplayedContent?.Depth + 1 ?? 0,
2021-05-06 00:50:49 +08:00
Children = new Drawable[]
{
new BeatmapInfoWedgeBackground(beatmap),
Info = new WedgeInfoText(beatmap, ruleset.Value),
2021-05-06 00:50:49 +08:00
}
}, loaded =>
{
// ensure we are the most recent loaded wedge.
if (loaded != loadingInfo) return;
removeOldInfo();
2021-05-06 01:14:04 +08:00
Add(DisplayedContent = loaded);
});
}
}
2018-04-13 17:19:50 +08:00
2021-04-20 05:41:51 +08:00
public partial class WedgeInfoText : Container
{
public OsuSpriteText VersionLabel { get; private set; }
public OsuSpriteText TitleLabel { get; private set; }
public OsuSpriteText ArtistLabel { get; private set; }
public FillFlowContainer MapperContainer { get; private set; }
private Container difficultyColourBar;
private StarRatingDisplay starRatingDisplay;
private ILocalisedBindableString titleBinding;
private ILocalisedBindableString artistBinding;
private FillFlowContainer infoLabelContainer;
private Container bpmLabelContainer;
2018-04-13 17:19:50 +08:00
private readonly WorkingBeatmap working;
private readonly RulesetInfo ruleset;
[Resolved]
private IBindable<IReadOnlyList<Mod>> mods { get; set; }
[Resolved]
private BeatmapDifficultyCache difficultyCache { get; set; }
[Resolved]
private OsuColour colours { get; set; }
private ModSettingChangeTracker settingChangeTracker;
public WedgeInfoText(WorkingBeatmap working, RulesetInfo userRuleset)
2017-11-21 10:49:21 +08:00
{
this.working = working;
ruleset = userRuleset ?? working.BeatmapInfo.Ruleset;
2017-11-21 10:49:21 +08:00
}
2018-04-13 17:19:50 +08:00
private CancellationTokenSource cancellationSource;
private IBindable<StarDifficulty?> starDifficulty;
2018-05-11 13:13:52 +08:00
[BackgroundDependencyLoader]
private void load(LocalisationManager localisation)
{
var beatmapInfo = working.BeatmapInfo;
var metadata = beatmapInfo.Metadata;
2018-04-13 17:19:50 +08:00
RelativeSizeAxes = Axes.Both;
2018-04-13 17:19:50 +08:00
titleBinding = localisation.GetLocalisedBindableString(new RomanisableString(metadata.TitleUnicode, metadata.Title));
artistBinding = localisation.GetLocalisedBindableString(new RomanisableString(metadata.ArtistUnicode, metadata.Artist));
2018-04-13 17:19:50 +08:00
2021-08-19 18:19:46 +08:00
const float top_height = 0.7f;
Children = new Drawable[]
{
difficultyColourBar = new Container
{
RelativeSizeAxes = Axes.Y,
Width = 20f,
Children = new[]
{
new Box
{
RelativeSizeAxes = Axes.Both,
2021-08-19 18:19:46 +08:00
Width = top_height,
},
new Box
{
RelativeSizeAxes = Axes.Both,
RelativePositionAxes = Axes.Both,
Alpha = 0.5f,
2021-08-19 18:19:46 +08:00
X = top_height,
Width = 1 - top_height,
}
}
},
new FillFlowContainer
{
Name = "Topleft-aligned metadata",
Anchor = Anchor.TopLeft,
Origin = Anchor.TopLeft,
Direction = FillDirection.Vertical,
2019-09-25 07:28:40 +08:00
Padding = new MarginPadding { Top = 10, Left = 25, Right = shear_width * 2.5f },
AutoSizeAxes = Axes.Y,
RelativeSizeAxes = Axes.X,
Children = new Drawable[]
2017-04-02 14:56:12 +08:00
{
VersionLabel = new OsuSpriteText
{
Text = beatmapInfo.DifficultyName,
2019-02-20 15:52:36 +08:00
Font = OsuFont.GetFont(size: 24, italics: true),
RelativeSizeAxes = Axes.X,
Truncate = true,
},
}
},
new FillFlowContainer
{
Name = "Topright-aligned metadata",
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
Direction = FillDirection.Vertical,
2019-09-25 07:28:40 +08:00
Padding = new MarginPadding { Top = 14, Right = shear_width / 2 },
AutoSizeAxes = Axes.Both,
2020-09-01 01:31:47 +08:00
Shear = wedged_container_shear,
Spacing = new Vector2(0f, 5f),
Children = new Drawable[]
{
starRatingDisplay = new StarRatingDisplay(default, animated: true)
2020-08-31 14:03:41 +08:00
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
Shear = -wedged_container_shear,
Alpha = 0f,
},
new BeatmapSetOnlineStatusPill
{
AutoSizeAxes = Axes.Both,
2020-09-01 01:23:19 +08:00
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
2020-09-01 01:31:47 +08:00
Shear = -wedged_container_shear,
TextSize = 11,
TextPadding = new MarginPadding { Horizontal = 8, Vertical = 2 },
Status = beatmapInfo.Status,
Alpha = string.IsNullOrEmpty(beatmapInfo.DifficultyName) ? 0 : 1
}
}
},
new FillFlowContainer
{
Name = "Centre-aligned metadata",
Anchor = Anchor.CentreLeft,
Origin = Anchor.TopLeft,
2019-09-25 07:28:40 +08:00
Y = -7,
Direction = FillDirection.Vertical,
2019-09-25 07:28:40 +08:00
Padding = new MarginPadding { Left = 25, Right = shear_width },
AutoSizeAxes = Axes.Y,
RelativeSizeAxes = Axes.X,
Children = new Drawable[]
{
TitleLabel = new OsuSpriteText
{
2022-03-30 16:59:45 +08:00
Current = { BindTarget = titleBinding },
2019-02-20 15:52:36 +08:00
Font = OsuFont.GetFont(size: 28, italics: true),
RelativeSizeAxes = Axes.X,
Truncate = true,
},
ArtistLabel = new OsuSpriteText
{
2022-03-30 16:59:45 +08:00
Current = { BindTarget = artistBinding },
2019-02-20 15:52:36 +08:00
Font = OsuFont.GetFont(size: 17, italics: true),
RelativeSizeAxes = Axes.X,
Truncate = true,
},
MapperContainer = new FillFlowContainer
{
Margin = new MarginPadding { Top = 10 },
Direction = FillDirection.Horizontal,
AutoSizeAxes = Axes.Both,
2021-04-20 01:24:46 +08:00
Child = getMapper(metadata),
},
infoLabelContainer = new FillFlowContainer
{
Margin = new MarginPadding { Top = 20 },
Spacing = new Vector2(20, 0),
AutoSizeAxes = Axes.Both,
}
}
}
};
addInfoLabels();
}
protected override void LoadComplete()
{
base.LoadComplete();
starRatingDisplay.DisplayedStars.BindValueChanged(s =>
{
difficultyColourBar.Colour = colours.ForStarDifficulty(s.NewValue);
}, true);
starDifficulty = difficultyCache.GetBindableDifficulty(working.BeatmapInfo, (cancellationSource = new CancellationTokenSource()).Token);
starDifficulty.BindValueChanged(s =>
{
starRatingDisplay.Current.Value = s.NewValue ?? default;
// Don't roll the counter on initial display (but still allow it to roll on applying mods etc.)
if (!starRatingDisplay.IsPresent)
starRatingDisplay.FinishTransforms(true);
starRatingDisplay.FadeIn(transition_duration);
});
mods.BindValueChanged(m =>
{
settingChangeTracker?.Dispose();
refreshBPMLabel();
settingChangeTracker = new ModSettingChangeTracker(m.NewValue);
settingChangeTracker.SettingChanged += _ => refreshBPMLabel();
}, true);
}
private void addInfoLabels()
{
if (working.Beatmap?.HitObjects?.Any() != true)
return;
2018-04-13 17:19:50 +08:00
infoLabelContainer.Children = new Drawable[]
{
new InfoLabel(new BeatmapStatistic
{
Name = "Length",
CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Length),
Content = working.BeatmapInfo.Length.ToFormattedDuration().ToString(),
}),
bpmLabelContainer = new Container
{
AutoSizeAxes = Axes.Both,
},
new FillFlowContainer
{
AutoSizeAxes = Axes.Both,
Spacing = new Vector2(20, 0),
Children = getRulesetInfoLabels()
}
};
}
private InfoLabel[] getRulesetInfoLabels()
{
try
{
IBeatmap playableBeatmap;
2018-04-13 17:19:50 +08:00
try
{
// Try to get the beatmap with the user's ruleset
playableBeatmap = working.GetPlayableBeatmap(ruleset, Array.Empty<Mod>());
}
catch (BeatmapInvalidForRulesetException)
{
// Can't be converted to the user's ruleset, so use the beatmap's own ruleset
playableBeatmap = working.GetPlayableBeatmap(working.BeatmapInfo.Ruleset, Array.Empty<Mod>());
}
return playableBeatmap.GetStatistics().Select(s => new InfoLabel(s)).ToArray();
}
catch (Exception e)
{
Logger.Error(e, "Could not load beatmap successfully!");
}
2018-04-13 17:19:50 +08:00
return Array.Empty<InfoLabel>();
}
2018-04-13 17:19:50 +08:00
private void refreshBPMLabel()
{
var beatmap = working.Beatmap;
if (beatmap == null || bpmLabelContainer == null)
return;
// this doesn't consider mods which apply variable rates, yet.
double rate = 1;
foreach (var mod in mods.Value.OfType<IApplicableToRate>())
rate = mod.ApplyToRate(0, rate);
int bpmMax = (int)Math.Round(Math.Round(beatmap.ControlPointInfo.BPMMaximum) * rate);
int bpmMin = (int)Math.Round(Math.Round(beatmap.ControlPointInfo.BPMMinimum) * rate);
int mostCommonBPM = (int)Math.Round(Math.Round(60000 / beatmap.GetMostCommonBeatLength()) * rate);
2018-04-13 17:19:50 +08:00
string labelText = bpmMin == bpmMax
? $"{bpmMin}"
: $"{bpmMin}-{bpmMax} (mostly {mostCommonBPM})";
2018-04-13 17:19:50 +08:00
bpmLabelContainer.Child = new InfoLabel(new BeatmapStatistic
{
Name = "BPM",
CreateIcon = () => new BeatmapStatisticIcon(BeatmapStatisticsIconType.Bpm),
Content = labelText
});
}
2018-04-13 17:19:50 +08:00
2021-04-20 01:24:46 +08:00
private Drawable getMapper(BeatmapMetadata metadata)
{
if (string.IsNullOrEmpty(metadata.Author.Username))
2021-04-20 01:24:46 +08:00
return Empty();
2018-04-13 17:19:50 +08:00
2021-04-19 22:53:44 +08:00
return new LinkFlowContainer(s =>
{
2021-04-19 22:53:44 +08:00
s.Font = OsuFont.GetFont(weight: FontWeight.Bold, size: 15);
}).With(d =>
{
d.AutoSizeAxes = Axes.Both;
d.AddText("mapped by ");
d.AddUserLink(metadata.Author);
});
}
2018-04-13 17:19:50 +08:00
protected override void Dispose(bool isDisposing)
{
base.Dispose(isDisposing);
settingChangeTracker?.Dispose();
cancellationSource?.Cancel();
}
public partial class InfoLabel : Container, IHasTooltip
2016-12-17 22:53:26 +08:00
{
public LocalisableString TooltipText { get; }
2018-04-13 17:19:50 +08:00
2021-08-23 01:01:26 +08:00
internal BeatmapStatistic Statistic { get; }
public InfoLabel(BeatmapStatistic statistic)
{
2021-08-23 01:01:26 +08:00
Statistic = statistic;
TooltipText = statistic.Name;
AutoSizeAxes = Axes.Both;
2018-04-13 17:19:50 +08:00
Children = new Drawable[]
{
2017-12-15 12:01:06 +08:00
new Container
2017-11-21 10:49:21 +08:00
{
Anchor = Anchor.CentreLeft,
2017-12-15 12:01:06 +08:00
Origin = Anchor.CentreLeft,
2017-11-21 10:49:21 +08:00
Size = new Vector2(20),
2017-12-15 12:01:06 +08:00
Children = new[]
{
new SpriteIcon
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
Colour = Color4Extensions.FromHex(@"441288"),
2019-04-02 18:55:24 +08:00
Icon = FontAwesome.Solid.Square,
2017-12-15 12:01:06 +08:00
Rotation = 45,
},
new SpriteIcon
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
Colour = Color4Extensions.FromHex(@"f7dd55"),
Icon = FontAwesome.Regular.Circle,
Size = new Vector2(0.8f)
2017-12-15 12:01:06 +08:00
},
statistic.CreateIcon().With(i =>
{
i.Anchor = Anchor.Centre;
i.Origin = Anchor.Centre;
i.RelativeSizeAxes = Axes.Both;
i.Colour = Color4Extensions.FromHex(@"f7dd55");
i.Size = new Vector2(0.64f);
}),
2017-12-15 12:01:06 +08:00
}
2017-11-21 10:49:21 +08:00
},
new OsuSpriteText
{
Anchor = Anchor.CentreLeft,
2017-12-15 12:01:06 +08:00
Origin = Anchor.CentreLeft,
2017-11-21 10:49:21 +08:00
Colour = new Color4(255, 221, 85, 255),
Font = OsuFont.GetFont(weight: FontWeight.Bold, size: 17),
2017-12-15 12:01:06 +08:00
Margin = new MarginPadding { Left = 30 },
2017-11-21 10:49:21 +08:00
Text = statistic.Content,
}
};
}
}
}
}
}