static void Postfix(CustomPreviewBeatmapLevel __instance) { #if DEBUG //Logger.Log($"Selected CustomLevel Path :\n {__instance.customLevelPath}", LogLevel.Notice); #endif customLevelPath = __instance.customLevelPath; }
public async void LoadScene() { IDifficultyBeatmap diffBeatmap = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData.difficultyBeatmap; CustomPreviewBeatmapLevel customPreviewBeatmapLevel = diffBeatmap.level as CustomPreviewBeatmapLevel; if (customPreviewBeatmapLevel != null) { string customLevelPath = customPreviewBeatmapLevel.customLevelPath; string mapFileName = diffBeatmap.difficulty.Name(); string filepath = customLevelPath + "\\ExpertPlusEffect.dat"; Logger.log.Error("custom level path = " + filepath); Logger.log.Error("custom level difficulty = " + mapFileName); player = new CutEffectPlayer(); player.Init(gameObject); if (await player.TryLoadCutEffectMap(filepath)) { return; } } player = null; //string cutEffectMapPath = "D:\\ProgramFiles\\Steam\\steamapps\\common\\Beat Saber\\Beat Saber_Data\\CustomLevels\\2a7 (Night of Nights - squeaksies)\\ExpertPlusEffect.dat"; }
public double GetPP(CustomPreviewBeatmapLevel beatmapLevel, BeatmapDifficulty difficulty, BeatDataCharacteristics beatDataCharacteristics) { if (beatDataCharacteristics == BeatDataCharacteristics.Standard && this._downloader.Init && this._downloader.RowPPs.TryGetValue(beatmapLevel.GetHashOrLevelID().ToUpper(), out var pp)) { // PP counterと同じ処理 switch (difficulty) { case BeatmapDifficulty.Easy: return(pp.EasySoloStandard); case BeatmapDifficulty.Normal: return(pp.NormalSoloStandard); case BeatmapDifficulty.Hard: return(pp.HardSoloStandard); case BeatmapDifficulty.Expert: return(pp.ExpertSoloStandard); case BeatmapDifficulty.ExpertPlus: return(pp.ExpertPlusSoloStandard); default: break; } } var song = this.GetBeatStarSongDiffculityStats(beatmapLevel, difficulty, beatDataCharacteristics); if (song != null) { return(song.PP); } return(0); }
/** If the callback is null, call the callback with the randomSongId, otherwise select the newly downloaded song */ public async Task DownloadRandomSongAsync(RSPDownloadedCallback callback) { Beatmap mapData = await RandomSongGenerator.GenerateRandomKey(); if (!(mapData is null)) { string path; bool freshDownload; (freshDownload, path) = await MapInstaller.InstallMap(mapData); Logger.log.Info("Chosen Random Song: " + path); path = Path.GetFullPath(path); if (freshDownload) { Action OnLevelPacksRefreshed = null; OnLevelPacksRefreshed = () => { Loader.OnLevelPacksRefreshed -= OnLevelPacksRefreshed; CustomPreviewBeatmapLevel installedMap = randomSongsFolder.Levels[path]; callback?.Invoke(installedMap); }; Loader.OnLevelPacksRefreshed += OnLevelPacksRefreshed; Loader.Instance.RefreshSongs(false); } else { CustomPreviewBeatmapLevel installedMap = randomSongsFolder.Levels[path]; callback?.Invoke(installedMap); } } }
private List <string> HandleMusicVideoData(CustomPreviewBeatmapLevel level, string videoDataFile) { var returnList = new List <string>(); var fileData = File.ReadAllText(videoDataFile); if (fileData.Substring(0, 1) == "{") { var video = JsonConvert.DeserializeObject <VideoDatas.VideoData>(fileData); if (!string.IsNullOrWhiteSpace(video.videoPath)) { AddIfExists(returnList, level, video.videoPath); } } else { var videoData = JsonConvert.DeserializeObject <VideoDatas>(fileData); if (videoData?.videos == null || !videoData.videos.Any()) { return(returnList); } foreach (var dataVideo in videoData.videos) { AddIfExists(returnList, level, dataVideo.videoPath); } } return(returnList); }
public static string GetCustomLevelHash(CustomPreviewBeatmapLevel level) { if (GetCachedSongData(level.customLevelPath, out var directoryHash, out var songHash)) { return(songHash); } List <byte> combinedBytes = new List <byte>(); combinedBytes.AddRange(File.ReadAllBytes(level.customLevelPath + '/' + "info.dat")); for (var i = 0; i < level.standardLevelInfoSaveData.difficultyBeatmapSets.Length; i++) { for (var i2 = 0; i2 < level.standardLevelInfoSaveData.difficultyBeatmapSets[i].difficultyBeatmaps.Length; i2++) { if (File.Exists(level.customLevelPath + '/' + level.standardLevelInfoSaveData.difficultyBeatmapSets[i].difficultyBeatmaps[i2].beatmapFilename)) { combinedBytes.AddRange(File.ReadAllBytes(level.customLevelPath + '/' + level.standardLevelInfoSaveData.difficultyBeatmapSets[i].difficultyBeatmaps[i2].beatmapFilename)); } } } string hash = CreateSha1FromBytes(combinedBytes.ToArray()); cachedSongHashData[level.customLevelPath] = new SongHashData(directoryHash, hash); return(hash); }
public void FilterSongList(ref List <BeatmapDetails> detailsList) { if (!_isInitialized || (!_oneSaberAppliedValue && !_lightshowAppliedValue && _mappingExtensionsAppliedValue == SongRequirement.Off)) { return; } for (int i = 0; i < detailsList.Count;) { BeatmapDetails beatmap = detailsList[i]; List <CustomPreviewBeatmapLevel> customLevels = null; if (_mappingExtensionsAppliedValue != SongRequirement.Off) { customLevels = Loader.CustomLevels.Values.ToList(); } if (_lightshowAppliedValue && !beatmap.DifficultyBeatmapSets.Any(diffSet => diffSet.DifficultyBeatmaps.Any(diff => diff.NotesCount == 0))) { detailsList.RemoveAt(i); } else if (_oneSaberAppliedValue && !beatmap.DifficultyBeatmapSets.Any(diffSet => diffSet.CharacteristicName == "OneSaber")) { detailsList.RemoveAt(i); } else if (_mappingExtensionsAppliedValue != SongRequirement.Off && !beatmap.IsOST) { // remove songs that somehow aren't OST, but also aren't custom levels handled by SongCore CustomPreviewBeatmapLevel customLevel = customLevels.FirstOrDefault(x => x.levelID == beatmap.LevelID); if (customLevel == null) { detailsList.RemoveAt(i); continue; } ExtraSongData songData = Collections.RetrieveExtraSongData(Hashing.GetCustomLevelHash(customLevel), customLevel.customLevelPath); if (songData == null) { detailsList.RemoveAt(i); continue; } bool required = songData._difficulties?.Any(x => x.additionalDifficultyData?._requirements?.Any(y => y == "Mapping Extensions") == true) == true; if ((_mappingExtensionsAppliedValue == SongRequirement.Required && !required) || (_mappingExtensionsAppliedValue == SongRequirement.NotRequired && required)) { detailsList.RemoveAt(i); continue; } // passes check, requires mapping extensions ++i; } else { ++i; } } }
static bool Prefix(MissionLevelDetailViewController __instance, MissionNode ____missionNode, TextMeshProUGUI ____missionText, TextMeshProUGUI ____songNameText, TextMeshProUGUI ____difficultyText, TextMeshProUGUI ____characteristicsText, ObjectiveListItemsList ____objectiveListItems, GameplayModifiersModelSO ____gameplayModifiersModel, GameObject ____modifiersPanelGO, GameplayModifierInfoListItemsList ____gameplayModifierInfoListItemsList) { if (____missionNode.missionData is CustomMissionDataSO) { CustomMissionDataSO missionData = (____missionNode.missionData as CustomMissionDataSO); CustomPreviewBeatmapLevel level = missionData.customLevel; ____missionText.text = Localization.Get("CAMPAIGN_MISSION") + " " + ____missionNode.formattedMissionNodeName; if (level == null) { ____songNameText.text = string.Format(Localization.Get("CAMPAIGN_SONG"), "SONG NOT FOUND"); ____difficultyText.text = string.Format(Localization.Get("CAMPAIGN_DIFFICULTY"), "NOT FOUND"); ____characteristicsText.text = string.Format(Localization.Get("CAMPAIGN_TYPE"), "NOT FOUND"); } else { ____songNameText.text = string.Format(Localization.Get("CAMPAIGN_SONG"), level.songName); ____difficultyText.text = string.Format(Localization.Get("CAMPAIGN_DIFFICULTY"), BeatmapDifficultyMethods.Name(missionData.beatmapDifficulty)); ____characteristicsText.text = string.Format(Localization.Get("CAMPAIGN_TYPE"), Localization.Get(missionData.beatmapCharacteristic.characteristicNameLocalizationKey)); } MissionObjective[] missionObjectives = missionData.missionObjectives; ____objectiveListItems.SetData((missionObjectives.Length == 0) ? 1 : missionObjectives.Length, delegate(int idx, ObjectiveListItem objectiveListItem) { if (idx == 0 && missionObjectives.Length == 0) { objectiveListItem.title = Localization.Get("CAMPAIGN_FINISH_LEVEL"); objectiveListItem.conditionText = ""; objectiveListItem.hideCondition = true; } else { MissionObjective missionObjective = missionObjectives[idx]; if (missionObjective.type.noConditionValue) { objectiveListItem.title = missionObjective.type.objectiveNameLocalized.Replace(" ", "\n"); objectiveListItem.hideCondition = true; } else { objectiveListItem.title = missionObjective.type.objectiveNameLocalized; objectiveListItem.hideCondition = false; ObjectiveValueFormatterSO objectiveValueFormater = missionObjective.type.objectiveValueFormater; objectiveListItem.conditionText = $"{MissionDataExtensions.Name(missionObjective.referenceValueComparisonType)} {objectiveValueFormater.FormatValue(missionObjective.referenceValue)}"; } } }); List <GameplayModifierParamsSO> modifierParamsList = ____gameplayModifiersModel.GetModifierParams(missionData.gameplayModifiers); ____modifiersPanelGO.SetActive(modifierParamsList.Count > 0); ____gameplayModifierInfoListItemsList.SetData(modifierParamsList.Count, delegate(int idx, GameplayModifierInfoListItem gameplayModifierInfoListItem) { GameplayModifierParamsSO gameplayModifierParamsSO = modifierParamsList[idx]; gameplayModifierInfoListItem.modifierIcon = gameplayModifierParamsSO.icon; gameplayModifierInfoListItem.modifierName = Localization.Get(gameplayModifierParamsSO.modifierNameLocalizationKey); gameplayModifierInfoListItem.modifierDescription = Localization.Get(gameplayModifierParamsSO.descriptionLocalizationKey); gameplayModifierInfoListItem.showSeparator = (idx != modifierParamsList.Count - 1); }); return(false); } return(true); }
internal void EnvironmentButtonPressed() { CustomPreviewBeatmapLevel level = SongCore.Loader.GetLevelByHash(LEVEL_HASH); BeatmapDifficulty beatmapDifficulty = level.previewDifficultyBeatmapSets[0].beatmapDifficulties[0]; BeatmapCharacteristicSO beatmapCharacteristic = level.previewDifficultyBeatmapSets[0].beatmapCharacteristic; Utils.PlaySong(level, beatmapCharacteristic, beatmapDifficulty); }
public static async Task <IPreviewBeatmapLevel?> DownloadSong(string levelId, CancellationToken cancellationToken) { string hash = levelId.Replace("custom_level_", ""); var bm = await BeatSaverSharp.BeatSaver.Client.Hash(hash, cancellationToken); string folderPath = GetSongDirectoryName(bm.Key, bm.Metadata.SongName, bm.Metadata.LevelAuthorName); folderPath = Path.Combine(CustomLevelsFolder, folderPath); if (bm == null) { Plugin.Log?.Warn($"Could not find song '{hash}' on Beat Saver."); return(null); } byte[] beatmapBytes = await bm.DownloadZip(false, cancellationToken); using (var ms = new MemoryStream(beatmapBytes)) { var result = await ExtractZip(ms, folderPath); if (folderPath != result.OutputDirectory) { folderPath = result.OutputDirectory ?? throw new Exception("Zip extract failed, no output directory."); } if (result.Exception != null) { throw result.Exception; } } Plugin.Log.Info($"Downloaded song to '{folderPath}'"); using (var awaiter = new EventAwaiter <SongCore.Loader, Dictionary <string, CustomPreviewBeatmapLevel> >(cancellationToken)) { try { SongCore.Loader.SongsLoadedEvent += awaiter.OnEvent; SongCore.Collections.AddSong($"custom_level_{hash}", folderPath); SongCore.Loader.Instance.RefreshSongs(false); await awaiter.Task; } catch (OperationCanceledException) { } catch (Exception e) { Plugin.Log?.Error($"Error waiting for songs to load: {e.Message}"); Plugin.Log?.Debug(e); throw; } finally { SongCore.Loader.SongsLoadedEvent -= awaiter.OnEvent; } } CustomPreviewBeatmapLevel beatmap = SongCore.Loader.GetLevelByHash(hash); return(beatmap); }
private async Task <CustomBeatmapLevel> LoadCustomBeatmapLevelAsync(CustomPreviewBeatmapLevel level, CancellationToken token) { CustomBeatmapLevel customLevel = new CustomBeatmapLevel(level, null, null); BeatmapLevelData beatmapData = await _customLevelLoader.LoadBeatmapLevelDataAsync(level.customLevelPath, customLevel, level.standardLevelInfoSaveData, token).ConfigureAwait(false); customLevel.SetBeatmapLevelData(beatmapData); return(customLevel); }
public Song(CustomPreviewBeatmapLevel _data) { songName = _data.songName; songSubName = _data.songSubName; songAuthorName = _data.songAuthorName; levelAuthorName = _data.levelAuthorName; path = _data.customLevelPath; hash = SongCore.Collections.hashForLevelID(_data.levelID).ToLower(); }
public BeatSongDataDifficultyStats GetBeatStarSongDiffculityStats(CustomPreviewBeatmapLevel beatmapLevel, BeatmapDifficulty difficulty, BeatDataCharacteristics beatDataCharacteristics) { var song = this.GetBeatStarSong(beatmapLevel); if (song == null) { return(null); } return(this.GetBeatStarSongDiffculityStats(song, difficulty, beatDataCharacteristics)); }
/// <summary> /// Song date is stored in SongMetadata config file to be preserved after moving files to a different location. /// Initial date is loaded from file date. /// </summary> /// <param name="level"></param> /// <returns></returns> private DateTime GetSongUserDate(CustomPreviewBeatmapLevel level) { var metadata = SongMetadataStore.Instance.GetMetadataForLevelID(level.levelID); if (metadata.AddedAt == null) { metadata.AddedAt = GetSongUserDateFromFilesystem(level); } return(metadata.AddedAt.Value); }
/// <summary> /// Get the BeatmapDetails associated with a specific levelID from data retrieved by SongDataCore.BeatSaver. /// </summary> /// <param name="level">The song's associated preview beatmap level.</param> /// <param name="beatmapDetails">The returned BeatmapDetails object, or null if it could not be retrieved.</param> /// <returns>An enum representing success or what went wrong.</returns> public static SongDataCoreDataStatus GetBeatmapDetails(CustomPreviewBeatmapLevel level, out BeatmapDetails beatmapDetails) { if (!IsModAvailable) { beatmapDetails = null; return(SongDataCoreDataStatus.NoData); } return(_GetBeatmapDetails(level, out beatmapDetails)); }
/// <summary> /// /// </summary> /// <param name="installedMap"></param> private void OnLevelPacksRefreshedSelect(CustomPreviewBeatmapLevel installedMap) { int installedLevelIndex = Array.FindIndex(randomSongsFolder.LevelPack.beatmapLevelCollection.beatmapLevels, x => (x.levelID == installedMap.levelID)); LevelCollectionTableView levelCollectionTable = Resources.FindObjectsOfTypeAll <LevelCollectionTableView>().First(); var tableView = levelCollectionTable.GetPrivateField <HMUI.TableView>("_tableView"); tableView.ScrollToCellWithIdx(installedLevelIndex + 1, HMUI.TableView.ScrollPositionType.Center, true); tableView.SelectCellWithIdx(installedLevelIndex + 1, true); }
static bool Prefix(MissionLevelDetailViewController __instance, MissionNode ____missionNode, LevelBar ____levelBar, ObjectiveListItemsList ____objectiveListItems, GameplayModifiersModelSO ____gameplayModifiersModel, GameObject ____modifiersPanelGO, GameplayModifierInfoListItemsList ____gameplayModifierInfoListItemsList) { if (____missionNode.missionData is CustomMissionDataSO) { CustomMissionDataSO missionData = (____missionNode.missionData as CustomMissionDataSO); CustomPreviewBeatmapLevel level = missionData.customLevel; if (level == null) { // TODO: Localization? ____levelBar.GetPrivateField <TextMeshProUGUI>("_songNameText").text = "SONG NOT FOUND"; ____levelBar.GetPrivateField <TextMeshProUGUI>("_difficultyText").text = "SONG NOT FOUND"; ____levelBar.GetPrivateField <TextMeshProUGUI>("_authorNameText").text = "SONG NOT FOUND"; } else { ____levelBar.Setup(level, missionData.beatmapCharacteristic, missionData.beatmapDifficulty); } MissionObjective[] missionObjectives = missionData.missionObjectives; ____objectiveListItems.SetData((missionObjectives.Length == 0) ? 1 : missionObjectives.Length, delegate(int idx, ObjectiveListItem objectiveListItem) { if (idx == 0 && missionObjectives.Length == 0) { objectiveListItem.title = Localization.Get("CAMPAIGN_FINISH_LEVEL"); objectiveListItem.conditionText = ""; objectiveListItem.hideCondition = true; } else { MissionObjective missionObjective = missionObjectives[idx]; if (missionObjective.type.noConditionValue) { objectiveListItem.title = missionObjective.type.objectiveNameLocalized.Replace(" ", "\n"); objectiveListItem.hideCondition = true; } else { objectiveListItem.title = missionObjective.type.objectiveNameLocalized; objectiveListItem.hideCondition = false; ObjectiveValueFormatterSO objectiveValueFormater = missionObjective.type.objectiveValueFormater; objectiveListItem.conditionText = $"{MissionDataExtensions.Name(missionObjective.referenceValueComparisonType)} {objectiveValueFormater.FormatValue(missionObjective.referenceValue)}"; } } }); List <GameplayModifierParamsSO> modifierParamsList = ____gameplayModifiersModel.GetModifierParams(missionData.gameplayModifiers); ____modifiersPanelGO.SetActive(modifierParamsList.Count > 0); ____gameplayModifierInfoListItemsList.SetData(modifierParamsList.Count, delegate(int idx, GameplayModifierInfoListItem gameplayModifierInfoListItem) { GameplayModifierParamsSO gameplayModifierParamsSO = modifierParamsList[idx]; gameplayModifierInfoListItem.modifierIcon = gameplayModifierParamsSO.icon; gameplayModifierInfoListItem.hoverHintText = Localization.Get(gameplayModifierParamsSO.modifierNameLocalizationKey) + " - " + Localization.Get(gameplayModifierParamsSO.descriptionLocalizationKey); }); return(false); } return(true); }
public CustomPreviewBeatmapLevel FindSong() { try { CustomPreviewBeatmapLevel level = Loader.CustomLevels.Values.First(x => x.customLevelPath.Contains("\\" + songid + (customDownloadURL == "" ? " " : ""))); //Including the space is to ensure that if they have a map with an old style beatsaver id it won't be falsely detected return(level); } catch { return(null); } }
private static void StartLevel(IBeatmapLevel beatmapLevel, CustomPreviewBeatmapLevel beatmap, BeatmapDifficulty difficulty) { Logger.log.Info("Starting level"); MenuTransitionsHelper menuSceneSetupData = Resources.FindObjectsOfTypeAll <MenuTransitionsHelper>().FirstOrDefault(); PlayerData playerSettings = Resources.FindObjectsOfTypeAll <PlayerDataModel>().FirstOrDefault().playerData; var gamePlayModifiers = new GameplayModifiers(); gamePlayModifiers.IsWithoutModifiers(); IBeatmapLevel level = beatmapLevel; BeatmapCharacteristicSO characteristics = beatmap.previewDifficultyBeatmapSets[0].beatmapCharacteristic; IDifficultyBeatmap levelDifficulty = BeatmapLevelDataExtensions.GetDifficultyBeatmap(level.beatmapLevelData, characteristics, difficulty); menuSceneSetupData.StartStandardLevel(levelDifficulty, playerSettings.overrideEnvironmentSettings.overrideEnvironments ? playerSettings.overrideEnvironmentSettings : null, playerSettings.colorSchemesSettings.overrideDefaultColors ? playerSettings.colorSchemesSettings.GetSelectedColorScheme() : null, gamePlayModifiers, playerSettings.playerSpecificSettings, playerSettings.practiceSettings, "Exit", false, () => { }, (StandardLevelScenesTransitionSetupDataSO sceneTransition, LevelCompletionResults results) => { bool newHighScore = false; var mainFlowCoordinator = Resources.FindObjectsOfTypeAll <MainFlowCoordinator>().First(); RandomSongMenu randomSongMenu = BeatSaberUI.CreateFlowCoordinator <RandomSongMenu>(); if (results.levelEndAction == LevelCompletionResults.LevelEndAction.Restart) { Logger.log.Info("Restarting level"); return; } switch (results.levelEndStateType) { case LevelCompletionResults.LevelEndStateType.None: break; case LevelCompletionResults.LevelEndStateType.Cleared: UploadScore(levelDifficulty, results, out newHighScore); randomSongMenu.Show(beatmap, difficulty, levelDifficulty, results, newHighScore); Logger.log.Info("Showing menu"); break; case LevelCompletionResults.LevelEndStateType.Failed: Logger.log.Info("Showing menu"); randomSongMenu.Show(beatmap, difficulty, levelDifficulty, results, newHighScore); break; default: break; } }); }
public void Show(CustomPreviewBeatmapLevel customPreviewBeatmapLevel, BeatmapDifficulty difficulty, IDifficultyBeatmap levelDifficulty, LevelCompletionResults results, bool newHighScore) { this.beatmap = customPreviewBeatmapLevel; this.difficulty = difficulty; this.levelDifficulty = levelDifficulty; this.levelCompletionResults = results; this.newHighScore = newHighScore; mainFlowCoordinator = Resources.FindObjectsOfTypeAll <MainFlowCoordinator>().First(); BeatSaberUI.PresentFlowCoordinator(mainFlowCoordinator, this); }
//bananbread api public Song(CustomPreviewBeatmapLevel _data) { songName = _data.songName; songSubName = _data.songSubName; songAuthorName = _data.songAuthorName; levelAuthorName = _data.levelAuthorName; // difficultyLevels = ConvertDifficultyLevels(_data.standardLevelInfoSaveData.difficultyBeatmapSets.SelectMany(x => x.difficultyBeatmaps).ToArray()); path = _data.customLevelPath; //bananabread id hash hash = SongCore.Collections.hashForLevelID(_data.levelID).ToLower(); // hash = SongCore.Utilities.Utils.GetCustomLevelHash(_data); }
private void Setup() { Plugin.Log.Debug($"Setup start."); if (this.pauseController != null) { this.pauseController.didResumeEvent += OnGameResume; } if (ScoreDataBase.Instance.Init) { this.relativeScoreAndImmediateRankCounter.relativeScoreOrImmediateRankDidChangeEvent += this.RelativeScoreAndImmediateRankCounter_relativeScoreOrImmediateRankDidChangeEvent; } var beatmapLevel = CurrentData.difficultyBeatmap.level; this._currentBeatmapDifficulty = CurrentData.difficultyBeatmap.difficulty; var levelID = beatmapLevel.levelID; this._currentCustomBeatmapLevel = Loader.GetLevelByHash(levelID.Split('_').Last()); this.songRawPP = ScoreDataBase.Instance.Init ? PPCounterUtil.GetPP(_currentCustomBeatmapLevel, _currentBeatmapDifficulty) : 0; if (_currentCustomBeatmapLevel != null) { HMMainThreadDispatcher.instance.Enqueue(this.SetCustomLabel(_currentCustomBeatmapLevel, _currentBeatmapDifficulty)); } this._currentStarSong = SongDataCoreUtil.GetBeatStarSong(_currentCustomBeatmapLevel); this._currentStarSongDiff = SongDataCoreUtil.GetBeatStarSongDiffculityStats(_currentCustomBeatmapLevel, _currentBeatmapDifficulty); if (this.statusManager.StatusJSON["beatmap"] == null) { this.statusManager.StatusJSON["beatmap"] = new JSONObject(); } var beatmapJson = this.statusManager.StatusJSON["beatmap"].AsObject; if (this._currentStarSong != null && this._currentStarSongDiff != null) { var multiplier = this.statusManager.GameStatus.songSpeedMultiplier; if (ScoreDataBase.Instance.Init) { if (multiplier == 1 || !PPCounterUtil.AllowedPositiveModifiers(levelID)) { beatmapJson["pp"] = new JSONNumber(this.songRawPP * 1.12); } else { beatmapJson["pp"] = new JSONNumber(PPCounterUtil.CalculatePP(this.songRawPP, multiplier)); } } beatmapJson["star"] = new JSONNumber(this._currentStarSongDiff.star); beatmapJson["downloadCount"] = new JSONNumber(this._currentStarSong.downloadCount); beatmapJson["upVotes"] = new JSONNumber(this._currentStarSong.upVotes); beatmapJson["downVotes"] = new JSONNumber(this._currentStarSong.downVotes); beatmapJson["rating"] = new JSONNumber(this._currentStarSong.rating); } HMMainThreadDispatcher.instance.Enqueue(this.SongStartWait(this._currentStarSong != null && this._currentStarSongDiff != null)); }
internal static BeatSaver_CustomBeatmapLevel FromBeatSaver(Beatmap p_BeatMap) { List <PreviewDifficultyBeatmapSet> l_PreviewDifficultyBeatmapSet = new List <PreviewDifficultyBeatmapSet>(); foreach (var l_Current in p_BeatMap.Metadata.Characteristics) { if (l_Current.Difficulties.Count == 0) { continue; } var l_Difficulties = new List <BeatmapDifficulty>(); foreach (var l_CurrentDiff in l_Current.Difficulties.Where(x => x.Value.HasValue).ToList()) { if (!l_CurrentDiff.Value.HasValue) { continue; } l_Difficulties.Add(Utils.Songs.SerializedToDifficulty(l_CurrentDiff.Key)); } l_PreviewDifficultyBeatmapSet.Add(new PreviewDifficultyBeatmapSet( SongCore.Loader.beatmapCharacteristicCollection.GetBeatmapCharacteristicBySerializedName(l_Current.Name), l_Difficulties.ToArray() )); } var l_CustomPreviewBeatmapLevel = new CustomPreviewBeatmapLevel( null, null, "", null, null, "custom_level_" + p_BeatMap.Hash.ToUpper(), p_BeatMap.Metadata.SongName, p_BeatMap.Metadata.SongSubName, p_BeatMap.Metadata.SongAuthorName, p_BeatMap.Metadata.LevelAuthorName, p_BeatMap.Metadata.BPM, 0f, ///< todo 0f, ///< todo 0f, ///< todo 0f, ///< todo p_BeatMap.Metadata.Duration, null, null, l_PreviewDifficultyBeatmapSet.ToArray() ); return(new BeatSaver_CustomBeatmapLevel(p_BeatMap, l_CustomPreviewBeatmapLevel, null)); }
static void Postfix(CustomPreviewBeatmapLevel __instance) { #if DEBUG Logger.log.Notice($"Selected CustomLevel Path :\n {__instance.customLevelPath}"); #endif if (File.Exists(Path.Combine(__instance.customLevelPath, "SongScript.json"))) { customLevelPath = Path.Combine(__instance.customLevelPath, "SongScript.json"); } else { customLevelPath = string.Empty; } }
static bool Prefix(MissionNodeVisualController missionNodeVisualController, MissionSelectionMapViewController __instance, SongPreviewPlayer ____songPreviewPlayer) { if (missionNodeVisualController.missionNode.missionData is CustomMissionDataSO) { __instance.SetPrivateField("_selectedMissionNode", missionNodeVisualController.missionNode); CustomPreviewBeatmapLevel level = (missionNodeVisualController.missionNode.missionData as CustomMissionDataSO).customLevel; if (level != null) { ____songPreviewPlayer.CrossfadeTo(level.GetPreviewAudioClipAsync(CancellationToken.None).Result, level.previewStartTime, level.previewDuration); } __instance.GetPrivateField <Action <MissionSelectionMapViewController, MissionNode> >("didSelectMissionLevelEvent")(__instance, missionNodeVisualController.missionNode); return(false); } return(true); }
public static void AddLevelToPlaylist(Playlist playlist, CustomPreviewBeatmapLevel level) { string hash = SongCore.Utilities.Hashing.GetCustomLevelHash(level); if (playlist.songs.Any(x => string.Equals(x.hash, hash, StringComparison.OrdinalIgnoreCase))) { return; } PlaylistSong song = new PlaylistSong(); song.hash = hash; song.level = level; song.levelId = level.levelID; song.songName = level.songName + " - " + level.levelAuthorName; playlist.songs.Add(song); playlist.SavePlaylist(); }
private void AddIfExists(List <string> whiteListedFiles, CustomPreviewBeatmapLevel level, string file, Func <CustomPreviewBeatmapLevel, string, List <string> > callbackOnFound = null) { // this check is necessary for performance on comparing file lists var path = Path.Combine(level.customLevelPath, file); if (!File.Exists(path)) { return; } //Log.Debug($"found {file}"); whiteListedFiles.Add(file); if (callbackOnFound != null) { whiteListedFiles.AddRange(callbackOnFound.Invoke(level, path)); } }
//////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// /// <summary> /// Init the entry /// </summary> public void Init() { if (m_WasInit) { return; } if (CustomLevel == null && BeatSaver_Map != null && !BeatSaver_Map.Partial) { var l_LocalLevel = SongCore.Loader.GetLevelByHash(BeatSaver_Map.Hash.ToUpper()); if (l_LocalLevel != null && SongCore.Loader.CustomLevels.ContainsKey(l_LocalLevel.customLevelPath)) { CustomLevel = l_LocalLevel; } } m_WasInit = true; }
internal static void PlayLevel(CustomPreviewBeatmapLevel beatmap, BeatmapDifficulty difficulty) { try { LoadBeatmapLevelAsync(beatmap, (success, beatmapLevel) => { Logger.log.Log(IPALogger.Level.Info, "Loading Beatmap level Success:" + success); if (success) { StartLevel(beatmapLevel, beatmap, difficulty); } }); } catch (Exception ex) { Logger.log.Log(IPALogger.Level.Critical, ex); } }
/// <summary> /// Try to get the date from the cover file, likely the most reliable. /// Fall back on the folders creation date. /// </summary> /// <param name="level"></param> /// <returns></returns> private double GetSongUserDate(CustomPreviewBeatmapLevel level) { var coverPath = Path.Combine(level.customLevelPath, level.standardLevelInfoSaveData.coverImageFilename); var lastTime = EPOCH; if (File.Exists(coverPath)) { var lastWriteTime = File.GetLastWriteTimeUtc(coverPath); var lastCreateTime = File.GetCreationTimeUtc(coverPath); lastTime = lastWriteTime > lastCreateTime ? lastWriteTime : lastCreateTime; } else { var lastCreateTime = File.GetCreationTimeUtc(level.customLevelPath); lastTime = lastCreateTime; } return((lastTime - EPOCH).TotalMilliseconds); }