1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-26 02:22:54 +08:00
osu-lazer/osu.Game/Screens/Select/BeatmapCarousel.cs

595 lines
22 KiB
C#
Raw Normal View History

// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
2016-12-06 17:56:20 +08:00
using OpenTK;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using System;
using System.Collections.Generic;
using System.Linq;
using osu.Game.Configuration;
using osu.Framework.Input;
using OpenTK.Input;
using osu.Framework.MathUtils;
using System.Diagnostics;
using System.Threading.Tasks;
using osu.Framework.Allocation;
2017-12-12 16:48:38 +08:00
using osu.Framework.Caching;
using osu.Framework.Threading;
using osu.Framework.Configuration;
2017-12-14 19:40:58 +08:00
using osu.Framework.Extensions.IEnumerableExtensions;
2017-07-26 12:22:46 +08:00
using osu.Game.Beatmaps;
using osu.Game.Graphics.Containers;
2017-09-14 14:41:32 +08:00
using osu.Game.Graphics.Cursor;
2017-12-12 16:48:38 +08:00
using osu.Game.Screens.Select.Carousel;
2016-11-25 17:14:56 +08:00
namespace osu.Game.Screens.Select
{
public class BeatmapCarousel : OsuScrollContainer
{
2017-12-13 18:56:16 +08:00
/// <summary>
/// Triggered when the <see cref="BeatmapSets"/> loaded change and are completely loaded.
2017-12-13 18:56:16 +08:00
/// </summary>
public Action BeatmapSetsChanged;
2017-12-13 18:56:16 +08:00
/// <summary>
/// The currently selected beatmap.
/// </summary>
2017-12-12 16:48:38 +08:00
public BeatmapInfo SelectedBeatmap => selectedBeatmap?.Beatmap;
private CarouselBeatmap selectedBeatmap => selectedBeatmapSet?.Beatmaps.FirstOrDefault(s => s.State == CarouselItemState.Selected);
/// <summary>
/// The currently selected beatmap set.
/// </summary>
public BeatmapSetInfo SelectedBeatmapSet => selectedBeatmapSet?.BeatmapSet;
private CarouselBeatmapSet selectedBeatmapSet;
2017-12-13 18:56:16 +08:00
/// <summary>
/// Raised when the <see cref="SelectedBeatmap"/> is changed.
/// </summary>
public Action<BeatmapInfo> SelectionChanged;
2017-12-13 18:56:16 +08:00
public override bool HandleInput => AllowSelection;
/// <summary>
2017-12-27 22:14:48 +08:00
/// Used to avoid firing null selections before the initial beatmaps have been loaded via <see cref="BeatmapSets"/>.
/// </summary>
private bool initialLoadComplete;
2017-12-18 10:57:13 +08:00
private IEnumerable<CarouselBeatmapSet> beatmapSets => root.Children.OfType<CarouselBeatmapSet>();
2017-12-14 12:49:43 +08:00
public IEnumerable<BeatmapSetInfo> BeatmapSets
{
2017-12-14 12:49:43 +08:00
get { return beatmapSets.Select(g => g.BeatmapSet); }
set
{
CarouselGroup newRoot = new CarouselGroupEagerSelect();
2017-12-14 19:40:58 +08:00
Task.Run(() =>
{
2017-12-14 19:40:58 +08:00
value.Select(createCarouselSet).Where(g => g != null).ForEach(newRoot.AddChild);
2017-12-16 15:27:39 +08:00
newRoot.Filter(activeCriteria);
// preload drawables as the ctor overhead is quite high currently.
2017-12-18 07:05:57 +08:00
var _ = newRoot.Drawables;
}).ContinueWith(_ => Schedule(() =>
{
2017-12-18 07:05:57 +08:00
root = newRoot;
scrollableContent.Clear(false);
itemsCache.Invalidate();
scrollPositionCache.Invalidate();
Schedule(() =>
{
BeatmapSetsChanged?.Invoke();
initialLoadComplete = true;
});
2017-12-18 07:05:57 +08:00
}));
}
}
private readonly List<float> yPositions = new List<float>();
private Cached itemsCache = new Cached();
private Cached scrollPositionCache = new Cached();
2017-12-12 16:48:38 +08:00
private readonly Container<DrawableCarouselItem> scrollableContent;
public Bindable<RandomSelectAlgorithm> RandomAlgorithm = new Bindable<RandomSelectAlgorithm>();
private readonly List<CarouselBeatmapSet> previouslyVisitedRandomSets = new List<CarouselBeatmapSet>();
private readonly Stack<CarouselBeatmap> randomSelectedBeatmaps = new Stack<CarouselBeatmap>();
2017-12-13 20:08:12 +08:00
protected List<DrawableCarouselItem> Items = new List<DrawableCarouselItem>();
private CarouselGroup root = new CarouselGroupEagerSelect();
2016-11-21 14:59:46 +08:00
2017-03-17 18:12:54 +08:00
public BeatmapCarousel()
2017-01-18 08:18:15 +08:00
{
2017-12-14 12:49:43 +08:00
Child = new OsuContextMenuContainer
2017-01-18 08:18:15 +08:00
{
RelativeSizeAxes = Axes.X,
2017-09-14 14:41:32 +08:00
AutoSizeAxes = Axes.Y,
2017-12-12 16:48:38 +08:00
Child = scrollableContent = new Container<DrawableCarouselItem>
2017-09-14 14:41:32 +08:00
{
RelativeSizeAxes = Axes.X,
}
2017-12-14 12:49:43 +08:00
};
2017-01-18 08:18:15 +08:00
}
[BackgroundDependencyLoader(permitNulls: true)]
private void load(OsuConfigManager config)
{
config.BindWith(OsuSetting.RandomSelectAlgorithm, RandomAlgorithm);
}
2017-12-13 18:56:16 +08:00
public void RemoveBeatmapSet(BeatmapSetInfo beatmapSet)
{
Schedule(() =>
{
var existingSet = beatmapSets.FirstOrDefault(b => b.BeatmapSet.ID == beatmapSet.ID);
if (existingSet == null)
return;
root.RemoveChild(existingSet);
itemsCache.Invalidate();
});
}
public void UpdateBeatmapSet(BeatmapSetInfo beatmapSet)
{
Schedule(() =>
{
CarouselBeatmapSet existingSet = beatmapSets.FirstOrDefault(b => b.BeatmapSet.ID == beatmapSet.ID);
2017-12-12 16:48:38 +08:00
bool hadSelection = existingSet?.State?.Value == CarouselItemState.Selected;
var newSet = createCarouselSet(beatmapSet);
if (existingSet != null)
root.RemoveChild(existingSet);
if (newSet == null)
{
itemsCache.Invalidate();
return;
}
root.AddChild(newSet);
applyActiveCriteria(false, false);
//check if we can/need to maintain our current selection.
if (hadSelection)
select((CarouselItem)newSet.Beatmaps.FirstOrDefault(b => b.Beatmap.ID == selectedBeatmap?.Beatmap.ID) ?? newSet);
itemsCache.Invalidate();
Schedule(() => BeatmapSetsChanged?.Invoke());
});
}
2017-12-16 15:27:39 +08:00
public void SelectBeatmap(BeatmapInfo beatmap)
{
if (beatmap?.Hidden != false)
return;
2017-12-14 12:49:43 +08:00
foreach (CarouselBeatmapSet group in beatmapSets)
{
2017-12-12 16:48:38 +08:00
var item = group.Beatmaps.FirstOrDefault(p => p.Beatmap.Equals(beatmap));
if (item != null)
{
2017-12-13 11:46:02 +08:00
select(item);
return;
}
}
}
/// <summary>
/// Increment selection in the carousel in a chosen direction.
/// </summary>
/// <param name="direction">The direction to increment. Negative is backwards.</param>
/// <param name="skipDifficulties">Whether to skip individual difficulties and only increment over full groups.</param>
public void SelectNext(int direction = 1, bool skipDifficulties = true)
{
if (!Items.Any())
return;
DrawableCarouselItem drawable = null;
if (selectedBeatmap != null && (drawable = selectedBeatmap.Drawables.FirstOrDefault()) == null)
// if the selected beatmap isn't present yet, we can't correctly change selection.
// we can fix this by changing this method to not reference drawables / Items in the first place.
2017-12-28 10:35:53 +08:00
return;
int originalIndex = Items.IndexOf(drawable);
int currentIndex = originalIndex;
// local function to increment the index in the required direction, wrapping over extremities.
2017-12-13 20:08:12 +08:00
int incrementIndex() => currentIndex = (currentIndex + direction + Items.Count) % Items.Count;
2017-12-12 16:48:38 +08:00
while (incrementIndex() != originalIndex)
{
2017-12-13 20:08:12 +08:00
var item = Items[currentIndex].Item;
2017-05-22 07:53:36 +08:00
2017-12-12 16:48:38 +08:00
if (item.Filtered || item.State == CarouselItemState.Selected) continue;
2017-12-12 16:48:38 +08:00
switch (item)
{
2017-12-12 16:48:38 +08:00
case CarouselBeatmap beatmap:
if (skipDifficulties) continue;
select(beatmap);
return;
case CarouselBeatmapSet set:
if (skipDifficulties)
select(set);
else
select(direction > 0 ? set.Beatmaps.First(b => !b.Filtered) : set.Beatmaps.Last(b => !b.Filtered));
2017-12-12 16:48:38 +08:00
return;
}
2017-12-12 16:48:38 +08:00
}
}
/// <summary>
/// Select the next beatmap in the random sequence.
/// </summary>
/// <returns>True if a selection could be made, else False.</returns>
public bool SelectNextRandom()
{
var visible = beatmapSets.Where(s => !s.Filtered).ToList();
if (!visible.Any())
return false;
2017-12-12 16:48:38 +08:00
if (selectedBeatmap != null)
{
2017-12-12 16:48:38 +08:00
randomSelectedBeatmaps.Push(selectedBeatmap);
// when performing a random, we want to add the current set to the previously visited list
// else the user may be "randomised" to the existing selection.
if (previouslyVisitedRandomSets.LastOrDefault() != selectedBeatmapSet)
previouslyVisitedRandomSets.Add(selectedBeatmapSet);
}
CarouselBeatmapSet set;
2017-06-02 01:54:42 +08:00
if (RandomAlgorithm == RandomSelectAlgorithm.RandomPermutation)
{
var notYetVisitedSets = visible.Except(previouslyVisitedRandomSets).ToList();
if (!notYetVisitedSets.Any())
2017-06-01 02:31:05 +08:00
{
previouslyVisitedRandomSets.Clear();
notYetVisitedSets = visible;
}
set = notYetVisitedSets.ElementAt(RNG.Next(notYetVisitedSets.Count));
previouslyVisitedRandomSets.Add(set);
}
else
set = visible.ElementAt(RNG.Next(visible.Count));
2017-12-14 19:40:58 +08:00
select(set.Beatmaps.Skip(RNG.Next(set.Beatmaps.Count())).FirstOrDefault());
return true;
}
2017-06-05 17:24:28 +08:00
public void SelectPreviousRandom()
2017-06-02 01:54:42 +08:00
{
2017-06-05 17:24:28 +08:00
while (randomSelectedBeatmaps.Any())
2017-06-02 01:54:42 +08:00
{
2017-12-12 16:48:38 +08:00
var beatmap = randomSelectedBeatmaps.Pop();
if (!beatmap.Filtered)
2017-06-02 01:54:42 +08:00
{
if (RandomAlgorithm == RandomSelectAlgorithm.RandomPermutation)
previouslyVisitedRandomSets.Remove(selectedBeatmapSet);
2017-12-12 16:48:38 +08:00
select(beatmap);
2017-06-02 01:54:42 +08:00
break;
}
}
}
private void select(CarouselItem item)
{
if (item == null) return;
item.State.Value = CarouselItemState.Selected;
}
2017-12-16 15:27:39 +08:00
private FilterCriteria activeCriteria = new FilterCriteria();
2017-12-13 20:08:12 +08:00
protected ScheduledDelegate FilterTask;
public bool AllowSelection = true;
2017-12-16 15:27:39 +08:00
public void FlushPendingFilterOperations()
2017-07-21 16:20:52 +08:00
{
2017-12-13 20:08:12 +08:00
if (FilterTask?.Completed == false)
applyActiveCriteria(false, false);
2017-07-21 16:20:52 +08:00
}
2017-12-16 15:27:39 +08:00
public void Filter(FilterCriteria newCriteria, bool debounce = true)
{
if (newCriteria != null)
2017-12-16 15:27:39 +08:00
activeCriteria = newCriteria;
applyActiveCriteria(debounce, true);
2017-12-16 15:27:39 +08:00
}
private void applyActiveCriteria(bool debounce, bool scroll)
2017-12-16 15:27:39 +08:00
{
2017-12-18 10:57:13 +08:00
if (root.Children.Any() != true) return;
void perform()
2016-11-25 17:14:56 +08:00
{
2017-12-13 20:08:12 +08:00
FilterTask = null;
2017-12-16 15:27:39 +08:00
root.Filter(activeCriteria);
itemsCache.Invalidate();
if (scroll) scrollPositionCache.Invalidate();
}
2017-12-13 20:08:12 +08:00
FilterTask?.Cancel();
FilterTask = null;
if (debounce)
2017-12-13 20:08:12 +08:00
FilterTask = Scheduler.AddDelayed(perform, 250);
else
perform();
}
2017-12-17 01:33:01 +08:00
private float? scrollTarget;
public void ScrollToSelected() => scrollPositionCache.Invalidate();
2017-07-29 21:03:17 +08:00
protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
{
int direction = 0;
bool skipDifficulties = false;
switch (args.Key)
{
case Key.Up:
direction = -1;
break;
case Key.Down:
direction = 1;
break;
case Key.Left:
direction = -1;
skipDifficulties = true;
break;
case Key.Right:
direction = 1;
skipDifficulties = true;
break;
}
if (direction == 0)
return base.OnKeyDown(state, args);
SelectNext(direction, skipDifficulties);
return true;
}
protected override void Update()
{
base.Update();
if (!itemsCache.IsValid)
updateItems();
if (!scrollPositionCache.IsValid)
updateScrollPosition();
float drawHeight = DrawHeight;
// Remove all items that should no longer be on-screen
scrollableContent.RemoveAll(p => p.Y < Current - p.DrawHeight || p.Y > Current + drawHeight || !p.IsPresent);
// Find index range of all items that should be on-screen
Trace.Assert(Items.Count == yPositions.Count);
int firstIndex = yPositions.BinarySearch(Current - DrawableCarouselItem.MAX_HEIGHT);
if (firstIndex < 0) firstIndex = ~firstIndex;
int lastIndex = yPositions.BinarySearch(Current + drawHeight);
if (lastIndex < 0) lastIndex = ~lastIndex;
int notVisibleCount = 0;
// Add those items within the previously found index range that should be displayed.
for (int i = firstIndex; i < lastIndex; ++i)
{
DrawableCarouselItem item = Items[i];
if (!item.Item.Visible)
{
if (!item.IsPresent)
notVisibleCount++;
continue;
}
// Only add if we're not already part of the content.
if (!scrollableContent.Contains(item))
{
// Makes sure headers are always _below_ items,
// and depth flows downward.
item.Depth = i + (item is DrawableCarouselBeatmapSet ? -Items.Count : 0);
switch (item.LoadState)
{
case LoadState.NotLoaded:
LoadComponentAsync(item);
break;
case LoadState.Loading:
break;
default:
scrollableContent.Add(item);
break;
}
}
}
// this is not actually useful right now, but once we have groups may well be.
if (notVisibleCount > 50)
itemsCache.Invalidate();
// Update externally controlled state of currently visible items
// (e.g. x-offset and opacity).
float halfHeight = drawHeight / 2;
foreach (DrawableCarouselItem p in scrollableContent.Children)
updateItem(p, halfHeight);
}
private CarouselBeatmapSet createCarouselSet(BeatmapSetInfo beatmapSet)
{
if (beatmapSet.Beatmaps.All(b => b.Hidden))
return null;
2017-12-12 16:48:38 +08:00
// todo: remove the need for this.
2017-06-07 19:53:37 +08:00
foreach (var b in beatmapSet.Beatmaps)
2017-04-18 09:04:32 +08:00
{
if (b.Metadata == null)
b.Metadata = beatmapSet.Metadata;
2017-05-06 15:37:53 +08:00
}
2017-12-12 16:48:38 +08:00
var set = new CarouselBeatmapSet(beatmapSet);
foreach (var c in set.Beatmaps)
{
2017-12-12 16:48:38 +08:00
c.State.ValueChanged += v =>
{
if (v == CarouselItemState.Selected)
{
selectedBeatmapSet = set;
2017-12-12 16:48:38 +08:00
SelectionChanged?.Invoke(c.Beatmap);
itemsCache.Invalidate();
scrollPositionCache.Invalidate();
2017-12-12 16:48:38 +08:00
}
};
}
return set;
}
/// <summary>
2017-12-12 16:48:38 +08:00
/// Computes the target Y positions for every item in the carousel.
/// </summary>
2017-12-12 16:48:38 +08:00
/// <returns>The Y position of the currently selected item.</returns>
private void updateItems()
{
Items = root.Drawables.ToList();
yPositions.Clear();
2016-11-21 14:59:46 +08:00
float currentY = DrawHeight / 2;
2017-12-17 01:33:01 +08:00
DrawableCarouselBeatmapSet lastSet = null;
2016-11-21 14:59:46 +08:00
2017-12-17 01:33:01 +08:00
scrollTarget = null;
2017-12-13 20:08:12 +08:00
foreach (DrawableCarouselItem d in Items)
2017-12-12 16:48:38 +08:00
{
2017-12-17 01:33:01 +08:00
if (d.IsPresent)
{
2017-12-17 01:33:01 +08:00
switch (d)
{
case DrawableCarouselBeatmapSet set:
lastSet = set;
set.MoveToX(set.Item.State == CarouselItemState.Selected ? -100 : 0, 500, Easing.OutExpo);
set.MoveToY(currentY, 750, Easing.OutExpo);
2017-12-17 01:33:01 +08:00
break;
case DrawableCarouselBeatmap beatmap:
if (beatmap.Item.State.Value == CarouselItemState.Selected)
scrollTarget = currentY + beatmap.DrawHeight / 2 - DrawHeight / 2;
void performMove(float y, float? startY = null)
{
if (startY != null) beatmap.MoveTo(new Vector2(0, startY.Value));
beatmap.MoveToX(beatmap.Item.State == CarouselItemState.Selected ? -50 : 0, 500, Easing.OutExpo);
beatmap.MoveToY(y, 750, Easing.OutExpo);
2017-12-17 01:33:01 +08:00
}
Debug.Assert(lastSet != null);
float? setY = null;
if (!d.IsLoaded || beatmap.Alpha == 0) // can't use IsPresent due to DrawableCarouselItem override.
setY = lastSet.Y + lastSet.DrawHeight + 5;
if (d.IsLoaded)
performMove(currentY, setY);
else
{
float y = currentY;
d.OnLoadComplete = _ => performMove(y, setY);
}
2017-12-17 01:33:01 +08:00
break;
}
}
2017-12-13 11:46:02 +08:00
yPositions.Add(currentY);
if (d.Item.Visible)
currentY += d.DrawHeight + 5;
}
2016-11-21 14:59:46 +08:00
currentY += DrawHeight / 2;
scrollableContent.Height = currentY;
if (initialLoadComplete && (selectedBeatmapSet == null || selectedBeatmap == null || selectedBeatmapSet.State.Value != CarouselItemState.Selected))
{
selectedBeatmapSet = null;
SelectionChanged?.Invoke(null);
}
itemsCache.Validate();
2016-11-21 14:59:46 +08:00
}
private void updateScrollPosition()
{
if (scrollTarget != null) ScrollTo(scrollTarget.Value);
scrollPositionCache.Validate();
}
/// <summary>
2017-12-12 16:48:38 +08:00
/// Computes the x-offset of currently visible items. Makes the carousel appear round.
/// </summary>
/// <param name="dist">
/// Vertical distance from the center of the carousel container
/// ranging from -1 to 1.
/// </param>
/// <param name="halfHeight">Half the height of the carousel container.</param>
private static float offsetX(float dist, float halfHeight)
{
// The radius of the circle the carousel moves on.
const float circle_radius = 3;
double discriminant = Math.Max(0, circle_radius * circle_radius - dist * dist);
float x = (circle_radius - (float)Math.Sqrt(discriminant)) * halfHeight;
return 125 + x;
}
/// <summary>
2017-12-12 16:48:38 +08:00
/// Update a item's x position and multiplicative alpha based on its y position and
/// the current scroll position.
/// </summary>
2017-12-12 16:48:38 +08:00
/// <param name="p">The item to be updated.</param>
/// <param name="halfHeight">Half the draw height of the carousel container.</param>
2017-12-12 16:48:38 +08:00
private void updateItem(DrawableCarouselItem p, float halfHeight)
{
var height = p.IsPresent ? p.DrawHeight : 0;
2017-12-12 16:48:38 +08:00
float itemDrawY = p.Position.Y - Current + height / 2;
float dist = Math.Abs(1f - itemDrawY / halfHeight);
2017-03-04 21:05:02 +08:00
// Setting the origin position serves as an additive position on top of potential
2017-12-12 16:48:38 +08:00
// local transformation we may want to apply (e.g. when a item gets selected, we
// may want to smoothly transform it leftwards.)
p.OriginPosition = new Vector2(-offsetX(dist, halfHeight), 0);
2017-03-04 21:05:02 +08:00
// We are applying a multiplicative alpha (which is internally done by nesting an
// additional container and setting that container's alpha) such that we can
// layer transformations on top, with a similar reasoning to the previous comment.
p.SetMultiplicativeAlpha(MathHelper.Clamp(1.75f - 1.5f * dist, 0, 1));
}
}
}