The Everything Update (UI Overhaul + Bug Fixes)

.gitignore

@@ -354,3 +354,4 @@ MigrationBackup/
 ScoreSaber/ObfuscationSettings.cs
 ScoreSaber/Core/ReplaySystem/Legacy/LegacyRecorder.cs
 ScoreSaber/Core/ReplaySystem/Legacy/OldLegacyReplayPlayer.cs
+/.idea

README.md

@@ -1,4 +1,12 @@
 # ScoreSaber-Plugin
-Clone, and goodluck. The open source release of ScoreSaber was done hastily and quite a lot needs to be changed and plenty of "security through obscurity" practices covered by obfuscation can finally be removed, cleaning up the project. 
+ScoreSaber is Beat Saber's largest leaderboard system for custom songs, hosting 60 million scores across 170,000+ leaderboards, with more than 1 million users worldwide
 
-Everything here is licensed under MIT and we'll be accepting contributors immediately, so if you're looking to help us out, that'd be greatly appreciated, we're going to need it.
+![image](https://github.com/user-attachments/assets/f638f92b-d961-46e1-8277-d2628676128a)
+
+Scores can also be viewed on [the website](https://scoresaber.com)
+
+# Installation
+## Method 1
+- Install from your preferred mod manager
+## Method 2
+- Download from the [releases](https://github.com/ScoreSaber/scoresaber-plugin/releases/latest)

ScoreSaber/Core/AffinityPatches/MenuPresencePatches.cs

@@ -0,0 +1,102 @@
+using HarmonyLib;
+using ScoreSaber.Core.Data.Models;
+using ScoreSaber.Core.Services;
+using ScoreSaber.Core.Utils;
+using SiraUtil.Affinity;
+using SiraUtil.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Zenject;
+
+namespace ScoreSaber.Core.AffinityPatches {
+    public class MenuPresencePatches : IAffinity {
+
+        [Inject] private readonly RichPresenceService _richPresenceService = null;
+
+        [AffinityPatch(typeof(SinglePlayerLevelSelectionFlowCoordinator), "HandleStandardLevelDidFinish")]
+        [AffinityPostfix]
+        public void HandleStopStandardLevelPostfix() {
+            var jsonObject = new SceneChangeEvent() {
+                Timestamp = _richPresenceService.TimeRightNow,
+                Scene = Scene.menu
+            };
+
+            _richPresenceService.SendUserProfileChannel("scene_change", jsonObject);
+        }
+
+        [AffinityPatch(typeof(SinglePlayerLevelSelectionFlowCoordinator), nameof(SinglePlayerLevelSelectionFlowCoordinator.StartLevel))]
+        [AffinityPostfix]
+        public void HandleStartLevelPostfix(SinglePlayerLevelSelectionFlowCoordinator __instance, Action beforeSceneSwitchCallback, bool practice) {
+
+            bool isPractice = practice;
+            GameMode gameMode = GameMode.solo;
+
+            if (isPractice) {
+                gameMode = GameMode.practice;
+
+                // this is to privatise the practice mode song, as it would be exposed in the rich presence, still not shown in UI though.
+                var songEventPrivate = new SongRichPresenceInfo(_richPresenceService.TimeRightNow, gameMode,
+                                    "PRACTICE",
+                                    string.Empty,
+                                    "PRACTICE AUTHOR",
+                                    "PRACTICE MAPPER",
+                                    "Standard",
+                                    "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE",
+                                    (int)2000000000,
+                                    1,
+                                    0,
+                                    1);
+
+                _richPresenceService.SendUserProfileChannel("start_song", songEventPrivate);
+                return;
+            }
+
+            GameplayModifiers gameplayModifiers = __instance.gameplayModifiers;
+            int startTime = 0;
+            if (__instance.isInPracticeView) {
+                startTime = (int)__instance._practiceViewController._practiceSettings.startSongTime;
+            }
+
+            var songEvent = CreateSongStartEvent(__instance.selectedBeatmapLevel, __instance.selectedBeatmapKey, gameplayModifiers, startTime, gameMode);
+
+            _richPresenceService.SendUserProfileChannel("start_song", songEvent);
+        }
+
+        [AffinityPatch(typeof(MultiplayerLevelSelectionFlowCoordinator), nameof(MultiplayerLevelSelectionFlowCoordinator.HandleLobbyGameStateControllerGameStarted))]
+        [AffinityPostfix]
+        public void HandleMultiplayerGameStartPostfix(MultiplayerLevelSelectionFlowCoordinator __instance, ILevelGameplaySetupData levelGameplaySetupData) {
+
+            // i dont like this, but i have to do it, just in case the users selected level doesnt match what the game started with
+            BeatmapLevel beatmapLevel = SongCore.Loader.GetLevelById(levelGameplaySetupData.beatmapKey.levelId);
+
+            GameplayModifiers gameplayModifiers = levelGameplaySetupData.gameplayModifiers;
+            int startTime = 0;
+
+            var songEvent = CreateSongStartEvent(beatmapLevel, levelGameplaySetupData.beatmapKey, gameplayModifiers, startTime, GameMode.multiplayer);
+
+            _richPresenceService.SendUserProfileChannel("start_song", songEvent);
+        }
+
+        private SongRichPresenceInfo CreateSongStartEvent(BeatmapLevel beatmapLevel, BeatmapKey beatmapKey, GameplayModifiers gameplayModifiers, int startTime, GameMode gameMode) {
+
+            string hash = BeatmapUtils.GetHashFromLevelID(beatmapLevel, out bool isOst);
+
+            var songEvent = new SongRichPresenceInfo(_richPresenceService.TimeRightNow, gameMode,
+                                    beatmapLevel.songName,
+                                    beatmapLevel.songSubName,
+                                    BeatmapUtils.FriendlyLevelAuthorName(beatmapLevel.allMappers, beatmapLevel.allLighters),
+                                    beatmapLevel.songAuthorName,
+                                    beatmapKey.beatmapCharacteristic.SerializedName(),
+                                    hash,
+                                    (int)beatmapLevel.songDuration,
+                                    ((int)beatmapKey.difficulty * 2) + 1,
+                                    startTime,
+                                    gameplayModifiers.songSpeedMul);
+
+            return songEvent;
+        }
+    }
+}

ScoreSaber/Core/AppInstaller.cs

@@ -1,4 +1,6 @@
 using ScoreSaber.Core.Daemons;
+using ScoreSaber.Core.Http;
+using ScoreSaber.Core.Services;
 using System.Reflection;
 using Zenject;
 
@@ -7,8 +9,11 @@ internal class AppInstaller : Installer {
 
         public override void InstallBindings() {
             Plugin.Container = Container;
+            Container.Bind<PlayerService>().AsSingle();
 
             Container.Bind<ReplayService>().AsSingle().NonLazy();
+            Container.BindInterfacesAndSelfTo<RichPresenceService>().AsSingle();
+            Container.Bind<ScoreSaberHttpClient>().FromInstance(new ScoreSaberHttpClient(new HttpClientOptions(applicationName: "ScoreSaber-PC", version: Plugin.Instance.LibVersion, defaultTimeout: 5, uploadTimeout: 120))).AsSingle();
         }
     }
 }

ScoreSaber/Core/Daemons/UploadDaemon.cs

@@ -15,6 +15,9 @@
 using ScoreSaber.Core.Utils;
 using static ScoreSaber.UI.Leaderboard.ScoreSaberLeaderboardViewController;
 using System.Threading;
+using ScoreSaber.Core.Http;
+using ScoreSaber.Core.Http.Configuration;
+using ScoreSaber.Core.Http.Endpoints.API;
 
 namespace ScoreSaber.Core.Daemons {
 
@@ -28,18 +31,20 @@ internal class UploadDaemon : IDisposable, IUploadDaemon {
         private readonly PlayerService _playerService = null;
         private readonly ReplayService _replayService = null;
         private readonly LeaderboardService _leaderboardService = null;
+        private readonly ScoreSaberHttpClient _scoreSaberHttpClient = null;
 
         private readonly PlayerDataModel _playerDataModel = null;
         private readonly MaxScoreCache _maxScoreCache = null;
 
         private const string UPLOAD_SECRET = "f0b4a81c9bd3ded1081b365f7628781f";
 
-        public UploadDaemon(PlayerService playerService, LeaderboardService leaderboardService, ReplayService replayService, PlayerDataModel playerDataModel, MaxScoreCache maxScoreCache) {
+        public UploadDaemon(PlayerService playerService, LeaderboardService leaderboardService, ReplayService replayService, PlayerDataModel playerDataModel, MaxScoreCache maxScoreCache, ScoreSaberHttpClient scoreSaberHttpClient) {
             _playerService = playerService;
             _replayService = replayService;
             _leaderboardService = leaderboardService;
             _playerDataModel = playerDataModel;
             _maxScoreCache = maxScoreCache;
+            _scoreSaberHttpClient = scoreSaberHttpClient;
 
             SetupUploader();
             Plugin.Log.Debug("Upload service setup!");
@@ -127,33 +132,31 @@ public void Five(string gameMode, BeatmapLevel beatmapLevel, BeatmapKey beatmapK
         //This starts the upload processs
         async void Six(BeatmapLevel beatmapLevel, BeatmapKey beatmapKey, LevelCompletionResults levelCompletionResults) {
 
-            if (!beatmapLevel.hasPrecalculatedData) {
-                int maxScore = await _maxScoreCache.GetMaxScore(beatmapLevel, beatmapKey);
+            int maxScore = await _maxScoreCache.GetMaxScore(beatmapLevel, beatmapKey);
 
-                if (levelCompletionResults.multipliedScore > maxScore) {
-                    UploadStatusChanged?.Invoke(UploadStatus.Error, "Failed to upload (score was impossible)");
-                    Plugin.Log.Debug($"Score was better than possible, not uploading!");
-                    return;
-                }
+            if (levelCompletionResults.multipliedScore > maxScore) {
+                UploadStatusChanged?.Invoke(UploadStatus.Error, "Failed to upload (score was impossible)");
+                Plugin.Log.Debug($"Score was better than possible, not uploading!");
+                return;
+            }
 
-                try {
-                    UploadStatusChanged?.Invoke(UploadStatus.Packaging, "Packaging score...");
-                    ScoreSaberUploadData data = ScoreSaberUploadData.Create(beatmapLevel, beatmapKey, levelCompletionResults, _playerService.localPlayerInfo, GetVersionHash());
-                    string scoreData = JsonConvert.SerializeObject(data);
-
-                    // TODO: Simplify now that we're open source
-                    byte[] encodedPassword = new UTF8Encoding().GetBytes($"{UPLOAD_SECRET}-{_playerService.localPlayerInfo.playerKey}-{_playerService.localPlayerInfo.playerId}-{UPLOAD_SECRET}");
-                    byte[] keyHash = ((HashAlgorithm)CryptoConfig.CreateFromName("MD5")).ComputeHash(encodedPassword);
-                    string key = BitConverter.ToString(keyHash)
-                          .Replace("-", string.Empty)
-                          .ToLower();
-
-                    string scoreDataHex = BitConverter.ToString(Swap(Encoding.UTF8.GetBytes(scoreData), Encoding.UTF8.GetBytes(key))).Replace("-", "");
-                    Seven(data, scoreDataHex, beatmapLevel, beatmapKey, levelCompletionResults).RunTask();
-                } catch (Exception ex) {
-                    UploadStatusChanged?.Invoke(UploadStatus.Error, "Failed to upload score, error written to log.");
-                    Plugin.Log.Error($"Failed to upload score: {ex}");
-                }
+            try {
+                UploadStatusChanged?.Invoke(UploadStatus.Packaging, "Packaging score...");
+                ScoreSaberUploadData data = ScoreSaberUploadData.Create(beatmapLevel, beatmapKey, levelCompletionResults, _playerService.localPlayerInfo, GetVersionHash());
+                string scoreData = JsonConvert.SerializeObject(data);
+
+                // TODO: Simplify now that we're open source
+                byte[] encodedPassword = new UTF8Encoding().GetBytes($"{UPLOAD_SECRET}-{_playerService.localPlayerInfo.playerKey}-{_playerService.localPlayerInfo.playerId}-{UPLOAD_SECRET}");
+                byte[] keyHash = ((HashAlgorithm)CryptoConfig.CreateFromName("MD5")).ComputeHash(encodedPassword);
+                string key = BitConverter.ToString(keyHash)
+                        .Replace("-", string.Empty)
+                        .ToLower();
+
+                string scoreDataHex = BitConverter.ToString(Swap(Encoding.UTF8.GetBytes(scoreData), Encoding.UTF8.GetBytes(key))).Replace("-", "");
+                Seven(data, scoreDataHex, beatmapLevel, beatmapKey, levelCompletionResults).RunTask();
+            } catch (Exception ex) {
+                UploadStatusChanged?.Invoke(UploadStatus.Error, "Failed to upload score, error written to log.");
+                Plugin.Log.Error($"Failed to upload score: {ex}");
             }
         }
 
@@ -165,7 +168,7 @@ public async Task Seven(ScoreSaberUploadData scoreSaberUploadData, string upload
                 UploadStatusChanged?.Invoke(UploadStatus.Packaging, "Checking leaderboard ranked status...");
 
                 bool ranked = true;
-                Leaderboard currentLeaderboard = await _leaderboardService.GetCurrentLeaderboard(beatmapKey);
+                Leaderboard currentLeaderboard = await _leaderboardService.GetCurrentLeaderboard(beatmapKey, beatmapLevel);
 
                 if (currentLeaderboard != null) {
                     ranked = currentLeaderboard.leaderboardInfo.ranked;
@@ -204,12 +207,12 @@ public async Task Seven(ScoreSaberUploadData scoreSaberUploadData, string upload
                     Plugin.Log.Info("Attempting score upload...");
                     UploadStatusChanged?.Invoke(UploadStatus.Uploading, "Uploading score...");
                     try {
-                        response = await Plugin.HttpInstance.PostAsync("/game/upload", form);
-                    } catch (HttpErrorException httpException) {
-                        if (httpException.isScoreSaberError) {
-                            Plugin.Log.Error($"Failed to upload score: {httpException.scoreSaberError.errorMessage}:{httpException}");
+                        response = await _scoreSaberHttpClient.PostRawAsync(new UploadRequest().BuildUrl(), form); // this endpoint doesnt give back json, just a raw string, so we have to use PostRawAsync
+                    } catch (HttpRequestException httpException) {
+                        if (httpException.IsScoreSaberError) {
+                            Plugin.Log.Error($"Failed to upload score: {httpException.ScoreSaberError.errorMessage}:{httpException}");
                         } else {
-                            Plugin.Log.Error($"Failed to upload score: {httpException.isNetworkError}:{httpException.isHttpError}:{httpException}");
+                            Plugin.Log.Error($"Failed to upload score: {httpException.IsNetworkError}:{httpException.IsHttpError}:{httpException}");
                         }
                     } catch (Exception ex) {
                         Plugin.Log.Error($"Failed to upload score: {ex.ToString()}");

ScoreSaber/Core/Data/Internal/Settings.cs

@@ -8,12 +8,12 @@ namespace ScoreSaber.Core.Data
 {
     internal class Settings
     {
-        private static int _currentVersion => 8;
+        private static int _currentVersion => 9;
 
         public bool hideReplayUI = false;
 
         public int fileVersion { get; set; }
-        public bool disableScoreSaber { get; set; }
+        public bool disableScoreSaber { get; set; } // Unused
         public bool showLocalPlayerRank { get; set; }
         public bool showScorePP { get; set; }
         public bool showStatusText { get; set; }
@@ -36,6 +36,13 @@ internal class Settings
         public bool leftHandedReplayUI { get; set; }
         public bool lockedReplayUIMode { get; set; }
         public List<SpectatorPoseRoot> spectatorPositions { get; set; }
+        public Vec2 replayUIPosition { get; set; }
+        public float replayUISize { get; set; }
+        public bool startReplayUIHidden { get; set; }
+        public bool hideWatermarkIfUsersReplay { get; set; }
+        public bool enableRichPresence { get; set; }
+        public bool hasAcceptedRichPresenceDisclaimer { get; set; }
+        public bool showMainMenuButton { get; set; }
 
         internal static string dataPath => "UserData";
         internal static string configPath => dataPath + @"\ScoreSaber";
@@ -65,6 +72,13 @@ public void SetDefaults() {
             hasOpenedReplayUI = false;
             leftHandedReplayUI = false;
             lockedReplayUIMode = false;
+            replayUIPosition = new Vec2(new Vector2(0.12f, 0.14f));
+            replayUISize = 1.25f;
+            startReplayUIHidden = false;
+            hideWatermarkIfUsersReplay = false;
+            enableRichPresence = false;
+            hasAcceptedRichPresenceDisclaimer = false;
+            showMainMenuButton = true;
             SetDefaultSpectatorPositions();
         }
 
@@ -113,6 +127,15 @@ internal static Settings LoadSettings() {
                     if(decoded.fileVersion < 8) {
                         decoded.replayCameraSmoothing = true;
                     }
+                    if (decoded.fileVersion < 9) {
+                        decoded.replayUIPosition = new Vec2(new Vector2(0.12f, 0.14f));
+                        decoded.replayUISize = 1.25f;
+                        decoded.startReplayUIHidden = false;
+                        decoded.enableRichPresence = false;
+                        decoded.hasAcceptedRichPresenceDisclaimer = false;
+                        decoded.hideWatermarkIfUsersReplay = false;
+                        decoded.showMainMenuButton = true;
+                    }
                     SaveSettings(decoded);
                 }
                 return decoded;
@@ -136,6 +159,22 @@ internal static void SaveSettings(Settings settings) {
             }
         }
 
+        internal struct Vec2 {
+            [JsonProperty("x")]
+            internal float x { get; set; }
+            [JsonProperty("y")]
+            internal float y { get; set; }
+
+            internal Vec2(Vector2 position) {
+                x = position.x;
+                y = position.y;
+            }
+
+            internal Vector2 ToVector2() {
+                return new Vector2(x, y);
+            }
+        }
+
         internal struct SpectatorPoseRoot {
             [JsonProperty("name")]
             internal string name { get; set; }

ScoreSaber/Core/Data/Models/GameMode.cs

@@ -0,0 +1,17 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ScoreSaber.Core.Data.Models {
+    public enum GameMode {
+        [JsonProperty("solo")]
+        solo,
+        [JsonProperty("multi")]
+        multiplayer,
+        [JsonProperty("practice")]
+        practice
+    }
+}

ScoreSaber/Core/Data/Models/LeaderboardUploadData.cs

@@ -60,11 +60,11 @@ internal static ScoreSaberUploadData Create(BeatmapLevel beatmapLevel, BeatmapKe
             data.gameMode = $"Solo{beatmapKey.beatmapCharacteristic.serializedName}";
             data.difficulty = BeatmapDifficultyMethods.DefaultRating(beatmapKey.difficulty);
             data.infoHash = infoHash;
-            data.leaderboardId = levelInfo[2];
+            data.leaderboardId = BeatmapUtils.GetHashFromLevelID(beatmapKey, out bool isOst);
             data.songName = beatmapLevel.songName;
             data.songSubName = beatmapLevel.songSubName;
             data.songAuthorName = beatmapLevel.songAuthorName;
-            data.levelAuthorName = friendlyLevelAuthorName(beatmapLevel.allMappers, beatmapLevel.allLighters);
+            data.levelAuthorName = BeatmapUtils.FriendlyLevelAuthorName(beatmapLevel.allMappers, beatmapLevel.allLighters) ?? "";
             data.bpm = Convert.ToInt32(beatmapLevel.beatsPerMinute);
 
             data.playerName = playerInfo.playerName;
@@ -83,16 +83,5 @@ internal static ScoreSaberUploadData Create(BeatmapLevel beatmapLevel, BeatmapKe
             data.deviceControllerRightIdentifier = VRDevices.GetDeviceControllerRight();
             return data;
         }
-
-        static string friendlyLevelAuthorName(string[] mappers, string[] lighters) {
-            List<string> mappersAndLighters = new List<string>();
-            mappersAndLighters.AddRange(mappers);
-            mappersAndLighters.AddRange(lighters);
-
-            if(mappersAndLighters.Count <= 1) {
-                return mappersAndLighters.FirstOrDefault();
-            }
-            return $"{string.Join(", ", mappersAndLighters.Take(mappersAndLighters.Count - 1))} & {mappersAndLighters.Last()}";
-        }
     }
 }