public float GetAcc(SongID songID) { // First check for song specific accuracy if (_songSpecificAcc.ContainsKey(songID)) { return(RoundedAcc(_songSpecificAcc[songID])); } double bestAcc = 0; // Next check for max of current best acc and star acc if (ProfileDataLoader.instance.songDataInfo.ContainsKey(songID)) { bestAcc = ProfileDataLoader.instance.songDataInfo[songID].acc; } // Next check for star acc var star = SongDataUtils.GetRoundedStars(songID); if (_starAcc.ContainsKey(star)) { bestAcc = Math.Max(bestAcc, _starAcc[star]); } if (bestAcc > 0) { return(RoundedAcc(bestAcc)); } // Finally resort to default return(Config.defaultAcc); }
public static float GetRawPP(SongID songID) { if (!init) { Logger.log.Error("Tried to use RawPPLoader when it wasn't initialized!"); throw new Exception("Tried to use RawPPLoader when it wasn't initialized"); } switch (songID.difficulty) { case BeatmapDifficulty.Easy: return(_songData[songID.id]._Easy_SoloStandard); case BeatmapDifficulty.Normal: return(_songData[songID.id]._Normal_SoloStandard); case BeatmapDifficulty.Hard: return(_songData[songID.id]._Hard_SoloStandard); case BeatmapDifficulty.Expert: return(_songData[songID.id]._Expert_SoloStandard); case BeatmapDifficulty.ExpertPlus: return(_songData[songID.id]._ExpertPlus_SoloStandard); default: Logger.log.Error("Unknown beatmap difficulty: " + songID.difficulty.ToString()); throw new Exception("Unknown difficultry"); } }
// Purposefully ignore modifiers here - only 2 maps have them enabled and it doesn't make much sense to just filter to those two private static float GetHighestPP(IPreviewBeatmapLevel previewBeatmapLevel, bool ppGain) { float maxPP = 0; var id = SongDataUtils.GetHash(previewBeatmapLevel.levelID); // Check if in SDC if (SongDataCore.Plugin.Songs.Data.Songs.ContainsKey(id)) { // Loop through each diff foreach (var diff in SongDataCore.Plugin.Songs.Data.Songs[id].diffs) { var difficulty = SongDataUtils.GetBeatmapDifficulty(diff.diff); var songID = new SongID(id, difficulty); // Only go through ranked songs if (SongDataUtils.IsRankedSong(songID)) { float pp = PPUtils.CalculatePP(songID, AccLoader.instance.GetAcc(songID)); if (ppGain) { pp = PPUtils.GetPPGain(pp, songID); } maxPP = pp > maxPP ? pp : maxPP; } } return(maxPP); } return(0); }
IEnumerator FindDifficultyBeatmap() { yield return(new WaitUntil(() => BS_Utils.Plugin.LevelData.IsSet)); _difficultyBeatmap = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData.difficultyBeatmap; _songID = new SongID(SongDataUtils.GetHash(_difficultyBeatmap.level.levelID), _difficultyBeatmap.difficulty); _rawPP = SongDataUtils.GetRawPP(_songID); // modifiers var gameplayModifiersModelSO = Resources.FindObjectsOfTypeAll <GameplayModifiersModelSO>().FirstOrDefault(); var gameplayModifiers = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData.gameplayModifiers; _multiplier = gameplayModifiersModelSO.GetTotalMultiplier(gameplayModifiers); _multiplier = (Config.ignoreNoFail && gameplayModifiers.noFail) ? _multiplier + 0.5 : _multiplier; // Only update for ranked songs if (SongDataUtils.IsRankedSong(_songID)) { yield return(new WaitUntil(() => _beatmapObjectManager != null)); _beatmapObjectManager.noteWasCutEvent += OnNoteCut; _beatmapObjectManager.noteWasMissedEvent += OnNoteMissed; yield return(new WaitUntil(() => _scoreController != null)); _scoreController.scoreDidChangeEvent += OnScoreChange; if (!Config.hideOnStart) { UpdateCounter(); } } }
public static float GetRawPP(SongID songID) { if (RawPPLoader.InDict(songID.id)) { return(RawPPLoader.GetRawPP(songID)); } return(0); }
public static bool IsRankedSong(SongID songID) { if (RawPPLoader.InDict(songID.id)) { return(RawPPLoader.GetRawPP(songID) > 0); } return(false); }
public static void UpdatePlayHistory(SongID songID, double acc) { Logger.log.Debug($"Updating play history w/ {acc} on {songID}"); if (!playHistory.ContainsKey(songID) || acc > playHistory[songID]) { playHistory[songID] = acc; WriteToPlayHistory(); } }
public override TrackLink ToLink() { TrackLink link = new TrackLink("gs"); link["S"] = SongID.ToString(CultureInfo.InvariantCulture); link["A"] = ArtistID.ToString(CultureInfo.InvariantCulture); link["N"] = Name; link["AR"] = Artist; return(link); }
public void SubmitPlay(SongID songID, double acc) { // Unplayed or better than previous acc if (!songDataInfo.ContainsKey(songID) || acc > songDataInfo[songID].acc) { Logger.log.Debug("Unplayed or better score"); double pp = PPUtils.CalculatePP(songID, (float)(acc * 100)); int oldIndex = songDataInfo.ContainsKey(songID) ? songIndex[songID] : songIndex.Count; double weight = Double.NegativeInfinity; // Find first song that it's worth more than var i = 0; foreach (var song in songOrder) { var songWorth = songDataInfo[song].pp; if (songWorth < pp) { weight = songDataInfo[song].weight; break; } i++; } // found a song it's worth more than, decrease weight of songs below it that are above original if (weight != Double.NegativeInfinity) { for (; i < oldIndex; i++) { var song = songOrder[i]; songDataInfo[song].weight *= PPUtils.FALLOFF_RATE; } } // Lowest value song else { Logger.log.Debug("Lowest value song"); weight = songDataInfo[songOrder.Last()].weight * PPUtils.FALLOFF_RATE; } // Add/update this song songDataInfo[songID] = new SongData(acc, pp, weight); // recalculate and save data CalculateSums(); SaveSongData(); } }
public void LevelCleared(StandardLevelScenesTransitionSetupDataSO standardLevelScenesTransitionSetupDataSO, LevelCompletionResults levelCompletionResults) { Logger.log.Debug("Level cleared"); // Score submission disabled or using practice mode if (BS_Utils.Gameplay.ScoreSubmission.WasDisabled || BS_Utils.Gameplay.ScoreSubmission.ProlongedDisabled || ((GameplayCoreSceneSetupData)standardLevelScenesTransitionSetupDataSO.sceneSetupDataArray.First(x => x.GetType().Equals(typeof(GameplayCoreSceneSetupData)))).practiceSettings != null) { Logger.log.Debug("Practice mode or score disabled"); return; } var gameplayCoreSceneSetupData = ((GameplayCoreSceneSetupData)standardLevelScenesTransitionSetupDataSO.sceneSetupDataArray[1]); var difficultyBeatmap = gameplayCoreSceneSetupData.difficultyBeatmap; SongID songID = SongDataUtils.GetSongID(difficultyBeatmap); // I don't like putting play history here but until I do a refactor I'm gonna keep it here if (SongDataUtils.IsRankedSong(songID) || Config.playHistory) { Logger.log.Debug("Beat song"); GameplayModifiers modifiers = new GameplayModifiers(levelCompletionResults.gameplayModifiers); // Remove positive modifiers if not allowed if (!PPUtils.AllowedModifiers(songID.id, modifiers)) { Logger.log.Debug("Using invalid modifiers, removing from score"); modifiers = BeatSaberUtils.RemovePositiveModifiers(modifiers); } var multiplier = levelCompletionResults.gameplayModifiersModel.GetTotalMultiplier(modifiers); var score = levelCompletionResults.rawScore * multiplier; var maxScore = ScoreModel.MaxRawScoreForNumberOfNotes(difficultyBeatmap.beatmapData.notesCount); double acc = (double)score / (double)maxScore; Logger.log.Debug($"acc: {acc}"); if (SongDataUtils.IsRankedSong(songID)) { SubmitPlay(songID, acc); } else { PlayHistoryTracker.UpdatePlayHistory(songID, acc); } } }
public override void CounterInit() { var id = SongDataUtils.GetHash(difficultyBeatmap.level.levelID); songID = new SongID(id, difficultyBeatmap.difficulty); // Don't show anything for unranked songs or if data not initialized if (!ppUtils.DataInitialized() || !ppUtils.IsRanked(songID)) { return; } var gameplayModifiersModelSO = IPA.Utilities.FieldAccessor <RelativeScoreAndImmediateRankCounter, GameplayModifiersModelSO> .Get(relativeScoreAndImmediateRank, "_gameplayModifiersModel"); GameplayModifiers updatedModifiers = ppUtils.AllowedPositiveModifiers(songID) ? gameplayModifiers : GameplayModifierUtils.RemovePositiveModifiers(gameplayModifiers); _multiplier = GameplayModifierUtils.CalculateMultiplier(gameplayModifiersModelSO, updatedModifiers); counter = CanvasUtility.CreateTextFromSettings(Settings); counter.fontSize = 3; relativeScoreAndImmediateRank.relativeScoreOrImmediateRankDidChangeEvent += ScoreUpdated; UpdateCounterText(ppUtils.CalculatePP(songID, _multiplier, ppUtils.AllowedPositiveModifiers(songID))); if (PluginSettings.Instance.relativeGain) { var highScore = playerDataModel.playerData.GetPlayerLevelStatsData(difficultyBeatmap).highScore; if (highScore == 0) { _pbPP = 0; return; } var maxScore = ScoreModel.ComputeMaxMultipliedScoreForBeatmap(beatmapData); var acc = (float)highScore / maxScore; _pbPP = ppUtils.CalculatePP(songID, acc, ppUtils.AllowedPositiveModifiers(songID)); } }
public override string ToString() { return(string.Format("{0:20} | {1:15} | {2:15} | {3:15} | {4:2} | {5:15} ", Score.ToString(), SongID.ToString(), GameType.ToString(), Name.ToString(), Grade.ToString(), Difficulty.ToString())); }
internal void ClearAcc(SongID id) { _songSpecificAcc.Remove(id); WriteSongSpecificAccuracy(); }
internal void SaveAcc(SongID id, float accuracy) { _songSpecificAcc[id] = accuracy / 100f; WriteSongSpecificAccuracy(); }
private static SongDataCore.BeatStar.BeatStarSongDifficultyStats GetDifficultyStat(SongID songID) { var difficultyStats = SongDataCore.Plugin.Songs.Data.Songs[songID.id].diffs; foreach (var difficultyStat in difficultyStats) { if (difficultyStat.diff.Equals(SongDataUtils.GetDifficultyAsString(songID.difficulty))) { return(difficultyStat); } } throw new ArgumentException(); }
public static double GetRoundedStars(SongID songID) { var star = GetStars(songID); return(GetRoundedStars(star)); }
public static double GetStars(SongID songID) { var difficultyStat = GetDifficultyStat(songID); return(difficultyStat.star); }
protected virtual UriQuery GetUriQuery() { UriQuery query = new UriQuery(BaseUrl); query.Add("api_key", ApiKey); query.Add("format", "json"); if (!string.IsNullOrEmpty(Type)) { query.Add("type", Type); } if (ArtistID.Count() > 0) { foreach (Term artistId in ArtistID) { query.Add("artist_id", artistId); } } if (Artist.Count() > 0) { foreach (Term artist in Artist) { query.Add("artist", artist); } } if (SongID.Count() > 0) { foreach (Term songId in SongID) { query.Add("song_id", songId); } } if (TrackID.Count() > 0) { foreach (Term trackId in TrackID) { query.Add("track_id", trackId); } } if (Results.HasValue) { query.Add("results", Results.Value); } if (Bucket.HasValue) { foreach (string bucket in Bucket.Value.GetBucketDescriptions()) { query.Add("bucket", bucket); } } if (Limit.HasValue) { query.Add("limit", Limit.Value.ToString().ToLower()); } if (Dmca.HasValue) { query.Add("dmca", Dmca.Value.ToString().ToLower()); } return(query); }