1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-17 03:55:30 +08:00
osu-lazer/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylistItem.cs

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

667 lines
25 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.
2022-06-17 15:37:17 +08:00
#nullable disable
using System;
using System.Collections.Generic;
using System.Linq;
2021-11-25 22:15:28 +08:00
using System.Threading.Tasks;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Extensions.ObjectExtensions;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Colour;
using osu.Framework.Graphics.Containers;
2021-11-25 22:15:28 +08:00
using osu.Framework.Graphics.Cursor;
using osu.Framework.Graphics.Shapes;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Graphics.UserInterface;
using osu.Framework.Input.Events;
2021-11-25 22:15:28 +08:00
using osu.Framework.Localisation;
using osu.Framework.Logging;
using osu.Game.Beatmaps;
using osu.Game.Beatmaps.Drawables;
using osu.Game.Collections;
2021-11-25 22:15:28 +08:00
using osu.Game.Database;
using osu.Game.Graphics;
using osu.Game.Graphics.Containers;
using osu.Game.Graphics.UserInterface;
using osu.Game.Online;
using osu.Game.Online.Chat;
2020-12-25 12:38:11 +08:00
using osu.Game.Online.Rooms;
using osu.Game.Overlays;
2021-01-13 16:33:00 +08:00
using osu.Game.Overlays.BeatmapSet;
using osu.Game.Resources.Localisation.Web;
using osu.Game.Rulesets;
using osu.Game.Rulesets.Mods;
using osu.Game.Screens.Play.HUD;
2021-11-25 22:15:28 +08:00
using osu.Game.Users.Drawables;
using osuTK;
using osuTK.Graphics;
namespace osu.Game.Screens.OnlinePlay
{
public class DrawableRoomPlaylistItem : OsuRearrangeableListItem<PlaylistItem>, IHasContextMenu
{
public const float HEIGHT = 50;
2021-12-09 16:48:09 +08:00
private const float icon_height = 34;
/// <summary>
/// Invoked when this item requests to be deleted.
/// </summary>
public Action<PlaylistItem> RequestDeletion;
/// <summary>
/// Invoked when this item requests its results to be shown.
/// </summary>
2021-12-09 00:52:59 +08:00
public Action<PlaylistItem> RequestResults;
/// <summary>
/// Invoked when this item requests to be edited.
/// </summary>
public Action<PlaylistItem> RequestEdit;
/// <summary>
/// The currently-selected item, used to show a border around this item.
/// May be updated by this item if <see cref="AllowSelection"/> is <c>true</c>.
/// </summary>
2020-02-14 15:55:05 +08:00
public readonly Bindable<PlaylistItem> SelectedItem = new Bindable<PlaylistItem>();
public readonly PlaylistItem Item;
public bool IsSelectedItem => SelectedItem.Value?.ID == Item.ID;
private readonly DelayedLoadWrapper onScreenLoader = new DelayedLoadWrapper(Empty) { RelativeSizeAxes = Axes.Both };
private readonly IBindable<bool> valid = new Bindable<bool>();
private IBeatmapInfo beatmap;
private IRulesetInfo ruleset;
private Mod[] requiredMods = Array.Empty<Mod>();
private Container maskingContainer;
private Container difficultyIconContainer;
private LinkFlowContainer beatmapText;
private LinkFlowContainer authorText;
2022-05-15 01:52:38 +08:00
private ExplicitContentBeatmapBadge explicitContent;
private ModDisplay modDisplay;
private FillFlowContainer buttonsFlow;
2021-11-25 22:15:28 +08:00
private UpdateableAvatar ownerAvatar;
private Drawable showResultsButton;
private Drawable editButton;
2021-12-09 23:38:18 +08:00
private Drawable removeButton;
private PanelBackground panelBackground;
private FillFlowContainer mainFillFlow;
2022-07-27 14:59:36 +08:00
[Resolved]
private RealmAccess realm { get; set; }
[Resolved]
private RulesetStore rulesets { get; set; }
[Resolved]
private BeatmapManager beatmaps { get; set; }
2021-11-25 22:15:28 +08:00
[Resolved]
private OsuColour colours { get; set; }
[Resolved]
private UserLookupCache userLookupCache { get; set; }
[Resolved]
private BeatmapLookupCache beatmapLookupCache { get; set; }
[Resolved(CanBeNull = true)]
private BeatmapSetOverlay beatmapOverlay { get; set; }
[Resolved(CanBeNull = true)]
private ManageCollectionsDialog manageCollectionsDialog { get; set; }
protected override bool ShouldBeConsideredForInput(Drawable child) => AllowReordering || AllowDeletion || !AllowSelection || SelectedItem.Value == Model;
public DrawableRoomPlaylistItem(PlaylistItem item)
: base(item)
{
Item = item;
valid.BindTo(item.Valid);
2020-09-08 15:36:36 +08:00
if (item.Expired)
Colour = OsuColour.Gray(0.5f);
}
[BackgroundDependencyLoader]
private void load()
{
maskingContainer.BorderColour = colours.Yellow;
ruleset = rulesets.GetRuleset(Item.RulesetID);
var rulesetInstance = ruleset?.CreateInstance();
if (rulesetInstance != null)
requiredMods = Item.RequiredMods.Select(m => m.ToMod(rulesetInstance)).ToArray();
}
protected override void LoadComplete()
{
base.LoadComplete();
2021-11-17 10:28:43 +08:00
SelectedItem.BindValueChanged(selected =>
{
if (!valid.Value)
{
// Don't allow selection when not valid.
if (IsSelectedItem)
2021-11-17 10:28:43 +08:00
{
SelectedItem.Value = selected.OldValue;
}
// Don't update border when not valid (the border is displaying this fact).
return;
}
2020-02-14 15:55:05 +08:00
maskingContainer.BorderThickness = IsSelectedItem ? 5 : 0;
2021-11-17 10:28:43 +08:00
}, true);
valid.BindValueChanged(_ => Scheduler.AddOnce(refresh));
onScreenLoader.DelayedLoadStarted += _ =>
{
Task.Run(async () =>
{
try
{
if (showItemOwner)
{
var foundUser = await userLookupCache.GetUserAsync(Item.OwnerID).ConfigureAwait(false);
Schedule(() => ownerAvatar.User = foundUser);
}
beatmap = await beatmapLookupCache.GetBeatmapAsync(Item.Beatmap.OnlineID).ConfigureAwait(false);
Scheduler.AddOnce(refresh);
}
catch (Exception e)
{
Logger.Log($"Error while populating playlist item {e}");
}
});
};
refresh();
}
/// <summary>
/// Whether this item can be selected.
/// </summary>
public bool AllowSelection { get; set; }
/// <summary>
/// Whether this item can be reordered in the playlist.
/// </summary>
public bool AllowReordering
{
get => ShowDragHandle.Value;
set => ShowDragHandle.Value = value;
}
private bool allowDeletion;
/// <summary>
/// Whether this item can be deleted.
/// </summary>
public bool AllowDeletion
{
get => allowDeletion;
set
{
allowDeletion = value;
2021-12-09 23:38:18 +08:00
if (removeButton != null)
removeButton.Alpha = value ? 1 : 0;
}
}
private bool allowShowingResults;
/// <summary>
/// Whether this item can have results shown.
/// </summary>
public bool AllowShowingResults
{
get => allowShowingResults;
set
{
allowShowingResults = value;
if (showResultsButton != null)
showResultsButton.Alpha = value ? 1 : 0;
}
}
private bool allowEditing;
/// <summary>
/// Whether this item can be edited.
/// </summary>
public bool AllowEditing
{
get => allowEditing;
set
{
allowEditing = value;
if (editButton != null)
editButton.Alpha = value ? 1 : 0;
}
}
private bool showItemOwner;
/// <summary>
/// Whether to display the avatar of the user which owns this playlist item.
/// </summary>
public bool ShowItemOwner
{
get => showItemOwner;
set
{
showItemOwner = value;
if (ownerAvatar != null)
ownerAvatar.Alpha = value ? 1 : 0;
}
}
2020-02-14 15:55:05 +08:00
private void refresh()
{
if (!valid.Value)
{
maskingContainer.BorderThickness = 5;
maskingContainer.BorderColour = colours.Red;
}
if (beatmap != null)
difficultyIconContainer.Child = new DifficultyIcon(beatmap, ruleset) { Size = new Vector2(icon_height) };
else
difficultyIconContainer.Clear();
panelBackground.Beatmap.Value = beatmap;
2020-02-14 15:55:05 +08:00
beatmapText.Clear();
if (beatmap != null)
2021-07-22 12:18:37 +08:00
{
beatmapText.AddLink(beatmap.GetDisplayTitleRomanisable(includeCreator: false),
LinkAction.OpenBeatmap,
beatmap.OnlineID.ToString(),
null,
text =>
{
text.Truncate = true;
});
}
2020-02-14 15:55:05 +08:00
authorText.Clear();
if (!string.IsNullOrEmpty(beatmap?.Metadata.Author.Username))
2020-02-14 15:55:05 +08:00
{
authorText.AddText("mapped by ");
authorText.AddUserLink(beatmap.Metadata.Author);
2020-02-14 15:55:05 +08:00
}
bool hasExplicitContent = (beatmap?.BeatmapSet as IBeatmapSetOnlineInfo)?.HasExplicitContent == true;
2022-05-15 01:52:38 +08:00
explicitContent.Alpha = hasExplicitContent ? 1 : 0;
2021-01-13 16:33:00 +08:00
2020-02-14 15:55:05 +08:00
modDisplay.Current.Value = requiredMods.ToArray();
buttonsFlow.Clear();
buttonsFlow.ChildrenEnumerable = createButtons();
difficultyIconContainer.FadeInFromZero(500, Easing.OutQuint);
mainFillFlow.FadeInFromZero(500, Easing.OutQuint);
2020-02-14 15:55:05 +08:00
}
2021-02-02 16:09:59 +08:00
protected override Drawable CreateContent()
{
2021-02-02 16:09:59 +08:00
Action<SpriteText> fontParameters = s => s.Font = OsuFont.Default.With(weight: FontWeight.SemiBold);
return maskingContainer = new Container
{
2021-02-02 16:09:59 +08:00
RelativeSizeAxes = Axes.X,
Height = HEIGHT,
2021-02-02 16:09:59 +08:00
Masking = true,
CornerRadius = 10,
Children = new Drawable[]
{
2021-02-02 16:09:59 +08:00
new Box // A transparent box that forces the border to be drawn if the panel background is opaque
{
2021-02-02 16:09:59 +08:00
RelativeSizeAxes = Axes.Both,
Alpha = 0,
AlwaysPresent = true
},
onScreenLoader,
panelBackground = new PanelBackground
2021-02-02 16:09:59 +08:00
{
RelativeSizeAxes = Axes.Both,
},
2021-07-22 12:18:37 +08:00
new GridContainer
2021-02-02 16:09:59 +08:00
{
RelativeSizeAxes = Axes.Both,
2021-07-22 12:18:37 +08:00
ColumnDimensions = new[]
{
2021-07-22 12:18:37 +08:00
new Dimension(GridSizeMode.AutoSize),
new Dimension(),
new Dimension(GridSizeMode.AutoSize),
2021-11-26 16:17:06 +08:00
new Dimension(GridSizeMode.AutoSize)
2021-07-22 12:18:37 +08:00
},
Content = new[]
{
new Drawable[]
2021-02-02 16:09:59 +08:00
{
2021-07-22 12:18:37 +08:00
difficultyIconContainer = new Container
{
Anchor = Anchor.CentreLeft,
Origin = Anchor.CentreLeft,
AutoSizeAxes = Axes.Both,
2021-11-26 16:17:06 +08:00
Margin = new MarginPadding { Left = 8, Right = 8 },
2021-07-22 12:18:37 +08:00
},
mainFillFlow = new FillFlowContainer
{
2021-07-22 12:18:37 +08:00
Anchor = Anchor.CentreLeft,
Origin = Anchor.CentreLeft,
AutoSizeAxes = Axes.Y,
RelativeSizeAxes = Axes.X,
Direction = FillDirection.Vertical,
Children = new Drawable[]
{
2021-07-22 12:18:37 +08:00
beatmapText = new LinkFlowContainer(fontParameters)
2021-01-13 16:33:00 +08:00
{
2021-07-22 12:18:37 +08:00
RelativeSizeAxes = Axes.X,
// workaround to ensure only the first line of text shows, emulating truncation (but without ellipsis at the end).
// TODO: remove when text/link flow can support truncation with ellipsis natively.
Height = OsuFont.DEFAULT_FONT_SIZE,
Masking = true
2021-07-22 12:18:37 +08:00
},
new FillFlowContainer
{
AutoSizeAxes = Axes.Both,
Direction = FillDirection.Horizontal,
Spacing = new Vector2(10f, 0),
Children = new Drawable[]
2021-01-13 16:33:00 +08:00
{
2021-07-22 12:18:37 +08:00
new FillFlowContainer
2021-01-13 16:33:00 +08:00
{
2021-07-22 12:18:37 +08:00
AutoSizeAxes = Axes.Both,
Direction = FillDirection.Horizontal,
Spacing = new Vector2(10f, 0),
Children = new Drawable[]
2021-02-02 16:09:59 +08:00
{
2021-07-22 12:18:37 +08:00
authorText = new LinkFlowContainer(fontParameters) { AutoSizeAxes = Axes.Both },
2022-05-15 01:52:38 +08:00
explicitContent = new ExplicitContentBeatmapBadge
2021-07-22 12:18:37 +08:00
{
Alpha = 0f,
Anchor = Anchor.CentreLeft,
Origin = Anchor.CentreLeft,
Margin = new MarginPadding { Top = 3f },
}
},
2021-02-02 16:09:59 +08:00
},
2021-07-22 12:18:37 +08:00
new Container
2021-02-02 16:09:59 +08:00
{
2021-07-22 12:18:37 +08:00
Anchor = Anchor.CentreLeft,
Origin = Anchor.CentreLeft,
AutoSizeAxes = Axes.Both,
Child = modDisplay = new ModDisplay
{
Scale = new Vector2(0.4f),
ExpansionMode = ExpansionMode.AlwaysExpanded
}
2021-02-02 16:09:59 +08:00
}
2021-01-13 16:33:00 +08:00
}
}
}
2021-07-22 12:18:37 +08:00
},
buttonsFlow = new FillFlowContainer
2021-07-22 12:18:37 +08:00
{
Anchor = Anchor.CentreRight,
Origin = Anchor.CentreRight,
Direction = FillDirection.Horizontal,
2021-11-26 16:40:45 +08:00
Margin = new MarginPadding { Horizontal = 8 },
2021-07-22 12:18:37 +08:00
AutoSizeAxes = Axes.Both,
Spacing = new Vector2(5),
ChildrenEnumerable = createButtons().Select(button => button.With(b =>
2021-07-22 12:18:37 +08:00
{
b.Anchor = Anchor.Centre;
b.Origin = Anchor.Centre;
}))
2021-11-26 16:17:06 +08:00
},
ownerAvatar = new OwnerAvatar
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
2021-12-09 16:48:09 +08:00
Size = new Vector2(icon_height),
2021-11-26 16:40:45 +08:00
Margin = new MarginPadding { Right = 8 },
2021-11-26 16:17:06 +08:00
Masking = true,
CornerRadius = 4,
Alpha = ShowItemOwner ? 1 : 0
2021-11-26 16:17:06 +08:00
},
}
}
2021-02-02 16:09:59 +08:00
},
},
2021-02-02 16:09:59 +08:00
};
}
2022-02-16 14:51:18 +08:00
private IEnumerable<Drawable> createButtons() => new[]
2021-12-09 16:48:09 +08:00
{
2022-02-16 14:51:18 +08:00
showResultsButton = new GrayButton(FontAwesome.Solid.ChartPie)
{
2022-02-16 14:51:18 +08:00
Size = new Vector2(30, 30),
Action = () => RequestResults?.Invoke(Item),
Alpha = AllowShowingResults ? 1 : 0,
TooltipText = "View results"
},
beatmap == null ? Empty() : new PlaylistDownloadButton(beatmap),
editButton = new PlaylistEditButton
{
Size = new Vector2(30, 30),
Alpha = AllowEditing ? 1 : 0,
Action = () => RequestEdit?.Invoke(Item),
TooltipText = CommonStrings.ButtonsEdit
2022-02-16 14:51:18 +08:00
},
removeButton = new PlaylistRemoveButton
{
Size = new Vector2(30, 30),
Alpha = AllowDeletion ? 1 : 0,
Action = () => RequestDeletion?.Invoke(Item),
TooltipText = "Remove from playlist"
},
};
protected override bool OnClick(ClickEvent e)
{
if (AllowSelection && valid.Value)
2020-02-14 15:55:05 +08:00
SelectedItem.Value = Model;
return true;
}
public MenuItem[] ContextMenuItems
{
get
{
List<MenuItem> items = new List<MenuItem>();
if (beatmapOverlay != null)
items.Add(new OsuMenuItem("Details...", MenuItemType.Standard, () => beatmapOverlay.FetchAndShowBeatmap(Item.Beatmap.OnlineID)));
2022-07-27 14:59:36 +08:00
if (beatmap != null)
{
if (beatmaps.QueryBeatmap(b => b.OnlineID == beatmap.OnlineID) is BeatmapInfo local && !local.BeatmapSet.AsNonNull().DeletePending)
{
var collectionItems = realm.Realm.All<BeatmapCollection>().AsEnumerable().Select(c => new CollectionToggleMenuItem(c.ToLive(realm), beatmap)).Cast<OsuMenuItem>().ToList();
if (manageCollectionsDialog != null)
collectionItems.Add(new OsuMenuItem("Manage...", MenuItemType.Standard, manageCollectionsDialog.Show));
items.Add(new OsuMenuItem("Collections") { Items = collectionItems });
}
}
return items.ToArray();
}
}
public class PlaylistEditButton : GrayButton
{
public PlaylistEditButton()
: base(FontAwesome.Solid.Edit)
{
}
}
2021-12-09 23:38:18 +08:00
public class PlaylistRemoveButton : GrayButton
{
public PlaylistRemoveButton()
: base(FontAwesome.Solid.MinusSquare)
{
}
}
private sealed class PlaylistDownloadButton : BeatmapDownloadButton
{
private readonly IBeatmapInfo beatmap;
[Resolved]
private BeatmapManager beatmapManager { get; set; }
2021-10-27 20:26:26 +08:00
// required for download tracking, as this button hides itself. can probably be removed with a bit of consideration.
public override bool IsPresent => true;
private const float width = 50;
public PlaylistDownloadButton(IBeatmapInfo beatmap)
: base(beatmap.BeatmapSet)
{
this.beatmap = beatmap;
Size = new Vector2(width, 30);
Alpha = 0;
}
protected override void LoadComplete()
{
State.BindValueChanged(stateChanged, true);
// base implementation calls FinishTransforms, so should be run after the above state update.
base.LoadComplete();
}
private void stateChanged(ValueChangedEvent<DownloadState> state)
{
switch (state.NewValue)
{
case DownloadState.LocallyAvailable:
// Perform a local query of the beatmap by beatmap checksum, and reset the state if not matching.
if (beatmapManager.QueryBeatmap(b => b.MD5Hash == beatmap.MD5Hash) == null)
State.Value = DownloadState.NotDownloaded;
else
{
this.FadeTo(0, 500)
.ResizeWidthTo(0, 500, Easing.OutQuint);
}
break;
default:
this.ResizeWidthTo(width, 500, Easing.OutQuint)
.FadeTo(1, 500);
break;
}
}
}
// For now, this is the same implementation as in PanelBackground, but supports a beatmap info rather than a working beatmap
private class PanelBackground : Container // todo: should be a buffered container (https://github.com/ppy/osu-framework/issues/3222)
{
public readonly Bindable<IBeatmapInfo> Beatmap = new Bindable<IBeatmapInfo>();
public PanelBackground()
{
UpdateableBeatmapBackgroundSprite backgroundSprite;
InternalChildren = new Drawable[]
{
backgroundSprite = new UpdateableBeatmapBackgroundSprite
{
RelativeSizeAxes = Axes.Both,
FillMode = FillMode.Fill,
},
new FillFlowContainer
{
Depth = -1,
RelativeSizeAxes = Axes.Both,
Direction = FillDirection.Horizontal,
// This makes the gradient not be perfectly horizontal, but diagonal at a ~40° angle
Shear = new Vector2(0.8f, 0),
Alpha = 0.5f,
Children = new[]
{
// The left half with no gradient applied
new Box
{
RelativeSizeAxes = Axes.Both,
Colour = Color4.Black,
Width = 0.4f,
},
2021-02-03 05:05:25 +08:00
// Piecewise-linear gradient with 2 segments to make it appear smoother
new Box
{
RelativeSizeAxes = Axes.Both,
Colour = ColourInfo.GradientHorizontal(Color4.Black, new Color4(0f, 0f, 0f, 0.7f)),
Width = 0.4f,
},
new Box
{
RelativeSizeAxes = Axes.Both,
Colour = ColourInfo.GradientHorizontal(new Color4(0f, 0f, 0f, 0.7f), new Color4(0, 0, 0, 0.4f)),
Width = 0.4f,
},
}
}
};
// manual binding required as playlists don't expose IBeatmapInfo currently.
// may be removed in the future if this changes.
Beatmap.BindValueChanged(beatmap => backgroundSprite.Beatmap.Value = beatmap.NewValue);
}
}
2021-11-25 22:15:28 +08:00
private class OwnerAvatar : UpdateableAvatar, IHasTooltip
{
public OwnerAvatar()
{
AddInternal(new TooltipArea(this)
{
RelativeSizeAxes = Axes.Both,
Depth = -1
});
}
public LocalisableString TooltipText => User == null ? string.Empty : $"queued by {User.Username}";
2021-11-25 22:15:28 +08:00
private class TooltipArea : Component, IHasTooltip
{
private readonly OwnerAvatar avatar;
public TooltipArea(OwnerAvatar avatar)
{
this.avatar = avatar;
}
public LocalisableString TooltipText => avatar.TooltipText;
}
}
}
}