The Everything Update (UI Overhaul + Bug Fixes)

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,116 @@
+using HarmonyLib;
+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 ScoreSaberRichPresenceService _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) {
+
+            string hash = string.Empty;
+
+            if (__instance.selectedBeatmapLevel.hasPrecalculatedData) {
+                hash = "#" + __instance.selectedBeatmapLevel.levelID;
+            } else {
+                hash = __instance.selectedBeatmapLevel.levelID.Split('_')[2];
+            }
+
+            bool isPractice = practice;
+            Services.GameMode gameMode = Services.GameMode.solo;
+
+            if (isPractice) {
+                gameMode = Services.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.GetLevelByHash(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 = string.Empty;
+
+            if (!beatmapLevel.levelID.StartsWith("custom_level_")) {
+                hash = "#" + beatmapLevel.levelID;
+            } else {
+                hash = beatmapLevel.levelID.Split('_')[2];
+            }
+
+
+            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,5 @@
 using ScoreSaber.Core.Daemons;
+using ScoreSaber.Core.Services;
 using System.Reflection;
 using Zenject;
 
@@ -7,8 +8,10 @@ internal class AppInstaller : Installer {
 
         public override void InstallBindings() {
             Plugin.Container = Container;
+            Container.Bind<PlayerService>().AsSingle();
 
             Container.Bind<ReplayService>().AsSingle().NonLazy();
+            Container.BindInterfacesAndSelfTo<ScoreSaberRichPresenceService>().AsSingle();
         }
     }
 }

ScoreSaber/Core/Daemons/UploadDaemon.cs

@@ -165,7 +165,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;

ScoreSaber/Core/Data/Internal/Settings.cs

@@ -8,7 +8,7 @@ namespace ScoreSaber.Core.Data
 {
     internal class Settings
     {
-        private static int _currentVersion => 8;
+        private static int _currentVersion => 9;
 
         public bool hideReplayUI = false;
 
@@ -36,6 +36,12 @@ 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; }
 
         internal static string dataPath => "UserData";
         internal static string configPath => dataPath + @"\ScoreSaber";
@@ -65,6 +71,12 @@ 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;
             SetDefaultSpectatorPositions();
         }
 
@@ -113,6 +125,14 @@ 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;
+                    }
                     SaveSettings(decoded);
                 }
                 return decoded;
@@ -136,6 +156,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/LeaderboardUploadData.cs

@@ -64,7 +64,7 @@ internal static ScoreSaberUploadData Create(BeatmapLevel beatmapLevel, BeatmapKe
             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()}";
-        }
     }
 }

ScoreSaber/Core/Data/Models/ScoreSaberTeam.cs

@@ -1,18 +1,17 @@
 #pragma warning disable IDE1006 // Naming Styles
 using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Linq;
+using System;
 using System.Collections.Generic;
 
-namespace ScoreSaber.Core.Data.Models
-{
-    internal class ScoreSaberTeam
-    {
+namespace ScoreSaber.Core.Data.Models {
+    internal class ScoreSaberTeam {
         [JsonProperty("TeamMembers")]
+        [JsonConverter(typeof(TeamMembersJsonConverter))]
         public Dictionary<TeamType, List<TeamMember>> TeamMembers { get; set; }
     }
 
-    internal class TeamMember
-    {
+    internal class TeamMember {
         [JsonProperty("Name")]
         internal string Name { get; set; }
         [JsonProperty("ProfilePicture")]
@@ -29,17 +28,72 @@ internal class TeamMember
         internal string YouTube { get; set; }
     }
 
-    [JsonConverter(typeof(StringEnumConverter))]
-    internal enum TeamType
-    {
-        Backend,
-        Frontend,
-        Mod,
-        PPv3,
-        Admin,
-        RT,
-        NAT,
-        QAT,
-        CAT
+    internal class TeamType {
+        private readonly string _value;
+
+        private TeamType(string value) => _value = value;
+
+        public static readonly TeamType Backend = new TeamType("Backend");
+        public static readonly TeamType Frontend = new TeamType("Frontend");
+        public static readonly TeamType Mod = new TeamType("Mod");
+        public static readonly TeamType PPv3 = new TeamType("PPv3");
+        public static readonly TeamType Admin = new TeamType("Admin");
+        public static readonly TeamType RT = new TeamType("RT");
+        public static readonly TeamType NAT = new TeamType("NAT");
+        public static readonly TeamType QAT = new TeamType("QAT");
+        public static readonly TeamType CAT = new TeamType("CAT");
+        public static readonly TeamType CCT = new TeamType("CCT");
+
+
+        // holds the known team types as of building the plugin, can handle unknown team types
+        public static TeamType FromString(string value) => value switch {
+            "Backend" => Backend,
+            "Frontend" => Frontend,
+            "Mod" => Mod,
+            "PPv3" => PPv3,
+            "Admin" => Admin,
+            "RT" => RT,
+            "NAT" => NAT,
+            "QAT" => QAT,
+            "CAT" => CAT,
+            "CCT" => CCT,
+            _ => new TeamType(value)
+        };
+
+        public override string ToString() => _value;
+
+        public override bool Equals(object obj) => obj is TeamType other && _value == other._value;
+
+        public override int GetHashCode() => _value.GetHashCode();
+
+        public static implicit operator string(TeamType teamType) => teamType._value;
     }
+
+    internal class TeamMembersJsonConverter : JsonConverter<Dictionary<TeamType, List<TeamMember>>> {
+        public override Dictionary<TeamType, List<TeamMember>> ReadJson(JsonReader reader, Type objectType, Dictionary<TeamType, List<TeamMember>> existingValue, bool hasExistingValue, JsonSerializer serializer) {
+            var dictionary = new Dictionary<TeamType, List<TeamMember>>();
+
+            var jsonObject = JObject.Load(reader);
+
+            foreach (var property in jsonObject.Properties()) {
+                var teamType = TeamType.FromString(property.Name);
+
+                var teamMembers = property.Value.ToObject<List<TeamMember>>(serializer);
+
+                dictionary[teamType] = teamMembers;
+            }
+
+            return dictionary;
+        }
+
+        public override void WriteJson(JsonWriter writer, Dictionary<TeamType, List<TeamMember>> value, JsonSerializer serializer) {
+            writer.WriteStartObject();
+            foreach (var kvp in value) {
+                writer.WritePropertyName(kvp.Key.ToString());
+                serializer.Serialize(writer, kvp.Value);
+            }
+            writer.WriteEndObject();
+        }
+    }
+
 }

ScoreSaber/Core/Data/Wrappers/LeaderboardMap.cs

@@ -22,5 +22,7 @@ internal LeaderboardMap(Leaderboard leaderboard, BeatmapLevel beatmapLevel, Beat
             }
             return leaderboardTableScoreData;
         }
+
+
     }
 }