/// <summary>
/// Populate word storage with the words in the song name, sub-name, author, and map creator of a level pack.
/// </summary>
/// <param name="levelPack">The level pack whose words you want to store.</param>
public void SetupStorage(IAnnotatedBeatmapLevelCollection levelPack)
{
IsLoading = true;
_manualResetEvent = new ManualResetEvent(true);
_taskCancelled = false;
_task = new HMTask(
delegate()
{
var sw = System.Diagnostics.Stopwatch.StartNew();
Logger.log.Info($"Creating word count storage object for the \"{levelPack.collectionName}\" level pack (contains {levelPack.beatmapLevelCollection.beatmapLevels.Length} songs)");
if (!SetWordsFromLevelPack(levelPack))
{
return;
}
sw.Stop();
Logger.log.Info($"Finished creating word count storage object for the \"{levelPack.collectionName}\" level pack (took {sw.ElapsedMilliseconds/1000f} seconds, {_words.Count} unique words processed)");
},
delegate()
{
_manualResetEvent = null;
_task = null;
IsLoading = false;
});
_task.Run();
}
public static void OnSpriteLoaded(object sender, EventArgs e)
{
if (sender is IDeferredSpriteLoad deferredSpriteLoad)
{
if (EventTable.TryGetValue(deferredSpriteLoad, out AnnotatedBeatmapLevelCollectionTableCell tableCell))
{
IAnnotatedBeatmapLevelCollection collection = BeatmapCollectionAccessor(ref tableCell);
if (collection == deferredSpriteLoad)
{
#if DEBUG
Plugin.Log.Debug($"Updating image for {collection.collectionName}");
#endif
CoverImageAccessor(ref tableCell).sprite = deferredSpriteLoad.Sprite;
}
else
{
Plugin.Log.Warn($"Collection '{collection.collectionName}' is not {(deferredSpriteLoad as IAnnotatedBeatmapLevelCollection).collectionName}");
EventTable.Remove(deferredSpriteLoad);
deferredSpriteLoad.SpriteLoaded -= OnSpriteLoaded;
}
}
else
{
Plugin.Log.Warn($"{(deferredSpriteLoad as IAnnotatedBeatmapLevelCollection).collectionName} is not in the EventTable.");
deferredSpriteLoad.SpriteLoaded -= OnSpriteLoaded;
}
}
else
{
Plugin.Log.Warn($"Wrong sender type for deferred sprite load: {sender?.GetType().Name ?? "<NULL>"}");
}
}
/// <summary>
/// Select a level collection.
/// </summary>
/// <param name="levelCollectionName"></param>
public void SelectLevelCollection(String levelCollectionName)
{
Logger.Trace("SelectLevelCollection({0})", levelCollectionName);
try
{
IAnnotatedBeatmapLevelCollection collection = GetLevelCollectionByName(levelCollectionName);
if (collection == null)
{
Logger.Debug("Could not locate requested level collection...");
return;
}
Logger.Info("Selecting level collection: {0}", collection.collectionName);
LevelFilteringNavigationController.SelectBeatmapLevelPackOrPlayList(collection as IBeatmapLevelPack, collection as IPlaylist);
LevelFilteringNavigationController.TabBarDidSwitch();
Logger.Debug("Done selecting level collection!");
}
catch (Exception e)
{
Logger.Exception(e);
}
}
internal static void Prefix(ref IAnnotatedBeatmapLevelCollection[] annotatedBeatmapLevelCollections)
{
// Check if annotatedBeatmapLevelCollections is empty (Versus Tab)
if (annotatedBeatmapLevelCollections.Length == 0)
{
return;
}
// Checks if this is the playlists view
if (annotatedBeatmapLevelCollections[0] is CustomBeatmapLevelPack)
{
isCustomBeatmapLevelPack = true;
IAnnotatedBeatmapLevelCollection[] allCustomBeatmapLevelCollections = new IAnnotatedBeatmapLevelCollection[LoadedPlaylists.Length + annotatedBeatmapLevelCollections.Length];
otherCustomBeatmapLevelCollections = new IAnnotatedBeatmapLevelCollection[annotatedBeatmapLevelCollections.Length];
for (int i = 0; i < annotatedBeatmapLevelCollections.Length; i++)
{
allCustomBeatmapLevelCollections[i] = annotatedBeatmapLevelCollections[i];
otherCustomBeatmapLevelCollections[i] = annotatedBeatmapLevelCollections[i];
}
int j = 0;
for (int i = annotatedBeatmapLevelCollections.Length; i < allCustomBeatmapLevelCollections.Length; i++)
{
allCustomBeatmapLevelCollections[i] = LoadedPlaylists[j++];
}
annotatedBeatmapLevelCollections = allCustomBeatmapLevelCollections;
}
else
{
isCustomBeatmapLevelPack = false;
}
}
private static void Postfix(AnnotatedBeatmapLevelCollectionCell __instance, IAnnotatedBeatmapLevelCollection ____annotatedBeatmapLevelCollection)
{
if (____annotatedBeatmapLevelCollection is CustomBeatmapLevelPack)
{
__instance.SetDownloadIconVisible(false);
}
}
private void DismissFilterFlowCoordinator()
{
_freePlayFlowCoordinator.InvokeMethod("DismissFlowCoordinator", _filterFlowCoordinator, null, false);
ButtonPanel.instance.ShowPanel();
// instead of applying filters inside the filter flow coordinator, apply the filters when the flow coordinator is dismissed
// that way, we don't get the unity complaining about the LevelSelectionNavigationController being not active
if (SongBrowserTweaks.Initialized && FilterList.AnyApplied)
{
SongBrowserTweaks.ApplyFilters();
}
else if (_levelsToApply != null)
{
// NOTE: levels should already be sorted
LevelSelectionNavigationController.SetData(
_levelsToApply,
true,
LevelSelectionNavigationController.GetPrivateField <bool>("_showPlayerStatsInDetailView"),
LevelSelectionNavigationController.GetPrivateField <bool>("_showPracticeButtonInDetailView"),
null);
_levelsToApply = null;
if (_uiAdditions != null)
{
_uiAdditions.RefreshPageButtons();
}
}
}
/// <summary>
/// Get level collection by level collection name.
/// </summary>
/// <param name="levelCollectionName"></param>
/// <returns></returns>
public IAnnotatedBeatmapLevelCollection GetLevelCollectionByName(String levelCollectionName)
{
IAnnotatedBeatmapLevelCollection levelCollection = null;
// search level packs
foreach (IBeatmapLevelPack o in BeatmapLevelsModel.allLoadedBeatmapLevelPackCollection.beatmapLevelPacks)
{
if (String.Equals(o.collectionName, levelCollectionName))
{
levelCollection = o;
break;
}
}
// search playlists
if (levelCollection == null)
{
IAnnotatedBeatmapLevelCollection[] _annotatedBeatmapLevelCollections = AnnotatedBeatmapLevelCollectionsViewController.GetPrivateField <IAnnotatedBeatmapLevelCollection[]>("_annotatedBeatmapLevelCollections");
foreach (IAnnotatedBeatmapLevelCollection c in _annotatedBeatmapLevelCollections)
{
if (String.Equals(c.collectionName, levelCollectionName))
{
levelCollection = c;
break;
}
}
}
return(levelCollection);
}
private void ApplyQuickFilterPressed(QuickFilter quickFilter)
{
FilterList.ApplyQuickFilter(quickFilter);
IPreviewBeatmapLevel[] unfilteredLevels = null;
if (_lastPack == null)
{
_lastPack = LevelSelectionNavigationController.GetPrivateField <IBeatmapLevelPack>("_levelPack");
}
if (_lastPack == null)
{
unfilteredLevels = _levelCollectionTableView.GetPrivateField <IPreviewBeatmapLevel[]>("_previewBeatmapLevels");
}
else
{
unfilteredLevels = _lastPack.beatmapLevelCollection.beatmapLevels;
}
if (unfilteredLevels == null)
{
Logger.log.Warn("Unable to apply quick filter (could not find songs to filter)");
return;
}
_filteredLevelPack.SetupFromUnfilteredLevels(unfilteredLevels);
LevelSelectionNavigationController.SetData(
_filteredLevelPack,
true,
LevelSelectionNavigationController.GetPrivateField <bool>("_showPlayerStatsInDetailView"),
LevelSelectionNavigationController.GetPrivateField <bool>("_showPracticeButtonInDetailView"));
ButtonPanel.instance.SetFilterStatus(true);
}
/// <summary>
/// Get level collection by level collection name.
/// </summary>
/// <param name="levelCollectionName"></param>
/// <returns></returns>
public IAnnotatedBeatmapLevelCollection GetLevelCollectionByName(String levelCollectionName)
{
IAnnotatedBeatmapLevelCollection levelCollection = null;
// search level packs
BeatmapLevelPackCollectionSO beatMapLevelPackCollection = Resources.FindObjectsOfTypeAll <BeatmapLevelPackCollectionSO>().Last();
IBeatmapLevelPack[] levelPacks = beatMapLevelPackCollection.GetField <IBeatmapLevelPack[], BeatmapLevelPackCollectionSO>("_allBeatmapLevelPacks");
foreach (IBeatmapLevelPack o in levelPacks)
{
if (String.Equals(o.collectionName, levelCollectionName))
{
levelCollection = o;
break;
}
}
// search playlists
if (levelCollection == null)
{
IReadOnlyList <IAnnotatedBeatmapLevelCollection> _annotatedBeatmapLevelCollections = AnnotatedBeatmapLevelCollectionsViewController.GetField <IReadOnlyList <IAnnotatedBeatmapLevelCollection>, AnnotatedBeatmapLevelCollectionsViewController>("_annotatedBeatmapLevelCollections");
foreach (IAnnotatedBeatmapLevelCollection c in _annotatedBeatmapLevelCollections)
{
if (String.Equals(c.collectionName, levelCollectionName))
{
levelCollection = c;
break;
}
}
}
return(levelCollection);
}
private void FilterFlowCoordinatorFiltersUnapplied()
{
if (SongBrowserTweaks.ModLoaded)
{
SongBrowserTweaks.FiltersUnapplied();
}
else
{
if (_lastPack != null)
{
if (!SongSortModule.IsDefaultSort)
{
_levelsToApply = _sortedLevelsLevelPack.SetupFromLevelCollection(_lastPack);
}
else
{
_levelsToApply = _lastPack;
}
}
else // this should never happen (_lastPack should always be defined by this point)
{
Logger.log.Warn("Unable to unapply filters (could not find previous level pack)");
}
ButtonPanel.instance.SetFilterStatus(false);
}
}
private void DidSelectAnnotatedBeatmapLevelCollectionEvent(IAnnotatedBeatmapLevelCollection annotatedBeatmapLevelCollection)
{
if (annotatedBeatmapLevelCollection is BeatSaberPlaylistsLib.Types.IPlaylist)
{
Events.RaisePlaylistSelected((BeatSaberPlaylistsLib.Types.IPlaylist)annotatedBeatmapLevelCollection);
}
levelCollectionUpdater.LevelCollectionUpdated();
}
private void SelectAnnotatedBeatmapCollectionByIdx(int index)
{
annotatedBeatmapLevelCollectionsViewController.SetData(AnnotatedBeatmapLevelCollectionsViewController_SetData.otherCustomBeatmapLevelCollections, index, false);
IAnnotatedBeatmapLevelCollection selectedCollection = annotatedBeatmapLevelCollectionsViewController.selectedAnnotatedBeatmapLevelCollection;
levelCollectionViewController.SetData(selectedCollection.beatmapLevelCollection, selectedCollection.collectionName, selectedCollection.coverImage, false, null);
levelPackDetailViewController.SetData((IBeatmapLevelPack)selectedCollection);
didSelectAnnotatedBeatmapLevelCollectionEvent?.Invoke(selectedCollection);
}
/// <summary>
/// Presents this flow coordinator and sets search space.
/// This must be used instead of invoking the private PresentFlowCoordinator to ensure the list of levels is provided.
/// </summary>
/// <param name="parentFlowCoordinator">The flow coordinator that will be immediately higher in the hierarchy that will present this flow coordinator.</param>
/// <param name="levels">The list of levels that will be used as the search space.</param>
public void Activate(FlowCoordinator parentFlowCoordinator, IAnnotatedBeatmapLevelCollection levelPack)
{
_levelsSearchSpace = levelPack.beatmapLevelCollection.beatmapLevels;
Action onFinish = PushInitialViewControllersToNavigationController;
parentFlowCoordinator.PresentFlowCoordinator(this, onFinish);
WordPredictionEngine.instance.SetActiveWordStorageFromLevelPack(levelPack);
}
internal async System.Threading.Tasks.Task DownloadPlaylistAsync()
{
IAnnotatedBeatmapLevelCollection selectedPlaylist = annotatedBeatmapLevelCollectionsViewController.selectedAnnotatedBeatmapLevelCollection;
List <IPlaylistSong> missingSongs;
if (selectedPlaylist is BlistPlaylist)
{
missingSongs = ((BlistPlaylist)selectedPlaylist).Where(s => s.PreviewBeatmapLevel == null).Select(s => s).ToList();
}
else if (selectedPlaylist is LegacyPlaylist)
{
missingSongs = ((LegacyPlaylist)selectedPlaylist).Where(s => s.PreviewBeatmapLevel == null).Select(s => s).ToList();
}
else
{
modalMessage.text = "Error: The selected playlist cannot be downloaded.";
modalState = ModalState.OkModal;
modal.Show(true);
return;
}
modalMessage.text = string.Format("{0}/{1} songs downloaded", 0, missingSongs.Count);
modalState = ModalState.DownloadingModal;
modal.Show(true);
tokenSource.Dispose();
tokenSource = new CancellationTokenSource();
for (int i = 0; i < missingSongs.Count; i++)
{
try
{
if (!string.IsNullOrEmpty(missingSongs[i].Key))
{
await DownloaderUtils.instance.BeatmapDownloadByKey(missingSongs[i].Key, tokenSource.Token);
}
else if (!string.IsNullOrEmpty(missingSongs[i].Hash))
{
await DownloaderUtils.instance.BeatmapDownloadByHash(missingSongs[i].Hash, tokenSource.Token);
}
modalMessage.text = string.Format("{0}/{1} songs downloaded", i + 1, missingSongs.Count);
}
catch (Exception e)
{
if (e is TaskCanceledException)
{
Plugin.Log.Warn("Song Download Aborted.");
}
else
{
Plugin.Log.Critical("Failed to download Song!");
}
break;
}
}
modal.Hide(true);
SongCore.Loader.Instance.RefreshSongs(false);
downloadingBeatmapCollectionIdx = annotatedBeatmapLevelCollectionsViewController.selectedItemIndex;
LevelFilteringNavigationController_UpdateSecondChildControllerContent.SecondChildControllerUpdatedEvent += LevelFilteringNavigationController_UpdateSecondChildControllerContent_SecondChildControllerUpdatedEvent;
}
private void SortButtonPressed()
{
if (_lastPack == null)
{
_lastPack = LevelSelectionNavigationController.GetPrivateField <IBeatmapLevelPack>("_levelPack");
}
if (FilterList.AnyApplied)
{
_filteredLevelPack.SetupFromUnfilteredLevels(_lastPack.beatmapLevelCollection.beatmapLevels, _lastPack.coverImage, false);
LevelSelectionNavigationController.SetData(_filteredLevelPack,
true,
LevelSelectionNavigationController.GetPrivateField <bool>("_showPlayerStatsInDetailView"),
LevelSelectionNavigationController.GetPrivateField <bool>("_showPracticeButtonInDetailView"));
}
else
{
if (_lastPack != null && _lastPack is IBeatmapLevelPack beatmapLevelPack)
{
LevelSelectionNavigationController.SetData(
_sortedLevelsLevelPack.SetupFromLevelPack(beatmapLevelPack),
true,
LevelSelectionNavigationController.GetPrivateField <bool>("_showPlayerStatsInDetailView"),
LevelSelectionNavigationController.GetPrivateField <bool>("_showPracticeButtonInDetailView"));
}
else
{
var lastLevels = _levelCollectionTableView.GetPrivateField <IPreviewBeatmapLevel[]>("_previewBeatmapLevels");
if (lastLevels != null)
{
// if using default sort on a playlist, just show it as a playlist instead of creating a new level pack
if (SongSortModule.IsDefaultSort)
{
LevelSelectionNavigationController.SetData(
new BeatmapLevelCollection(lastLevels),
LevelSelectionNavigationController.GetPrivateField <bool>("_showPlayerStatsInDetailView"),
LevelSelectionNavigationController.GetPrivateField <bool>("_showPracticeButtonInDetailView"),
null);
}
else
{
LevelSelectionNavigationController.SetData(
_sortedLevelsLevelPack.SetupFromLevels(lastLevels),
true,
LevelSelectionNavigationController.GetPrivateField <bool>("_showPlayerStatsInDetailView"),
LevelSelectionNavigationController.GetPrivateField <bool>("_showPracticeButtonInDetailView"));
}
}
else
{
Logger.log.Warn("Unable to find songs to sort");
}
}
}
}
public void ClearButtonPressed()
{
if (FilterList.AnyApplied)
{
UnapplyFilters();
}
else
{
return;
}
if (SongBrowserTweaks.Initialized)
{
Logger.log.Debug("'Clear Filter' button pressed.");
return;
}
if (_lastPack == null)
{
var levelCollectionsViewController = Resources.FindObjectsOfTypeAll <AnnotatedBeatmapLevelCollectionsViewController>().FirstOrDefault();
if (levelCollectionsViewController != null)
{
_lastPack = levelCollectionsViewController.selectedAnnotatedBeatmapLevelCollection;
}
}
if (_lastPack != null)
{
if (SongSortModule.IsDefaultSort)
{
LevelSelectionNavigationController.SetData(_lastPack,
true,
LevelSelectionNavigationController.GetPrivateField <bool>("_showPlayerStatsInDetailView"),
LevelSelectionNavigationController.GetPrivateField <bool>("_showPracticeButtonInDetailView"),
null);
}
else
{
LevelSelectionNavigationController.SetData(_sortedLevelsLevelPack.SetupFromLevelCollection(_lastPack),
true,
LevelSelectionNavigationController.GetPrivateField <bool>("_showPlayerStatsInDetailView"),
LevelSelectionNavigationController.GetPrivateField <bool>("_showPracticeButtonInDetailView"));
}
}
else
{
Logger.log.Warn("Unable to find the last level pack");
}
if (ButtonPanel.IsSingletonAvailable && ButtonPanel.instance.Initialized)
{
ButtonPanel.instance.SetFilterStatus(false);
}
}
/// <summary>
/// Helper to get either or playlist or
/// </summary>
/// <returns></returns>
public IAnnotatedBeatmapLevelCollection GetCurrentSelectedAnnotatedBeatmapLevelCollection()
{
IAnnotatedBeatmapLevelCollection collection = GetCurrentSelectedLevelPack();
if (collection == null)
{
collection = GetCurrentSelectedPlaylist();
}
return(collection);
}
public static IPreviewBeatmapLevel[] GetLevelsForLevelCollection(IAnnotatedBeatmapLevelCollection levelCollection)
{
if (levelCollection is BeatSaberPlaylistsLib.Legacy.LegacyPlaylist legacyPlaylist)
{
return(legacyPlaylist.BeatmapLevels);
}
if (levelCollection is BeatSaberPlaylistsLib.Blist.BlistPlaylist blistPlaylist)
{
return(blistPlaylist.BeatmapLevels);
}
return(levelCollection.beatmapLevelCollection.beatmapLevels);
}
public void FilterButtonPressed()
{
if (_filterFlowCoordinator == null)
{
_filterFlowCoordinator = BeatSaberUI.CreateFlowCoordinator <FilterFlowCoordinator>();
_filterFlowCoordinator.name = "FilterFlowCoordinator";
_filterFlowCoordinator.BackButtonPressed += DismissFilterFlowCoordinator;
_filterFlowCoordinator.FilterApplied += FilterFlowCoordinatorSetFilteredSongs;
_filterFlowCoordinator.FiltersUnapplied += FilterFlowCoordinatorFiltersUnapplied;
}
if (_lastPack == null)
{
var levelPack = LevelSelectionNavigationController.GetPrivateField <IBeatmapLevelPack>("_levelPack");
if (levelPack != null && levelPack.packID != FilteredLevelsLevelPack.PackID && !levelPack.packID.Contains(SortedLevelsLevelPack.PackIDSuffix))
{
_lastPack = levelPack;
Logger.log.Debug($"Storing '{levelPack.packName}' (id = '{levelPack.packID}') level pack as last pack");
}
else
{
var levelCollectionsViewController = Resources.FindObjectsOfTypeAll <AnnotatedBeatmapLevelCollectionsViewController>().FirstOrDefault();
if (levelCollectionsViewController != null)
{
_lastPack = levelCollectionsViewController.selectedAnnotatedBeatmapLevelCollection;
}
if (_lastPack == null)
{
Logger.log.Error("Unable to find currently selected level pack for filtering. Will not display FilterFlowCoordinator");
return;
}
else
{
Logger.log.Debug($"Storing '{_lastPack.collectionName}' level collection as last pack");
}
}
}
IPreviewBeatmapLevel[] levels = _lastPack.beatmapLevelCollection.beatmapLevels;
_filterFlowCoordinator.Activate(_freePlayFlowCoordinator, levels);
if (!ButtonPanel.IsSingletonAvailable || !ButtonPanel.instance.Initialized)
{
Logger.log.Debug("'Filter' button pressed.");
}
}
private void FilterFlowCoordinatorSetFilteredSongs(IPreviewBeatmapLevel[] levels)
{
// filter application should be handled by FilterFlowCoordinator calling stuff in SongBrowserTweaks
if (SongBrowserTweaks.Initialized)
{
return;
}
// the filter view controller is always provided a default-sorted array of levels,
// so we apply sorting here
_filteredLevelPack.SetupFromPrefilteredLevels(levels);
_levelsToApply = _filteredLevelPack;
ButtonPanel.instance.SetFilterStatus(true);
}
/// <summary>
/// Applies and stores sorting of a provided <see cref="IAnnotatedBeatmapLevelCollection"/>.
/// </summary>
/// <param name="levelCollection">A level collection to sort.</param>
/// <returns>Returns itself if not using the non-default sort mode, otherwise returns the provided level pack.</returns>
public IBeatmapLevelPack SetupFromLevelCollection(IAnnotatedBeatmapLevelCollection levelCollection)
{
if (levelCollection is IBeatmapLevelPack levelPack)
{
return(SetupFromLevelPack(levelPack));
}
packID = CustomLevelLoader.kCustomLevelPackPrefixId + PackIDSuffix;
packName = PackName;
shortPackName = levelCollection.collectionName + PackIDSuffix;
coverImage = levelCollection.coverImage;
_beatmapLevelCollection.SetPrivateField("_levels", SongSortModule.SortSongs(levelCollection.beatmapLevelCollection.beatmapLevels), typeof(BeatmapLevelCollection));
return(this);
}
public void LevelCollectionUpdated(IAnnotatedBeatmapLevelCollection annotatedBeatmapLevelCollection, BeatSaberPlaylistsLib.PlaylistManager parentManager)
{
if (this.selectedPlaylist != null)
{
this.selectedPlaylist.SpriteLoaded -= SelectedPlaylist_SpriteLoaded;
}
if (annotatedBeatmapLevelCollection is Playlist selectedPlaylist)
{
this.selectedPlaylist = selectedPlaylist;
selectedPlaylist.SpriteLoaded += SelectedPlaylist_SpriteLoaded;
}
else
{
this.selectedPlaylist = null;
}
}
/// <summary>
/// Adds this plugin's name to the beginning of the author text in the song list view.
/// </summary>
static void Prefix(ref IAnnotatedBeatmapLevelCollection[] playlists)
{
if (playlists[0].GetType().Equals(typeof(UserFavoritesPlaylistSO))) //Checks if this is the playlists view
{
if (loadedPlaylists == null)
{
refreshPlaylists();
}
IAnnotatedBeatmapLevelCollection[] tempplaylists = new IAnnotatedBeatmapLevelCollection[playlists.Length + loadedPlaylists.Length];
for (int i = 0; i < playlists.Length; i++)
{
tempplaylists[i] = playlists[i];
}
int j = 0;
for (int i = playlists.Length; i < tempplaylists.Length; i++)
{
tempplaylists[i] = loadedPlaylists[j++];
}
playlists = tempplaylists;
}
}
static void Postfix(AnnotatedBeatmapLevelCollectionTableCell __instance, ref IAnnotatedBeatmapLevelCollection annotatedBeatmapLevelCollection, ref Image ____coverImage)
{
AnnotatedBeatmapLevelCollectionTableCell cell = __instance;
if (annotatedBeatmapLevelCollection is IDeferredSpriteLoad deferredSpriteLoad)
{
if (deferredSpriteLoad.SpriteWasLoaded)
{
#if DEBUG
Plugin.Log.Debug($"Sprite was already loaded for {(deferredSpriteLoad as IAnnotatedBeatmapLevelCollection).collectionName}");
#endif
}
if (EventTable.TryGetValue(deferredSpriteLoad, out AnnotatedBeatmapLevelCollectionTableCell existing))
{
EventTable.Remove(deferredSpriteLoad);
}
EventTable.Add(deferredSpriteLoad, cell);
deferredSpriteLoad.SpriteLoaded -= OnSpriteLoaded;
deferredSpriteLoad.SpriteLoaded += OnSpriteLoaded;
}
}
public void SetActiveWordStorageFromLevelPack(IAnnotatedBeatmapLevelCollection levelCollection)
{
WordCountStorage storage;
IBeatmapLevelPack levelPack = levelCollection as IBeatmapLevelPack;
string collectionName = levelCollection.collectionName;
bool storageWasCached;
if (levelPack != null)
{
storageWasCached = _cache.TryGetValue(levelPack.packID, out storage);
}
else
{
storageWasCached = _cache.TryGetValue(collectionName.Replace(SortedLevelsLevelPack.PackIDSuffix, ""), out storage);
}
if (!storageWasCached)
{
storage = new WordCountStorage(levelCollection);
// never cache filtered/built-in favorites level packs
// NOTE: ESAF filtered level pack should already be sorted (will never have sorted level pack suffix)
if (levelPack != null &&
levelPack.packID != FilteredLevelsLevelPack.PackID &&
!SongBrowserTweaks.IsFilterApplied())
{
_cache[levelPack.packID] = storage;
}
else if (collectionName != FilteredLevelsLevelPack.CollectionName &&
collectionName != BuiltInFavouritesPackCollectionName &&
collectionName != BuiltInFavouritesPackCollectionName + SortedLevelsLevelPack.PackIDSuffix &&
collectionName != SortedLevelsLevelPack.PackIDSuffix)
{
_cache[collectionName.Replace(SortedLevelsLevelPack.PackIDSuffix, "")] = storage;
}
}
_activeWordStorage = storage;
}
/// <summary>
/// Adds this plugin's name to the beginning of the author text in the song list view.
/// </summary>
internal static void Prefix(ref IAnnotatedBeatmapLevelCollection[] annotatedBeatmapLevelCollections)
{
// Check if annotatedBeatmapLevelCollections is empty (Versus Tab)
if (annotatedBeatmapLevelCollections.Length == 0)
{
return;
}
// Checks if this is the playlists view
if (annotatedBeatmapLevelCollections[0].GetType().Equals(typeof(UserFavoritesPlaylistSO)))
{
IAnnotatedBeatmapLevelCollection[] tempplaylists = new IAnnotatedBeatmapLevelCollection[annotatedBeatmapLevelCollections.Length + loadedPlaylists.Length];
for (int i = 0; i < annotatedBeatmapLevelCollections.Length; i++)
{
tempplaylists[i] = annotatedBeatmapLevelCollections[i];
}
int j = 0;
for (int i = annotatedBeatmapLevelCollections.Length; i < tempplaylists.Length; i++)
{
tempplaylists[i] = loadedPlaylists[j++];
}
annotatedBeatmapLevelCollections = tempplaylists;
}
}
private void _levelFilteringNavController_didSelectPackEvent(LevelFilteringNavigationController levelFilteringNavigationController, IAnnotatedBeatmapLevelCollection iAnnotatedBeatmapLevelCollection, GameObject gameObject, BeatmapCharacteristicSO beatmapCharacteristicSO)
{
IBeatmapLevelPack levelPack = iAnnotatedBeatmapLevelCollection as IBeatmapLevelPack;
Logger.log.Info(levelPack.packName);
if (levelPack == null || levelPack.packName != "Random Songs")
{
Logger.log.Info("Hiding RandomSongButton");
RandomButtonUI.instance.Hide();
return;
}
else
{
Logger.log.Info("Showing RandomSongButton");
RandomButtonUI.instance.Show();
}
}
private void PromoViewController_promoButtonWasPressedEvent(PromoViewController promoViewController, IAnnotatedBeatmapLevelCollection annotatedBeatmapLevelCollection, IPreviewBeatmapLevel previewBeatmapLevel)
{
IsInSoloFreeplay = true;
//Plugin.Log.Info($"Promo button was pressed, transitioning to SoloFreePlayController");
}
private void DidSelectAnnotatedBeatmapLevelCollectionEvent(IAnnotatedBeatmapLevelCollection annotatedBeatmapLevelCollection)
{
levelCollectionUpdater.LevelCollectionUpdated();
}
/// <summary>
/// Sort the song list based on the settings.
/// </summary>
public void ProcessSongList(IAnnotatedBeatmapLevelCollection selectedBeatmapCollection, LevelCollectionViewController levelCollectionViewController, LevelSelectionNavigationController navController)
{
Logger.Trace("ProcessSongList()");
List <IPreviewBeatmapLevel> unsortedSongs = null;
List <IPreviewBeatmapLevel> filteredSongs = null;
List <IPreviewBeatmapLevel> sortedSongs = null;
// Abort
if (selectedBeatmapCollection == null)
{
Logger.Debug("Cannot process songs yet, no level collection selected...");
return;
}
Logger.Debug("Using songs from level collection: {0}", selectedBeatmapCollection.collectionName);
unsortedSongs = selectedBeatmapCollection.beatmapLevelCollection.beatmapLevels.ToList();
// filter
Logger.Debug($"Starting filtering songs by {_settings.filterMode}");
Stopwatch stopwatch = Stopwatch.StartNew();
switch (_settings.filterMode)
{
case SongFilterMode.Favorites:
filteredSongs = FilterFavorites(unsortedSongs);
break;
case SongFilterMode.Search:
filteredSongs = FilterSearch(unsortedSongs);
break;
case SongFilterMode.Ranked:
filteredSongs = FilterRanked(unsortedSongs, true, false);
break;
case SongFilterMode.Unranked:
filteredSongs = FilterRanked(unsortedSongs, false, true);
break;
case SongFilterMode.Custom:
Logger.Info("Song filter mode set to custom. Deferring filter behaviour to another mod.");
filteredSongs = CustomFilterHandler != null?CustomFilterHandler.Invoke(selectedBeatmapCollection) : unsortedSongs;
break;
case SongFilterMode.None:
default:
Logger.Info("No song filter selected...");
filteredSongs = unsortedSongs;
break;
}
stopwatch.Stop();
Logger.Info("Filtering songs took {0}ms", stopwatch.ElapsedMilliseconds);
// sort
Logger.Debug("Starting to sort songs...");
stopwatch = Stopwatch.StartNew();
SortWasMissingData = false;
switch (_settings.sortMode)
{
case SongSortMode.Original:
sortedSongs = SortOriginal(filteredSongs);
break;
case SongSortMode.Newest:
sortedSongs = SortNewest(filteredSongs);
break;
case SongSortMode.Author:
sortedSongs = SortAuthor(filteredSongs);
break;
case SongSortMode.UpVotes:
sortedSongs = SortUpVotes(filteredSongs);
break;
case SongSortMode.PlayCount:
sortedSongs = SortBeatSaverPlayCount(filteredSongs);
break;
case SongSortMode.Rating:
sortedSongs = SortBeatSaverRating(filteredSongs);
break;
case SongSortMode.Heat:
sortedSongs = SortBeatSaverHeat(filteredSongs);
break;
case SongSortMode.YourPlayCount:
sortedSongs = SortPlayCount(filteredSongs);
break;
case SongSortMode.PP:
sortedSongs = SortPerformancePoints(filteredSongs);
break;
case SongSortMode.Stars:
sortedSongs = SortStars(filteredSongs);
break;
case SongSortMode.Random:
sortedSongs = SortRandom(filteredSongs);
break;
case SongSortMode.Custom:
sortedSongs = CustomSortHandler != null?CustomSortHandler.Invoke(filteredSongs) : filteredSongs;
break;
case SongSortMode.Default:
default:
sortedSongs = SortSongName(filteredSongs);
break;
}
if (this.Settings.invertSortResults && _settings.sortMode != SongSortMode.Random)
{
sortedSongs.Reverse();
}
stopwatch.Stop();
Logger.Info("Sorting songs took {0}ms", stopwatch.ElapsedMilliseconds);
// Still hacking in a custom level pack
// Asterisk the pack name so it is identifable as filtered.
var packName = selectedBeatmapCollection.collectionName;
if (!packName.EndsWith("*") && _settings.filterMode != SongFilterMode.None)
{
packName += "*";
}
BeatmapLevelPack levelPack = new BeatmapLevelPack(SongBrowserModel.FilteredSongsCollectionName, packName, selectedBeatmapCollection.collectionName, selectedBeatmapCollection.coverImage, new BeatmapLevelCollection(sortedSongs.ToArray()));
GameObject _noDataGO = levelCollectionViewController.GetPrivateField <GameObject>("_noDataInfoGO");
bool _showPlayerStatsInDetailView = navController.GetPrivateField <bool>("_showPlayerStatsInDetailView");
bool _showPracticeButtonInDetailView = navController.GetPrivateField <bool>("_showPracticeButtonInDetailView");
navController.SetData(levelPack, true, _showPlayerStatsInDetailView, _showPracticeButtonInDetailView, _noDataGO);
//_sortedSongs.ForEach(x => Logger.Debug(x.levelID));
}
