feat!: NaiveRating -> MoreProfileOptions

Extras/MoreProfileOptions/MU3.Battle/patch_Counters.cs

@@ -0,0 +1,51 @@
+using MU3.DB;
+using MU3.User;
+using MU3.Util;
+
+namespace MU3.Battle;
+class patch_Counters: Counters {
+    private long _techScoreLost;
+    private long _tsjBellLost;
+    private patch_UserOption.eAbort _eAbort;
+    private long _retireScoreBase;
+    private long _retireScoreCurrent;
+
+    private UserFumen _userFumen;
+    private int _previousPb;
+    public new int getTechScoreEnable() {
+        if(_eAbort == patch_UserOption.eAbort.FB && _tsjBellLost > 0) {
+            return 0;
+        }
+        return (int)(1010000 - _techScoreLost);
+    }
+
+    private extern void orig_updateUIScore(ScoreType type = ScoreType.Max);
+    private void updateUIScore(ScoreType type = ScoreType.Max) {
+        int self = -1;
+
+        if(_userFumen == null) {
+            GameEngine ge = SingletonMonoBehaviour<GameEngine>.instance;
+            UserManager userManager = Singleton<UserManager>.instance;
+            _userFumen = userManager.getUserFumen(ge.sessionInfo.musicData.id, ge.sessionInfo.musicLevel, create: false);
+            _previousPb = _userFumen?.TechScoreMax ?? 0;
+        }
+
+        switch(_eAbort) {
+        case patch_UserOption.eAbort.SSS1:
+            self = TechnicalRankID.SSS1.getLower();
+            break;
+        case patch_UserOption.eAbort.PB:
+            self = _previousPb;
+            break;
+        default:
+            break;
+        }
+
+        if(self >= 0) {
+            _retireScoreBase = 1010000L - self;
+            _retireScoreCurrent = _retireScoreBase;
+        }
+
+        orig_updateUIScore(type);
+    }
+}

Extras/MoreProfileOptions/MU3.CustomUI/patch_MU3UICounter.cs

@@ -0,0 +1,19 @@
+namespace MU3.CustomUI;
+
+class patch_MU3UICounter: MU3UICounter {
+    protected extern void orig_calcNumFiguresFloat(double value);
+    protected new void calcNumFiguresFloat(double value) {
+        orig_calcNumFiguresFloat(value);
+        if(isDispSuffix) {
+            pushFigureFront(10);
+        }
+    }
+    public bool isDispSuffix { get; set; }
+    protected void pushFigureFront(byte c) {
+        for(int i = numFigures_; i > 0; --i) {
+            figures_[i] = figures_[i - 1];
+        }
+        figures_[0] = c;
+        numFigures_ += 1;
+    }
+}

Extras/MoreProfileOptions/MU3.Data/patch_GameData.cs

@@ -0,0 +1,15 @@
+using MU3.DB;
+using MU3.Mod;
+
+namespace MU3.Data;
+
+class patch_GameData: GameData {
+    public extern static RatingColorID orig_getRatingColorIDFromRating100(int rating100);
+    public static new RatingColorID getRatingColorIDFromRating100(int rating100) {
+        if(NaiveRating.IsEnabled()) {
+            return orig_getRatingColorIDFromRating100(NaiveRating.Get());
+        } else {
+            return orig_getRatingColorIDFromRating100(rating100);
+        }
+    }
+}

Extras/MoreProfileOptions/MU3.Game/patch_SessionResult.cs

@@ -0,0 +1,14 @@
+using MU3.Battle;
+using MU3.Mod;
+
+namespace MU3.Game;
+
+class patch_SessionResult: SessionResult {
+    public int prevNaiveRating;
+
+    public extern void orig_calcTotalRewards();
+    public new void calcTotalRewards() {
+        orig_calcTotalRewards();
+        prevNaiveRating = NaiveRating.Get();
+    }
+}

Extras/MoreProfileOptions/MU3.Mod/NaiveRating.cs

@@ -0,0 +1,52 @@
+using MU3.Data;
+using MU3.DataStudio;
+using MU3.User;
+using MU3.Util;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace MU3.Mod;
+
+public static class NaiveRating {
+    // Adapted from MU3.User.UserRating.calcBest()
+    private static RatingList calcSane() {
+        RatingList ratingList = [];
+
+        var usMgr = Singleton<UserManager>.instance;
+        var musicDict = usMgr.userMusic;
+
+        foreach(KeyValuePair<int, UserMusic> item in musicDict) {
+            var musicData = SingletonStateMachine<DataManager, DataManager.EState>
+                .instance.getMusicData(item.Key);
+
+            if(musicData == null || item.Key == 1 || musicData.isBonusTrack) {
+                continue;
+            }
+            for(int i = 0; i < 5; i++) {
+                var fumenDifficulty = (FumenDifficulty)i;
+                var userFumen = usMgr.getUserFumen(item.Key, fumenDifficulty, create: false);
+                if(userFumen == null) {
+                    continue;
+                }
+                Rating rating = new(musicData.id, fumenDifficulty, userFumen.TechScoreMax);
+                if(rating.level100 == 0) {
+                    continue;
+                }
+                ratingList.Add(rating);
+            }
+        }
+
+        ratingList.Sort();
+        return ratingList;
+    }
+    public static int Get() {
+        int res = 0;
+        foreach(Rating best in calcSane().Take(45)) {
+            res += best.rate100;
+        }
+        return res / 45;
+    }
+    public static bool IsEnabled() {
+        return Singleton<UserManager>.instance.userOption.customSet.Rating == (UserOption.eRating)patch_UserOption.eRating.Naive;
+    }
+}

Extras/MoreProfileOptions/MU3.Notes/patch_NotesManager.cs

@@ -0,0 +1,48 @@
+using MU3.Battle;
+using MU3.DataStudio;
+using MU3.DB;
+using MU3.User;
+using MU3.Util;
+using UnityEngine;
+
+namespace MU3.Notes;
+
+class patch_NotesManager: NotesManager {
+    private RetireResult _retireResult;
+    private GameEngine _gameEngine;
+    private UserFumen _userFumen;
+    private int _previousPb;
+    public extern void orig_update();
+    public new void update() {
+        orig_update();
+
+        int threshold = 0;
+        var abort = (patch_UserOption.eAbort)GameOption.abort;
+        switch(abort) {
+        case patch_UserOption.eAbort.SSS1:
+            threshold = 1007500;
+            break;
+        case patch_UserOption.eAbort.FB:
+            threshold = 970000;
+            break;
+        case patch_UserOption.eAbort.PB:
+            if(_userFumen == null) {
+                UserManager userManager = Singleton<UserManager>.instance;
+                _userFumen = userManager.getUserFumen(_sessionInfo.musicData.id, _sessionInfo.musicLevel, create: false);
+                _previousPb = _userFumen?.TechScoreMax ?? 0;
+                UnityEngine.Debug.Log(_previousPb + "HELLO THIS ONLY EXECUTES ONCE");
+            }
+            threshold = _previousPb;
+            break;
+        default:
+            break;
+        }
+
+        if(_retireResult == RetireResult.None && threshold > 0) {
+            int techScoreEnable = _gameEngine.counters.getTechScoreEnable();
+            if(techScoreEnable < threshold) {
+                _retireResult = RetireResult.ScoreRetire;
+            }
+        }
+    }
+}

Extras/MoreProfileOptions/MU3.SceneObject/patch_ANM_CMN_User.cs

@@ -0,0 +1,13 @@
+using MU3.CustomUI;
+using MU3.Mod;
+
+namespace MU3.SceneObject;
+
+class patch_ANM_CMN_UserDeta_01: ANM_CMN_UserDeta_01 {
+    private patch_MU3UICounter rating;
+    public extern void orig_setUserDetail();
+    public new void setUserDetail() {
+        rating.isDispSuffix = NaiveRating.IsEnabled();
+        orig_setUserDetail();
+    }
+}

Extras/MoreProfileOptions/MU3.User/patch_UserOption.cs

@@ -0,0 +1,59 @@
+using MonoMod;
+
+namespace MU3.User;
+
+class patch_UserOption: UserOption {
+    [MonoModEnumReplace]
+    public new enum eRating {
+        OFF = 0,
+        Default = 1,
+        ON = 1,
+        Naive = 2,
+        MAX = 2
+    }
+
+    [MonoModEnumReplace]
+    public new enum eAbort {
+        OFF = 0,
+        S = 1,
+        SS = 2,
+        SSS = 3,
+        SSS1 = 4,
+        PB = 5,
+        FB = 6,
+        ZERO = 7,
+        MAX = 8,
+        Default = 0
+    }
+
+    class patch_DataSet: DataSet {
+        private eRating rating = eRating.ON;
+        private eAbort abort;
+
+        public extern bool orig_isMax(OptionName id);
+        public new bool isMax(OptionName id) {
+            if(id == OptionName.Rating) {
+                return rating == eRating.MAX;
+            }
+            return orig_isMax(id);
+        }
+        public void set_Rating(eRating value) {
+            if(eRating.MAX < value) {
+                rating = eRating.MAX;
+            } else if(value < eRating.OFF) {
+                rating = eRating.OFF;
+            } else {
+                rating = value;
+            }
+        }
+        public void set_Abort(eAbort value) {
+            if(eAbort.MAX < value) {
+                abort = eAbort.ZERO;
+            } else if(value < eAbort.OFF) {
+                abort = eAbort.OFF;
+            } else {
+                abort = value;
+            }
+        }
+    }
+}

Extras/MoreProfileOptions/MU3.User/patch_UserUtil.cs

@@ -0,0 +1,16 @@
+using MonoMod;
+using MU3.Mod;
+
+namespace MU3.User;
+
+[MonoModPatch("global::MU3.User.UserUtil")]
+public static class patch_UserUtil {
+    public extern static float orig_toRatingFloat(int rating);
+    public static float toRatingFloat(int rating) {
+        if(NaiveRating.IsEnabled()) {
+            return orig_toRatingFloat(NaiveRating.Get());
+        } else {
+            return orig_toRatingFloat(rating);
+        }
+    }
+}

Extras/MoreProfileOptions/MU3/patch_ANM_SWH_Profile.cs

@@ -0,0 +1,24 @@
+using MU3.User;
+using MU3.Util;
+using MU3.Mod;
+
+namespace MU3;
+
+class patch_ANM_SWH_Profile: ANM_SWH_Profile {
+    public extern void orig_setUpLogin();
+
+    // Fixes login display
+    public new void setUpLogin() {
+        UserManager instance = Singleton<UserManager>.instance;
+        var up = instance.userPreview;
+        if(NaiveRating.IsEnabled()) {
+            up.dispRating = 0;
+            instance.userPreview = up;
+            orig_setUpLogin();
+            up.dispRating = 2;
+            instance.userPreview = up;
+        } else {
+            orig_setUpLogin();
+        }
+    }
+}

Extras/MoreProfileOptions/MU3/patch_BattleUI.cs

@@ -0,0 +1,51 @@
+using MU3.DB;
+using MU3.Game;
+using MU3.User;
+using MU3.Util;
+
+namespace MU3;
+class patch_BattleUI: BattleUI {
+    private UIRetireInfo _retireInfo;
+    private SessionInfo _sessionInfo;
+    public new void setRetireInfo(UserOption.eAbort abort) {
+        UIRetireInfo.Rank rank;
+        int num;
+
+        var pabort = (patch_UserOption.eAbort)abort;
+        switch(pabort) {
+        case patch_UserOption.eAbort.S:
+            rank = UIRetireInfo.Rank.S;
+            num = 1010000 - TechnicalRankID.S.getLower();
+            break;
+        case patch_UserOption.eAbort.SS:
+            rank = UIRetireInfo.Rank.SS;
+            num = 1010000 - TechnicalRankID.SS.getLower();
+            break;
+        case patch_UserOption.eAbort.SSS:
+            rank = UIRetireInfo.Rank.SSS;
+            num = 1010000 - TechnicalRankID.SSS.getLower();
+            break;
+        case patch_UserOption.eAbort.SSS1:
+            rank = UIRetireInfo.Rank.S;
+            num = 1010000 - TechnicalRankID.SSS1.getLower();
+            break;
+        case patch_UserOption.eAbort.PB:
+            UserManager userManager = Singleton<UserManager>.instance;
+            var userFumen = userManager.getUserFumen(_sessionInfo.musicData.id, _sessionInfo.musicLevel, create: false);
+            var previousPb = userFumen?.TechScoreMax ?? 0;
+            rank = UIRetireInfo.Rank.S;
+            num = 1010000 - previousPb;
+            break;
+        case patch_UserOption.eAbort.FB:
+        case patch_UserOption.eAbort.ZERO:
+            rank = UIRetireInfo.Rank.S;
+            num = 1010000;
+            break;
+        default:
+            rank = UIRetireInfo.Rank.MAX;
+            num = 0;
+            break;
+        }
+        _retireInfo.setupRetireInfo(rank, num);
+    }
+}

Extras/MoreProfileOptions/MU3/patch_OptionMiniSummaryController.cs

@@ -0,0 +1,55 @@
+using MU3.CustomUI;
+using MU3.User;
+using UnityEngine;
+
+namespace MU3;
+
+class patch_OptionMiniSummaryController: OptionMiniSummaryController {
+    private GameObject[] arrayIcon = new GameObject[35];
+    private extern void orig_setParam(UserOption.OptionName id, int value);
+    private void setParam(UserOption.OptionName id, int value) {
+        var comp = arrayIcon[(int)id].transform.Find("NUL_Option_mini_Icon/TXT_Option_mini").GetComponent<MU3Text>();
+        if(id == UserOption.OptionName.Rating) {
+            switch(value) {
+            case 0:
+                comp.text = "OFF";
+                break;
+            case 1:
+                comp.text = "TYPE-A";
+                break;
+            case 2:
+                comp.text = "TYPE-B";
+                break;
+            }
+        } else if(id == UserOption.OptionName.Abort) {
+            switch(value) {
+            case 0:
+                comp.text = "OFF";
+                break;
+            case 1:
+                comp.text = "S未達で中断";
+                break;
+            case 2:
+                comp.text = "SS未達で中断";
+                break;
+            case 3:
+                comp.text = "SSS未達で中断";
+                break;
+            case 4:
+                comp.text = "SSS+未達で中断";
+                break;
+            case 5:
+                comp.text = "PB未達で中断";
+                break;
+            case 6:
+                comp.text = "FB未達で中断";
+                break;
+            case 7:
+                comp.text = "スコア表示";
+                break;
+            }
+        } else {
+            orig_setParam(id, value);
+        }
+    }
+}

Extras/MoreProfileOptions/MU3/patch_OptionSelecterController.cs

@@ -0,0 +1,61 @@
+using MonoMod;
+using MU3.CustomUI;
+using MU3.User;
+using MU3.Util;
+using System.Reflection;
+using UnityEngine;
+
+namespace MU3;
+
+class patch_OptionSelecterController: OptionSelecterController {
+    private chengeParamFuncArray[] cpFuncArray = new chengeParamFuncArray[35];
+
+    [MonoModIgnore]
+    private extern void setInputCursor(int currentParam);
+
+    public extern void orig_init(UserOption.OptionName id);
+    public new void init(UserOption.OptionName id) {
+        orig_init(id);
+        cpFuncArray[33].max = 2;
+        cpFuncArray[4].max = 7;
+
+        if(id == UserOption.OptionName.Rating) {
+            var rct = transform.Find("NUL_SWH_Option_00/NUL_Select/PAT_OnOff").GetComponent<RectTransform>();
+            var changer = transform.Find("NUL_SWH_Option_00/NUL_Select/PAT_OnOff").GetComponent<MU3UIImageChanger>();
+
+            rct.anchoredPosition = new Vector3(0f, -5f, 0);
+            rct.sizeDelta = new Vector2(158, 70);
+
+            var spritesFi = typeof(MU3UIImageChanger).GetField("_sprites", BindingFlags.Instance | BindingFlags.NonPublic);
+            var tex = ((Sprite[])spritesFi.GetValue(changer))[0].texture;
+            var newSprites = new Sprite[3];
+            spritesFi.SetValue(changer, newSprites);
+
+            changer.setSprite(0, Sprite.Create(tex, new Rect(1552.0f, 366.0f, 160.0f, 65.0f), new Vector2(80.0f, 0.0f)));
+            changer.setSprite(1, Sprite.Create(tex, new Rect(1221.0f, 1488.0f, 160.0f, 70.0f), new Vector2(80.0f, 35.0f)));
+            changer.setSprite(2, Sprite.Create(tex, new Rect(1221.0f, 1410.0f, 160.0f, 70.0f), new Vector2(80.0f, 35.0f)));
+
+            setInputCursor((int)Singleton<UserManager>.instance.userOption.customSet.Rating);
+        }
+    }
+
+    private extern void orig_chengeParamOther(int currentParam);
+    private void chengeParamOther(int currentParam) {
+        if(myOptionId == UserOption.OptionName.Rating) {
+            var changer = transform.Find("NUL_SWH_Option_00/NUL_Select/PAT_OnOff").GetComponent<MU3UIImageChanger>();
+            changer.patternNumber = currentParam;
+            Singleton<UserManager>.instance.userOption.customSet.Rating = (UserOption.eRating)currentParam;
+            SingletonMonoBehaviour<SystemUI>.instance.userData.setUserDetail();
+        } else {
+            orig_chengeParamOther(currentParam);
+        }
+    }
+
+    private extern void orig_chengeParamAbort(int currentParam);
+    private void chengeParamAbort(int currentParam) {
+        string text = "NUL_SWH_Option_00/NUL_Select/PAT_Clear";
+        GameObject gameObject = transform.Find(text).gameObject;
+        MU3UIImageChanger component = gameObject.GetComponent<MU3UIImageChanger>();
+        component.patternNumber = currentParam > 4 ? 0 : currentParam;
+    }
+}

Extras/MoreProfileOptions/MU3/patch_UIResultBattlePoint.cs

@@ -0,0 +1,54 @@
+using MonoMod;
+using MU3.CustomUI;
+using MU3.Sequence;
+using MU3.User;
+using MU3.Mod;
+using MU3.Game;
+using UnityEngine;
+
+namespace MU3;
+
+class patch_UIResultBattlePoint: UIResultBattlePoint {
+    private Animator animator_;
+    private patch_MU3UICounter counterScore_;
+    private MU3UIImageChanger imageHeader_;
+    private MU3UICounter counterScorePlus_;
+    private MU3UICounter counterScoreMinus_;
+    private GameObject hideScore_;
+
+    [MonoModIgnore]
+    private extern void disable(MU3UICounter counter);
+
+    public extern void orig_initTechRating(PlayInfo playInfo);
+    public new void initTechRating(PlayInfo playInfo) {
+        counterScore_.isDispSuffix = NaiveRating.IsEnabled();
+        if(!NaiveRating.IsEnabled()) {
+            orig_initTechRating(playInfo);
+            return;
+        }
+        int prevRating = ((patch_SessionResult)playInfo.sessionResult).prevNaiveRating;
+        int rating1 = NaiveRating.Get();
+
+        UnityEngine.Debug.Log(prevRating + " " + rating1);
+        if((bool)hideScore_) {
+            hideScore_.SetActive(false);
+        }
+        counterScore_.Counter = (double)UserUtil.toRatingFloat(rating1);
+        int ratingPatternNo = UserUtil.toRatingPatternNo(rating1);
+        counterScore_.SpriteIndex = ratingPatternNo;
+        imageHeader_.patternNumber = (float)ratingPatternNo;
+        int rating2 = rating1 - prevRating;
+        if(rating2 == 0) {
+            disable(counterScorePlus_);
+            disable(counterScoreMinus_);
+            animator_.SetInteger(Sys.Const.AnimatorID_State, 2);
+        } else if(0 < rating2) {
+            disable(counterScoreMinus_);
+            if((bool)counterScorePlus_) {
+                counterScorePlus_.Counter = rating2 * 0.01f + 1E-05f;
+            }
+            animator_.SetInteger(Sys.Const.AnimatorID_State, 0);
+        }
+        animator_.SetTrigger(Sys.Const.AnimatorID_In);
+    }
+}

Extras/MoreProfileOptions/MoreProfileOptions.csproj

@@ -0,0 +1,8 @@
+<Project>
+  <PropertyGroup>
+    <AssemblyName>Assembly-CSharp.MoreProfileOptions.mm</AssemblyName>
+    <Description>More profile options</Description>
+    <OutCategory>extras</OutCategory>
+  </PropertyGroup>
+  <Import Project="..\..\Mu3Mods.csproj" />
+</Project>