public override void CounterInit()
{
ColorUtility.TryParseHtmlString("#FFA500", out orange);
modifiersModel = SCGameplayModsModel(ref scoreController);
IDifficultyBeatmap beatmap = data.difficultyBeatmap;
int maxRawScore = ScoreModel.MaxRawScoreForNumberOfNotes(beatmap.beatmapData.notesCount);
maxPossibleScore = ScoreModel.GetModifiedScoreForGameplayModifiersScoreMultiplier(maxRawScore,
modifiersModel.GetTotalMultiplier(data.gameplayModifiers));
stats = playerDataModel.playerData.GetPlayerLevelStatsData(beatmap);
highScore = stats.highScore;
if (scoreConfig.Enabled && Settings.UnderScore)
{
counter = CanvasUtility.CreateTextFromSettings(scoreConfig, SCORE_COUNTER_OFFSET);
}
else
{
counter = CanvasUtility.CreateTextFromSettings(Settings);
}
counter.alignment = TextAlignmentOptions.Top;
counter.fontSize = Settings.TextSize;
SetPersonalBest((float)highScore / maxPossibleScore);
}
static void Postfix(ref StandardLevelDetailViewPatches __instance)
{
//Only run calculation, if it isn't disabled
if (!Settings.Config.EnableMenuHighscore)
{
return;
}
if (__instance._playerStatsContainer)
{
if (__instance._showPlayerStats && __instance._playerData != null)
{
__instance._playerStatsContainer.SetActive(true);
PlayerLevelStatsData playerLevelStatsData = __instance._playerData.GetPlayerLevelStatsData(__instance._level.levelID, __instance._selectedDifficultyBeatmap.difficulty, __instance._selectedDifficultyBeatmap.parentDifficultyBeatmapSet.beatmapCharacteristic);
if (playerLevelStatsData.validScore)
{
//calculate maximum possilble score
int currentDifficultyMaxScore = ScorePercentage.calculateMaxScore(__instance.selectedDifficultyBeatmap.beatmapData.notesCount);
//calculate actual score percentage
double currentDifficultyPercentageScore = ScorePercentage.calculatePercentage(currentDifficultyMaxScore, playerLevelStatsData.highScore);
//add percentage to highScoreText
string highScoreText = playerLevelStatsData.highScore.ToString() + " " + "(" + currentDifficultyPercentageScore.ToString() + "%)";
__instance._highScoreText.text = highScoreText;
return;
}
}
// __instance._playerStatsContainer.SetActive(false);
}
}
private static void UploadScore(IDifficultyBeatmap levelDifficulty, LevelCompletionResults results, out bool newHighScore)
{
var freePlayCoordinator = Resources.FindObjectsOfTypeAll <SoloFreePlayFlowCoordinator>().First();
var dataModel = freePlayCoordinator.GetPrivateField <PlayerDataModel>("_playerDataModel");
PlayerData currentLocalPlayer = dataModel.playerData;
PlayerLevelStatsData playerLevelStatsData = currentLocalPlayer.GetPlayerLevelStatsData(levelDifficulty.level.levelID, levelDifficulty.difficulty, levelDifficulty.parentDifficultyBeatmapSet.beatmapCharacteristic);
int prevHighScore = playerLevelStatsData.highScore;
LevelCompletionResults levelCompletionResults = results;
playerLevelStatsData.UpdateScoreData(levelCompletionResults.modifiedScore, levelCompletionResults.maxCombo, levelCompletionResults.fullCombo, levelCompletionResults.rank);
newHighScore = playerLevelStatsData.highScore > prevHighScore;
var platFormLeaderBoardsModel = freePlayCoordinator.GetPrivateField <PlatformLeaderboardsModel>("_platformLeaderboardsModel");
platFormLeaderBoardsModel.UploadScore(
levelDifficulty,
results.rawScore,
results.modifiedScore,
results.fullCombo,
results.goodCutsCount,
results.badCutsCount,
results.missedCount,
results.maxCombo,
results.energy,
results.gameplayModifiers);
}
static void Postfix(StandardLevelDetailViewController __instance, ref LevelParamsPanel ____levelParamsPanel, ref TextMeshProUGUI ____highScoreText, ref IDifficultyBeatmap ____selectedDifficultyBeatmap, ref PlayerData ____playerData)
{
try
{
IBeatmapLevel level = ____selectedDifficultyBeatmap.level;
PlayerData localPlayer = ____playerData;
if (localPlayer != null)
{
PlayerLevelStatsData playerLevelStats = localPlayer.GetPlayerLevelStatsData(level.levelID, ____selectedDifficultyBeatmap.difficulty, ____selectedDifficultyBeatmap.parentDifficultyBeatmapSet.beatmapCharacteristic);
if (playerLevelStats != null)
{
if (playerLevelStats.validScore)
{
int highScore = int.Parse(____highScoreText.text);
int maxScore = ScoreController.MaxRawScoreForNumberOfNotes(____selectedDifficultyBeatmap.beatmapData.notesCount);
float percent = (float)highScore / maxScore;
percent *= 100;
____highScoreText.overflowMode = TextOverflowModes.Overflow;
____highScoreText.enableWordWrapping = false;
____highScoreText.richText = true;
____highScoreText.text += "<size=75%> <#FFFFFF> (" + "<#FFD42A>" + percent.ToString("F2") + "%" + "<#FFFFFF>)";
}
}
}
}
catch (Exception ex)
{
Plugin.Log("Exception in DetailView Postfix: \n " + ex);
}
}
public void SetNextRankText()
{
if (!poll)
{
return;
}
// At launch, the UI exists, but no level is selected.
LevelSO.DifficultyBeatmap difficultyBeatMap = ReflectionUtil.GetPrivateField <LevelSO.DifficultyBeatmap>(_songDetailViewController, "_difficultyBeatmap");
if (difficultyBeatMap == null)
{
return;
}
// If the player hasn't finished a level, blank out the Next Rank text to fit in with the rest of the UI.
if (_highScoreText.text == "-")
{
_nextRankText.text = _highScoreText.text;
return;
}
BeatmapDifficulty difficulty = difficultyBeatMap.difficulty;
int notesCount = difficultyBeatMap.beatmapData.notesCount;
PlayerDataModelSO.LocalPlayer player = ReflectionUtil.GetPrivateField <PlayerDataModelSO.LocalPlayer>(_songDetailViewController, "_player");
PlayerLevelStatsData playerLevelStatsData = player.GetPlayerLevelStatsData(difficultyBeatMap.level.levelID, difficulty);
_nextRankText.text = GetPointsToNextRank(notesCount, playerLevelStatsData.highScore);
}
public override void CounterInit()
{
IDifficultyBeatmap beatmap = data.difficultyBeatmap;
maxPossibleScore = ScoreModel.ComputeMaxMultipliedScoreForBeatmap(beatmapData);
stats = playerDataModel.playerData.GetPlayerLevelStatsData(beatmap);
highScore = stats.highScore;
if (scoreConfig.Enabled && Settings.UnderScore)
{
HUDCanvas scoreCanvas = CanvasUtility.GetCanvasSettingsFromID(scoreConfig.CanvasID);
counter = CanvasUtility.CreateTextFromSettings(scoreConfig, SCORE_COUNTER_OFFSET * (3f / scoreCanvas.PositionScale));
}
else
{
counter = CanvasUtility.CreateTextFromSettings(Settings);
}
counter.alignment = TextAlignmentOptions.Top;
counter.fontSize = Settings.TextSize;
pbRatio = (float)highScore / maxPossibleScore;
SetPersonalBest(pbRatio);
ScoreUpdated(0);
}
/// <summary>
/// Update the gameplay play counts.
/// </summary>
/// <param name="gameplayMode"></param>
private void UpdatePlayCounts()
{
// Build a map of levelId to sum of all playcounts and sort.
PlayerDataModelSO playerData = Resources.FindObjectsOfTypeAll <PlayerDataModelSO>().FirstOrDefault();
foreach (KeyValuePair <string, List <BeatmapLevelSO> > entry in _levelPackToSongs)
{
foreach (var level in entry.Value)
{
if (!_levelIdToPlayCount.ContainsKey(level.levelID))
{
// Skip folders
int playCountSum = 0;
foreach (IDifficultyBeatmapSet set in level.difficultyBeatmapSets)
{
foreach (IDifficultyBeatmap beatmap in set.difficultyBeatmaps)
{
PlayerLevelStatsData stats = playerData.currentLocalPlayer.GetPlayerLevelStatsData(level.levelID, beatmap.difficulty, set.beatmapCharacteristic);
playCountSum += stats.playCount;
}
}
_levelIdToPlayCount.Add(level.levelID, playCountSum);
}
}
}
}
static void Postfix(ref StandardLevelDetailViewPatches __instance)
{
if (__instance._showPlayerStats && __instance._playerData != null)
{
PlayerLevelStatsData playerLevelStatsData = __instance._playerData.GetPlayerLevelStatsData(__instance._level.levelID, __instance._selectedDifficultyBeatmap.difficulty, __instance._selectedDifficultyBeatmap.parentDifficultyBeatmapSet.beatmapCharacteristic);
Plugin.scorePercentageCommon.currentScore = playerLevelStatsData.highScore;
//Prepare Data for LevelStatsView
if (playerLevelStatsData.validScore)
{
Plugin.log.Debug("Condition 2 is true");
//calculate maximum possilble score
int currentDifficultyMaxScore = ScorePercentageCommon.calculateMaxScore(__instance.selectedDifficultyBeatmap.beatmapData.cuttableNotesType);
//calculate actual score percentage
double currentDifficultyPercentageScore = ScorePercentageCommon.calculatePercentage(currentDifficultyMaxScore, playerLevelStatsData.highScore);
Plugin.scorePercentageCommon.currentPercentage = currentDifficultyPercentageScore;
return;
}
}
// Set currentScore and currentPercentage to 0, if no playerData exists
// Does this even do anything!?
Plugin.scorePercentageCommon.currentScore = 0;
Plugin.scorePercentageCommon.currentPercentage = 0;
}
public void SongFinished(StandardLevelSceneSetupDataSO sender, LevelCompletionResults levelCompletionResults, IDifficultyBeatmap difficultyBeatmap, GameplayModifiers gameplayModifiers)
{
try
{
if (sender == null || levelCompletionResults == null || difficultyBeatmap == null || gameplayModifiers == null)
{
return;
}
Logger.Debug("Finished song: " + levelCompletionResults.levelEndStateType + " - " + levelCompletionResults.songDuration + " - - " + levelCompletionResults.endSongTime);
PlayerDataModelSO _playerDataModel = Resources.FindObjectsOfTypeAll <PlayerDataModelSO>().First();
_playerDataModel.currentLocalPlayer.playerAllOverallStatsData.soloFreePlayOverallStatsData.UpdateWithLevelCompletionResults(levelCompletionResults);
_playerDataModel.Save();
if (levelCompletionResults.levelEndStateType != LevelCompletionResults.LevelEndStateType.Failed && levelCompletionResults.levelEndStateType != LevelCompletionResults.LevelEndStateType.Cleared)
{
return;
}
PlayerDataModelSO.LocalPlayer currentLocalPlayer = _playerDataModel.currentLocalPlayer;
bool cleared = levelCompletionResults.levelEndStateType == LevelCompletionResults.LevelEndStateType.Cleared;
string levelID = difficultyBeatmap.level.levelID;
BeatmapDifficulty difficulty = difficultyBeatmap.difficulty;
PlayerLevelStatsData playerLevelStatsData = currentLocalPlayer.GetPlayerLevelStatsData(levelID, difficulty);
bool newHighScore = playerLevelStatsData.highScore < levelCompletionResults.score;
playerLevelStatsData.IncreaseNumberOfGameplays();
if (cleared)
{
playerLevelStatsData.UpdateScoreData(levelCompletionResults.score, levelCompletionResults.maxCombo, levelCompletionResults.fullCombo, levelCompletionResults.rank);
Resources.FindObjectsOfTypeAll <PlatformLeaderboardsModel>().First().AddScore(difficultyBeatmap, levelCompletionResults.unmodifiedScore, gameplayModifiers);
}
} catch (Exception e)
{
Data.Logger.Error(e);
}
}
static void Postfix(ref StandardLevelDetailViewPatches __instance)
{
if (__instance._playerStatsContainer)
{
if (__instance._showPlayerStats && __instance._playerData != null)
{
__instance._playerStatsContainer.SetActive(true);
PlayerLevelStatsData playerLevelStatsData = __instance._playerData.GetPlayerLevelStatsData(__instance._level.levelID, __instance._selectedDifficultyBeatmap.difficulty, __instance._selectedDifficultyBeatmap.parentDifficultyBeatmapSet.beatmapCharacteristic);
Plugin.scorePercentageCommon.currentScore = playerLevelStatsData.highScore;
if (playerLevelStatsData.validScore)
{
//calculate maximum possilble score
int currentDifficultyMaxScore = ScorePercentageCommon.calculateMaxScore(__instance.selectedDifficultyBeatmap.beatmapData.notesCount);
//calculate actual score percentage
double currentDifficultyPercentageScore = ScorePercentageCommon.calculatePercentage(currentDifficultyMaxScore, playerLevelStatsData.highScore);
Plugin.scorePercentageCommon.currentPercentage = currentDifficultyPercentageScore;
//add percentage to highScoreText if it isn't disabled
if (PluginConfig.Instance.EnableMenuHighscore)
{
string highScoreText = playerLevelStatsData.highScore.ToString() + " " + "(" + currentDifficultyPercentageScore.ToString() + "%)";
__instance._highScoreText.text = highScoreText;
}
return;
}
}
// Set currentScore and currentPercentage to 0, if no playerData exists
// Does this even do anything!?
Plugin.scorePercentageCommon.currentScore = 0;
Plugin.scorePercentageCommon.currentPercentage = 0;
// __instance._playerStatsContainer.SetActive(false);
}
}
/// <summary>
/// Update the gameplay play counts.
/// </summary>
/// <param name="gameplayMode"></param>
private void UpdatePlayCounts()
{
// Build a map of levelId to sum of all playcounts and sort.
PlayerDataModelSO playerData = Resources.FindObjectsOfTypeAll <PlayerDataModelSO>().FirstOrDefault();
IEnumerable <BeatmapDifficulty> difficultyIterator = Enum.GetValues(typeof(BeatmapDifficulty)).Cast <BeatmapDifficulty>();
foreach (var level in _originalSongs)
{
if (!_levelIdToPlayCount.ContainsKey(level.levelID))
{
// Skip folders
if (level.levelID.StartsWith("Folder_"))
{
_levelIdToPlayCount.Add(level.levelID, 0);
}
else
{
int playCountSum = 0;
foreach (BeatmapDifficulty difficulty in difficultyIterator)
{
PlayerLevelStatsData stats = playerData.currentLocalPlayer.GetPlayerLevelStatsData(level.levelID, difficulty);
playCountSum += stats.playCount;
}
_levelIdToPlayCount.Add(level.levelID, playCountSum);
}
}
}
}
private void Init(CountersData data)
{
_scoreController = data.ScoreController;
PlayerDataModelSO player = data.PlayerData;
gameplayModsModel = data.ModifiersData;
gameplayMods = data.PlayerData.playerData.gameplayModifiers;
IDifficultyBeatmap beatmap = data.GCSSD.difficultyBeatmap;
stats = player.playerData.GetPlayerLevelStatsData(
beatmap.level.levelID, beatmap.difficulty, beatmap.parentDifficultyBeatmapSet.beatmapCharacteristic);
int maxRawScore = ScoreController.MaxRawScoreForNumberOfNotes(beatmap.beatmapData.notesCount);
_maxPossibleScore = Mathf.RoundToInt(maxRawScore * gameplayModsModel.GetTotalMultiplier(gameplayMods));
beginningPB = stats.highScore / (float)_maxPossibleScore;
highScore = stats.highScore;
Vector3 position = CountersController.DeterminePosition(gameObject, settings.Position, settings.Distance);
TextHelper.CreateText(out _PbTrackerText, position);
_PbTrackerText.fontSize = settings.TextSize;
_PbTrackerText.color = Color.white;
_PbTrackerText.alignment = TextAlignmentOptions.Center;
_scoreController.scoreDidChangeEvent += UpdateScore;
SetPersonalBest(beginningPB);
if (settings.UnderScore)
{
StartCoroutine(WaitForScoreCounter());
}
}
public override void CounterInit()
{
modifiersModel = SCGameplayModsModel(ref scoreController);
IDifficultyBeatmap beatmap = data.difficultyBeatmap;
int maxRawScore = ScoreModel.MaxRawScoreForNumberOfNotes(noteCountProcessor.NoteCount);
maxPossibleScore = ScoreModel.GetModifiedScoreForGameplayModifiersScoreMultiplier(maxRawScore,
modifiersModel.GetTotalMultiplier(data.gameplayModifiers));
stats = playerDataModel.playerData.GetPlayerLevelStatsData(beatmap);
highScore = stats.highScore;
if (scoreConfig.Enabled && Settings.UnderScore)
{
HUDCanvas scoreCanvas = CanvasUtility.GetCanvasSettingsFromID(scoreConfig.CanvasID);
counter = CanvasUtility.CreateTextFromSettings(scoreConfig, SCORE_COUNTER_OFFSET * (3f / scoreCanvas.PositionScale));
}
else
{
counter = CanvasUtility.CreateTextFromSettings(Settings);
}
counter.alignment = TextAlignmentOptions.Top;
counter.fontSize = Settings.TextSize;
pbRatio = (float)highScore / maxPossibleScore;
SetPersonalBest((float)highScore / maxPossibleScore);
ScoreUpdated(0);
}
public void SongFinished(StandardLevelScenesTransitionSetupDataSO sender, LevelCompletionResults levelCompletionResults, IDifficultyBeatmap difficultyBeatmap, GameplayModifiers gameplayModifiers, bool practice)
{
if (Client.Instance.InRadioMode)
{
PluginUI.instance.radioFlowCoordinator.lastDifficulty = difficultyBeatmap;
PluginUI.instance.radioFlowCoordinator.lastResults = levelCompletionResults;
}
if (Config.Instance.SpectatorMode || Client.disableScoreSubmission || ScoreSubmission.Disabled || ScoreSubmission.ProlongedDisabled)
{
List <string> reasons = new List <string>();
if (Config.Instance.SpectatorMode)
{
reasons.Add("Spectator mode");
}
if (Client.disableScoreSubmission)
{
reasons.Add("Multiplayer score submission disabled by another mod");
}
if (ScoreSubmission.Disabled)
{
reasons.Add("Score submission is disabled by " + ScoreSubmission.ModString);
}
if (ScoreSubmission.ProlongedDisabled)
{
reasons.Add("Score submission is disabled for a prolonged time by " + ScoreSubmission.ProlongedModString);
}
Misc.Logger.Warning("\nScore submission is disabled! Reason:\n" + string.Join(",\n", reasons));
return;
}
PlayerDataModelSO _playerDataModel = Resources.FindObjectsOfTypeAll <PlayerDataModelSO>().First();
_playerDataModel.currentLocalPlayer.playerAllOverallStatsData.soloFreePlayOverallStatsData.UpdateWithLevelCompletionResults(levelCompletionResults);
_playerDataModel.Save();
if (levelCompletionResults.levelEndStateType != LevelCompletionResults.LevelEndStateType.Failed && levelCompletionResults.levelEndStateType != LevelCompletionResults.LevelEndStateType.Cleared)
{
return;
}
PlayerDataModelSO.LocalPlayer currentLocalPlayer = _playerDataModel.currentLocalPlayer;
bool cleared = levelCompletionResults.levelEndStateType == LevelCompletionResults.LevelEndStateType.Cleared;
string levelID = difficultyBeatmap.level.levelID;
BeatmapDifficulty difficulty = difficultyBeatmap.difficulty;
BeatmapCharacteristicSO beatmapCharacteristic = difficultyBeatmap.parentDifficultyBeatmapSet.beatmapCharacteristic;
PlayerLevelStatsData playerLevelStatsData = currentLocalPlayer.GetPlayerLevelStatsData(levelID, difficulty, beatmapCharacteristic);
bool newHighScore = playerLevelStatsData.highScore < levelCompletionResults.score;
playerLevelStatsData.IncreaseNumberOfGameplays();
if (cleared)
{
Misc.Logger.Info("Submitting score...");
playerLevelStatsData.UpdateScoreData(levelCompletionResults.score, levelCompletionResults.maxCombo, levelCompletionResults.fullCombo, levelCompletionResults.rank);
Resources.FindObjectsOfTypeAll <PlatformLeaderboardsModel>().First().AddScore(difficultyBeatmap, levelCompletionResults.unmodifiedScore, gameplayModifiers);
Misc.Logger.Info("Score submitted!");
}
}
static bool Prefix(MissionLevelScenesTransitionSetupDataSO missionLevelScenesTransitionSetupData, MissionCompletionResults missionCompletionResults, CampaignFlowCoordinator __instance, MissionSelectionNavigationController ____missionSelectionNavigationController)
{
if (!(____missionSelectionNavigationController.selectedMissionNode.missionData is CustomMissionDataSO))
{
return(true);
}
ChallengeExternalModifiers.onChallengeEnd?.Invoke();
if (missionCompletionResults.levelCompletionResults.levelEndAction == LevelCompletionResults.LevelEndAction.Restart)
{
____missionSelectionNavigationController.GetPrivateField <Action <MissionSelectionNavigationController> >("didPressPlayButtonEvent")(____missionSelectionNavigationController);
return(false);
}
if (missionCompletionResults.levelCompletionResults.levelEndStateType == LevelCompletionResults.LevelEndStateType.Cleared && missionCompletionResults.IsMissionComplete)
{
CustomMissionDataSO customMissionData = ____missionSelectionNavigationController.selectedMissionNode.missionData as CustomMissionDataSO;
Campaign campaign = customMissionData.campaign;
Challenge challenge = customMissionData.challenge;
foreach (UnlockableItem item in challenge.unlockableItems)
{
try
{
item.UnlockItem(campaign.path);
} catch (Exception ex)
{
Console.WriteLine("Failed to unlock item: " + item.fileName + " - Exception: " + ex.Message);
}
}
UnlockedItemsViewController unlockedItemsViewController = Resources.FindObjectsOfTypeAll <UnlockedItemsViewController>().First();
unlockedItemsViewController.items = challenge.unlockableItems;
unlockedItemsViewController.index = 0;
if (unlockedItemsViewController.items.Count > 0)
{
__instance.InvokeMethod("SetBottomScreenViewController", new object[] { unlockedItemsViewController, false });
}
if (challenge.unlockMap)
{
UnlockedMaps.CompletedChallenge(challenge.name);
}
//Score submission
if (customMissionData.gameplayModifiers.songSpeedMul == 1f && customMissionData.gameplayModifiers.fastNotes == false && customMissionData.gameplayModifiers.failOnSaberClash == false)
{
SoloFreePlayFlowCoordinator freePlayCoordinator = Resources.FindObjectsOfTypeAll <SoloFreePlayFlowCoordinator>().First();
PlayerDataModelSO dataModel = freePlayCoordinator.GetPrivateField <PlayerDataModelSO>("_playerDataModel");
PlayerData currentLocalPlayer = dataModel.playerData;
IDifficultyBeatmap difficultyBeatmap = Loader.BeatmapLevelsModelSO.GetBeatmapLevelIfLoaded(customMissionData.customLevel.levelID).beatmapLevelData.GetDifficultyBeatmap(customMissionData.beatmapCharacteristic, customMissionData.beatmapDifficulty);
PlayerLevelStatsData playerLevelStatsData = currentLocalPlayer.GetPlayerLevelStatsData(difficultyBeatmap.level.levelID, difficultyBeatmap.difficulty, difficultyBeatmap.parentDifficultyBeatmapSet.beatmapCharacteristic);
LevelCompletionResults levelCompletionResults = missionCompletionResults.levelCompletionResults;
playerLevelStatsData.UpdateScoreData(levelCompletionResults.modifiedScore, levelCompletionResults.maxCombo, levelCompletionResults.fullCombo, levelCompletionResults.rank);
//todo Need change???
//freePlayCoordinator.GetPrivateField<PlatformLeaderboardsModel>("_platformLeaderboardsModel").AddScoreFromComletionResults(difficultyBeatmap, levelCompletionResults);
}
__instance.StartCoroutine(CustomCampaignLeaderboard.SubmitScore(challenge, missionCompletionResults));
}
return(true);
}
public void GetMaxScores(LevelCompletionResults results, SongData data)
{
IDifficultyBeatmap beatmap = data.GetGCSSD().difficultyBeatmap;
PlayerLevelStatsData stats = data.GetPlayerData().playerData.GetPlayerLevelStatsData(beatmap.level.levelID, beatmap.difficulty, beatmap.parentDifficultyBeatmapSet.beatmapCharacteristic);
maxRawScore = ScoreModel.MaxRawScoreForNumberOfNotes(beatmap.beatmapData.cuttableNotesType);
modifiersMultiplier = GetTotalMultiplier(data.GetPlayerData().playerData.gameplayModifiers, results.energy);
maxScore = Mathf.RoundToInt(maxRawScore * modifiersMultiplier);
personalBestModifiedRatio = stats.highScore / (float)maxScore;
personalBestRawRatio = stats.highScore / (float)maxRawScore;
personalBest = stats.highScore;
}
public static void GetSongInfo()
{
if (_mainGameSceneSetupData == null)
{
_mainGameSceneSetupData = Resources.FindObjectsOfTypeAll <StandardLevelSceneSetupDataSO>().FirstOrDefault();
}
//Get notes count
noteCount = _mainGameSceneSetupData.difficultyBeatmap.beatmapData.notesCount;
PlayerDataModelSO playerData = Resources.FindObjectsOfTypeAll <PlayerDataModelSO>().FirstOrDefault();
PlayerLevelStatsData playerLevelData = playerData.currentLocalPlayer.GetPlayerLevelStatsData(_mainGameSceneSetupData.difficultyBeatmap.level.levelID, _mainGameSceneSetupData.difficultyBeatmap.difficulty);
//Get Player Score
if (playerScore == 0)
{
Log("Attempting to grab Local Score");
playerScore = playerLevelData.validScore ? playerLevelData.highScore : 0;
}
CalculatePercentage();
}
public void SongFinished(StandardLevelSceneSetupDataSO sender, LevelCompletionResults levelCompletionResults, IDifficultyBeatmap difficultyBeatmap, GameplayModifiers gameplayModifiers, bool practice)
{
if (Client.Instance.InRadioMode)
{
PluginUI.instance.radioFlowCoordinator.lastDifficulty = difficultyBeatmap;
PluginUI.instance.radioFlowCoordinator.lastResults = levelCompletionResults;
}
if (Config.Instance.SpectatorMode || Client.disableScoreSubmission || ScoreSubmission.Disabled || ScoreSubmission.ProlongedDisabled)
{
return;
}
PlayerDataModelSO _playerDataModel = Resources.FindObjectsOfTypeAll <PlayerDataModelSO>().First();
_playerDataModel.currentLocalPlayer.playerAllOverallStatsData.soloFreePlayOverallStatsData.UpdateWithLevelCompletionResults(levelCompletionResults);
_playerDataModel.Save();
if (levelCompletionResults.levelEndStateType != LevelCompletionResults.LevelEndStateType.Failed && levelCompletionResults.levelEndStateType != LevelCompletionResults.LevelEndStateType.Cleared)
{
return;
}
PlayerDataModelSO.LocalPlayer currentLocalPlayer = _playerDataModel.currentLocalPlayer;
bool cleared = levelCompletionResults.levelEndStateType == LevelCompletionResults.LevelEndStateType.Cleared;
string levelID = difficultyBeatmap.level.levelID;
BeatmapDifficulty difficulty = difficultyBeatmap.difficulty;
PlayerLevelStatsData playerLevelStatsData = currentLocalPlayer.GetPlayerLevelStatsData(levelID, difficulty);
bool newHighScore = playerLevelStatsData.highScore < levelCompletionResults.score;
playerLevelStatsData.IncreaseNumberOfGameplays();
if (cleared)
{
playerLevelStatsData.UpdateScoreData(levelCompletionResults.score, levelCompletionResults.maxCombo, levelCompletionResults.fullCombo, levelCompletionResults.rank);
Resources.FindObjectsOfTypeAll <PlatformLeaderboardsModel>().First().AddScore(difficultyBeatmap, levelCompletionResults.unmodifiedScore, gameplayModifiers);
}
}
private void BSEvents_gameSceneLoaded()
{
ResetData();
LiveData.InLevel = true;
scoreController = Resources.FindObjectsOfTypeAll <ScoreController>().FirstOrDefault();
scoreController.scoreDidChangeEvent += ScoreController_scoreDidChangeEvent;
AudioTimeSyncController audioController = Resources.FindObjectsOfTypeAll <AudioTimeSyncController>().FirstOrDefault();
PlayerData playerData = Resources.FindObjectsOfTypeAll <PlayerDataModel>().FirstOrDefault().playerData;
GameplayCoreSceneSetupData currentMap = BS_Utils.Plugin.LevelData.GameplayCoreSceneSetupData;
IBeatmapLevel levelData = currentMap.difficultyBeatmap.level;
StaticData.SongName = levelData.songName;
StaticData.SongSubName = levelData.songSubName;
StaticData.SongAuthor = levelData.songAuthorName;
StaticData.Mapper = levelData.levelAuthorName;
StaticData.BPM = Convert.ToInt32(Math.Round(levelData.beatsPerMinute));
StaticData.Length = Convert.ToInt32(Math.Round(audioController.songLength));
PlayerLevelStatsData playerLevelStats = playerData.GetPlayerLevelStatsData(levelData.levelID, currentMap.difficultyBeatmap.difficulty,
currentMap.difficultyBeatmap.parentDifficultyBeatmapSet.beatmapCharacteristic);
StaticData.PreviousRecord = playerLevelStats.highScore;
if (previousMap == null || previousBeatmap == null || (levelData.levelID != previousMap.difficultyBeatmap.level.levelID))
{
Task.Run(async() =>
{
if (previousBeatmap != null)
{
StaticData.PreviousBSR = previousBeatmap.Key;
}
Beatmap bm = await beatSaver.Hash(levelData.levelID.Replace("custom_level_", ""));
if (bm != null)
{
StaticData.BSRKey = bm.Key;
StaticData.coverImage = BeatSaver.BaseURL + bm.CoverURL;
previousBeatmap = bm;
}
else
{
StaticData.BSRKey = null; StaticData.coverImage = null; previousBeatmap = null;
}
StaticData.Send();
});
}
else
{
StaticData.BSRKey = previousBeatmap.Key; StaticData.coverImage = BeatSaver.BaseURL + previousBeatmap.CoverURL;
}
StaticData.Difficulty = currentMap.difficultyBeatmap.difficultyRank;
StaticData.NJS = currentMap.difficultyBeatmap.noteJumpMovementSpeed;
StaticData.Modifiers.Add("instaFail", currentMap.gameplayModifiers.instaFail);
StaticData.Modifiers.Add("batteryEnergy", currentMap.gameplayModifiers.energyType == GameplayModifiers.EnergyType.Battery);
StaticData.Modifiers.Add("disappearingArrows", currentMap.gameplayModifiers.disappearingArrows);
StaticData.Modifiers.Add("ghostNotes", currentMap.gameplayModifiers.ghostNotes);
StaticData.Modifiers.Add("fasterSong", currentMap.gameplayModifiers.songSpeedMul == 1.2f ? true : false);
StaticData.Modifiers.Add("noFail", currentMap.gameplayModifiers.noFail);
LiveData.PlayerHealth = StaticData.Modifiers["noFail"] ? 100 : 50;
StaticData.Modifiers.Add("noObstacles", currentMap.gameplayModifiers.enabledObstacleType == GameplayModifiers.EnabledObstacleType.NoObstacles);
StaticData.Modifiers.Add("noBombs", currentMap.gameplayModifiers.noBombs);
StaticData.Modifiers.Add("slowerSong", currentMap.gameplayModifiers.songSpeedMul == 0.85f ? true : false);
StaticData.Modifiers.Add("noArrows", currentMap.gameplayModifiers.noArrows);
if (currentMap.practiceSettings != null) //In Practice mode
{
StaticData.PracticeMode = true;
startSongTime = new TimeSpan(0, 0, (int)Math.Round(currentMap.practiceSettings.startSongTime) - 1); //1s time desync
StaticData.PracticeModeModifiers.Add("songSpeedMul", currentMap.practiceSettings.songSpeedMul);
}
previousMap = currentMap;
TimeElapsed.Start();
TimeElapsedLogger.Start();
StaticData.Send();
LiveData.Send();
}
public void SetupMapDataAndMisc()
{
PlayerData playerData = Resources.FindObjectsOfTypeAll <PlayerDataModel>().FirstOrDefault().playerData;
IBeatmapLevel levelData = gameplayCoreSceneSetupData.difficultyBeatmap.level;
bool isCustomLevel = true;
string mapHash = string.Empty;
try { mapHash = levelData.levelID.Split('_')[2]; } catch { isCustomLevel = false; }
isCustomLevel = isCustomLevel && mapHash.Length == 40 ? true : false;
var difficultyData = SongCore.Collections.RetrieveDifficultyData(gameplayCoreSceneSetupData.difficultyBeatmap);
MapData.Hash = isCustomLevel ? mapHash : null;
MapData.SongName = levelData.songName;
MapData.SongSubName = levelData.songSubName;
MapData.SongAuthor = levelData.songAuthorName;
MapData.Mapper = levelData.levelAuthorName;
MapData.BPM = Convert.ToInt32(Math.Round(levelData.beatsPerMinute));
MapData.Length = Convert.ToInt32(Math.Round(audioTimeSyncController.songLength));
PlayerLevelStatsData playerLevelStats = playerData.GetPlayerLevelStatsData(levelData.levelID, gameplayCoreSceneSetupData.difficultyBeatmap.difficulty,
gameplayCoreSceneSetupData.difficultyBeatmap.parentDifficultyBeatmapSet.beatmapCharacteristic);
MapData.PreviousRecord = playerLevelStats.highScore;
MapData.MapType = gameplayCoreSceneSetupData.difficultyBeatmap.parentDifficultyBeatmapSet.beatmapCharacteristic.serializedName;
MapData.Difficulty = gameplayCoreSceneSetupData.difficultyBeatmap.difficulty.ToString("g");
MapData.NJS = gameplayCoreSceneSetupData.difficultyBeatmap.noteJumpMovementSpeed;
MapData.CustomDifficultyLabel = difficultyData?._difficultyLabel ?? null;
SongDataCoreCurrent sdc = new SongDataCoreCurrent {
available = isCustomLevel ? SongDataCore.Plugin.Songs.IsDataAvailable() : false
};
if (sdc.available)
{
BeatStarSong map;
SongDataCore.Plugin.Songs.Data.Songs.TryGetValue(mapHash, out map);
sdc.map = map;
if (sdc.map != null)
{
Dictionary <string, BeatStarSongDifficultyStats> diffs = sdc.map.characteristics[(BeatStarCharacteristics)Enum.Parse(typeof(BeatStarCharacteristics),
gameplayCoreSceneSetupData.difficultyBeatmap.parentDifficultyBeatmapSet.beatmapCharacteristic.serializedName)];
sdc.stats = diffs[MapData.Difficulty == "ExpertPlus" ? "Expert+" : MapData.Difficulty];
MapData.PP = sdc.stats.pp;
MapData.Star = sdc.stats.star;
}
else
{
sdc.available = false;
}
}
if (sdc.available)
{
MapData.BSRKey = sdc.map.key;
if (levelData is CustomPreviewBeatmapLevel customLevel)
{
MapData.coverImage = GetBase64CoverImage(customLevel);
}
else
{
getBeatsaverMap();
}
}
else
{
getBeatsaverMap();
}
void getBeatsaverMap()
{
Task.Run(async() =>
{
Beatmap bm = await beatSaver.Hash(mapHash);
if (bm != null)
{
MapData.BSRKey = bm.Key;
MapData.coverImage = BeatSaver.BaseURL + bm.CoverURL;
}
else
{
MapData.BSRKey = null;
}
MapData.Send();
});
}
if (MapData.Hash != previousStaticData.Hash)
{
MapData.PreviousBSR = previousStaticData.BSRKey;
}
MapData.Modifiers.Add("noFailOn0Energy", gameplayCoreSceneSetupData.gameplayModifiers.noFailOn0Energy);
MapData.Modifiers.Add("oneLife", gameplayCoreSceneSetupData.gameplayModifiers.instaFail);
MapData.Modifiers.Add("fourLives", gameplayCoreSceneSetupData.gameplayModifiers.energyType == GameplayModifiers.EnergyType.Battery);
MapData.Modifiers.Add("noBombs", gameplayCoreSceneSetupData.gameplayModifiers.noBombs);
MapData.Modifiers.Add("noWalls", gameplayCoreSceneSetupData.gameplayModifiers.enabledObstacleType == GameplayModifiers.EnabledObstacleType.NoObstacles);
MapData.Modifiers.Add("noArrows", gameplayCoreSceneSetupData.gameplayModifiers.noArrows);
MapData.Modifiers.Add("ghostNotes", gameplayCoreSceneSetupData.gameplayModifiers.ghostNotes);
MapData.Modifiers.Add("disappearingArrows", gameplayCoreSceneSetupData.gameplayModifiers.disappearingArrows);
MapData.Modifiers.Add("smallNotes", gameplayCoreSceneSetupData.gameplayModifiers.smallCubes);
MapData.Modifiers.Add("proMode", gameplayCoreSceneSetupData.gameplayModifiers.proMode);
MapData.Modifiers.Add("strictAngles", gameplayCoreSceneSetupData.gameplayModifiers.strictAngles);
MapData.Modifiers.Add("zenMode", gameplayCoreSceneSetupData.gameplayModifiers.zenMode);
MapData.Modifiers.Add("slowerSong", gameplayCoreSceneSetupData.gameplayModifiers.songSpeedMul == 0.85f ? true : false);
MapData.Modifiers.Add("fasterSong", gameplayCoreSceneSetupData.gameplayModifiers.songSpeedMul == 1.2f ? true : false);
MapData.Modifiers.Add("superFastSong", gameplayCoreSceneSetupData.gameplayModifiers.songSpeedMul == 1.5f ? true : false);
foreach (KeyValuePair <string, bool> keyValue in MapData.Modifiers)
{
if (MapData.Modifiers[keyValue.Key] && Enum.IsDefined(typeof(Modifiers), keyValue.Key))
{
MapData.ModifiersMultiplier += (int)(Modifiers)Enum.Parse(typeof(Modifiers), keyValue.Key) / 100f;
}
}
MapData.PracticeMode = gameplayCoreSceneSetupData.practiceSettings != null ? true : false;
MapData.PracticeModeModifiers.Add("songSpeedMul", MapData.PracticeMode ? gameplayCoreSceneSetupData.practiceSettings.songSpeedMul : 1);
MapData.PracticeModeModifiers.Add("startInAdvanceAndClearNotes", MapData.PracticeMode ? gameplayCoreSceneSetupData.practiceSettings.startInAdvanceAndClearNotes ? 1 : 0 : 0);
MapData.PracticeModeModifiers.Add("startSongTime", MapData.PracticeMode ? gameplayCoreSceneSetupData.practiceSettings.startSongTime : 0);
MapData.InLevel = true;
timer.Start();
MapData.Send();
LiveData.Send();
}
