├── Resources
    ├── online.jpg
    ├── standard.jpg
    ├── repo-banner.jpg
    └── uitweaks-logo-pdn.jpg
├── UITweaks
    ├── Directory.Build.props
    ├── manifest.json
    ├── Models
    │   ├── UITweaksConfigBase.cs
    │   ├── PreviewPanel.cs
    │   └── PanelDecoratorBase.cs
    ├── Views
    │   ├── ObjectPreview.bsml
    │   ├── Info.bsml
    │   └── ModSettings.bsml
    ├── Utilities
    │   ├── RainbowEffectManager.cs
    │   ├── MultiplayerEnergyBarCoroutineHandler.cs
    │   ├── SettableSettings
    │   │   ├── UITweaksSettingsWrapper.cs
    │   │   └── UITweaksSettableSettings.cs
    │   ├── Utilities.cs
    │   └── HSBColor.cs
    ├── Installers
    │   ├── TweaksMenuInstaller.cs
    │   ├── TweaksPanelDecoratorInstaller.cs
    │   └── TweaksAppInstaller.cs
    ├── PluginConfig.cs
    ├── UI
    │   ├── MenuButtonManager.cs
    │   ├── UITweaksFlowCoordinator.cs
    │   ├── ModInfoViewController.cs
    │   ├── MockMultiplayerPositionPanel.cs
    │   ├── SettingsPanelObjectGrabber.cs
    │   ├── ModSettingsViewController.cs
    │   └── ObjectPreviewViewController.cs
    ├── Config
    │   ├── EnergyConfig.cs
    │   ├── MultiplierConfig.cs
    │   ├── ProgressConfig.cs
    │   ├── PositionConfig.cs
    │   ├── ComboConfig.cs
    │   └── MiscConfig.cs
    ├── Plugin.cs
    ├── Decorators
    │   ├── ComboPanelDecorator.cs
    │   ├── SongProgressPanelDecorator.cs
    │   ├── MultiplayerPositionPanelDecorator.cs
    │   ├── EnergyBarPanelDecorator.cs
    │   ├── ScoreMultiplierPanelDecorator.cs
    │   └── ExtraPanelDecorator.cs
    └── UITweaks.csproj
├── .gitignore
├── .github
    └── FUNDING.yml
├── LICENSE
├── README.md
├── UITweaks.sln
└── CONTRIBUTING.md


/Resources/online.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Exomanz/UITweaks/HEAD/Resources/online.jpg


--------------------------------------------------------------------------------
/Resources/standard.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Exomanz/UITweaks/HEAD/Resources/standard.jpg


--------------------------------------------------------------------------------
/Resources/repo-banner.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Exomanz/UITweaks/HEAD/Resources/repo-banner.jpg


--------------------------------------------------------------------------------
/Resources/uitweaks-logo-pdn.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Exomanz/UITweaks/HEAD/Resources/uitweaks-logo-pdn.jpg


--------------------------------------------------------------------------------
/UITweaks/Directory.Build.props:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <!-- This file contains project properties used by the build. -->
3 | <Project>
4 | 	<PropertyGroup>
5 | 		<ImportBSMTTargets>True</ImportBSMTTargets>
6 | 		<BSMTProjectType>BSIPA</BSMTProjectType>
7 | 	</PropertyGroup>
8 | </Project>


--------------------------------------------------------------------------------
/UITweaks/manifest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "$schema": "https://raw.githubusercontent.com/bsmg/BSIPA-MetadataFileSchema/master/Schema.json",
 3 |   "id": "UITweaks",
 4 |   "name": "UITweaks",
 5 |   "author": "Exomanz",
 6 |   "version": "4.0.5",
 7 |   "description": "Add some color to your in-game HUD!",
 8 |   "gameVersion": "1.38.0",
 9 |   "dependsOn": {
10 |     "BSIPA": "^4.3.5",
11 |     "SiraUtil": "^3.1.12",
12 |     "BeatSaberMarkupLanguage": "^1.12.3"
13 |   }
14 | }


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | ################################################################################
 2 | # This .gitignore file was automatically created by Microsoft(R) Visual Studio.
 3 | ################################################################################
 4 | 
 5 | /UITweaks/obj/Release
 6 | /UITweaks/obj
 7 | /UITweaks/bin/Release
 8 | /UITweaks/bin/Debug
 9 | /UITweaks/UITweaks.csproj.user
10 | /.vs/UITweaks
11 | /.vs/
12 | /UITweaks/.vs/
13 | ./Wiki/UITweaks.wiki
14 | /Resources/*.pdn


--------------------------------------------------------------------------------
/UITweaks/Models/UITweaksConfigBase.cs:
--------------------------------------------------------------------------------
 1 | namespace UITweaks.Models
 2 | {
 3 |     /// <summary>
 4 |     /// Helper class that allows for easy Zenject-ification.
 5 |     /// <br></br>All configs inherit this class.
 6 |     /// </summary>
 7 |     public abstract class UITweaksConfigBase
 8 |     {
 9 |         /// <summary>
10 |         /// Controls whether a PanelDecorator is active in the given context.
11 |         /// </summary>
12 |         public virtual bool Enabled { get; set; }
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
 1 | # These are supported funding model platforms
 2 | 
 3 | github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 4 | patreon: # Replace with a single Patreon username
 5 | open_collective: # Replace with a single Open Collective username
 6 | ko_fi: exo_manz
 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | otechie: # Replace with a single Otechie username
12 | lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
13 | custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
14 | 


--------------------------------------------------------------------------------
/UITweaks/Views/ObjectPreview.bsml:
--------------------------------------------------------------------------------
 1 | <bg xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' 
 2 | 	xsi:schemaLocation='https://monkeymanboy.github.io/BSML-Docs/ 
 3 | 	https://raw.githubusercontent.com/monkeymanboy/BSML-Docs/gh-pages/BSMLSchema.xsd'>
 4 | 	<vertical vertical-fit='PreferredSize' child-control-height='False' spacing='3' anchor-pos-y='36'>
 5 | 		<vertical vertical-fit='PreferredSize' bg='panel-top' bg-color='#00ffffff' pad='1' pref-width='102'>
 6 | 			<vertical vertical-fit='PreferredSize' bg='panel-top' bg-color='#000000ff' pad-top='1' pref-width='100'>
 7 | 				<text text='Panel Previewer' align='Center' font-size='8' italics='True'/>
 8 | 			</vertical>
 9 | 		</vertical>
10 | 	</vertical>
11 | 	<vertical vertical-fit='PreferredSize' id='loading-container'>
12 | 		<loading-indicator preserve-aspect='true'/>
13 | 		<text text='Loading Object Previewer...' font-size='6' italics='true'/>
14 | 	</vertical>
15 | </bg>


--------------------------------------------------------------------------------
/UITweaks/Utilities/RainbowEffectManager.cs:
--------------------------------------------------------------------------------
 1 | using UITweaks.Config;
 2 | using UnityEngine;
 3 | using Zenject;
 4 | 
 5 | namespace UITweaks.Utilities
 6 | {
 7 |     internal class RainbowEffectManager : ITickable
 8 |     {
 9 |         [Inject] private readonly MiscConfig miscConfig;
10 | 
11 |         /// <summary>
12 |         /// The <see cref="Color"/> which controls the rainbow effect that UITweaks uses. All objects which use this effect will be in sync.
13 |         /// </summary>
14 |         /// <remarks>This property is updated every frame.</remarks>
15 |         public Color Rainbow { get; private set; }
16 | 
17 |         [Inject] public RainbowEffectManager() { }
18 | 
19 |         public void Tick()
20 |         {
21 |             this.Rainbow = new HSBColor(
22 |                 Mathf.PingPong(Time.time * miscConfig.GlobalRainbowSpeed, 1),
23 |                 1,
24 |                 1)
25 |                 .ToColor();
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/UITweaks/Installers/TweaksMenuInstaller.cs:
--------------------------------------------------------------------------------
 1 | using UITweaks.UI;
 2 | using UnityEngine;
 3 | using Zenject;
 4 | 
 5 | namespace UITweaks.Installers
 6 | {
 7 |     public class TweaksMenuInstaller : Installer
 8 |     {
 9 |         public override void InstallBindings()
10 |         {
11 |             Container.Bind<ModSettingsViewController>().FromNewComponentAsViewController().AsSingle();
12 |             Container.Bind<ModInfoViewController>().FromNewComponentAsViewController().AsSingle();
13 |             Container.Bind<ObjectPreviewViewController>().FromNewComponentAsViewController().AsSingle();
14 |             Container.Bind<SettingsPanelObjectGrabber>().FromNewComponentOn(new GameObject("SettingsPanelObjectGrabber")).AsSingle();
15 | 
16 |             Container.Bind<UITweaksFlowCoordinator>().FromNewComponentOn(new GameObject("UITweaksFlowCoordinator")).AsSingle();
17 |             Container.BindInterfacesAndSelfTo<MenuButtonManager>().AsSingle();
18 |         }
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/UITweaks/PluginConfig.cs:
--------------------------------------------------------------------------------
 1 | using IPA.Config.Stores.Attributes;
 2 | using UITweaks.Config;
 3 | 
 4 | namespace UITweaks
 5 | {
 6 |     public class PluginConfig
 7 |     {
 8 |         public virtual bool AllowAprilFools { get; set; } = true;
 9 | 
10 |         [NonNullable]
11 |         public virtual MultiplierConfig Multiplier { get; set; } = new MultiplierConfig();
12 | 
13 |         [NonNullable]
14 |         public virtual ComboConfig Combo { get; set; } = new ComboConfig();
15 | 
16 |         [NonNullable]
17 |         public virtual EnergyConfig Energy { get; set; } = new EnergyConfig();
18 | 
19 |         [NonNullable]
20 |         public virtual ProgressConfig Progress { get; set; } = new ProgressConfig();
21 | 
22 |         [NonNullable]
23 |         public virtual PositionConfig Position { get; set; } = new PositionConfig();
24 | 
25 |         [NonNullable]
26 |         public virtual MiscConfig Misc { get; set; } = new MiscConfig();
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/UITweaks/UI/MenuButtonManager.cs:
--------------------------------------------------------------------------------
 1 | using BeatSaberMarkupLanguage.MenuButtons;
 2 | using HMUI;
 3 | using System;
 4 | using Zenject;
 5 | 
 6 | namespace UITweaks.UI
 7 | {
 8 |     internal class MenuButtonManager : IInitializable, IDisposable
 9 |     {
10 |         [Inject] private readonly MainFlowCoordinator mainFlowCoordinator;
11 |         [Inject] private readonly UITweaksFlowCoordinator modFlowCoordinator;
12 |         private MenuButton button;
13 | 
14 |         public void Initialize()
15 |         {
16 |             button = new MenuButton("UI Tweaks", "Spice up your HUD!", () =>
17 |             {
18 |                 mainFlowCoordinator.PresentFlowCoordinator(modFlowCoordinator, null, ViewController.AnimationDirection.Vertical);
19 |             });
20 |             MenuButtons.Instance.RegisterButton(button);
21 |         }
22 | 
23 |         public void Dispose()
24 |         {
25 |             if (button != null)
26 |                 MenuButtons.Instance.UnregisterButton(button);
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/UITweaks/Utilities/MultiplayerEnergyBarCoroutineHandler.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections;
 2 | using UITweaks.PanelModifiers;
 3 | using UnityEngine;
 4 | using Zenject;
 5 | 
 6 | namespace UITweaks.Utilities
 7 | {
 8 |     internal class MultiplayerEnergyBarCoroutineHandler : MonoBehaviour
 9 |     {
10 |         [Inject] private readonly EnergyBarPanelDecorator energyBarPanelDecorator;
11 |         [Inject] private readonly GameplayModifiers gameplayModifiers;
12 | 
13 |         public void Start()
14 |         {
15 |             transform.SetParent(base.transform);
16 |             gameObject.SetActive(true);
17 |             base.StartCoroutine(PrepareMultiplayerEnergyBarColorsForEnergyType(gameplayModifiers.energyType));
18 |         }
19 | 
20 |         private IEnumerator PrepareMultiplayerEnergyBarColorsForEnergyType(GameplayModifiers.EnergyType energyType)
21 |         {
22 |             yield return StartCoroutine(energyBarPanelDecorator.BatteryEnergyAndOneLifeSetup(energyType));
23 |             gameObject.SetActive(false);
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Exomanz
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/UITweaks/Models/PreviewPanel.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | namespace UITweaks.Models
 4 | {
 5 |     /// <summary>
 6 |     /// Helper class which contains some useful properties for preview panel iteration and code reusability.
 7 |     /// </summary>
 8 |     public class PreviewPanel
 9 |     {
10 |         /// <summary>
11 |         /// The parent <see cref="GameObject"/> of the panel being previewed.
12 |         /// </summary>
13 |         public GameObject Panel { get; set; }
14 | 
15 |         /// <summary>
16 |         /// The settings tab index this panel is active on.
17 |         /// </summary>
18 |         public int ActiveTab { get; set; }
19 | 
20 |         /// <summary>
21 |         /// Creates a new instance of a <see cref="PreviewPanel"/> with a given parent object and settings tab index.
22 |         /// </summary>
23 |         /// <param name="activeTab">The index of the settings page this panel will appear on.</param>
24 |         /// <param name="panel">The parent <see cref="GameObject"/> of the panel being previewed.</param>
25 |         public PreviewPanel(int activeTab, GameObject panel)
26 |         {
27 |             ActiveTab = activeTab;
28 |             Panel = panel;
29 |         }
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/UITweaks/UI/UITweaksFlowCoordinator.cs:
--------------------------------------------------------------------------------
 1 | using BeatSaberMarkupLanguage;
 2 | using HMUI;
 3 | using Zenject;
 4 | 
 5 | namespace UITweaks.UI
 6 | {
 7 |     internal class UITweaksFlowCoordinator : FlowCoordinator
 8 |     {
 9 |         [Inject] private readonly MainFlowCoordinator mainFlowCoordinator;
10 |         [Inject] private readonly ModSettingsViewController settingsView;
11 |         [Inject] private readonly ModInfoViewController infoView;
12 |         [Inject] private readonly ObjectPreviewViewController previewView;
13 | 
14 |         protected override void DidActivate(bool firstActivation, bool addedToHierarchy, bool screenSystemEnabling)
15 |         {
16 |             if (firstActivation && addedToHierarchy)
17 |             {
18 |                 base.SetTitle("UITweaks");
19 |                 base.ProvideInitialViewControllers(settingsView, infoView, previewView);
20 |                 base.showBackButton = true;
21 |             }
22 |         }
23 | 
24 |         protected override void BackButtonWasPressed(ViewController topViewController)
25 |         {
26 |             base.BackButtonWasPressed(topViewController);
27 |             mainFlowCoordinator.DismissFlowCoordinator(this, null, ViewController.AnimationDirection.Vertical, false);
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/UITweaks/Config/EnergyConfig.cs:
--------------------------------------------------------------------------------
 1 | using IPA.Config.Stores.Attributes;
 2 | using IPA.Config.Stores.Converters;
 3 | using UITweaks.Models;
 4 | using UnityEngine;
 5 | 
 6 | namespace UITweaks.Config
 7 | {
 8 |     public class EnergyConfig : UITweaksConfigBase
 9 |     {
10 |         public override bool Enabled { get; set; } = true;
11 | 
12 |         /// <summary>
13 |         /// If set to <see langword="true"/>, the Energy Bar will play a rainbow animation when you reach full energy.
14 |         /// </summary>
15 |         public virtual bool RainbowOnFullEnergy { get; set; } = false;
16 | 
17 |         /// <summary>
18 |         /// The <see cref="Color"/> of the leftmost anchor point in the energy bar (0%).
19 |         /// </summary>
20 |         [UseConverter(typeof(HexColorConverter))]
21 |         public virtual Color Low { get; set; } = Color.red;
22 | 
23 |         /// <summary>
24 |         /// The <see cref="Color"/> of the center anchor point in the energy bar (50%).
25 |         /// </summary>
26 |         [UseConverter(typeof(HexColorConverter))]
27 |         public virtual Color Mid { get; set; } = Color.yellow;
28 | 
29 |         /// <summary>
30 |         /// The <see cref="Color"/> of the rightmost anchor point in the energy bar (100%).
31 |         /// </summary>
32 |         [UseConverter(typeof(HexColorConverter))]
33 |         public virtual Color High { get; set; } = Color.green;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <img src="Resources/uitweaks-logo-pdn.jpg" alt="UITweaks Logo" width=256px>
 2 | 
 3 | # 🛠️ UITweaks
 4 | A Beat Saber mod that aims to bring more color to the in-game HUD!
 5 | 
 6 | [![GitHub Release](https://img.shields.io/github/v/release/Exomanz/UITweaks?style=flat-square&color=cornflowerblue)](https://github.com/Exomanz/UITweaks/releases/latest)
 7 | [![GitHub Commits Since Latest Release (branch)](https://img.shields.io/github/commits-since/Exomanz/UITweaks/latest?style=flat-square&color=green)](https://github.com/Exomanz/UITweaks/commits)
 8 | 
 9 | ## Dependencies:
10 | - BSIPA v4.3.5+
11 | - SiraUtil v3.1.12+
12 | - BeatSaberMarkupLanguage v1.12.3+
13 | 
14 | ## Features
15 | - Multiplier ring colors, as well as an option to smoothly transition between them, and an optional rainbow animation on full 8x multiplier.
16 | - Energy bar colors corresponding to your current energy, and an optional rainbow animation on full.
17 | - Combo FC line colors, including optional gradient lines.
18 | - Colors for the progress bar, background, and slider knob. There also exists an option to smoothly transition between two colors as the song progresses.
19 | - Multiplayer player position panel colors for each position, an option to hide the first place animation, and an option for the static panel to use a static color.
20 | - And so much more!
21 | 
22 | ## Contributing
23 | Please read the [contributing file](CONTRIBUTING.md) for more information.
24 | 


--------------------------------------------------------------------------------
/UITweaks/UI/ModInfoViewController.cs:
--------------------------------------------------------------------------------
 1 | using BeatSaberMarkupLanguage.Attributes;
 2 | using BeatSaberMarkupLanguage.ViewControllers;
 3 | using IPA.Loader;
 4 | using SiraUtil.Logging;
 5 | using SiraUtil.Zenject;
 6 | using UnityEngine;
 7 | using Zenject;
 8 | 
 9 | namespace UITweaks.UI
10 | {
11 |     [ViewDefinition("UITweaks.Views.Info.bsml")]
12 |     [HotReload(RelativePathToLayout = @"..\Views\Info.bsml")]
13 |     public class ModInfoViewController : BSMLAutomaticViewController
14 |     {
15 |         [Inject] private readonly SiraLog logger;
16 |         private PluginMetadata meta;
17 | 
18 |         [Inject]
19 |         internal void Construct(UBinder<Plugin, PluginMetadata> metadata)
20 |         {
21 |             meta = metadata.Value;
22 |         }
23 | 
24 |         [UIValue("version-text")]
25 |         private string Version
26 |         {
27 |             get => $"Version  :  <color=#00BBFF>{meta.HVersion}</color>";
28 |         }
29 | 
30 |         [UIAction("open-gh-source")]
31 |         internal void OpenSourceLink() => Application.OpenURL("https://github.com/Exomanz/UITweaks");
32 | 
33 |         [UIAction("open-kofi")]
34 |         internal void OpenDonateLink() => Application.OpenURL("https://ko-fi.com/exo_manz");
35 | 
36 |         [UIAction("open-changelog")]
37 |         internal void OpenChangelogLink() => Application.OpenURL("https://github.com/Exomanz/UITweaks/commits/");
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/UITweaks.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.0.31919.166
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UITweaks", "UITweaks\UITweaks.csproj", "{4B5D5899-57C0-4FB5-891A-E83DD3071C69}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Heck-Debug|Any CPU = Heck-Debug|Any CPU
12 | 		Release|Any CPU = Release|Any CPU
13 | 	EndGlobalSection
14 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
15 | 		{4B5D5899-57C0-4FB5-891A-E83DD3071C69}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
16 | 		{4B5D5899-57C0-4FB5-891A-E83DD3071C69}.Debug|Any CPU.Build.0 = Debug|Any CPU
17 | 		{4B5D5899-57C0-4FB5-891A-E83DD3071C69}.Heck-Debug|Any CPU.ActiveCfg = Heck-Debug|Any CPU
18 | 		{4B5D5899-57C0-4FB5-891A-E83DD3071C69}.Heck-Debug|Any CPU.Build.0 = Heck-Debug|Any CPU
19 | 		{4B5D5899-57C0-4FB5-891A-E83DD3071C69}.Release|Any CPU.ActiveCfg = Release|Any CPU
20 | 		{4B5D5899-57C0-4FB5-891A-E83DD3071C69}.Release|Any CPU.Build.0 = Release|Any CPU
21 | 	EndGlobalSection
22 | 	GlobalSection(SolutionProperties) = preSolution
23 | 		HideSolutionNode = FALSE
24 | 	EndGlobalSection
25 | 	GlobalSection(ExtensibilityGlobals) = postSolution
26 | 		SolutionGuid = {EC8C1BED-52E9-4AB2-B7EA-CCD6FADE45DB}
27 | 	EndGlobalSection
28 | EndGlobal
29 | 


--------------------------------------------------------------------------------
/UITweaks/Utilities/SettableSettings/UITweaksSettingsWrapper.cs:
--------------------------------------------------------------------------------
 1 | namespace UITweaks.Utilities.SettableSettings
 2 | {
 3 | #if HECK
 4 |     using Heck.SettingsSetter;
 5 |     using System;
 6 |     using System.Reflection;
 7 |     using UnityEngine;
 8 |     public class UITweaksSettingsWrapper : ISettableSetting
 9 |     {
10 |         private readonly PropertyInfo settingsProperty;
11 |         private readonly object settingsInstance;
12 | 
13 |         private object originalValue;
14 | 
15 |         public string GroupName { get; }
16 |         public string FieldName { get; }
17 | 
18 |         public UITweaksSettingsWrapper(string groupName, string fieldName, PropertyInfo settingsProperty, object settingsInstance)
19 |         {
20 |             GroupName = groupName;
21 |             FieldName = fieldName;
22 | 
23 |             this.settingsProperty = settingsProperty;
24 |             this.settingsInstance = settingsInstance;
25 |         }
26 | 
27 |         public object TrueValue => settingsProperty.GetValue(settingsInstance);
28 | 
29 |         public void SetTemporary(object tempValue)
30 |         {
31 |             if (tempValue != null)
32 |             {
33 |                 originalValue = settingsProperty.GetValue(settingsInstance);
34 |                 settingsProperty.SetValue(settingsInstance, tempValue);
35 |             }
36 | 
37 |             else if (originalValue != null)
38 |             {
39 |                 settingsProperty.SetValue(settingsInstance, originalValue);
40 |                 originalValue = null;
41 |             }
42 |         }
43 |     }
44 | #endif
45 | }


--------------------------------------------------------------------------------
/UITweaks/Plugin.cs:
--------------------------------------------------------------------------------
 1 | using IPA;
 2 | using IPA.Config.Stores;
 3 | using IPA.Utilities;
 4 | using SiraUtil.Zenject;
 5 | using System;
 6 | using System.Linq;
 7 | using UITweaks.Installers;
 8 | using IPAConfig = IPA.Config.Config;
 9 | using IPALogger = IPA.Logging.Logger;
10 | 
11 | namespace UITweaks
12 | {
13 |     [Plugin(RuntimeOptions.DynamicInit), NoEnableDisable]
14 |     public class Plugin
15 |     {
16 |         public static bool APRIL_FOOLS
17 |         {
18 |             get
19 |             {
20 |                 if (Environment.GetCommandLineArgs().Any(x => x.ToLower() == "--uitweaks-aprilfools"))
21 |                     return true;
22 | 
23 |                 DateTime time = Utils.CurrentTime();
24 |                 return time.Month == 4 && time.Day == 1;
25 |             }
26 |         }
27 | 
28 |         [Init]
29 |         public Plugin(IPALogger logger, IPAConfig config, Zenjector zenject)
30 |         {
31 |             zenject.UseLogger(logger);
32 |             zenject.UseMetadataBinder<Plugin>();
33 | 
34 |             // Singleplayer and Campaign
35 |             zenject.Expose<CoreGameHUDController>("Environment");
36 | 
37 |             // Multiplayer
38 |             zenject.Expose<CoreGameHUDController>("IsActiveObjects");
39 |             zenject.Expose<MultiplayerPositionHUDController>("IsActiveObjects");
40 | 
41 |             zenject.Install<TweaksAppInstaller>(Location.App, config.Generated<PluginConfig>());
42 |             zenject.Install<TweaksMenuInstaller>(Location.Menu);
43 |             zenject.Install<TweaksPanelDecoratorInstaller>(Location.Player);
44 |         }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/UITweaks/UI/MockMultiplayerPositionPanel.cs:
--------------------------------------------------------------------------------
 1 | using HMUI;
 2 | using UnityEngine;
 3 | 
 4 | namespace UITweaks.UI
 5 | {
 6 |     public class MockMultiplayerPositionPanel : MonoBehaviour
 7 |     {
 8 |         [SerializeField] public bool IsSetup { get; private set; } = false;
 9 |         [SerializeField] public CurvedTextMeshPro positionText;
10 |         [SerializeField] public CurvedTextMeshPro playerCountText;
11 | 
12 |         public void Start()
13 |         {
14 |             gameObject.SetActive(false);
15 | 
16 |             var pt = new GameObject("PositionText").AddComponent<CurvedTextMeshPro>();
17 |             pt.transform.SetParent(this.transform, false);
18 |             pt.alignment = TMPro.TextAlignmentOptions.Center;
19 |             pt.fontStyle = TMPro.FontStyles.Italic;
20 |             pt.text = "1";
21 |             pt.transform.localPosition = new Vector3(-20, 0, 0);
22 | 
23 |             var pct = new GameObject("PlayerCountText").AddComponent<CurvedTextMeshPro>();
24 |             pct.transform.SetParent(this.transform, false);
25 |             pct.alignment = TMPro.TextAlignmentOptions.Center;
26 |             pct.fontStyle = TMPro.FontStyles.Italic;
27 |             pct.text = "/ 5";
28 |             pct.transform.localPosition = new Vector3(10, 0, 0);
29 | 
30 |             positionText = pt;
31 |             playerCountText = pct;
32 | 
33 |             gameObject.SetActive(true);
34 |             gameObject.AddComponent<Canvas>();
35 |             transform.localScale = new Vector3(0.02f, 0.02f, 0.02f);
36 |             transform.localPosition = new Vector3(-0.08f, 0, 0);
37 | 
38 |             IsSetup = true;
39 |         }
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/UITweaks/Installers/TweaksPanelDecoratorInstaller.cs:
--------------------------------------------------------------------------------
 1 | using UITweaks.Models;
 2 | using UITweaks.PanelModifiers;
 3 | using UITweaks.Utilities;
 4 | using UnityEngine;
 5 | using Zenject;
 6 | 
 7 | namespace UITweaks.Installers
 8 | {
 9 |     public class TweaksPanelDecoratorInstaller : Installer
10 |     {
11 |         [Inject] private readonly PluginConfig config;
12 | 
13 |         public override void InstallBindings()
14 |         {
15 |             bool isMultiplayer = Container.HasBinding<MultiplayerController>();
16 | 
17 |             BindPanelDecorator<ScoreMultiplierPanelDecorator>();
18 |             BindPanelDecorator<EnergyBarPanelDecorator>();
19 |             BindPanelDecorator<ComboPanelDecorator>();
20 |             BindPanelDecorator<SongProgressPanelDecorator>();
21 |             BindPanelDecorator<ExtraPanelDecorator>();
22 | 
23 |             if (isMultiplayer)
24 |             {
25 |                 BindPanelDecorator<MultiplayerPositionPanelDecorator>();
26 |                 Container.Bind<MultiplayerEnergyBarCoroutineHandler>().FromNewComponentOn(new GameObject("MultiplayerEnergyBarCoroutineHandler")).AsSingle().NonLazy();
27 |             }
28 | 
29 |             if (Plugin.APRIL_FOOLS && config.AllowAprilFools)
30 |                 Container.Bind<ExtraPanelDecorator.AprilFools>().FromNewComponentOn(new GameObject("UITweaks-AprilFoolsController")).AsSingle().NonLazy();
31 |         }
32 | 
33 |         /// <summary>
34 |         /// Shorthand function for binding <see cref="PanelDecoratorBase"/> classes.
35 |         /// </summary>
36 |         /// <typeparam name="T">Any class which derives from <see cref="PanelDecoratorBase"/>
37 |         private void BindPanelDecorator<T>() where T : PanelDecoratorBase
38 |         {
39 |             Container.Bind<T>().FromNewComponentOn(new GameObject(typeof(T).Name)).AsSingle().NonLazy();
40 |         }
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/UITweaks/Installers/TweaksAppInstaller.cs:
--------------------------------------------------------------------------------
 1 | using UITweaks.Models;
 2 | using UITweaks.Utilities;
 3 | using UITweaks.Utilities.SettableSettings;
 4 | using IPA.Loader;
 5 | using Zenject;
 6 | 
 7 | namespace UITweaks.Installers
 8 | {
 9 |     public class TweaksAppInstaller : Installer
10 |     {
11 |         private readonly PluginConfig config;
12 | 
13 |         [Inject]
14 |         public TweaksAppInstaller(PluginConfig pluginConfig)
15 |         {
16 |             config = pluginConfig;
17 |         }
18 | 
19 |         public override void InstallBindings()
20 |         {
21 |             Container.Bind<PluginConfig>().FromInstance(config).AsCached();
22 |             BindConfig(config.Multiplier);
23 |             BindConfig(config.Energy);
24 |             BindConfig(config.Combo);
25 |             BindConfig(config.Progress);
26 |             BindConfig(config.Position);
27 |             BindConfig(config.Misc);
28 | 
29 |             Container.BindInterfacesAndSelfTo<RainbowEffectManager>().AsSingle();
30 | 
31 | #if HECK
32 |             if (PluginManager.GetPlugin("Heck") != null)
33 |             {
34 |                 Container.BindInterfacesAndSelfTo<UITweaksSettableSettings>().AsSingle().NonLazy();
35 |             }
36 | #endif
37 |         }
38 | 
39 |         /// <summary>
40 |         /// Shorthand function for quickly binding configs in Zenject.<br></br>
41 |         /// </summary>
42 |         /// <typeparam name="T">Any class which derives from <see cref="UITweaksConfigBase"/></typeparam>
43 |         /// <param name="instance">An instance of a <see cref="UITweaksConfigBase"/>. These are usually defined inside of <see cref="PluginConfig"/></param>
44 |         private void BindConfig<T>(T instance) where T : UITweaksConfigBase
45 |         {
46 |             Container.Bind<T>().FromInstance(instance).AsCached();
47 |             Container.Bind<UITweaksConfigBase>().To<T>().FromInstance(instance).AsCached();
48 |         }
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/UITweaks/Config/MultiplierConfig.cs:
--------------------------------------------------------------------------------
 1 | using IPA.Config.Stores.Attributes;
 2 | using IPA.Config.Stores.Converters;
 3 | using UITweaks.Models;
 4 | using UnityEngine;
 5 | 
 6 | namespace UITweaks.Config
 7 | {
 8 |     public class MultiplierConfig : UITweaksConfigBase
 9 |     {
10 |         public override bool Enabled { get; set; } = true;
11 | 
12 |         /// <summary>
13 |         /// If set to <see langword="true"/>, the multiplier ring will crossfade between each set <see cref="Color"/> for each stage.
14 |         /// </summary>
15 |         public virtual bool SmoothTransition { get; set; } = false;
16 | 
17 |         /// <summary>
18 |         /// Setting this to <see langword="true"/> will enable a rainbow animation when your combo reaches 8x.
19 |         /// </summary>
20 |         public virtual bool RainbowOnMaxMultiplier { get; set; } = true;
21 | 
22 |         /// <summary>
23 |         /// The <see cref="Color"/> of the Multiplier ring when your combo is at 1x.
24 |         /// </summary>
25 |         [UseConverter(typeof(HexColorConverter))]
26 |         public virtual Color One { get; set; } = Color.red;
27 | 
28 |         /// <summary>
29 |         /// The <see cref="Color"/> of the Multiplier ring when your combo is at 2x.
30 |         /// </summary>
31 |         [UseConverter(typeof(HexColorConverter))]
32 |         public virtual Color Two { get; set; } = Color.yellow;
33 | 
34 |         /// <summary>
35 |         /// The <see cref="Color"/> of the Multiplier ring when your combo is at 4x.
36 |         /// </summary>
37 |         [UseConverter(typeof(HexColorConverter))]
38 |         public virtual Color Four { get; set; } = Color.green;
39 | 
40 |         /// <summary>
41 |         /// The <see cref="Color"/> of the Multiplier ring when your combo is at 8x and <see cref="RainbowOnMaxMultiplier"/> is set to <see langword="false"/>.
42 |         /// </summary>
43 |         [UseConverter(typeof(HexColorConverter))]
44 |         public virtual Color Eight { get; set; } = Color.cyan;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/UITweaks/Decorators/ComboPanelDecorator.cs:
--------------------------------------------------------------------------------
 1 | using HMUI;
 2 | using UITweaks.Config;
 3 | using UITweaks.Models;
 4 | using Zenject;
 5 | 
 6 | namespace UITweaks.PanelModifiers
 7 | {
 8 |     public class ComboPanelDecorator : PanelDecoratorBase
 9 |     {
10 |         [Inject] private readonly ComboConfig comboConfig;
11 | 
12 |         private ComboUIController comboUIController;
13 | 
14 |         [Inject]
15 |         protected override void Init()
16 |         {
17 |             comboUIController = base.gameHUDController.GetComponentInChildren<ComboUIController>();
18 |             ParentPanel = comboUIController?.gameObject;
19 |             Config = comboConfig;
20 |             transform.SetParent(ParentPanel?.transform);
21 | 
22 |             ModPanel(this);
23 |         }
24 | 
25 |         protected override bool ModPanel(in PanelDecoratorBase decorator)
26 |         {
27 |             if (!base.ModPanel(this)) return false;
28 | 
29 |             ImageView[] fcLines;
30 |             fcLines = ParentPanel.GetComponentsInChildren<ImageView>();
31 | 
32 |             if (comboConfig.UseGradient)
33 |             {
34 |                 fcLines[0].gradient = true;
35 |                 fcLines[1].gradient = true;
36 | 
37 |                 fcLines[0].color0 = comboConfig.TopLeft;
38 |                 fcLines[0].color1 = comboConfig.TopRight;
39 | 
40 |                 if (comboConfig.MirrorBottomLine)
41 |                 {
42 |                     fcLines[1].color0 = comboConfig.TopRight;
43 |                     fcLines[1].color1 = comboConfig.TopLeft;
44 |                 }
45 |                 else
46 |                 {
47 |                     fcLines[1].color0 = comboConfig.BottomLeft;
48 |                     fcLines[1].color1 = comboConfig.BottomRight;
49 |                 }
50 |             }
51 |             else
52 |             {
53 |                 fcLines[0].color = comboConfig.TopLine;
54 |                 fcLines[1].color = comboConfig.BottomLine;
55 |             }
56 | 
57 |             return true;
58 |         }
59 | 
60 |         protected override void OnDestroy() => base.OnDestroy();
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/UITweaks/Utilities/SettableSettings/UITweaksSettableSettings.cs:
--------------------------------------------------------------------------------
 1 | namespace UITweaks.Utilities.SettableSettings
 2 | {
 3 | #if HECK
 4 |     using Heck.SettingsSetter;
 5 |     using System;
 6 |     using System.Collections.Generic;
 7 |     using System.Reflection;
 8 |     using UITweaks.Models;
 9 | 
10 |     // Shoutout to Caeden117's Counters+ for providing a good example on how to register SettableSettings to Heck
11 |     internal class UITweaksSettableSettings : IDisposable
12 |     {
13 |         public static bool HasRunBefore { get; private set; } = false;
14 | 
15 |         private const string groupIdentifier = "_uiTweaks";
16 | 
17 |         private readonly BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance;
18 | 
19 |         private static List<ISettableSetting> settableSettings = new List<ISettableSetting>();
20 | 
21 |         public UITweaksSettableSettings(List<UITweaksConfigBase> configs)
22 |         {
23 |             if (HasRunBefore) return;
24 |             HasRunBefore = true;
25 | 
26 |             Type settableSettingsType = typeof(UITweaksSettingsWrapper);
27 | 
28 |             configs.Remove(configs.Find((c) => c.GetType().Name == "MiscConfig"));
29 | 
30 |             foreach (var conf in configs)
31 |             {
32 |                 var configType = conf.GetType();
33 |                 var normalizedTypeName = configType.BaseType.Name;
34 |                 var enabledProperty = configType.GetProperty("Enabled", bindingFlags);
35 | 
36 |                 ISettableSetting setting = Activator.CreateInstance(settableSettingsType,
37 |                     $"UITweaks - {normalizedTypeName}", enabledProperty.Name, enabledProperty, conf)
38 |                     as ISettableSetting;
39 | 
40 |                 settableSettings.Add(setting);
41 | 
42 |                 int indexOfConfig = normalizedTypeName.IndexOf("Config");
43 |                 string heckFieldName = $"_{normalizedTypeName.Remove(indexOfConfig).ToLowerInvariant()}{enabledProperty.Name}";
44 |                 SettingSetterSettableSettingsManager.RegisterSettableSetting(groupIdentifier, heckFieldName, setting);
45 |             }
46 |         }
47 | 
48 |         public void Dispose()
49 |         {
50 |             settableSettings.ForEach(x => x.SetTemporary(null));
51 |         }
52 |     }
53 | #endif
54 | }


--------------------------------------------------------------------------------
/UITweaks/Utilities/Utilities.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace UITweaks.Utilities
 4 | {
 5 |     internal static class Utilities
 6 |     {
 7 |         private static readonly Random Rand = new Random(Environment.TickCount + 2);
 8 | 
 9 |         /// <summary>
10 |         /// Generates a random decimal between 0.0 and <paramref name="max"></paramref>.
11 |         /// </summary>
12 |         /// <param name="max"/>
13 |         /// <returns>A non-negative decimal greater than or equal to 0.0 and less than <paramref name="max"/>.</returns>
14 |         public static decimal RandomDecimal(double max)
15 |         {
16 |             double sample = Rand.NextDouble();
17 |             decimal d = (decimal)(sample * max);
18 |             return d;
19 |         }
20 | 
21 |         /// <summary>
22 |         /// Generates a random decimal between 0.0 and <paramref name="max"/>, trimmed to a set amount of decimal places.
23 |         /// </summary>
24 |         /// <param name="max"/>
25 |         /// <param name="decimalSpaces"/>
26 |         /// <returns>A non-negative decimal greater than or equal to 0.0 and less than <paramref name="max"/>, trimmed to <paramref name="decimalSpaces"/> decimal spaces.</returns>
27 |         public static decimal RandomDecimal(double max, int decimalSpaces)
28 |         {
29 |             double sample = Rand.NextDouble();
30 |             decimal d = (decimal)(sample * max);
31 |             decimal d2 = decimal.Round(d, decimalSpaces);
32 | 
33 |             return d2;
34 |         }
35 | 
36 |         /// <summary>
37 |         /// Generates a random decimal between <paramref name="min"/> and <paramref name="max"/>, trimmed to a set amount of decimal places.
38 |         /// </summary>
39 |         /// <param name="min"/>
40 |         /// <param name="max"/>
41 |         /// <param name="decimalSpaces"/>
42 |         /// <returns>A non-negative decimal greater than or equal to <paramref name="min"/> and less than <paramref name="max"/>, rounded to <paramref name="decimalSpaces"/> decimal spaces.</returns>
43 |         public static decimal RandomDecimal(double min, double max, int decimalSpaces)
44 |         {
45 |             double sample = Rand.NextDouble();
46 |             decimal d = (decimal)(sample * (max - min)) + (decimal)min;
47 |             decimal d2 = decimal.Round(d, decimalSpaces);
48 | 
49 |             return d2;
50 |         }
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/UITweaks/Config/ProgressConfig.cs:
--------------------------------------------------------------------------------
 1 | using IPA.Config.Stores.Attributes;
 2 | using IPA.Config.Stores.Converters;
 3 | using UITweaks.Models;
 4 | using UnityEngine;
 5 | 
 6 | namespace UITweaks.Config
 7 | {
 8 |     public class ProgressConfig : UITweaksConfigBase
 9 |     {
10 |         public enum DisplayType
11 |         {
12 |             Fixed = 0,
13 |             Fade = 1,
14 |         }
15 | 
16 |         public override bool Enabled { get; set; } = true;
17 | 
18 |         /// <summary>
19 |         /// The <see cref="Color"/> of the Progress Bar's fill section.
20 |         /// </summary>
21 |         [UseConverter(typeof(HexColorConverter))]
22 |         public virtual Color Fill { get; set; } = Color.white;
23 | 
24 |         /// <summary>
25 |         /// The <see cref="Color"/> of the Progress Bar's background.
26 |         /// </summary>
27 |         [UseConverter(typeof(HexColorConverter))]
28 |         public virtual Color BG { get; set; } = Color.white;
29 | 
30 |         /// <summary>
31 |         /// The <see cref="Color"/> of the Progress Bar's handle, which is anchored to the Fill section.
32 |         /// </summary>
33 |         [UseConverter(typeof(HexColorConverter))]
34 |         public virtual Color Handle { get; set; } = Color.white;
35 | 
36 |         /// <summary>
37 |         /// Controls the mode in which the progress bar is decorated.
38 |         /// <list type="bullet">
39 |         /// <item>Fixed: All components will be statically colored for the entire song.</item>
40 |         /// <item>Fade: The Background component of the progress bar will fade between <see cref="StartColor"/> and <see cref="EndColor"/> as the song progresses.</item>
41 |         /// </list>
42 |         /// </summary>
43 |         public virtual DisplayType Mode { get; set; } = DisplayType.Fixed;
44 | 
45 |         /// <summary>
46 |         /// The <see cref="Color"/> of the progress bar fill section at the start of the song.
47 |         /// <br></br>This will only take effect if <see cref="UseFadeDisplayType"/> is <see langword="true"/>.
48 |         /// </summary>
49 |         [UseConverter(typeof(HexColorConverter))]
50 |         public virtual Color StartColor { get; set; } = Color.red;
51 | 
52 |         /// <summary>
53 |         /// The <see cref="Color"/> of the Progress Bar fill section at the end of the song.
54 |         /// <br></br>This will only take effect if <see cref="UseFadeDisplayType"/> is <see langword="true"/>.
55 |         /// </summary>
56 |         [UseConverter(typeof(HexColorConverter))]
57 |         public virtual Color EndColor { get; set; } = Color.green;
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/UITweaks/Config/PositionConfig.cs:
--------------------------------------------------------------------------------
 1 | using IPA.Config.Stores.Attributes;
 2 | using IPA.Config.Stores.Converters;
 3 | using UITweaks.Models;
 4 | using UnityEngine;
 5 | 
 6 | namespace UITweaks.Config
 7 | {
 8 |     public class PositionConfig : UITweaksConfigBase
 9 |     {
10 |         public override bool Enabled { get; set; } = true;
11 | 
12 |         /// <summary>
13 |         /// If set to <see langword="true"/>, the 1st place animation object will be hidden.
14 |         /// </summary>
15 |         public virtual bool HideFirstPlaceAnimation { get; set; } = false;
16 | 
17 |         /// <summary>
18 |         /// Controls the rainbow effect of the PanelDecorator when in first place.
19 |         /// </summary>
20 |         public virtual bool RainbowOnFirstPlace { get; set; } = false;
21 | 
22 |         /// <summary>
23 |         /// If set to <see langword="true"/>, the player count panel will use a static color regardless of your position.
24 |         /// </summary>
25 |         public virtual bool UseStaticColorForStaticPanel { get; set; } = false;
26 | 
27 |         /// <summary>
28 |         /// The <see cref="Color"/> of the player count section of the Position Panel.
29 |         /// </summary>
30 |         /// <remarks>This will only take effect if <see cref="UseStaticColorForStaticPanel"/> is <see langword="true"/>.</remarks>
31 |         [UseConverter(typeof(HexColorConverter))]
32 |         public virtual Color StaticPanelColor { get; set; } = Color.white;
33 | 
34 |         /// <summary>
35 |         /// The <see cref="Color"/> of the Position Panel when you are in first place.
36 |         /// </summary>
37 |         [UseConverter(typeof(HexColorConverter))]
38 |         public virtual Color First { get; set; } = Color.cyan;
39 | 
40 |         /// <summary>
41 |         /// The <see cref="Color"/> of the Position Panel when you are in second place.
42 |         /// </summary>
43 |         [UseConverter(typeof(HexColorConverter))]
44 |         public virtual Color Second { get; set; } = Color.green;
45 | 
46 |         /// <summary>
47 |         /// The <see cref="Color"/> of the Position Panel when you are in third place.
48 |         /// </summary>
49 |         [UseConverter(typeof(HexColorConverter))]
50 |         public virtual Color Third { get; set; } = Color.yellow;
51 | 
52 |         /// <summary>
53 |         /// The <see cref="Color"/> of the Position Panel when you are in fourth place.
54 |         /// </summary>
55 |         [UseConverter(typeof(HexColorConverter))]
56 |         public virtual Color Fourth { get; set; } = new Color(1f, 0.5f, 0f);
57 | 
58 |         /// <summary>
59 |         /// The <see cref="Color"/> of the Position Panel when you are in fifth place.
60 |         /// </summary>
61 |         [UseConverter(typeof(HexColorConverter))]
62 |         public virtual Color Fifth { get; set; } = Color.red;
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/UITweaks/Config/ComboConfig.cs:
--------------------------------------------------------------------------------
 1 | using IPA.Config.Stores.Attributes;
 2 | using IPA.Config.Stores.Converters;
 3 | using UITweaks.Models;
 4 | using UnityEngine;
 5 | 
 6 | namespace UITweaks.Config
 7 | {
 8 |     public class ComboConfig : UITweaksConfigBase
 9 |     {
10 |         public override bool Enabled { get; set; } = true;
11 | 
12 |         /// <summary>
13 |         /// The <see cref="Color"/> of the top Combo line.
14 |         /// </summary>
15 |         [UseConverter(typeof(HexColorConverter))]
16 |         public virtual Color TopLine { get; set; } = Color.cyan;
17 | 
18 |         /// <summary>
19 |         /// The <see cref="Color"/> of the bottom Combo line.
20 |         /// </summary>
21 |         [UseConverter(typeof(HexColorConverter))]
22 |         public virtual Color BottomLine { get; set; } = Color.cyan;
23 | 
24 |         /// <summary>
25 |         /// If set to <see langword="true"/>, each Combo line will have a gradient. 
26 |         /// </summary>
27 |         public virtual bool UseGradient { get; set; } = true;
28 | 
29 |         /// <summary>
30 |         /// If set to <see langword="true"/>, the bottom Combo line will reflect the top Combo line horizontally.
31 |         /// </summary>
32 |         /// <remarks>This will only take effect if <see cref="UseGradient"/> is <see langword="true"/>.</remarks>
33 |         public virtual bool MirrorBottomLine { get; set; } = true;
34 | 
35 |         /// <summary>
36 |         /// The left <see cref="Color"/> of the top Combo line.
37 |         /// </summary>
38 |         /// <remarks>This will only take effect if <see cref="UseGradient"/> is <see langword="true"/>.</remarks>
39 |         [UseConverter(typeof(HexColorConverter))]
40 |         public virtual Color TopLeft { get; set; } = Color.red;
41 | 
42 |         /// <summary>
43 |         /// The right <see cref="Color"/> of the top Combo line.
44 |         /// </summary>
45 |         /// <remarks>This will only take effect if <see cref="UseGradient"/> is <see langword="true"/>.</remarks>
46 |         [UseConverter(typeof(HexColorConverter))]
47 |         public virtual Color TopRight { get; set; } = Color.yellow;
48 | 
49 |         /// <summary>
50 |         /// The left <see cref="Color"/> of the bottom Combo line.
51 |         /// </summary>
52 |         /// <remarks>This will only take effect if <see cref="UseGradient"/> is <see langword="true"/> and <see cref="MirrorBottomLine"/> is <see langword="false"/>.</remarks>
53 |         [UseConverter(typeof(HexColorConverter))]
54 |         public virtual Color BottomLeft { get; set; } = Color.white;
55 | 
56 |         /// <summary>
57 |         /// The right <see cref="Color"/> of the bottom Combo line.
58 |         /// </summary>
59 |         /// <remarks>This will only take effect if <see cref="UseGradient"/> is <see langword="true"/> and <see cref="MirrorBottomLine"/> is <see langword="false"/>.</remarks>
60 |         [UseConverter(typeof(HexColorConverter))]
61 |         public virtual Color BottomRight { get; set; } = Color.white;
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/UITweaks/Decorators/SongProgressPanelDecorator.cs:
--------------------------------------------------------------------------------
 1 | using HMUI;
 2 | using System.Collections.Generic;
 3 | using UITweaks.Config;
 4 | using UITweaks.Models;
 5 | using Zenject;
 6 | 
 7 | namespace UITweaks.PanelModifiers
 8 | {
 9 |     public class SongProgressPanelDecorator : PanelDecoratorBase
10 |     {
11 |         [InjectOptional] private readonly StandardGameplaySceneSetupData gameplaySceneSetupData;
12 |         [Inject] private readonly CoreGameHUDController.InitData coreGameHudInitData;
13 |         [Inject] private readonly AudioTimeSyncController audioTimeSyncController;
14 |         [Inject] private readonly ProgressConfig progressConfig;
15 | 
16 |         private SongProgressUIController songProgressUIController;
17 |         private readonly List<ImageView> barComponents = new List<ImageView>();
18 | 
19 |         [Inject]
20 |         protected override void Init()
21 |         {
22 |             songProgressUIController = base.gameHUDController.GetComponentInChildren<SongProgressUIController>();
23 |             ParentPanel = songProgressUIController?.gameObject;
24 |             Config = progressConfig;
25 |             transform.SetParent(ParentPanel?.transform);
26 | 
27 |             ModPanel(this);
28 |         }
29 | 
30 |         protected override bool ModPanel(in PanelDecoratorBase decorator)
31 |         {
32 |             if (!coreGameHudInitData.advancedHUD)
33 |             {
34 |                 this.CanBeUsedSafely = false;
35 |                 return false;
36 |             }
37 | 
38 |             if (!base.ModPanel(this)) return false;
39 | 
40 |             if (gameplaySceneSetupData?.beatmapKey.beatmapCharacteristic.containsRotationEvents == true)
41 |             {
42 |                 logger.Logger.Debug("Selected map is 360/90. Disabling the SongProgressPanelModifier");
43 |                 CanBeUsedSafely = false;
44 |                 return false;
45 |             }
46 | 
47 |             foreach (ImageView x in songProgressUIController.GetComponentsInChildren<ImageView>())
48 |             {
49 |                 if (x.name != "BG")
50 |                 {
51 |                     // [0] Fill, [1] BG, [2] Handle
52 |                     barComponents.Add(x);
53 |                 }
54 |             }
55 | 
56 |             if (progressConfig.Mode == ProgressConfig.DisplayType.Fixed)
57 |             {
58 |                 barComponents[0].color = progressConfig.Fill;
59 |             }
60 |             barComponents[1].color = progressConfig.BG.ColorWithAlpha(0.25f);
61 |             barComponents[2].color = progressConfig.Handle;
62 | 
63 |             return true;
64 |         }
65 | 
66 |         public void Update()
67 |         {
68 |             if (!CanBeUsedSafely) return;
69 | 
70 |             if (progressConfig.Mode == ProgressConfig.DisplayType.Fade)
71 |             {
72 |                 barComponents[0].color = HSBColor.Lerp(
73 |                     HSBColor.FromColor(progressConfig.StartColor),
74 |                     HSBColor.FromColor(progressConfig.EndColor),
75 |                     audioTimeSyncController.songTime / audioTimeSyncController.songLength)
76 |                     .ToColor();
77 |             }
78 |         }
79 | 
80 |         protected override void OnDestroy() => base.OnDestroy();
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contributing to the UITweaks Repository 
 2 | Are you a player and want to potentially see a feature added into this mod? A developer who found a bug and fixed it? There are multiple ways to contribute your ideas to the UITweaks Repository!
 3 | 
 4 | This project is licensed under the [MIT License](LICENSE). Read the license file to learn more.
 5 | 
 6 | ## For Everyone - [Open an Issue](https://github.com/Exomanz/UITweaks/issues/new)
 7 | If you found a bug or have a feature request, please submit an issue. Fill out the form as fully as possible to make it easier to understand and reduce the back-and-forth trying to narrow down what is being discussed:
 8 | 
 9 | - **Title:** Short and to the point, include game and plugin versions if necessary.
10 | - **Description:** As verbose as necessary to explain the issue or feature request. Screenshots and steps to reproduce a bug are always appreciated.
11 | - **Attached Files:** If the issue pertains to a bug, please attach the `_latest.log` file from the Beat Saber directory and any additional screenshots/content you would like to include to aid in tracking down the cause of the problem. These can be videos, configuration files, etc. 
12 | 
13 | The more complete the issue form is, the faster the bug can be fixed and a patch can be released.
14 | 
15 | ## For Developers - Clone UITweaks and [Create a Pull Request](https://github.com/Exomanz/UITweaks/compare)
16 | If you are itching for a feature and want to implement it yourself, or simply have a code suggestion to help make this plugin better, submit a pull request! I would love to incorporate your code into this mod.
17 | 
18 | ### Dependencies for Building
19 | - .NET Framework v4.8.0
20 | - BSIPA v4.3.4+
21 | - SiraUtil v3.10.0+
22 | - BeatSaberMarkupLanguage v1.11.2+
23 | - _Heck v1.6.0+*
24 | 
25 | **If you are building the project without a local version of Heck installed, build in the `Debug` configuration. If Heck is present, build with `Heck-Debug` to enable features that integrate with Heck's API, such as `SettableSettings`. **You should not be building as `Release`.***
26 | 
27 | In order to build this project locally, clone the source code onto your machine, create the `UITweaks.csproj.user` file, and add your Beat Saber directory path to it.
28 | This file should not be uploaded to GitHub, and is filtered out by the `.gitignore`.
29 | 
30 | **UITweaks.csproj.user**   
31 | ```xml
32 | <?xml version="1.0" encoding="utf-8"?>
33 | <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
34 |   <PropertyGroup>
35 |     <!-- SET *YOUR OWN* BEAT SABER DIRECTORY HERE TO RESOLVE MOST DEPENDECY PATHS! -->
36 |     <BeatSaberDir>C:\Program Files (x86)\Steam\steamapps\common\Beat Saber</BeatSaberDir>
37 |   </PropertyGroup>
38 | </Project>
39 | ```
40 | 
41 | ### Adding New Dependencies
42 | If you are going to add new dependencies, please ensure that the paths use `$(BeatSaberDir)` in the `UITweaks.csproj` file. This reduces potential merge conflicts and problems when new developers clone the code themselves with dependencies not resolving.
43 | 
44 | **UITweaks.csproj**   
45 | ```xml
46 | ...
47 |   <Reference Include="Main.dll">
48 |     <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Main.dll</HintPath>
49 |   </Reference>
50 | ...
51 | ```
52 | 


--------------------------------------------------------------------------------
/UITweaks/Models/PanelDecoratorBase.cs:
--------------------------------------------------------------------------------
 1 | using SiraUtil.Logging;
 2 | using System;
 3 | using UITweaks.Utilities;
 4 | using UnityEngine;
 5 | using Zenject;
 6 | 
 7 | namespace UITweaks.Models
 8 | {
 9 |     /// <summary>
10 |     /// Helper class which contains shared resources for all UITweaks PanelDecorators, as well as helper methods to verify proper setup and disposal.
11 |     /// </summary>
12 |     public abstract class PanelDecoratorBase : MonoBehaviour
13 |     {
14 |         [Inject] private readonly GameplayCoreSceneSetupData gameplayCoreSceneSetupData;
15 |         [Inject] private readonly RainbowEffectManager rainbowEffectManager;
16 |         [Inject] protected readonly SiraLog logger;
17 |         [Inject] protected readonly CoreGameHUDController gameHUDController;
18 | 
19 |         /// <summary>
20 |         /// Determines whether a PanelDecorator is safe to use in the given context.
21 |         /// </summary>
22 |         /// <remarks>Always evaluates to <see langword="false"/> if the base configuration has the PanelDecorator disabled.</remarks>
23 |         public bool CanBeUsedSafely { get; protected set; } = true;
24 |         public Color RainbowColor => rainbowEffectManager.Rainbow;
25 | 
26 |         public UITweaksConfigBase Config;
27 |         public GameObject ParentPanel;
28 | 
29 |         protected abstract void Init();
30 | 
31 |         protected virtual bool ModPanel(in PanelDecoratorBase callingDecorator)
32 |         {
33 |             string callingTypeName = callingDecorator.GetType().Name;
34 |             logger.Logger.Debug($"Setting up new PanelDecorator of type {callingTypeName}");
35 | 
36 |             try
37 |             {
38 |                 if (callingDecorator.ParentPanel == null)
39 |                     throw new NullReferenceException($"Field 'parentPanel' cannot be null when creating an object of type {callingTypeName} (is Counters+ hiding it?)");
40 | 
41 |                 if (callingDecorator.Config == null)
42 |                     throw new NullReferenceException($"Field 'config' cannot be null when creating an object of type {callingTypeName}");
43 |             }
44 |             catch (NullReferenceException ex)
45 |             {
46 |                 logger.Logger.Error($"PanelDecorator of type {callingTypeName} cannot be properly initialized.");
47 |                 logger.Logger.Error(ex);
48 |                 callingDecorator.CanBeUsedSafely = false;
49 |                 return false;
50 |             }
51 | 
52 |             if (gameplayCoreSceneSetupData.playerSpecificSettings.noTextsAndHuds || gameplayCoreSceneSetupData.gameplayModifiers.zenMode)
53 |             {
54 |                 callingDecorator.CanBeUsedSafely = false;
55 |                 logger.Logger.Debug($"No Texts/HUDs OR Zen Mode are enabled. {callingTypeName} will not be initialized.");
56 |                 return false;
57 |             }
58 | 
59 |             if (!callingDecorator.Config.Enabled)
60 |             {
61 |                 callingDecorator.CanBeUsedSafely = false;
62 |                 logger.Logger.Debug($"PanelDecorator of type {callingTypeName} is disabled and will not be initialized.");
63 |                 return false;
64 |             }
65 | 
66 |             logger.Logger.Debug($"Successfully initialized new PanelDecorator of type {callingTypeName}");
67 |             callingDecorator.CanBeUsedSafely = true;
68 |             return true;
69 |         }
70 | 
71 |         protected virtual void OnDestroy()
72 |         {
73 |             ParentPanel = null;
74 |             Config = null;
75 |         }
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/UITweaks/Config/MiscConfig.cs:
--------------------------------------------------------------------------------
 1 | using IPA.Config.Stores.Attributes;
 2 | using IPA.Config.Stores.Converters;
 3 | using UITweaks.Models;
 4 | using UnityEngine;
 5 | 
 6 | namespace UITweaks.Config
 7 | {
 8 |     public class MiscConfig : UITweaksConfigBase
 9 |     {
10 |         [Ignore] public override bool Enabled { get; set; } = true;
11 | 
12 |         /// <summary>
13 |         /// Controls the speed of the rainbow effect globally.
14 |         /// </summary>
15 |         public virtual float GlobalRainbowSpeed { get; set; } = 0.5f;
16 | 
17 |         /// <summary>
18 |         /// If set to <see langword="true"/>, the "Combo" text and number will be italicized.
19 |         /// </summary>
20 |         public virtual bool ItalicizeComboPanel { get; set; } = false;
21 | 
22 |         /// <summary>
23 |         /// If set to <see langword="true"/>, the score will be italicized.
24 |         /// </summary>
25 |         public virtual bool ItalicizeScore { get; set; } = false;
26 | 
27 |         /// <summary>
28 |         /// If set to <see langword="true"/>, the immediate rank panel will be italicized.
29 |         /// </summary>
30 |         public virtual bool ItalicizeImmediateRank { get; set; } = false;
31 | 
32 |         /// <summary>
33 |         /// If set to true, <see langword="true"/>, the rank text (SS, A, etc.) will be colored.
34 |         /// </summary>
35 |         public virtual bool AllowRankColoring { get; set; } = true;
36 | 
37 |         /// <summary>
38 |         /// If set to <see langword="true"/>, enables the rainbow effect of the rank text while maintaining an "SS" rank.
39 |         /// </summary>
40 |         public virtual bool RainbowOnSSRank { get; set; } = false;
41 | 
42 |         /// <summary>
43 |         /// The <see cref="Color"/> of the rank text when the rank is "SS".
44 |         /// </summary>
45 |         [UseConverter(typeof(HexColorConverter))]
46 |         public virtual Color RankSSColor { get; set; } = Color.cyan;
47 | 
48 |         /// <summary>
49 |         /// The <see cref="Color"/> of the rank text when the rank is "S".
50 |         /// </summary>
51 |         [UseConverter(typeof(HexColorConverter))]
52 |         public virtual Color RankSColor { get; set; } = Color.green;
53 | 
54 |         /// <summary>
55 |         /// The <see cref="Color"/> of the rank text when the rank is "A".
56 |         /// </summary>
57 |         [UseConverter(typeof(HexColorConverter))]
58 |         public virtual Color RankAColor { get; set; } = Color.yellow;
59 | 
60 |         /// <summary>
61 |         /// The <see cref="Color"/> of the rank text when the rank is "B".
62 |         /// </summary>
63 |         [UseConverter(typeof(HexColorConverter))]
64 |         public virtual Color RankBColor { get; set; } = new Color(1, 0.66f, 0);
65 | 
66 |         /// <summary>
67 |         /// The <see cref="Color"/> of the rank text when the rank is "C".
68 |         /// </summary>
69 |         [UseConverter(typeof(HexColorConverter))]
70 |         public virtual Color RankCColor { get; set; } = new Color(1, 0.33f, 0);
71 | 
72 |         /// <summary>
73 |         /// The <see cref="Color"/> of the rank text when the rank is "D".
74 |         /// </summary>
75 |         [UseConverter(typeof(HexColorConverter))]
76 |         public virtual Color RankDColor { get; set; } = Color.red;
77 | 
78 |         /// <summary>
79 |         /// The <see cref="Color"/> of the rank text when the rank is "E".
80 |         /// </summary>
81 |         [UseConverter(typeof(HexColorConverter))]
82 |         public virtual Color RankEColor { get; set; } = Color.red;
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/UITweaks/Decorators/MultiplayerPositionPanelDecorator.cs:
--------------------------------------------------------------------------------
 1 | using HMUI;
 2 | using System.Collections.Generic;
 3 | using TMPro;
 4 | using UITweaks.Config;
 5 | using UITweaks.Models;
 6 | using UnityEngine;
 7 | using Zenject;
 8 | 
 9 | namespace UITweaks.PanelModifiers
10 | {
11 |     public class MultiplayerPositionPanelDecorator : PanelDecoratorBase
12 |     {
13 |         [Inject] private readonly PositionConfig positionConfig;
14 |         [Inject] private readonly MultiplayerScoreProvider scoreProvider;
15 | 
16 |         private MultiplayerPositionHUDController positionHUDController;
17 |         private Dictionary<int, Color> playerCountToConfigValuesMap;
18 |         private MultiplayerScoreProvider.RankedPlayer localConnectedPlayer;
19 |         private TextMeshProUGUI playerCountText;
20 |         private TextMeshProUGUI dynamicPositionText;
21 | 
22 |         [Inject]
23 |         protected override void Init()
24 |         {
25 |             positionHUDController = base.gameHUDController.transform.parent.GetComponentInChildren<MultiplayerPositionHUDController>();
26 |             ParentPanel = positionHUDController?.gameObject;
27 |             Config = positionConfig;
28 |             transform.SetParent(ParentPanel?.transform);
29 | 
30 |             playerCountToConfigValuesMap = new Dictionary<int, Color>()
31 |             {
32 |                 { 0, Color.white },
33 |                 { 1, positionConfig.First },
34 |                 { 2, positionConfig.Second },
35 |                 { 3, positionConfig.Third },
36 |                 { 4, positionConfig.Fourth },
37 |                 { 5, positionConfig.Fifth }
38 |             };
39 | 
40 |             ModPanel(this);
41 |         }
42 | 
43 |         protected override bool ModPanel(in PanelDecoratorBase decorator)
44 |         {
45 |             if (!base.ModPanel(this)) return false;
46 | 
47 |             playerCountText = positionHUDController._playerCountText;
48 |             dynamicPositionText = positionHUDController._positionText;
49 | 
50 |             return true;
51 |         }
52 | 
53 |         public void Start()
54 |         {
55 |             if (!CanBeUsedSafely) return;
56 | 
57 |             int localPlayerIdx = scoreProvider._rankedPlayers.FindIndex(player => player.isMe);
58 |             localConnectedPlayer = scoreProvider.rankedPlayers[localPlayerIdx];
59 | 
60 |             dynamicPositionText.color = playerCountToConfigValuesMap[localPlayerIdx + 1];
61 |             playerCountText.color = positionConfig.UseStaticColorForStaticPanel ? positionConfig.StaticPanelColor.ColorWithAlpha(0.25f) : playerCountToConfigValuesMap[scoreProvider.rankedPlayers.Count].ColorWithAlpha(0.25f);
62 | 
63 |             if (positionConfig.HideFirstPlaceAnimation)
64 |                 positionHUDController._firstPlayerAnimationGo.transform.Rotate(0, 180, 0); // Text can't render upside-down
65 |         }
66 | 
67 |         public void Update()
68 |         {
69 |             if (!CanBeUsedSafely) return;
70 | 
71 |             int position = scoreProvider._rankedPlayers.IndexOf(localConnectedPlayer) + 1;
72 |             if (positionHUDController._prevPosition != position)
73 |             {
74 |                 dynamicPositionText.color = playerCountToConfigValuesMap[position];
75 | 
76 |                 if (!positionConfig.UseStaticColorForStaticPanel)
77 |                     playerCountText.color = playerCountToConfigValuesMap[position].ColorWithAlpha(0.25f);
78 |             }
79 | 
80 |             if (position == 1 && positionConfig.RainbowOnFirstPlace)
81 |             {
82 |                 dynamicPositionText.color = base.RainbowColor;
83 |                 if (positionHUDController._firstPlayerAnimationGo?.gameObject != null)
84 |                     positionHUDController._firstPlayerAnimationGo.GetComponent<CurvedTextMeshPro>().color = base.RainbowColor;
85 | 
86 |                 if (!positionConfig.UseStaticColorForStaticPanel)
87 |                     playerCountText.color = base.RainbowColor.ColorWithAlpha(0.25f);
88 |             }
89 |         }
90 | 
91 |         protected override void OnDestroy()
92 |         {
93 |             base.OnDestroy();
94 |         }
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/UITweaks/Views/Info.bsml:
--------------------------------------------------------------------------------
 1 | <bg xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' 
 2 | 	xsi:schemaLocation='https://monkeymanboy.github.io/BSML-Docs/ 
 3 | 	https://raw.githubusercontent.com/monkeymanboy/BSML-Docs/gh-pages/BSMLSchema.xsd'>
 4 | 	<vertical vertical-fit='PreferredSize' child-control-height='False' spacing='3' anchor-pos-y='10'>
 5 | 		<vertical vertical-fit='PreferredSize' bg='panel-top' bg-color='#ff7700ff' pad='1' pref-width='102'>
 6 | 			<vertical vertical-fit='PreferredSize' bg='panel-top' pad-top='1' bg-color='#000000ff' pref-width='100'>
 7 | 				<text text='About' align='Center' font-size='8' italics='True'/>
 8 | 			</vertical>
 9 | 		</vertical>
10 | 		<vertical vertical-fit='PreferredSize' bg='round-rect-panel' pref-width='110' pad='2'>
11 | 			<horizontal>
12 | 				<vertical vertical-fit='PreferredSize' spacing='2.5' pad-top='1'>
13 | 					<text text='Mod  :  &lt;color=#3FF74D&gt;UITweaks' italics='True'/>
14 | 					<text text='~version-text' italics='True'/>
15 | 					<text text='Developer  :  &lt;color=#FF6666&gt;exomanz' italics='True'/>
16 | 				</vertical>
17 | 				<vertical vertical-fit='PreferredSize'>
18 | 					<button text='Source' face-color='#FFAA33' click-event='show-gh-modal' pref-width='20'/>
19 | 					<modal show-event='show-gh-modal' hide-event='hide'
20 | 						   click-off-closes='True' move-to-center='True' size-delta-x='95' size-delta-y='40'>
21 | 						<vertical vertical-fit='PreferredSize'>
22 | 							<text text='Notice' font-color='#FF3F3F' font-size='7' bold='True' align='Center'/>
23 | 							<text text='You are about to open a link in your browser.&#xA;Do you wish to continue?'
24 | 								  align='Center'/>
25 | 							<text text='Link  :  &lt;color=#55A1FF&gt;https://github.com/Exomanz/UITweaks/tree/main/UITweaks'
26 | 								  font-size='3' align='Center'/>
27 | 							<horizontal horizontal-fit='PreferredSize' spacing='4' pad-top='2'>
28 | 								<button text='No' click-event='hide' face-color='#FF3737'/>
29 | 								<button text='Yes' click-event='hide' on-click='open-gh-source' face-color='#37FF37'/>
30 | 							</horizontal>
31 | 						</vertical>
32 | 					</modal>
33 | 					
34 | 					<button text='Donate' face-color='#FF77FF' click-event='show-kofi-modal' pref-width='20'/>
35 | 					<modal show-event='show-kofi-modal' hide-event='hide'
36 | 						   click-off-closes='True' move-to-center='True' size-delta-x='95' size-delta-y='40'>
37 | 						<vertical vertical-fit='PreferredSize'>
38 | 							<text text='Notice' font-color='#FF3F3F' font-size='7' bold='True' align='Center'/>
39 | 							<text text='You are about to open a link in your browser.&#xA;Do you wish to continue?'
40 | 								  align='Center'/>
41 | 							<text text='Link  :  &lt;color=#55A1FF&gt;https://ko-fi.com/exo_manz/'
42 | 								  font-size='3' align='Center'/>
43 | 							<horizontal horizontal-fit='PreferredSize' spacing='4' pad-top='2'>
44 | 								<button text='No' click-event='hide' face-color='#FF3737'/>
45 | 								<button text='Yes' click-event='hide' on-click='open-kofi' face-color='#37FF37'/>
46 | 							</horizontal>
47 | 						</vertical>
48 | 					</modal>
49 | 					
50 | 					<button text='Changelog' face-color='#33ff44' click-event='show-changelog-modal' pref-width='20'/>
51 | 					<modal show-event='show-changelog-modal' hide-event='hide'
52 | 						   click-off-closes='True' move-to-center='True' size-delta-x='95' size-delta-y='40'>
53 | 						<vertical vertical-fit='PreferredSize'>
54 | 							<text text='Notice' font-color='#FF3F3F' font-size='7' bold='True' align='Center'/>
55 | 							<text text='You are about to open a link in your browser.&#xA;Do you wish to continue?'
56 | 								  align='Center'/>
57 | 							<text text='Link  :  &lt;color=#55A1FF&gt;https://github.com/Exomanz/UITweaks/commits'
58 | 								  font-size='3' align='Center'/>
59 | 							<horizontal horizontal-fit='PreferredSize' spacing='4' pad-top='2'>
60 | 								<button text='No' click-event='hide' face-color='#FF3737'/>
61 | 								<button text='Yes' click-event='hide' on-click='open-changelog' face-color='#37FF37'/>
62 | 							</horizontal>
63 | 						</vertical>
64 | 					</modal>
65 | 				</vertical>
66 | 			</horizontal>
67 | 			<text text='----------' align='Center' italics='True'/>
68 | 			<text text='This mod aims to bring you more customization to the in-game HUD!&#xA;
69 | Featuring an extensive configuration system which allows you to tweak nearly every single thing to your liking,
70 | you can make it exactly what you want it to be.' align='Center' italics='True' word-wrapping='True'/>
71 | 		</vertical>
72 | 	</vertical>
73 | </bg>


--------------------------------------------------------------------------------
/UITweaks/Decorators/EnergyBarPanelDecorator.cs:
--------------------------------------------------------------------------------
  1 | using HMUI;
  2 | using System.Collections;
  3 | using System.Collections.Generic;
  4 | using UITweaks.Config;
  5 | using UITweaks.Models;
  6 | using UnityEngine;
  7 | using UnityEngine.UI;
  8 | using Zenject;
  9 | 
 10 | namespace UITweaks.PanelModifiers
 11 | {
 12 |     public class EnergyBarPanelDecorator : PanelDecoratorBase
 13 |     {
 14 |         [InjectOptional] internal readonly MultiplayerController mpController;
 15 |         [Inject] private readonly IGameEnergyCounter gameEnergyCounter;
 16 |         [Inject] private readonly GameplayModifiers gameplayModifiers;
 17 |         [Inject] private readonly EnergyConfig energyConfig;
 18 | 
 19 |         private GameEnergyUIPanel gameEnergyUIPanel;
 20 |         private ImageView energyBar;
 21 | 
 22 |         [Inject]
 23 |         protected override void Init()
 24 |         {
 25 |             gameEnergyUIPanel = base.gameHUDController.GetComponentInChildren<GameEnergyUIPanel>();
 26 |             ParentPanel = gameEnergyUIPanel?.gameObject;
 27 |             Config = energyConfig;
 28 |             transform.SetParent(ParentPanel?.transform);
 29 | 
 30 |             ModPanel(this);
 31 |         }
 32 | 
 33 |         protected override bool ModPanel(in PanelDecoratorBase decorator)
 34 |         {
 35 |             if (!base.ModPanel(this)) return false;
 36 | 
 37 |             PrepareColorsForEnergyType(gameplayModifiers.energyType);
 38 | 
 39 |             return true;
 40 |         }
 41 | 
 42 |         private void PrepareColorsForEnergyType(GameplayModifiers.EnergyType type)
 43 |         {
 44 |             if (!CanBeUsedSafely) return;
 45 | 
 46 |             if (type == GameplayModifiers.EnergyType.Bar && !gameplayModifiers.instaFail)
 47 |             {
 48 |                 energyBar = gameEnergyUIPanel.transform.Find("EnergyBarWrapper/EnergyBar").GetComponent<ImageView>();
 49 |                 energyBar.color = energyConfig.Mid;
 50 |                 gameEnergyCounter.gameEnergyDidChangeEvent += HandleEnergyDidChange;
 51 | 
 52 |                 return;
 53 |             }
 54 | 
 55 |             if (mpController?.gameObject == null)
 56 |                 base.StartCoroutine(BatteryEnergyAndOneLifeSetup(type));
 57 |         }
 58 | 
 59 |         internal IEnumerator BatteryEnergyAndOneLifeSetup(GameplayModifiers.EnergyType energyType)
 60 |         {
 61 |             yield return new WaitUntil(() => gameEnergyUIPanel.isActiveAndEnabled);
 62 | 
 63 |             if (energyType == GameplayModifiers.EnergyType.Battery)
 64 |             {
 65 |                 List<Image> batterySegments = gameEnergyUIPanel._batteryLifeSegments;
 66 | 
 67 |                 batterySegments[0].color = energyConfig.Low;
 68 |                 batterySegments[1].color = HSBColor.Lerp(HSBColor.FromColor(energyConfig.Low), HSBColor.FromColor(energyConfig.Mid), 0.5f).ToColor();
 69 |                 batterySegments[2].color = HSBColor.Lerp(HSBColor.FromColor(energyConfig.Mid), HSBColor.FromColor(energyConfig.High), 0.5f).ToColor();
 70 |                 batterySegments[3].color = energyConfig.High;
 71 | 
 72 |                 yield break;
 73 |             }
 74 | 
 75 |             else if (energyType == GameplayModifiers.EnergyType.Bar && gameplayModifiers.instaFail)
 76 |             {
 77 |                 energyBar = gameEnergyUIPanel.transform.Find("BatteryLifeSegment(Clone)").GetComponent<ImageView>();
 78 |                 energyBar.color = energyConfig.High;
 79 |             }
 80 | 
 81 |             else yield break;
 82 |         }
 83 | 
 84 |         private void HandleEnergyDidChange(float energy)
 85 |         {
 86 |             if (energy == 0.5f) energyBar.color = energyConfig.Mid;
 87 | 
 88 |             else if (energy > 0.5f)
 89 |                 energyBar.color = HSBColor.Lerp(
 90 |                     HSBColor.FromColor(energyConfig.Mid),
 91 |                     HSBColor.FromColor(energyConfig.High),
 92 |                     (energy - 0.5f) * 2).ToColor();
 93 | 
 94 |             else if (energy < 0.5f)
 95 |                 energyBar.color = HSBColor.Lerp(
 96 |                     HSBColor.FromColor(energyConfig.Low),
 97 |                     HSBColor.FromColor(energyConfig.Mid),
 98 |                     energy * 2).ToColor();
 99 |         }
100 | 
101 |         public void Update()
102 |         {
103 |             if (!CanBeUsedSafely || !gameEnergyUIPanel.isActiveAndEnabled || energyBar?.gameObject == null) return;
104 | 
105 |             if (energyConfig.RainbowOnFullEnergy)
106 |             {
107 |                 if (gameplayModifiers.instaFail || (gameEnergyCounter.energy == 1 && gameplayModifiers.energyType == GameplayModifiers.EnergyType.Bar))
108 |                     energyBar.color = base.RainbowColor;
109 |             }
110 |         }
111 | 
112 |         protected override void OnDestroy()
113 |         {
114 |             base.OnDestroy();
115 |             gameEnergyCounter.gameEnergyDidChangeEvent -= HandleEnergyDidChange;
116 |         }
117 |     }
118 | }
119 | 


--------------------------------------------------------------------------------
/UITweaks/UI/SettingsPanelObjectGrabber.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using UITweaks.Models;
 5 | using UnityEngine;
 6 | using UnityEngine.AddressableAssets;
 7 | using UnityEngine.ResourceManagement.AsyncOperations;
 8 | using UnityEngine.ResourceManagement.ResourceProviders;
 9 | using UnityEngine.SceneManagement;
10 | 
11 | namespace UITweaks.UI
12 | {
13 |     internal class SettingsPanelObjectGrabber : MonoBehaviour
14 |     {
15 |         public bool IsCompleted { get; private set; } = false;
16 |         public List<PreviewPanel> PreviewPanels { get; private set; } = new List<PreviewPanel>();
17 | 
18 |         private readonly WaitForEndOfFrame DELAY = new WaitForEndOfFrame();
19 |         private PreviewPanel multiplierPanel;
20 |         private PreviewPanel energyPanel;
21 |         private PreviewPanel comboPanel;
22 |         private PreviewPanel progressPanel;
23 |         private PreviewPanel positionPanel;
24 |         private PreviewPanel immediateRankPanel;
25 | 
26 |         public IEnumerator GetPanels()
27 |         {
28 |             AsyncOperationHandle<SceneInstance> defaultSceneInstanceLoader = Addressables.LoadSceneAsync("DefaultEnvironment", LoadSceneMode.Additive);
29 | 
30 |             while (!defaultSceneInstanceLoader.IsDone)
31 |                 yield return DELAY;
32 | 
33 |             CoreGameHUDController gameHudController = Resources.FindObjectsOfTypeAll<CoreGameHUDController>().FirstOrDefault();
34 |             GameObject currentPanel;
35 | 
36 |             ScoreMultiplierUIController scoreMultiplierUIController = gameHudController.transform.Find("RightPanel/MultiplierCanvas").GetComponent<ScoreMultiplierUIController>();
37 |             currentPanel = FinalizePanel(scoreMultiplierUIController);
38 |             multiplierPanel = new PreviewPanel(0, currentPanel);
39 |             PreviewPanels.Add(multiplierPanel);
40 | 
41 |             GameEnergyUIPanel gameEnergyUIPanel = gameHudController.transform.Find("EnergyPanel").GetComponent<GameEnergyUIPanel>();
42 |             currentPanel = FinalizePanel(gameEnergyUIPanel);
43 |             energyPanel = new PreviewPanel(1, currentPanel);
44 |             PreviewPanels.Add(energyPanel);
45 | 
46 |             ComboUIController comboController = gameHudController.transform.Find("LeftPanel/ComboPanel").GetComponent<ComboUIController>();
47 |             currentPanel = FinalizePanel(comboController);
48 |             comboPanel = new PreviewPanel(2, currentPanel);
49 |             PreviewPanels.Add(comboPanel);
50 | 
51 |             SongProgressUIController progressController = gameHudController.transform.Find("RightPanel/SongProgressCanvas").GetComponent<SongProgressUIController>();
52 |             currentPanel = FinalizePanel(progressController);
53 |             progressPanel = new PreviewPanel(3, currentPanel);
54 |             PreviewPanels.Add(progressPanel);
55 | 
56 |             MockMultiplayerPositionPanel mockMultiplayerPositionPanel = new GameObject("UIT_Preview-MockMultipliayerPositionPanel").AddComponent<MockMultiplayerPositionPanel>();
57 |             while (!mockMultiplayerPositionPanel.IsSetup)
58 |                 yield return DELAY;
59 |             mockMultiplayerPositionPanel.transform.SetParent(transform, false);
60 |             mockMultiplayerPositionPanel.transform.localPosition = Vector3.zero;
61 |             mockMultiplayerPositionPanel.transform.localRotation = Quaternion.identity;
62 |             currentPanel = mockMultiplayerPositionPanel.gameObject;
63 |             positionPanel = new PreviewPanel(4, currentPanel);
64 |             PreviewPanels.Add(positionPanel);
65 | 
66 |             ImmediateRankUIPanel rankController = gameHudController.transform.Find("LeftPanel/ScoreCanvas").GetComponent<ImmediateRankUIPanel>();
67 |             Destroy(rankController.transform.Find("ScoreText").GetComponent<ScoreUIController>()); // Fixes score randomization in menu not working on first open
68 |             currentPanel = FinalizePanel(rankController);
69 |             immediateRankPanel = new PreviewPanel(5, currentPanel);
70 |             PreviewPanels.Add(immediateRankPanel);
71 | 
72 |             SceneManager.UnloadSceneAsync("DefaultEnvironment");
73 | 
74 |             IsCompleted = true;
75 | 
76 |             yield break;
77 |         }
78 | 
79 |         private GameObject FinalizePanel(MonoBehaviour controller)
80 |         {
81 |             try
82 |             {
83 |                 GameObject go = Instantiate(controller.gameObject);
84 |                 Destroy(go.GetComponent(controller.GetType()));
85 |                 go.transform.SetParent(transform);
86 |                 go.transform.localPosition = Vector3.zero;
87 |                 go.transform.localRotation = Quaternion.identity;
88 |                 go.name = "UIT_Preview-" + controller.GetType().Name;
89 |                 return go;
90 |             }
91 |             catch (System.Exception ex)
92 |             {
93 |                 System.Console.WriteLine(ex);
94 |                 return null;
95 |             }
96 |         }
97 |     }
98 | }
99 | 


--------------------------------------------------------------------------------
/UITweaks/Decorators/ScoreMultiplierPanelDecorator.cs:
--------------------------------------------------------------------------------
  1 | using UITweaks.Config;
  2 | using UITweaks.Models;
  3 | using UnityEngine.UI;
  4 | using Zenject;
  5 | 
  6 | namespace UITweaks.PanelModifiers
  7 | {
  8 |     public class ScoreMultiplierPanelDecorator : PanelDecoratorBase
  9 |     {
 10 |         [Inject] private readonly MultiplierConfig multiplierConfig;
 11 |         [Inject] private readonly IScoreController scoreController;
 12 | 
 13 |         private ScoreMultiplierUIController scoreMultiplierUIController;
 14 |         private Image bg;
 15 |         private Image fg;
 16 |         private int currentMultiplier = 0;
 17 | 
 18 |         [Inject]
 19 |         protected override void Init()
 20 |         {
 21 |             scoreMultiplierUIController = base.gameHUDController.GetComponentInChildren<ScoreMultiplierUIController>();
 22 |             ParentPanel = scoreMultiplierUIController?.gameObject;
 23 |             Config = multiplierConfig;
 24 | 
 25 |             transform.SetParent(ParentPanel?.transform);
 26 | 
 27 |             ModPanel(this);
 28 |         }
 29 | 
 30 |         protected override bool ModPanel(in PanelDecoratorBase decorator)
 31 |         {
 32 |             if (!base.ModPanel(this)) return false;
 33 | 
 34 |             scoreController.multiplierDidChangeEvent += HandleMultiplierDidChange;
 35 | 
 36 |             bg = ParentPanel.transform.Find("BGCircle").GetComponent<Image>();
 37 |             fg = ParentPanel.transform.Find("FGCircle").GetComponent<Image>();
 38 |             HandleMultiplierDidChange(1, 0);
 39 | 
 40 |             return true;
 41 |         }
 42 | 
 43 |         private void HandleMultiplierDidChange(int multiplier, float progress)
 44 |         {
 45 |             currentMultiplier = multiplier;
 46 | 
 47 |             if (multiplier == 1)
 48 |             {
 49 |                 bg.color = multiplierConfig.One.ColorWithAlpha(0.25f);
 50 |                 fg.color = multiplierConfig.One;
 51 |             }
 52 |             else if (multiplier == 2)
 53 |             {
 54 |                 bg.color = multiplierConfig.Two.ColorWithAlpha(0.25f);
 55 |                 fg.color = multiplierConfig.Two;
 56 |             }
 57 |             else if (multiplier == 4)
 58 |             {
 59 |                 bg.color = multiplierConfig.Four.ColorWithAlpha(0.25f);
 60 |                 fg.color = multiplierConfig.Four;
 61 |             }
 62 |             else if (multiplier == 8 && !multiplierConfig.RainbowOnMaxMultiplier)
 63 |                 fg.color = multiplierConfig.Eight.ColorWithAlpha(0.25f);
 64 |         }
 65 | 
 66 |         public void Update()
 67 |         {
 68 |             if (!CanBeUsedSafely || !scoreMultiplierUIController.isActiveAndEnabled) return;
 69 | 
 70 |             if (multiplierConfig.SmoothTransition)
 71 |             {
 72 |                 if (currentMultiplier == 1)
 73 |                 {
 74 |                     bg.color = HSBColor.Lerp(
 75 |                         HSBColor.FromColor(multiplierConfig.One),
 76 |                         HSBColor.FromColor(multiplierConfig.Two),
 77 |                         fg.fillAmount)
 78 |                         .ToColor().ColorWithAlpha(0.25f);
 79 | 
 80 |                     fg.color = HSBColor.Lerp(
 81 |                         HSBColor.FromColor(multiplierConfig.One),
 82 |                         HSBColor.FromColor(multiplierConfig.Two),
 83 |                         fg.fillAmount)
 84 |                         .ToColor();
 85 |                 }
 86 |                 else if (currentMultiplier == 2)
 87 |                 {
 88 |                     bg.color = HSBColor.Lerp(
 89 |                         HSBColor.FromColor(multiplierConfig.Two),
 90 |                         HSBColor.FromColor(multiplierConfig.Four),
 91 |                         fg.fillAmount)
 92 |                         .ToColor().ColorWithAlpha(0.25f);
 93 | 
 94 |                     fg.color = HSBColor.Lerp(
 95 |                         HSBColor.FromColor(multiplierConfig.Two),
 96 |                         HSBColor.FromColor(multiplierConfig.Four),
 97 |                         fg.fillAmount)
 98 |                         .ToColor();
 99 |                 }
100 |                 else if (currentMultiplier == 4)
101 |                 {
102 |                     bg.color = HSBColor.Lerp(
103 |                         HSBColor.FromColor(multiplierConfig.Four),
104 |                         HSBColor.FromColor(multiplierConfig.Eight),
105 |                         fg.fillAmount)
106 |                         .ToColor().ColorWithAlpha(0.25f);
107 | 
108 |                     fg.color = HSBColor.Lerp(
109 |                         HSBColor.FromColor(multiplierConfig.Four),
110 |                         HSBColor.FromColor(multiplierConfig.Eight),
111 |                         fg.fillAmount)
112 |                         .ToColor();
113 |                 }
114 |             }
115 | 
116 |             if (currentMultiplier == 8 && multiplierConfig.RainbowOnMaxMultiplier)
117 |             {
118 |                 bg.color = base.RainbowColor;
119 |             }
120 |         }
121 | 
122 |         protected override void OnDestroy()
123 |         {
124 |             base.OnDestroy();
125 |             scoreController.multiplierDidChangeEvent -= HandleMultiplierDidChange;
126 |         }
127 |     }
128 | }
129 | 


--------------------------------------------------------------------------------
/UITweaks/Decorators/ExtraPanelDecorator.cs:
--------------------------------------------------------------------------------
  1 | using HMUI;
  2 | using IPA.Loader;
  3 | using TMPro;
  4 | using UITweaks.Config;
  5 | using UITweaks.Models;
  6 | using UnityEngine;
  7 | using Zenject;
  8 | 
  9 | namespace UITweaks.PanelModifiers
 10 | {
 11 |     public class ExtraPanelDecorator : PanelDecoratorBase
 12 |     {
 13 |         internal class AprilFools : MonoBehaviour
 14 |         {
 15 |             [InjectOptional] private readonly StandardGameplaySceneSetupData data;
 16 |             [Inject] private readonly CoreGameHUDController gameHUDController;
 17 | 
 18 |             public void Start()
 19 |             {
 20 |                 if (data?.beatmapKey.beatmapCharacteristic.containsRotationEvents == true)
 21 |                 {
 22 |                     var container = gameHUDController.transform.Find("Container");
 23 |                     container.transform.Rotate(0, 0, 180);
 24 |                     return;
 25 |                 }
 26 | 
 27 |                 var leftPanel = gameHUDController.transform.Find("LeftPanel");
 28 |                 leftPanel.position = new Vector3(3.2f, 2.2f, 7);
 29 |                 leftPanel.Rotate(0, 0, 180);
 30 | 
 31 |                 var rightPanel = gameHUDController.transform.Find("RightPanel");
 32 |                 rightPanel.position = new Vector3(-3.2f, 2.2f, 7);
 33 |                 rightPanel.Rotate(0, 0, 180);
 34 | 
 35 |                 var energyPanel = gameHUDController.transform.Find("EnergyPanel/EnergyBarWrapper");
 36 |                 energyPanel.Rotate(0, 0, 180);
 37 |             }
 38 |         }
 39 | 
 40 |         [Inject] private readonly MiscConfig miscConfig;
 41 |         [Inject] private readonly IScoreController scoreController;
 42 |         [Inject] private readonly RelativeScoreAndImmediateRankCounter rankCounter;
 43 | 
 44 |         private ComboUIController comboUIController;
 45 |         private ImmediateRankUIPanel immediateRankUIPanel;
 46 |         private TextMeshProUGUI rankText;
 47 | 
 48 |         [Inject]
 49 |         protected override void Init()
 50 |         {
 51 |             comboUIController = base.gameHUDController.GetComponentInChildren<ComboUIController>();
 52 |             immediateRankUIPanel = base.gameHUDController.GetComponentInChildren<ImmediateRankUIPanel>();
 53 |             ParentPanel = immediateRankUIPanel?.gameObject;
 54 |             Config = miscConfig;
 55 |             transform.SetParent(ParentPanel?.transform);
 56 | 
 57 |             ModPanel(this);
 58 |         }
 59 | 
 60 |         protected override bool ModPanel(in PanelDecoratorBase decorator)
 61 |         {
 62 |             if (!base.ModPanel(this)) return false;
 63 | 
 64 |             if (PluginManager.GetPlugin("Counters+") != null)
 65 |                 CanBeUsedSafely = false;
 66 | 
 67 |             rankText = immediateRankUIPanel._rankText;
 68 |             if (miscConfig.AllowRankColoring)
 69 |             {
 70 |                 rankCounter.relativeScoreOrImmediateRankDidChangeEvent += UpdateRankColorsOnScoreChanged;
 71 |                 UpdateRankColorsOnScoreChanged();
 72 |             }
 73 | 
 74 |             if (miscConfig.ItalicizeComboPanel)
 75 |             {
 76 |                 if (comboUIController?.gameObject == null)
 77 |                     logger.Warn("Setting 'ItalicizeComboPanel' is true, but the Combo Panel isn't here! Skipping...");
 78 | 
 79 |                 else
 80 |                 {
 81 |                     var comboText = comboUIController.transform.Find("ComboText").GetComponent<CurvedTextMeshPro>();
 82 |                     comboText.fontStyle = FontStyles.Italic | FontStyles.UpperCase;
 83 | 
 84 |                     var num = comboUIController._comboText;
 85 |                     num.fontStyle = FontStyles.Italic;
 86 |                     num.transform.localPosition = new Vector3(-2.5f, 4);
 87 |                 }
 88 |             }
 89 | 
 90 |             if (miscConfig.ItalicizeScore)
 91 |             {
 92 |                 var scoreText = immediateRankUIPanel.transform.Find("ScoreText").GetComponent<CurvedTextMeshPro>();
 93 |                 scoreText.fontStyle = FontStyles.Italic;
 94 |                 scoreText.transform.localPosition = new Vector3(-1, 20);
 95 |             }
 96 | 
 97 |             if (miscConfig.ItalicizeImmediateRank)
 98 |             {
 99 |                 rankText.fontStyle = FontStyles.Italic;
100 |                 rankText.transform.localPosition = new Vector3(-3, -0.5f);
101 | 
102 |                 immediateRankUIPanel._relativeScoreText.fontStyle = FontStyles.Italic;
103 |             }
104 | 
105 |             return true;
106 |         }
107 | 
108 |         public void Update()
109 |         {
110 |             if (!CanBeUsedSafely || !immediateRankUIPanel.isActiveAndEnabled || !miscConfig.AllowRankColoring) return;
111 | 
112 |             if (miscConfig.RainbowOnSSRank && rankCounter.immediateRank == RankModel.Rank.SS)
113 |             {
114 |                 rankText.color = base.RainbowColor;
115 |             }
116 |         }
117 | 
118 |         private void UpdateRankColorsOnScoreChanged()
119 |         {
120 |             rankText.color = rankCounter.immediateRank switch
121 |             {
122 |                 RankModel.Rank.SSS or RankModel.Rank.SS => miscConfig.RankSSColor,
123 |                 RankModel.Rank.S => miscConfig.RankSColor,
124 |                 RankModel.Rank.A => miscConfig.RankAColor,
125 |                 RankModel.Rank.B => miscConfig.RankBColor,
126 |                 RankModel.Rank.C => miscConfig.RankCColor,
127 |                 RankModel.Rank.D => miscConfig.RankDColor,
128 |                 RankModel.Rank.E => miscConfig.RankEColor,
129 |                 _ => Color.white.ColorWithAlpha(0.5f),
130 |             };
131 |         }
132 | 
133 |         protected override void OnDestroy()
134 |         {
135 |             base.OnDestroy();
136 |             rankCounter.relativeScoreOrImmediateRankDidChangeEvent -= UpdateRankColorsOnScoreChanged;
137 |         }
138 |     }
139 | }
140 | 


--------------------------------------------------------------------------------
/UITweaks/Utilities/HSBColor.cs:
--------------------------------------------------------------------------------
  1 | using UnityEngine;
  2 | 
  3 | [System.Serializable]
  4 | public struct HSBColor
  5 | {
  6 |     public float h;
  7 |     public float s;
  8 |     public float b;
  9 |     public float a;
 10 | 
 11 |     public HSBColor(float h, float s, float b, float a)
 12 |     {
 13 |         this.h = h;
 14 |         this.s = s;
 15 |         this.b = b;
 16 |         this.a = a;
 17 |     }
 18 | 
 19 |     public HSBColor(float h, float s, float b)
 20 |     {
 21 |         this.h = h;
 22 |         this.s = s;
 23 |         this.b = b;
 24 |         this.a = 1f;
 25 |     }
 26 | 
 27 |     public HSBColor(Color col)
 28 |     {
 29 |         HSBColor temp = FromColor(col);
 30 |         h = temp.h;
 31 |         s = temp.s;
 32 |         b = temp.b;
 33 |         a = temp.a;
 34 |     }
 35 | 
 36 |     public static HSBColor FromColor(Color color)
 37 |     {
 38 |         HSBColor ret = new HSBColor(0f, 0f, 0f, color.a);
 39 | 
 40 |         float r = color.r;
 41 |         float g = color.g;
 42 |         float b = color.b;
 43 | 
 44 |         float max = Mathf.Max(r, Mathf.Max(g, b));
 45 | 
 46 |         if (max <= 0)
 47 |         {
 48 |             return ret;
 49 |         }
 50 | 
 51 |         float min = Mathf.Min(r, Mathf.Min(g, b));
 52 |         float dif = max - min;
 53 | 
 54 |         if (max > min)
 55 |         {
 56 |             if (g == max)
 57 |             {
 58 |                 ret.h = (b - r) / dif * 60f + 120f;
 59 |             }
 60 |             else if (b == max)
 61 |             {
 62 |                 ret.h = (r - g) / dif * 60f + 240f;
 63 |             }
 64 |             else if (b > g)
 65 |             {
 66 |                 ret.h = (g - b) / dif * 60f + 360f;
 67 |             }
 68 |             else
 69 |             {
 70 |                 ret.h = (g - b) / dif * 60f;
 71 |             }
 72 |             if (ret.h < 0)
 73 |             {
 74 |                 ret.h = ret.h + 360f;
 75 |             }
 76 |         }
 77 |         else
 78 |         {
 79 |             ret.h = 0;
 80 |         }
 81 | 
 82 |         ret.h *= 1f / 360f;
 83 |         ret.s = (dif / max) * 1f;
 84 |         ret.b = max;
 85 | 
 86 |         return ret;
 87 |     }
 88 | 
 89 |     public static Color ToColor(HSBColor hsbColor)
 90 |     {
 91 |         float r = hsbColor.b;
 92 |         float g = hsbColor.b;
 93 |         float b = hsbColor.b;
 94 |         if (hsbColor.s != 0)
 95 |         {
 96 |             float max = hsbColor.b;
 97 |             float dif = hsbColor.b * hsbColor.s;
 98 |             float min = hsbColor.b - dif;
 99 | 
100 |             float h = hsbColor.h * 360f;
101 | 
102 |             if (h < 60f)
103 |             {
104 |                 r = max;
105 |                 g = h * dif / 60f + min;
106 |                 b = min;
107 |             }
108 |             else if (h < 120f)
109 |             {
110 |                 r = -(h - 120f) * dif / 60f + min;
111 |                 g = max;
112 |                 b = min;
113 |             }
114 |             else if (h < 180f)
115 |             {
116 |                 r = min;
117 |                 g = max;
118 |                 b = (h - 120f) * dif / 60f + min;
119 |             }
120 |             else if (h < 240f)
121 |             {
122 |                 r = min;
123 |                 g = -(h - 240f) * dif / 60f + min;
124 |                 b = max;
125 |             }
126 |             else if (h < 300f)
127 |             {
128 |                 r = (h - 240f) * dif / 60f + min;
129 |                 g = min;
130 |                 b = max;
131 |             }
132 |             else if (h <= 360f)
133 |             {
134 |                 r = max;
135 |                 g = min;
136 |                 b = -(h - 360f) * dif / 60 + min;
137 |             }
138 |             else
139 |             {
140 |                 r = 0;
141 |                 g = 0;
142 |                 b = 0;
143 |             }
144 |         }
145 | 
146 |         return new Color(Mathf.Clamp01(r), Mathf.Clamp01(g), Mathf.Clamp01(b), hsbColor.a);
147 |     }
148 | 
149 |     public Color ToColor()
150 |     {
151 |         return ToColor(this);
152 |     }
153 | 
154 |     public override string ToString()
155 |     {
156 |         return "H:" + h + " S:" + s + " B:" + b;
157 |     }
158 | 
159 |     public static HSBColor Lerp(HSBColor a, HSBColor b, float t)
160 |     {
161 |         float h, s;
162 | 
163 |         //check special case black (color.b==0): interpolate neither hue nor saturation!
164 |         //check special case grey (color.s==0): don't interpolate hue!
165 |         if (a.b == 0)
166 |         {
167 |             h = b.h;
168 |             s = b.s;
169 |         }
170 |         else if (b.b == 0)
171 |         {
172 |             h = a.h;
173 |             s = a.s;
174 |         }
175 |         else
176 |         {
177 |             if (a.s == 0)
178 |             {
179 |                 h = b.h;
180 |             }
181 |             else if (b.s == 0)
182 |             {
183 |                 h = a.h;
184 |             }
185 |             else
186 |             {
187 |                 // works around bug with LerpAngle
188 |                 float angle = Mathf.LerpAngle(a.h * 360f, b.h * 360f, t);
189 |                 while (angle < 0f)
190 |                     angle += 360f;
191 |                 while (angle > 360f)
192 |                     angle -= 360f;
193 |                 h = angle / 360f;
194 |             }
195 |             s = Mathf.Lerp(a.s, b.s, t);
196 |         }
197 |         return new HSBColor(h, s, Mathf.Lerp(a.b, b.b, t), Mathf.Lerp(a.a, b.a, t));
198 |     }
199 | 
200 |     public static void Test()
201 |     {
202 |         HSBColor color;
203 | 
204 |         color = new HSBColor(Color.red);
205 |         Debug.Log("red: " + color);
206 | 
207 |         color = new HSBColor(Color.green);
208 |         Debug.Log("green: " + color);
209 | 
210 |         color = new HSBColor(Color.blue);
211 |         Debug.Log("blue: " + color);
212 | 
213 |         color = new HSBColor(Color.grey);
214 |         Debug.Log("grey: " + color);
215 | 
216 |         color = new HSBColor(Color.white);
217 |         Debug.Log("white: " + color);
218 | 
219 |         color = new HSBColor(new Color(0.4f, 1f, 0.84f, 1f));
220 |         Debug.Log("0.4, 1f, 0.84: " + color);
221 | 
222 |         Debug.Log("164,82,84   .... 0.643137f, 0.321568f, 0.329411f  :" + ToColor(new HSBColor(new Color(0.643137f, 0.321568f, 0.329411f))));
223 |     }
224 | }
225 | 


--------------------------------------------------------------------------------
/UITweaks/UITweaks.csproj:
--------------------------------------------------------------------------------
  1 | <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" Sdk="Microsoft.NET.Sdk">
  2 |   <PropertyGroup>
  3 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  4 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  5 |     <ProjectGuid>{4B5D5899-57C0-4FB5-891A-E83DD3071C69}</ProjectGuid>
  6 |     <OutputType>Library</OutputType>
  7 |     <LocalRefsDir Condition="Exists('..\Refs')">..\Refs</LocalRefsDir>
  8 |     <BeatSaberDir>$(LocalRefsDir)</BeatSaberDir>
  9 |     <AppOutputBase>$(MSBuildProjectDirectory)\</AppOutputBase>
 10 |     <LangVersion>9</LangVersion>
 11 |     <TargetFramework>net48</TargetFramework>
 12 |     <Configurations>Debug;Release;Heck-Debug</Configurations>
 13 |   </PropertyGroup>
 14 |   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
 15 |     <Optimize>false</Optimize>
 16 |     <OutputPath>bin\Debug\</OutputPath>
 17 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 18 |   </PropertyGroup>
 19 |   <PropertyGroup Condition=" '$(Configuration)' == 'Heck-Debug' ">
 20 |     <Optimize>false</Optimize>
 21 |     <OutputPath>bin\Debug\</OutputPath>
 22 |     <DefineConstants>DEBUG;TRACE;HECK</DefineConstants>
 23 |   </PropertyGroup>
 24 |   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
 25 |     <Optimize>true</Optimize>
 26 |     <OutputPath>bin\Release\</OutputPath>
 27 |     <ErrorReport>prompt</ErrorReport>
 28 |     <WarningLevel>4</WarningLevel>
 29 |     <DefineConstants>HECK</DefineConstants>
 30 |   </PropertyGroup>
 31 |   <PropertyGroup Condition="$(DefineConstants.Contains('CIBuild')) OR '$(NCrunch)' == '1'">
 32 |     <DisableCopyToPlugins>True</DisableCopyToPlugins>
 33 |   </PropertyGroup>
 34 |   <PropertyGroup Condition="'$(NCrunch)' == '1'">
 35 |     <DisableCopyToPlugins>True</DisableCopyToPlugins>
 36 |     <DisableZipRelease>True</DisableZipRelease>
 37 |   </PropertyGroup>
 38 |   <ItemGroup>
 39 |     <Reference Include="BeatSaber.ViewSystem">
 40 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\BeatSaber.ViewSystem.dll</HintPath>
 41 |       <Private>False</Private>
 42 |     </Reference>
 43 |     <Reference Include="BGLib.AppFlow">
 44 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\BGLib.AppFlow.dll</HintPath>
 45 |       <Private>False</Private>
 46 |     </Reference>
 47 |     <Reference Include="BGLib.UnityExtension">
 48 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\BGLib.UnityExtension.dll</HintPath>
 49 |       <Private>False</Private>
 50 |     </Reference>
 51 |     <Reference Include="BGNetCore">
 52 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\BGNetCore.dll</HintPath>
 53 |       <Private>False</Private>
 54 |     </Reference>
 55 |     <Reference Include="BSML">
 56 |       <HintPath>$(BeatSaberDir)\Plugins\BSML.dll</HintPath>
 57 |       <Private>False</Private>
 58 |     </Reference>
 59 |     <Reference Include="DataModels">
 60 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\DataModels.dll</HintPath>
 61 |       <Private>False</Private>
 62 |     </Reference>
 63 |     <Reference Include="GameplayCore">
 64 |       <Private>False</Private>
 65 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\GameplayCore.dll</HintPath>
 66 |     </Reference>
 67 |     <Reference Include="Hive.Verioning">
 68 |       <HintPath>$(BeatSaberDir)\IPA\Libs\Hive.Versioning.dll</HintPath>
 69 |       <Private>False</Private>
 70 |     </Reference>
 71 |     <Reference Include="Heck" Condition="Exists('$(BeatSaberDir)\Plugins\Heck.dll')">
 72 |       <HintPath>$(BeatSaberDir)\Plugins\Heck.dll</HintPath>
 73 |       <Private>False</Private>
 74 |     </Reference>
 75 |     <Reference Include="SegmentedControl">
 76 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\SegmentedControl.dll</HintPath>
 77 |       <Private>False</Private>
 78 |     </Reference>
 79 |     <Reference Include="SiraUtil">
 80 |       <HintPath>$(BeatSaberDir)\Plugins\SiraUtil.dll</HintPath>
 81 |       <Private>False</Private>
 82 |     </Reference>
 83 |     <Reference Include="System" />
 84 |     <Reference Include="System.Core" />
 85 |     <Reference Include="System.Xml.Linq" />
 86 |     <Reference Include="System.Data.DataSetExtensions" />
 87 |     <Reference Include="System.Data" />
 88 |     <Reference Include="System.Xml" />
 89 |     <Reference Include="Main">
 90 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Main.dll</HintPath>
 91 |       <Private>False</Private>
 92 |       <Publicize>True</Publicize>
 93 |     </Reference>
 94 |     <Reference Include="HMLib">
 95 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\HMLib.dll</HintPath>
 96 |       <Private>False</Private>
 97 |     </Reference>
 98 |     <Reference Include="HMUI">
 99 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\HMUI.dll</HintPath>
100 |       <Private>False</Private>
101 |     </Reference>
102 |     <Reference Include="IPA.Loader">
103 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\IPA.Loader.dll</HintPath>
104 |       <Private>False</Private>
105 |     </Reference>
106 |     <Reference Include="Tweening">
107 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Tweening.dll</HintPath>
108 |       <Private>False</Private>
109 |     </Reference>
110 |     <Reference Include="Unity.Addressables">
111 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Unity.Addressables.dll</HintPath>
112 |       <Private>False</Private>
113 |     </Reference>
114 |     <Reference Include="Unity.ResourceManager">
115 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Unity.ResourceManager.dll</HintPath>
116 |       <Private>False</Private>
117 |     </Reference>
118 |     <Reference Include="Unity.TextMeshPro">
119 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Unity.TextMeshPro.dll</HintPath>
120 |       <Private>False</Private>
121 |     </Reference>
122 |     <Reference Include="UnityEngine">
123 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.dll</HintPath>
124 |       <Private>False</Private>
125 |     </Reference>
126 |     <Reference Include="UnityEngine.AssetBundleModule">
127 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.AssetBundleModule.dll</HintPath>
128 |       <Private>False</Private>
129 |     </Reference>
130 |     <Reference Include="UnityEngine.CoreModule">
131 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.CoreModule.dll</HintPath>
132 |       <Private>False</Private>
133 |     </Reference>
134 |     <Reference Include="UnityEngine.UI">
135 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.UI.dll</HintPath>
136 |       <Private>False</Private>
137 |     </Reference>
138 |     <Reference Include="UnityEngine.UIElementsModule">
139 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.UIElementsModule.dll</HintPath>
140 |       <Private>False</Private>
141 |     </Reference>
142 |     <Reference Include="UnityEngine.UIModule">
143 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.UIModule.dll</HintPath>
144 |       <Private>False</Private>
145 |     </Reference>
146 |     <Reference Include="UnityEngine.VRModule">
147 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\UnityEngine.VRModule.dll</HintPath>
148 |       <Private>False</Private>
149 |     </Reference>
150 |     <Reference Include="Zenject">
151 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Zenject.dll</HintPath>
152 |       <Private>False</Private>
153 |     </Reference>
154 |     <Reference Include="Zenject-usage">
155 |       <HintPath>$(BeatSaberDir)\Beat Saber_Data\Managed\Zenject-usage.dll</HintPath>
156 |       <Private>False</Private>
157 |     </Reference>
158 |   </ItemGroup>
159 |   <ItemGroup>
160 | 	<EmbeddedResource Include="manifest.json" />
161 |     <EmbeddedResource Include="Views\ModSettings.bsml" />
162 |     <EmbeddedResource Include="Views\Info.bsml" />
163 |     <EmbeddedResource Include="Views\ObjectPreview.bsml" />
164 |   </ItemGroup>
165 |   <ItemGroup>
166 |     <None Include="Directory.Build.props" Condition="Exists('Directory.Build.props')" />
167 |     <None Include="UITweaks.csproj.user" Condition="Exists('UITweaks.csproj.user')" />
168 |   </ItemGroup>
169 |   <ItemGroup>
170 |     <PackageReference Include="BeatSaberModdingTools.Tasks">
171 |       <Version>2.0.0-beta7</Version>
172 |       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
173 |       <PrivateAssets>all</PrivateAssets>
174 |     </PackageReference>
175 |     <PackageReference Include="BepInEx.AssemblyPublicizer.MSBuild" Version="0.4.2">
176 |       <PrivateAssets>all</PrivateAssets>
177 |       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
178 |     </PackageReference>
179 |   </ItemGroup>
180 | </Project>


--------------------------------------------------------------------------------
/UITweaks/Views/ModSettings.bsml:
--------------------------------------------------------------------------------
  1 | <bg xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' 
  2 | 	xsi:schemaLocation='https://monkeymanboy.github.io/BSML-Docs/ 
  3 | 	https://raw.githubusercontent.com/monkeymanboy/BSML-Docs/gh-pages/BSMLSchema.xsd'>
  4 | 	<vertical child-control-height='False'>
  5 | 		<tab-selector select-cell='update-tab' tab-tag='_'/>
  6 | 
  7 | 		<!--Multiplier Tab-->
  8 | 		<tab tab-name='Multiplier Panel' tags='_'>
  9 | 			<modifier-container child-expand-width='true' horizontal-fit='PreferredSize'>
 10 | 				<checkbox text='Enabled' value='multiplier-enabled' apply-on-change='true'/>
 11 | 				<checkbox text='Smooth Transition' value='smooth-transition' apply-on-change='true' interactable='~multiplier-enabled'
 12 | 						  hover-hint='Allows the &lt;color=#FF3333&gt;Multiplier Ring&lt;/color&gt; to
 13 | smoothly transition between each of the colors below as your multiplier increases.
 14 | &#xA;&lt;color=#FF3333&gt;This change will not apply until the next preview cycle.&lt;/color&gt;'/>
 15 | 				<checkbox text='Rainbow On Max Multiplier' value='rainbow-on-8x' apply-on-change='true' interactable='~multiplier-enabled'/>
 16 | 				<color-setting text='1x Color' value='color-1x' apply-on-change='true' interactable='~multiplier-enabled'/>
 17 | 				<color-setting text='2x Color' value='color-2x' apply-on-change='true' interactable='~multiplier-enabled'/>
 18 | 				<color-setting text='4x Color' value='color-4x' apply-on-change='true' interactable='~multiplier-enabled'/>
 19 | 				<color-setting text='8x Color' value='color-8x' apply-on-change='true' interactable='~multiplier-enabled' active='~invert-rainbow-8x'/>
 20 | 			</modifier-container>
 21 | 		</tab>
 22 | 
 23 | 		<!--Energy Tab-->
 24 | 		<tab tab-name='Energy Bar' tags='_'>
 25 | 			<modifier-container child-expand-width='true' horizontal-fit='PreferredSize'>
 26 | 				<checkbox text='Enabled' value='energy-enabled' apply-on-change='true'/>
 27 | 				<checkbox text='Rainbow On Full Energy' value='rainbow-on-full' apply-on-change='true' interactable='~energy-enabled'/>
 28 | 				<color-setting text='Low Energy Color' value='color-low' apply-on-change='true' interactable='~energy-enabled'/>
 29 | 				<color-setting text='Middle Energy Color' value='color-mid' apply-on-change='true' interactable='~energy-enabled'/>
 30 | 				<color-setting text='High Energy Color' value='color-high' apply-on-change='true' interactable='~energy-enabled'/>
 31 | 				<slider-setting text='Preview Fill Amount' on-change='update-energy-preview' min='0.01' max='1' increment='0.01' interactable='~energy-enabled'/>
 32 | 			</modifier-container>
 33 | 		</tab>
 34 | 
 35 | 		<!--Combo Tab-->
 36 | 		<tab tab-name='Combo Panel' tags='_'>
 37 | 			<modifier-container child-expand-width='true' horizontal-fit='PreferredSize'>
 38 | 				<checkbox text='Enabled' value='combo-enabled' apply-on-change='true'/>
 39 | 				<checkbox text='Use Gradient' value='gradient-enabled' apply-on-change='true' interactable='~combo-enabled'/>
 40 | 				<color-setting text='Top Line Color' value='color-top-line' apply-on-change='true' interactable='~combo-enabled' active='~invert-gradient'/>
 41 | 				<color-setting text='Bottom Line Color' value='color-bottom-line' apply-on-change='true' interactable='~combo-enabled' active='~invert-gradient'/>
 42 | 				<button text='Gradient Settings' click-event='open-gradient-settings' interactable='~complex' active='~gradient-enabled'/>
 43 | 
 44 | 				<modal show-event='open-gradient-settings' hide-event='hide-all-modals'
 45 | 						   move-to-center='True' click-off-closes='True' size-delta-x='130' size-delta-y='52'>
 46 | 					<vertical pref-height='50' vertical-fit='PreferredSize'>
 47 | 						<horizontal spacing='5'>
 48 | 							<vertical pad='2' pref-width='60' pref-height='20' child-control-height='False'>
 49 | 								<horizontal bg='panel-top' pad-left='5' pad-right='5' pad-top='1'>
 50 | 									<text text='Top Line' font-size='6' align='Center' italics='True'/>
 51 | 								</horizontal>
 52 | 								<color-setting text='Left Color' value='color-top-line-left' apply-on-change='True'/>
 53 | 								<color-setting text='Right Color' value='color-top-line-right' apply-on-change='True'/>
 54 | 							</vertical>
 55 | 							<vertical pad='2' pref-width='60' pref-height='20' child-control-height='False'>
 56 | 								<horizontal bg='panel-top' pad-left='5' pad-right='5' pad-top='1'>
 57 | 									<text text='Bottom Line' font-size='6' align='Center' italics='True'/>
 58 | 								</horizontal>
 59 | 								<checkbox text='Reflect Top Line' value='mirror-bottom-line' apply-on-change='True'/>
 60 | 								<color-setting text='Left Color' value='color-bottom-line-left' apply-on-change='True' active='~invert-mbl'/>
 61 | 								<color-setting text='Right Color' value='color-bottom-line-right' apply-on-change='True' active='~invert-mbl'/>
 62 | 							</vertical>
 63 | 						</horizontal>
 64 | 						<button text='Close' click-event='hide-all-modals'/>
 65 | 					</vertical>
 66 | 				</modal>
 67 | 			</modifier-container>
 68 | 		</tab>
 69 | 
 70 | 		<!--Progress Tab-->
 71 | 		<tab tab-name='Progress Bar' tags='_'>
 72 | 			<modifier-container child-expand-width='true' horizontal-fit='PreferredSize'>
 73 | 				<checkbox text='Enabled' value='progress-enabled' apply-on-change='true'/>
 74 | 				<list-setting text='Display Type' value='render-mode' choices='progress-bar-render-modes' apply-on-change='true' interactable='~progress-enabled'
 75 | 							  hover-hint='&lt;color=#FF3333&gt;Fixed&lt;/color&gt;: All components will be the same color for the entire song.
 76 | &#xA;&lt;color=#33CC33&gt;Fade&lt;/color&gt;: The BG will fade between two colors as the song progresses.'/>
 77 | 				<color-setting text='Handle Color' value='color-handle' apply-on-change='true' interactable='~progress-enabled'/>
 78 | 				<color-setting text='Fill Color' value='color-fill' apply-on-change='true' interactable='~progress-enabled' active='~displaytype-is-fixed'/>
 79 | 				<color-setting text='BG Color' value='color-bg' apply-on-change='true' interactable='~progress-enabled' active='~displaytype-is-fixed'/>
 80 | 				<color-setting text='BG Start Color' value='color-song-start' apply-on-change='true' interactable='~progress-enabled' active='~displaytype-is-fade'/>
 81 | 				<color-setting text='BG End Color' value='color-song-end' apply-on-change='true' interactable='~progress-enabled' active='~displaytype-is-fade'/>
 82 | 				<slider-setting text='Preview Song Progress' on-change='update-progress-preview' min='0.01' max='1' increment='0.01' interactable='~progress-enabled' active='~displaytype-is-fade'/>
 83 | 			</modifier-container>
 84 | 		</tab>
 85 | 		
 86 | 		<!--Position Tab-->
 87 | 		<tab tab-name='Position (MP)' tags='_'>
 88 | 			<modifier-container child-expand-width='true' horizontal-fit='PreferredSize'>
 89 | 				<checkbox text='Enabled' value='position-enabled' apply-on-change='true'/>
 90 | 				<checkbox text='Hide 1st Place Animation' value='hide-first-place-anim' apply-on-change='true' interactable='~position-enabled'/>
 91 | 				<checkbox text='Static Player Count Color' value='use-static-color' apply-on-change='true' interactable='~position-enabled'/>
 92 | 				<color-setting text='Static Panel Color' value='color-static-panel' apply-on-change='true' active='~use-static-color'/>
 93 | 				<button text='Modify Position Colors' click-event='open-position-settings' interactable='~position-enabled'/>
 94 | 				<modal show-event='open-position-settings' hide-event='hide-all-modals' click-off-closes='true' move-to-center='true' size-delta-x='60' size-delta-y='55'>
 95 | 					<vertical horizontal-fit='PreferredSize' pref-width='55' vertical-fit='PreferredSize' pref-height='45'>
 96 | 						<checkbox text='Rainbow on 1st Place' value='rainbow-on-first-place' apply-on-change='true' interactable='~position-enabled'/>
 97 | 						<color-setting text='1st Place' value='color-first-place' apply-on-change='true' interactable='~position-enabled' active='~invert-rainbow-first-place'/>
 98 | 						<color-setting text='2nd Place' value='color-second-place' apply-on-change='true' interactable='~position-enabled'/>
 99 | 						<color-setting text='3rd Place' value='color-third-place' apply-on-change='true' interactable='~position-enabled'/>
100 | 						<color-setting text='4th Place' value='color-fourth-place' apply-on-change='true' interactable='~position-enabled'/>
101 | 						<color-setting text='5th Place' value='color-fifth-place' apply-on-change='true' interactable='~position-enabled'/>
102 | 						<button text='Close' click-event='hide-all-modals'/>
103 | 					</vertical>
104 | 				</modal>
105 | 			</modifier-container>
106 | 		</tab>
107 | 
108 | 		<!--Miscellaneous Tab-->
109 | 		<tab tab-name='Extras' tags='_'>
110 | 			<modifier-container child-expand-width='true' horizontal-fit='PreferredSize'>
111 | 				<vertical vertical-fit='PreferredSize' spacing='3'>
112 | 					<vertical vertical-fit='PreferredSize'>
113 | 						<slider-setting id='rainbowspeed-slider' value='rainbow-speed' text='Rainbow Speed' min='0.1' max='1' increment='0.1'/>
114 | 						<checkbox text='Italicize Combo Panel' value='combo-panel-italics' apply-on-change='true'/>
115 | 						<checkbox text='Italicize Score Panel' value='score-panel-italics' apply-on-change='true'/>
116 | 						<checkbox text='Italicize Immediate Rank' value='rank-panel-italics' apply-on-change='true'/>
117 | 						<macro.if value='fools-toggle-check'>
118 | 							<checkbox text='Allow April Fools' value='allow-april-fools' apply-on-change='true'/>
119 | 						</macro.if>
120 | 						<checkbox text='Allow Rank Coloring' value='allow-rank-colors' apply-on-change='true'/>
121 | 						<button text='Modify Rank Colors' click-event='open-rank-settings' interactable='~allow-rank-colors'/>
122 | 						<modal show-event='open-rank-settings' hide-event='hide-all-modals' click-off-closes='true' move-to-center='true' size-delta-x='60' size-delta-y='80'>
123 | 							<vertical horizontal-fit='PreferredSize' pref-width='45' vertical-fit='PreferredSize' pref-height='70'>
124 | 								<checkbox text='Rainbow on SS' value='rainbow-on-ss-rank' apply-on-change='true' interactable='~allow-rank-colors'/>
125 | 								<color-setting text='SS' value='rank-ss-color' apply-on-change='true' interactable='~allow-rank-colors' active='~invert-rainbow-ss'/>
126 | 								<color-setting text='S' value='rank-s-color' apply-on-change='true' interactable='~allow-rank-colors'/>
127 | 								<color-setting text='A' value='rank-a-color' apply-on-change='true' interactable='~allow-rank-colors'/>
128 | 								<color-setting text='B' value='rank-b-color' apply-on-change='true' interactable='~allow-rank-colors'/>
129 | 								<color-setting text='C' value='rank-c-color' apply-on-change='true' interactable='~allow-rank-colors'/>
130 | 								<color-setting text='D' value='rank-d-color' apply-on-change='true' interactable='~allow-rank-colors'/>
131 | 								<color-setting text='E' value='rank-e-color' apply-on-change='true' interactable='~allow-rank-colors'/>
132 | 								<button text='Close' click-event='hide-all-modals'/>
133 | 							</vertical>
134 | 						</modal>
135 | 						<text text='Set Rank Letter' align='Center' italics='True' underlined='True'/>
136 | 						<horizontal>
137 | 							<button text='SS' on-click='switch-rank-text.ss'/>
138 | 							<button text='S' on-click='switch-rank-text.s'/>
139 | 							<button text='A' on-click='switch-rank-text.a'/>
140 | 							<button text='B' on-click='switch-rank-text.b'/>
141 | 							<button text='C' on-click='switch-rank-text.c'/>
142 | 							<button text='D' on-click='switch-rank-text.d'/>
143 | 							<button text='E' on-click='switch-rank-text.e'/>
144 | 						</horizontal>
145 | 					</vertical>
146 | 				</vertical>
147 | 			</modifier-container>
148 | 		</tab>
149 | 	</vertical>
150 | </bg>


--------------------------------------------------------------------------------
/UITweaks/UI/ModSettingsViewController.cs:
--------------------------------------------------------------------------------
  1 | using BeatSaberMarkupLanguage.Attributes;
  2 | using BeatSaberMarkupLanguage.Components.Settings;
  3 | using BeatSaberMarkupLanguage.ViewControllers;
  4 | using HMUI;
  5 | using System;
  6 | using System.Collections.Generic;
  7 | using UITweaks.Config;
  8 | using UnityEngine;
  9 | using Zenject;
 10 | 
 11 | namespace UITweaks.UI
 12 | {
 13 |     [ViewDefinition("UITweaks.Views.ModSettings.bsml")]
 14 |     [HotReload(RelativePathToLayout = @"..\Views\ModSettings.bsml")]
 15 |     public class ModSettingsViewController : BSMLAutomaticViewController
 16 |     {
 17 |         private PluginConfig pluginConfig;
 18 |         private MultiplierConfig multiplierConfig;
 19 |         private EnergyConfig energyConfig;
 20 |         private ComboConfig comboConfig;
 21 |         private ProgressConfig progressConfig;
 22 |         private PositionConfig positionConfig;
 23 |         private MiscConfig miscConfig;
 24 | 
 25 |         [UIValue("fools-toggle-check")] private bool _aprilFoolsToggle => Plugin.APRIL_FOOLS;
 26 |         [UIValue("progress-bar-render-modes")] private List<object> _renderModes = new List<object>() { "Fixed", "Fade" };
 27 |         [UIComponent("rainbowspeed-slider")] public SliderSetting rainbowSpeedSetting;
 28 | 
 29 |         public event Action<string> RankShouldBeUpdatedEvent = delegate { };
 30 |         public event Action<int> TabWasChangedEvent = delegate { };
 31 |         private int selectedTab = 0;
 32 |         private float energyBarFillAmount = 0.01f;
 33 |         private float progressBarFillAmount = 0.01f;
 34 | 
 35 |         [Inject] internal void Construct(PluginConfig c)
 36 |         {
 37 |             pluginConfig = c;
 38 |             multiplierConfig = c.Multiplier;
 39 |             energyConfig = c.Energy;
 40 |             comboConfig = c.Combo;
 41 |             progressConfig = c.Progress;
 42 |             positionConfig = c.Position;
 43 |             miscConfig = c.Misc;
 44 |         }
 45 | 
 46 |         public int SelectedTab
 47 |         {
 48 |             get => selectedTab;
 49 |             set
 50 |             {
 51 |                 if (selectedTab != value)
 52 |                     selectedTab = value;
 53 |             }
 54 |         }
 55 | 
 56 |         public float EnergyBarFillAmount
 57 |         {
 58 |             get => energyBarFillAmount;
 59 |             set
 60 |             {
 61 |                 if (energyBarFillAmount != value)
 62 |                     energyBarFillAmount = value;
 63 |             }
 64 |         }
 65 | 
 66 |         public float ProgressBarFillAmount
 67 |         {
 68 |             get => progressBarFillAmount;
 69 |             set
 70 |             {
 71 |                 if (progressBarFillAmount != value)
 72 |                     progressBarFillAmount = value;
 73 |             }
 74 |         }
 75 | 
 76 |         protected override void DidActivate(bool firstActivation, bool addedToHierarchy, bool screenSystemEnabling)
 77 |         {
 78 |             base.DidActivate(firstActivation, addedToHierarchy, screenSystemEnabling);
 79 |             if (firstActivation && rainbowSpeedSetting.gameObject != null)
 80 |             {
 81 |                 rainbowSpeedSetting.Slider.valueDidChangeEvent += HandleRainbowSliderValueChanged;
 82 |             }
 83 |             TabWasChangedEvent.Invoke(SelectedTab);
 84 |         }
 85 | 
 86 |         protected override void DidDeactivate(bool removedFromHierarchy, bool screenSystemDisabling)
 87 |         {
 88 |             base.DidDeactivate(removedFromHierarchy, screenSystemDisabling);
 89 |             rainbowSpeedSetting.Slider.valueDidChangeEvent -= HandleRainbowSliderValueChanged;
 90 |         }
 91 | 
 92 |         [UIAction("update-tab")]
 93 |         internal void UpdateTab(SegmentedControl _, int tab)
 94 |         {
 95 |             SelectedTab = tab;
 96 |             TabWasChangedEvent.Invoke(tab);
 97 |         }
 98 | 
 99 |         [UIAction("update-energy-preview")]
100 |         internal void UpdateEnergyPreview(float fillAmount) => EnergyBarFillAmount = fillAmount;
101 | 
102 |         [UIAction("update-progress-preview")]
103 |         internal void UpdateProgressPreview(float time) => ProgressBarFillAmount = time;
104 | 
105 |         [UIAction("switch-rank-text.ss")]
106 |         internal void SwitchRankText_SS() => HandleRankTextChangeRequest("SS");
107 | 
108 |         [UIAction("switch-rank-text.s")]
109 |         internal void SwitchRankText_S() => HandleRankTextChangeRequest("S");
110 | 
111 |         [UIAction("switch-rank-text.a")]
112 |         internal void SwitchRankText_A() => HandleRankTextChangeRequest("A");
113 | 
114 |         [UIAction("switch-rank-text.b")]
115 |         internal void SwitchRankText_B() => HandleRankTextChangeRequest("B");
116 | 
117 |         [UIAction("switch-rank-text.c")]
118 |         internal void SwitchRankText_C() => HandleRankTextChangeRequest("C");
119 | 
120 |         [UIAction("switch-rank-text.d")]
121 |         internal void SwitchRankText_D() => HandleRankTextChangeRequest("D");
122 | 
123 |         [UIAction("switch-rank-text.e")]
124 |         internal void SwitchRankText_E() => HandleRankTextChangeRequest("E");
125 | 
126 |         private void HandleRankTextChangeRequest(string rankString)
127 |         {
128 |             this.RankShouldBeUpdatedEvent.Invoke(rankString);
129 |         }
130 | 
131 |         private void HandleRainbowSliderValueChanged(RangeValuesTextSlider _, float value)
132 |         {
133 |             if (RainbowSpeed != value)
134 |                 RainbowSpeed = value;
135 |         }
136 | 
137 |         public void RaiseTabEvent(int raiseWithTab = 0) => TabWasChangedEvent.Invoke(raiseWithTab == SelectedTab ? SelectedTab : raiseWithTab);
138 | 
139 | #pragma warning disable IDE0051
140 |         #region Notifiable Properties
141 |         [UIValue("invert-rainbow-8x")] private bool _RainbowToggle => !RainbowAnimationOnMax;
142 | 
143 |         [UIValue("invert-mbl")] private bool _MirrorBottomLineToggle => !MirrorOnBottom;
144 | 
145 |         [UIValue("invert-gradient")] private bool _GradientToggle => !GradientEnabled;
146 | 
147 |         [UIValue("complex")] private bool _Complex { get => ComboEnabled && GradientEnabled; }
148 | 
149 |         [UIValue("displaytype-is-fixed")] private bool _ProgressBarDisplayTypeIsFixed => RenderMode.Equals(ProgressConfig.DisplayType.Fixed.ToString());
150 | 
151 |         [UIValue("displaytype-is-fade")] private bool _ProgressBarDisplayTypeIsFade => RenderMode.Equals(ProgressConfig.DisplayType.Fade.ToString());
152 | 
153 |         [UIValue("invert-rainbow-first-place")] private bool _InvertRainbowFirstPlace => !RainbowOnFirstPlace;
154 | 
155 |         [UIValue("invert-rainbow-ss")] private bool _InvertRainbowSS => !RainbowOnSSRank;
156 |         #endregion
157 | 
158 |         #region Multiplier Config
159 |         [UIValue("multiplier-enabled")]
160 |         private bool MultiplierEnabled
161 |         {
162 |             get => multiplierConfig.Enabled;
163 |             set
164 |             {
165 |                 if (multiplierConfig.Enabled != value)
166 |                 {
167 |                     multiplierConfig.Enabled = value;
168 |                     NotifyPropertyChanged();
169 |                 }
170 |             }
171 |         }
172 | 
173 |         [UIValue("rainbow-on-8x")]
174 |         private bool RainbowAnimationOnMax
175 |         {
176 |             get => multiplierConfig.RainbowOnMaxMultiplier;
177 |             set
178 |             {
179 |                 if (multiplierConfig.RainbowOnMaxMultiplier != value)
180 |                 {
181 |                     multiplierConfig.RainbowOnMaxMultiplier = value;
182 |                     NotifyPropertyChanged(nameof(_RainbowToggle));
183 |                 }
184 |             }
185 |         }
186 | 
187 |         [UIValue("smooth-transition")]
188 |         private bool SmoothTransition
189 |         {
190 |             get => multiplierConfig.SmoothTransition;
191 |             set => multiplierConfig.SmoothTransition = value;
192 |         }
193 | 
194 |         [UIValue("color-1x")]
195 |         private Color One
196 |         {
197 |             get => multiplierConfig.One;
198 |             set => multiplierConfig.One = value;
199 |         }
200 | 
201 |         [UIValue("color-2x")]
202 |         private Color Two
203 |         {
204 |             get => multiplierConfig.Two;
205 |             set => multiplierConfig.Two = value;
206 |         }
207 | 
208 |         [UIValue("color-4x")]
209 |         private Color Four
210 |         {
211 |             get => multiplierConfig.Four;
212 |             set => multiplierConfig.Four = value;
213 |         }
214 | 
215 |         [UIValue("color-8x")]
216 |         private Color Eight
217 |         {
218 |             get => multiplierConfig.Eight;
219 |             set => multiplierConfig.Eight = value;
220 |         }
221 |         #endregion
222 | 
223 |         #region Energy Config
224 |         [UIValue("energy-enabled")]
225 |         private bool EnergyEnabled
226 |         {
227 |             get => energyConfig.Enabled;
228 |             set
229 |             {
230 |                 if (energyConfig.Enabled != value)
231 |                 {
232 |                     energyConfig.Enabled = value;
233 |                     NotifyPropertyChanged();
234 |                 }
235 |             }
236 |         }
237 | 
238 |         [UIValue("rainbow-on-full")]
239 |         private bool RainbowOnFullEnergy
240 |         {
241 |             get => energyConfig.RainbowOnFullEnergy;
242 |             set
243 |             {
244 |                 if (energyConfig.RainbowOnFullEnergy != value)
245 |                 {
246 |                     energyConfig.RainbowOnFullEnergy = value;
247 |                     NotifyPropertyChanged();
248 |                 }
249 |             }
250 |         }
251 | 
252 |         [UIValue("color-low")]
253 |         private Color LowEnergy
254 |         {
255 |             get => energyConfig.Low;
256 |             set => energyConfig.Low = value;
257 |         }
258 | 
259 |         [UIValue("color-mid")]
260 |         private Color MidEnergy
261 |         {
262 |             get => energyConfig.Mid;
263 |             set => energyConfig.Mid = value;
264 |         }
265 | 
266 |         [UIValue("color-high")]
267 |         private Color HighEnergy
268 |         {
269 |             get => energyConfig.High;
270 |             set => energyConfig.High = value;
271 |         }
272 |         #endregion
273 | 
274 |         #region Combo Config
275 |         [UIValue("combo-enabled")]
276 |         private bool ComboEnabled
277 |         {
278 |             get => comboConfig.Enabled;
279 |             set
280 |             {
281 |                 if (comboConfig.Enabled != value)
282 |                 {
283 |                     comboConfig.Enabled = value;
284 |                     NotifyPropertyChanged();
285 |                     NotifyPropertyChanged(nameof(_Complex));
286 |                 }
287 |             }
288 |         }
289 | 
290 |         [UIValue("color-top-line")]
291 |         private Color TopLine
292 |         {
293 |             get => comboConfig.TopLine;
294 |             set => comboConfig.TopLine = value;
295 |         }
296 | 
297 |         [UIValue("color-bottom-line")]
298 |         private Color BottomLine
299 |         {
300 |             get => comboConfig.BottomLine;
301 |             set => comboConfig.BottomLine = value;
302 |         }
303 | 
304 |         [UIValue("gradient-enabled")]
305 |         private bool GradientEnabled
306 |         {
307 |             get => comboConfig.UseGradient;
308 |             set
309 |             {
310 |                 if (comboConfig.UseGradient != value)
311 |                 {
312 |                     comboConfig.UseGradient = value;
313 |                     NotifyPropertyChanged();
314 |                     NotifyPropertyChanged(nameof(_Complex));
315 |                     NotifyPropertyChanged(nameof(_GradientToggle));
316 |                 }
317 |             }
318 |         }
319 | 
320 |         [UIValue("color-top-line-left")]
321 |         private Color TopLeftGradient
322 |         {
323 |             get => comboConfig.TopLeft;
324 |             set => comboConfig.TopLeft = value;
325 |         }
326 | 
327 |         [UIValue("color-top-line-right")]
328 |         private Color TopRightGradient
329 |         {
330 |             get => comboConfig.TopRight;
331 |             set => comboConfig.TopRight = value;
332 |         }
333 | 
334 |         [UIValue("mirror-bottom-line")]
335 |         private bool MirrorOnBottom
336 |         {
337 |             get => comboConfig.MirrorBottomLine;
338 |             set
339 |             {
340 |                 if (comboConfig.MirrorBottomLine != value)
341 |                 {
342 |                     comboConfig.MirrorBottomLine = value;
343 |                     NotifyPropertyChanged(nameof(_MirrorBottomLineToggle));
344 |                 }
345 |             }
346 |         }
347 | 
348 |         [UIValue("color-bottom-line-left")]
349 |         private Color BottomLeftGradient
350 |         {
351 |             get => comboConfig.BottomLeft;
352 |             set => comboConfig.BottomLeft = value;
353 |         }
354 | 
355 |         [UIValue("color-bottom-line-right")]
356 |         private Color BottomRightGradient
357 |         {
358 |             get => comboConfig.BottomRight;
359 |             set => comboConfig.BottomRight = value;
360 |         }
361 |         #endregion
362 | 
363 |         #region Progress Config
364 |         [UIValue("progress-enabled")]
365 |         private bool ProgressEnabled
366 |         {
367 |             get => progressConfig.Enabled;
368 |             set
369 |             {
370 |                 if (progressConfig.Enabled != value)
371 |                 {
372 |                     progressConfig.Enabled = value;
373 |                     NotifyPropertyChanged();
374 |                 }
375 |             }
376 |         }
377 | 
378 |         [UIValue("color-fill")]
379 |         private Color FillColor
380 |         {
381 |             get => progressConfig.Fill;
382 |             set => progressConfig.Fill = value;
383 |         }
384 | 
385 |         [UIValue("color-bg")]
386 |         private Color BGColor
387 |         {
388 |             get => progressConfig.BG;
389 |             set => progressConfig.BG = value;
390 |         }
391 | 
392 |         [UIValue("color-handle")]
393 |         private Color HandleColor
394 |         {
395 |             get => progressConfig.Handle;
396 |             set => progressConfig.Handle = value;
397 |         }
398 | 
399 |         [UIValue("render-mode")]
400 |         private string RenderMode
401 |         {
402 |             get => progressConfig.Mode.ToString();
403 |             set
404 |             {
405 |                 if (value != progressConfig.Mode.ToString())
406 |                 {
407 |                     ProgressConfig.DisplayType convertedValue = (ProgressConfig.DisplayType)Enum.Parse(typeof(ProgressConfig.DisplayType), value.ToString(), true);
408 |                     progressConfig.Mode = convertedValue;
409 |                     NotifyPropertyChanged();
410 |                     NotifyPropertyChanged(nameof(_ProgressBarDisplayTypeIsFade));
411 |                     NotifyPropertyChanged(nameof(_ProgressBarDisplayTypeIsFixed));
412 |                 }
413 |             }
414 |         }
415 | 
416 |         [UIValue("color-song-start")]
417 |         private Color SongStartColor
418 |         {
419 |             get => progressConfig.StartColor;
420 |             set => progressConfig.StartColor = value;
421 |         }
422 | 
423 |         [UIValue("color-song-end")]
424 |         private Color SongEndColor
425 |         {
426 |             get => progressConfig.EndColor;
427 |             set => progressConfig.EndColor = value;
428 |         }
429 |         #endregion
430 | 
431 |         #region Position Config
432 |         [UIValue("position-enabled")]
433 |         private bool PositionEnabled
434 |         {
435 |             get => positionConfig.Enabled;
436 |             set
437 |             {
438 |                 if (positionConfig.Enabled != value)
439 |                 {
440 |                     positionConfig.Enabled = value;
441 |                     NotifyPropertyChanged();
442 |                 }
443 |             }
444 |         }
445 | 
446 |         [UIValue("hide-first-place-anim")]
447 |         private bool HideFirstPlace
448 |         {
449 |             get => positionConfig.HideFirstPlaceAnimation;
450 |             set => positionConfig.HideFirstPlaceAnimation = value;
451 |         }
452 | 
453 |         [UIValue("rainbow-on-first-place")]
454 |         private bool RainbowOnFirstPlace
455 |         {
456 |             get => positionConfig.RainbowOnFirstPlace;
457 |             set
458 |             {
459 |                 if (positionConfig.RainbowOnFirstPlace != value)
460 |                 {
461 |                     positionConfig.RainbowOnFirstPlace = value;
462 |                     NotifyPropertyChanged();
463 |                     NotifyPropertyChanged(nameof(_InvertRainbowFirstPlace));
464 |                 }
465 |             }
466 |         }
467 | 
468 |         [UIValue("use-static-color")]
469 |         private bool UseStaticColor
470 |         {
471 |             get => positionConfig.UseStaticColorForStaticPanel;
472 |             set
473 |             {
474 |                 if (positionConfig.UseStaticColorForStaticPanel != value)
475 |                 {
476 |                     positionConfig.UseStaticColorForStaticPanel = value;
477 |                     NotifyPropertyChanged();
478 |                 }
479 |             }
480 |         }
481 | 
482 |         [UIValue("color-static-panel")]
483 |         private Color StaticPanelColor
484 |         {
485 |             get => positionConfig.StaticPanelColor;
486 |             set => positionConfig.StaticPanelColor = value;
487 |         }
488 | 
489 |         [UIValue("color-first-place")]
490 |         private Color FirstPlace
491 |         {
492 |             get => positionConfig.First;
493 |             set => positionConfig.First = value;
494 |         }
495 | 
496 |         [UIValue("color-second-place")]
497 |         private Color SecondPlace
498 |         {
499 |             get => positionConfig.Second;
500 |             set => positionConfig.Second = value;
501 |         }
502 | 
503 |         [UIValue("color-third-place")]
504 |         private Color ThirdPlace
505 |         {
506 |             get => positionConfig.Third;
507 |             set => positionConfig.Third = value;
508 |         }
509 | 
510 |         [UIValue("color-fourth-place")]
511 |         private Color FourthPlace
512 |         {
513 |             get => positionConfig.Fourth;
514 |             set => positionConfig.Fourth = value;
515 |         }
516 | 
517 |         [UIValue("color-fifth-place")]
518 |         private Color FifthPlace
519 |         {
520 |             get => positionConfig.Fifth;
521 |             set => positionConfig.Fifth = value;
522 |         }
523 |         #endregion
524 | 
525 |         #region Miscellaneous Config
526 |         [UIValue("rainbow-speed")]
527 |         private float RainbowSpeed
528 |         {
529 |             get => miscConfig.GlobalRainbowSpeed;
530 |             set => miscConfig.GlobalRainbowSpeed = value;
531 |         }
532 | 
533 |         [UIValue("combo-panel-italics")]
534 |         private bool ComboPanelItalics
535 |         {
536 |             get => miscConfig.ItalicizeComboPanel;
537 |             set => miscConfig.ItalicizeComboPanel = value;
538 |         }
539 | 
540 |         [UIValue("score-panel-italics")]
541 |         private bool ScorePanelItalics
542 |         {
543 |             get => miscConfig.ItalicizeScore;
544 |             set => miscConfig.ItalicizeScore = value;
545 |         }
546 | 
547 |         [UIValue("rank-panel-italics")]
548 |         private bool RankPanelItalics
549 |         {
550 |             get => miscConfig.ItalicizeImmediateRank;
551 |             set => miscConfig.ItalicizeImmediateRank = value;
552 |         }
553 | 
554 |         [UIValue("allow-april-fools")]
555 |         private bool AllowAprilFools
556 |         {
557 |             get => pluginConfig.AllowAprilFools;
558 |             set => pluginConfig.AllowAprilFools = value;
559 |         }
560 | 
561 |         [UIValue("allow-rank-colors")]
562 |         private bool AllowRankColors
563 |         {
564 |             get => miscConfig.AllowRankColoring;
565 |             set
566 |             {
567 |                 if (miscConfig.AllowRankColoring != value)
568 |                 {
569 |                     miscConfig.AllowRankColoring = value;
570 |                     NotifyPropertyChanged();
571 |                 }
572 |             }
573 |         }
574 | 
575 |         [UIValue("rainbow-on-ss-rank")]
576 |         private bool RainbowOnSSRank
577 |         {
578 |             get => miscConfig.RainbowOnSSRank;
579 |             set
580 |             {
581 |                 if (miscConfig.RainbowOnSSRank != value)
582 |                 {
583 |                     miscConfig.RainbowOnSSRank = value;
584 |                     NotifyPropertyChanged(nameof(_InvertRainbowSS));
585 |                     NotifyPropertyChanged();
586 |                 }
587 |             }
588 |         }
589 | 
590 |         [UIValue("rank-ss-color")]
591 |         private Color RankSSColor
592 |         {
593 |             get => miscConfig.RankSSColor;
594 |             set => miscConfig.RankSSColor = value;
595 |         }
596 | 
597 |         [UIValue("rank-s-color")]
598 |         private Color RankSColor
599 |         {
600 |             get => miscConfig.RankSColor;
601 |             set => miscConfig.RankSColor = value;
602 |         }
603 | 
604 |         [UIValue("rank-a-color")]
605 |         private Color RankAColor
606 |         {
607 |             get => miscConfig.RankAColor;
608 |             set => miscConfig.RankAColor = value;
609 |         }
610 | 
611 |         [UIValue("rank-b-color")]
612 |         private Color RankBColor
613 |         {
614 |             get => miscConfig.RankBColor;
615 |             set => miscConfig.RankBColor = value;
616 |         }
617 | 
618 |         [UIValue("rank-c-color")]
619 |         private Color RankCColor
620 |         {
621 |             get => miscConfig.RankCColor;
622 |             set => miscConfig.RankCColor = value;
623 |         }
624 | 
625 |         [UIValue("rank-d-color")]
626 |         private Color RankDColor
627 |         {
628 |             get => miscConfig.RankDColor;
629 |             set => miscConfig.RankDColor = value;
630 |         }
631 | 
632 |         [UIValue("rank-e-color")]
633 |         private Color RankEColor
634 |         {
635 |             get => miscConfig.RankEColor;
636 |             set => miscConfig.RankEColor = value;
637 |         }
638 |         #endregion
639 | #pragma warning restore
640 |     }
641 | }
642 | 


--------------------------------------------------------------------------------
/UITweaks/UI/ObjectPreviewViewController.cs:
--------------------------------------------------------------------------------
  1 | using BeatSaberMarkupLanguage.Attributes;
  2 | using BeatSaberMarkupLanguage.ViewControllers;
  3 | using HMUI;
  4 | using SiraUtil.Logging;
  5 | using System;
  6 | using System.Collections;
  7 | using System.Collections.Generic;
  8 | using System.Linq;
  9 | using Tweening;
 10 | using UITweaks.Config;
 11 | using UITweaks.Models;
 12 | using UITweaks.Utilities;
 13 | using UnityEngine;
 14 | using UnityEngine.UI;
 15 | using Zenject;
 16 | 
 17 | namespace UITweaks.UI
 18 | {
 19 |     [ViewDefinition("UITweaks.Views.ObjectPreview.bsml")]
 20 |     [HotReload(RelativePathToLayout = @"..\Views\ObjectPreview.bsml")]
 21 |     public class ObjectPreviewViewController : BSMLAutomaticViewController
 22 |     {
 23 |         [UIComponent("loading-container")] private readonly VerticalLayoutGroup loadingContainer;
 24 |         [Inject] private readonly SettingsPanelObjectGrabber objectGrabber;
 25 |         [Inject] private readonly ModSettingsViewController modSettingsViewController;
 26 |         [Inject] private readonly SiraLog logger;
 27 |         [Inject] private readonly TimeTweeningManager tweeningManager;
 28 |         [Inject] private readonly RainbowEffectManager rainbowEffectManager;
 29 | 
 30 |         private MultiplierConfig multiplierConfig;
 31 |         private EnergyConfig energyConfig;
 32 |         private ComboConfig comboConfig;
 33 |         private ProgressConfig progressConfig;
 34 |         private PositionConfig positionConfig;
 35 |         private MiscConfig miscConfig;
 36 | 
 37 |         private readonly Vector3 DEFAULT_POSITION = new(3.53f, 1.3f, 2.4f);
 38 |         private readonly Vector3 VOID_POSITION = new(0, -1000, 0);
 39 |         private readonly WaitForSecondsRealtime MULTIPLIER_DELAY = new WaitForSecondsRealtime(1f);
 40 |         private readonly WaitForSecondsRealtime POSITION_DELAY = new WaitForSecondsRealtime(1f);
 41 |         private FloatTween oneTwoFloatTween;
 42 |         private FloatTween twoFourFloatTween;
 43 |         private FloatTween fourEightFloatTween;
 44 |         private List<PreviewPanel> enableablePanels;
 45 |         private List<PreviewPanel> transformablePanels;
 46 | 
 47 |         private bool OBJECT_CHECK
 48 |         {
 49 |             get => objectGrabber.gameObject != null && objectGrabber.IsCompleted;
 50 |         }
 51 | 
 52 |         #region Preview Objects
 53 |         // Multiplier Panel
 54 |         public PreviewPanel MultiplierPanel => objectGrabber.PreviewPanels[0];
 55 |         private Image[] multiplierCircles;
 56 |         private CurvedTextMeshPro multiplierText;
 57 |         private bool previewCoroOn8x = false;
 58 | 
 59 |         // Energy Panel
 60 |         public PreviewPanel EnergyPanel => objectGrabber.PreviewPanels[1];
 61 |         private Image energyBar;
 62 |         private float fillAmount = 0.01f;
 63 | 
 64 |         // Combo Panel
 65 |         public PreviewPanel ComboPanel => objectGrabber.PreviewPanels[2];
 66 |         private ImageView[] comboLines;
 67 |         private CurvedTextMeshPro comboNumberText;
 68 |         private CurvedTextMeshPro comboText;
 69 | 
 70 |         // Progress Panel
 71 |         public PreviewPanel ProgressPanel => objectGrabber.PreviewPanels[3];
 72 |         private Image[] progressPanelImages;
 73 | 
 74 |         // Position Panel
 75 |         public PreviewPanel PositionPanel => objectGrabber.PreviewPanels[4];
 76 |         private MockMultiplayerPositionPanel positionPanel;
 77 |         private GameObject firstPlaceAnimationGO;
 78 |         private CurvedTextMeshPro firstPlaceAnimationGOText;
 79 |         private CurvedTextMeshPro positionText;
 80 |         private CurvedTextMeshPro playerCountText;
 81 |         private bool previewPositionIsFirst = false;
 82 |         private float animationOpacity;
 83 |         private Vector3 animationScale;
 84 |         private FloatTween positionPanelScaleTween;
 85 |         private FloatTween positionPanelOpacityTween;
 86 | 
 87 |         // Score Panel
 88 |         public PreviewPanel RankPanel => objectGrabber.PreviewPanels[5];
 89 |         private CurvedTextMeshPro scoreText;
 90 |         private CurvedTextMeshPro percentText;
 91 |         private CurvedTextMeshPro rankText;
 92 |         private decimal rank = 0.00m;
 93 |         #endregion
 94 | 
 95 |         [Inject] internal void Construct(PluginConfig c)
 96 |         {
 97 |             multiplierConfig = c.Multiplier;
 98 |             energyConfig = c.Energy;
 99 |             comboConfig = c.Combo;
100 |             progressConfig = c.Progress;
101 |             positionConfig = c.Position;
102 |             miscConfig = c.Misc;
103 |         }
104 | 
105 |         protected override void DidActivate(bool firstActivation, bool addedToHierarchy, bool screenSystemEnabling)
106 |         {
107 |             base.DidActivate(firstActivation, addedToHierarchy, screenSystemEnabling);
108 | 
109 |             if (firstActivation && objectGrabber.gameObject != null)
110 |             {
111 |                 objectGrabber.transform.Rotate(0, 57, 0);
112 |                 this.StartCoroutine(FinalizePanels());
113 |             }
114 | 
115 |             loadingContainer?.gameObject.SetActive(!objectGrabber.IsCompleted);
116 |             objectGrabber.transform.position = objectGrabber.IsCompleted ? DEFAULT_POSITION : VOID_POSITION;
117 |             modSettingsViewController.TabWasChangedEvent += UpdatePanelVisibility;
118 |             modSettingsViewController.RankShouldBeUpdatedEvent += HandleRankLetterRequest;
119 |         }
120 | 
121 |         protected override void DidDeactivate(bool removedFromHierarchy, bool screenSystemDisabling)
122 |         {
123 |             base.DidDeactivate(removedFromHierarchy, screenSystemDisabling);
124 |             tweeningManager.KillAllTweens(this);
125 |             modSettingsViewController.TabWasChangedEvent -= UpdatePanelVisibility;
126 |             objectGrabber.transform.position = VOID_POSITION;
127 |         }
128 | 
129 |         private IEnumerator FinalizePanels()
130 |         {
131 |             this.StartCoroutine(objectGrabber.GetPanels());
132 |             yield return new WaitUntil(() => objectGrabber.IsCompleted);
133 | 
134 |             try
135 |             {
136 |                 MultiplierPanel.Panel.SetActive(true);
137 |                 GameObject panel;
138 | 
139 |                 // Multiplier Panel Setup
140 |                 {
141 |                     panel = MultiplierPanel.Panel;
142 |                     multiplierText = panel.GetComponentsInChildren<CurvedTextMeshPro>().Last();
143 |                     multiplierCircles = panel.transform.GetComponentsInChildren<Image>();
144 | 
145 |                     multiplierCircles[1].color = multiplierConfig.One;
146 |                     multiplierCircles[0].color = multiplierConfig.One.ColorWithAlpha(0.25f);
147 | 
148 |                     oneTwoFloatTween = new FloatTween(0, 1, (float time) =>
149 |                     {
150 |                         Color frame = HSBColor.Lerp(
151 |                             HSBColor.FromColor(multiplierConfig.One),
152 |                             HSBColor.FromColor(multiplierConfig.Two), time)
153 |                             .ToColor();
154 | 
155 |                         multiplierCircles[1].fillAmount = time;
156 |                         multiplierCircles[1].color = frame;
157 |                         multiplierCircles[0].color = frame.ColorWithAlpha(0.25f);
158 |                     },
159 |                     1, EaseType.Linear);
160 | 
161 |                     twoFourFloatTween = new FloatTween(0, 1, (float time) =>
162 |                     {
163 |                         Color frame = HSBColor.Lerp(
164 |                             HSBColor.FromColor(multiplierConfig.Two),
165 |                             HSBColor.FromColor(multiplierConfig.Four), time)
166 |                             .ToColor();
167 | 
168 |                         multiplierCircles[1].fillAmount = time;
169 |                         multiplierCircles[1].color = frame;
170 |                         multiplierCircles[0].color = frame.ColorWithAlpha(0.25f);
171 |                     },
172 |                     1, EaseType.Linear);
173 | 
174 |                     fourEightFloatTween = new FloatTween(0, 1, (time) =>
175 |                     {
176 |                         Color frame = HSBColor.Lerp(
177 |                             HSBColor.FromColor(multiplierConfig.Four),
178 |                             HSBColor.FromColor(multiplierConfig.Eight), time)
179 |                             .ToColor();
180 | 
181 |                         multiplierCircles[1].fillAmount = time;
182 |                         multiplierCircles[1].color = frame;
183 |                         multiplierCircles[0].color = frame.ColorWithAlpha(0.25f);
184 |                     }, 0.98f, EaseType.Linear);
185 |                 }
186 | 
187 |                 // Energy Bar Setup
188 |                 panel = EnergyPanel.Panel;
189 |                 energyBar = panel.transform.Find("EnergyBarWrapper/EnergyBar").GetComponent<Image>();
190 | 
191 |                 // Combo Panel Setup
192 |                 {
193 |                     panel = ComboPanel.Panel;
194 |                     comboLines = panel.transform.GetComponentsInChildren<ImageView>();
195 |                     comboNumberText = panel.transform.Find("ComboCanvas/NumText").GetComponent<CurvedTextMeshPro>();
196 |                     comboText = panel.transform.Find("ComboText").GetComponent<CurvedTextMeshPro>();
197 |                 }
198 | 
199 |                 // Progress Panel Setup
200 |                 {
201 |                     panel = ProgressPanel.Panel;
202 |                     progressPanelImages = panel.transform.GetComponentsInChildren<Image>();
203 |                     CurvedTextMeshPro[] texts = panel.transform.GetComponentsInChildren<CurvedTextMeshPro>();
204 |                     texts[0].text = "0";
205 |                     texts[1].text = "00";
206 |                     texts[2].text = "0";
207 |                     texts[3].text = "01";
208 |                 }
209 | 
210 |                 // Position Panel Setup 
211 |                 {
212 |                     panel = PositionPanel.Panel;
213 |                     positionPanel = panel.GetComponent<MockMultiplayerPositionPanel>();
214 |                     positionPanel.transform.localPosition = VOID_POSITION;
215 |                     positionText = positionPanel.positionText;
216 |                     playerCountText = positionPanel.playerCountText;
217 | 
218 |                     firstPlaceAnimationGO = GameObject.Instantiate(positionText.gameObject, panel.transform, true);
219 |                     firstPlaceAnimationGO.SetActive(false);
220 | 
221 |                     firstPlaceAnimationGOText = firstPlaceAnimationGO.GetComponent<CurvedTextMeshPro>();
222 |                     firstPlaceAnimationGOText.text = "1";
223 |                     firstPlaceAnimationGOText.color = positionConfig.First;
224 | 
225 |                     positionPanelOpacityTween = new FloatTween(0.75f, 0f, time =>
226 |                     {
227 |                         animationOpacity = time;
228 |                     }, 1f, EaseType.Linear);
229 | 
230 |                     positionPanelScaleTween = new FloatTween(1f, 3f, time =>
231 |                     {
232 |                         animationScale = new Vector3(time, time, time);
233 |                     }, 1f, EaseType.Linear);
234 |                 }
235 | 
236 |                 // Immediate Rank Panel Setup
237 |                 {
238 |                     panel = RankPanel.Panel;
239 |                     Transform immediateRankTransform = panel.transform;
240 |                     scoreText = immediateRankTransform.Find("ScoreText").GetComponent<CurvedTextMeshPro>();
241 |                     percentText = immediateRankTransform.Find("RelativeScoreText").GetComponent<CurvedTextMeshPro>();
242 |                     rankText = immediateRankTransform.Find("ImmediateRankText").GetComponent<CurvedTextMeshPro>();
243 | 
244 |                     immediateRankTransform.localPosition = new Vector3(0.75f, 0, 0);
245 |                 }
246 |             }
247 |             catch (Exception ex)
248 |             {
249 |                 logger.Error(ex);
250 |             }
251 | 
252 |             if (objectGrabber.PreviewPanels.Count > 0)
253 |             {
254 |                 enableablePanels = new List<PreviewPanel>()
255 |                 {
256 |                     objectGrabber.PreviewPanels[1],
257 |                     objectGrabber.PreviewPanels[2],
258 |                     objectGrabber.PreviewPanels[3],
259 |                     objectGrabber.PreviewPanels[5],
260 |                 };
261 | 
262 |                 transformablePanels = new List<PreviewPanel>()
263 |                 {
264 |                     objectGrabber.PreviewPanels[0],
265 |                     objectGrabber.PreviewPanels[4],
266 |                 };
267 |             }
268 | 
269 |             objectGrabber.transform.position = DEFAULT_POSITION;
270 |             loadingContainer.gameObject.SetActive(false);
271 |             modSettingsViewController.RaiseTabEvent(modSettingsViewController.SelectedTab);
272 |             this.StartCoroutine(MultiplierPreviewCoroutine());
273 |             this.StartCoroutine(MultiplayerPositionPreviewCoroutine());
274 |             yield break;
275 |         }
276 | 
277 |         private void UpdatePanelVisibility(int tab)
278 |         {
279 |             if (!OBJECT_CHECK) return;
280 |             System.Random rand = new System.Random();
281 | 
282 |             foreach (PreviewPanel panel in enableablePanels)
283 |             {
284 |                 panel.Panel.SetActive(tab == panel.ActiveTab);
285 |             }
286 | 
287 |             foreach (PreviewPanel panel in transformablePanels)
288 |             {
289 |                 panel.Panel.transform.localPosition = tab == panel.ActiveTab ? Vector3.zero : VOID_POSITION;
290 |             }
291 | 
292 |             if (tab == 2)
293 |             {
294 |                 comboNumberText.text = rand.Next(0, 250).ToString();
295 |                 objectGrabber.PreviewPanels[2].Panel.transform.localPosition = Vector3.zero;
296 |             }
297 | 
298 |             if (tab == 5)
299 |             {
300 |                 rank = Utilities.Utilities.RandomDecimal(100, 1);
301 |                 percentText.text = rank.ToString() + "%";
302 |                 comboNumberText.text = rand.Next(0, 250).ToString();
303 |                 scoreText.text = rand.Next(0, 999999).ToString();
304 | 
305 |                 objectGrabber.PreviewPanels[2].Panel.SetActive(true);
306 |                 objectGrabber.PreviewPanels[2].Panel.transform.localPosition = new Vector3(-0.75f, 0, 0);
307 |             }
308 |         }
309 | 
310 |         public void Update()
311 |         {
312 |             if (!OBJECT_CHECK) return;
313 | 
314 |             int tab = modSettingsViewController.SelectedTab;
315 |             switch (tab)
316 |             {
317 |                 case 0:
318 |                     if (previewCoroOn8x)
319 |                     {
320 |                         if (multiplierConfig.RainbowOnMaxMultiplier)
321 |                             multiplierCircles[0].color = rainbowEffectManager.Rainbow;
322 |                         else multiplierCircles[0].color = multiplierConfig.Eight.ColorWithAlpha(0.25f);
323 |                     }
324 |                     break;
325 |                 case 1:
326 |                     if (fillAmount == 1 && energyConfig.RainbowOnFullEnergy)
327 |                         energyBar.color = rainbowEffectManager.Rainbow;
328 |                     else if (!energyConfig.RainbowOnFullEnergy)
329 |                         energyBar.color = energyConfig.High;
330 | 
331 |                     UpdateEnergyBar(modSettingsViewController.EnergyBarFillAmount);
332 |                     break;
333 |                 case 2:
334 |                     UpdateComboPanel();
335 |                     break;
336 |                 case 3:
337 |                     UpdateProgressBar(modSettingsViewController.ProgressBarFillAmount);
338 |                     break;
339 |                 case 4:
340 |                     if (previewPositionIsFirst)
341 |                     {
342 |                         bool firstPlaceAnimPresent = firstPlaceAnimationGO.gameObject != null;
343 | 
344 |                         if (positionConfig.RainbowOnFirstPlace)
345 |                         {
346 |                             positionPanel.positionText.color = rainbowEffectManager.Rainbow;
347 |                             if (firstPlaceAnimPresent)
348 |                                 firstPlaceAnimationGOText.color = rainbowEffectManager.Rainbow;
349 | 
350 |                             if (!positionConfig.UseStaticColorForStaticPanel)
351 |                                 positionPanel.playerCountText.color = rainbowEffectManager.Rainbow.ColorWithAlpha(0.25f);
352 |                             else positionPanel.playerCountText.color = positionConfig.StaticPanelColor.ColorWithAlpha(0.25f);
353 |                         }
354 |                         else
355 |                         {
356 |                             positionPanel.positionText.color = positionConfig.First;
357 |                             if (firstPlaceAnimPresent)
358 |                                 firstPlaceAnimationGOText.color = positionConfig.First;
359 |                         }
360 | 
361 |                         if (firstPlaceAnimPresent)
362 |                         {
363 |                             firstPlaceAnimationGO.transform.localScale = animationScale;
364 |                             firstPlaceAnimationGOText.alpha = animationOpacity;
365 |                         }
366 |                     }
367 |                     break;
368 |                 case 5:
369 |                     UpdateComboPanel();
370 |                     UpdateImmediateRankPanel();
371 |                     if (rank >= 90.00m && miscConfig.RainbowOnSSRank && miscConfig.AllowRankColoring)
372 |                         rankText.color = rainbowEffectManager.Rainbow;
373 |                     break;
374 |             }
375 |         }
376 | 
377 |         private IEnumerator MultiplierPreviewCoroutine()
378 |         {
379 |             previewCoroOn8x = false;
380 | 
381 |             if (!multiplierConfig.SmoothTransition)
382 |             {
383 |                 multiplierCircles[1].fillAmount = 0.5f;
384 | 
385 |                 multiplierCircles[0].color = multiplierConfig.One.ColorWithAlpha(0.25f);
386 |                 multiplierCircles[1].color = multiplierConfig.One;
387 |                 multiplierText.text = "1";
388 |                 yield return MULTIPLIER_DELAY;
389 | 
390 |                 multiplierCircles[0].color = multiplierConfig.Two.ColorWithAlpha(0.25f);
391 |                 multiplierCircles[1].color = multiplierConfig.Two;
392 |                 multiplierText.text = "2";
393 |                 yield return MULTIPLIER_DELAY;
394 | 
395 |                 multiplierCircles[0].color = multiplierConfig.Four.ColorWithAlpha(0.25f);
396 |                 multiplierCircles[1].color = multiplierConfig.Four;
397 |                 multiplierText.text = "4";
398 |                 yield return MULTIPLIER_DELAY;
399 | 
400 |                 previewCoroOn8x = true;
401 |                 multiplierText.text = "8";
402 |                 multiplierCircles[1].fillAmount = 0;
403 |                 if (!multiplierConfig.RainbowOnMaxMultiplier)
404 |                     multiplierCircles[0].color = multiplierConfig.Eight.ColorWithAlpha(0.25f);
405 |                 yield return MULTIPLIER_DELAY;
406 |             }
407 | 
408 |             else
409 |             {
410 |                 multiplierText.text = "1";
411 |                 tweeningManager.RestartTween(oneTwoFloatTween, this);
412 |                 yield return MULTIPLIER_DELAY;
413 | 
414 |                 multiplierText.text = "2";
415 |                 tweeningManager.RestartTween(twoFourFloatTween, this);
416 |                 yield return MULTIPLIER_DELAY;
417 | 
418 |                 multiplierText.text = "4";
419 |                 tweeningManager.RestartTween(fourEightFloatTween, this);
420 |                 yield return MULTIPLIER_DELAY;
421 | 
422 | 
423 |                 previewCoroOn8x = true;
424 |                 multiplierText.text = "8";
425 |                 multiplierCircles[1].color = Color.clear;
426 |                 multiplierCircles[1].fillAmount = 0;
427 |                 yield return MULTIPLIER_DELAY;
428 |             }
429 | 
430 |             yield return MultiplierPreviewCoroutine();
431 |         }
432 | 
433 |         private void UpdateEnergyBar(float fillAmount)
434 |         {
435 |             this.fillAmount = fillAmount;
436 |             energyBar.rectTransform.anchorMax = new Vector2(fillAmount, 1);
437 | 
438 |             if (fillAmount == 0.5f) energyBar.color = energyConfig.Mid;
439 | 
440 |             else if (fillAmount > 0.5f && fillAmount < 1) energyBar.color = HSBColor.Lerp(
441 |                 HSBColor.FromColor(energyConfig.Mid),
442 |                 HSBColor.FromColor(energyConfig.High),
443 |                 (fillAmount - 0.5f) * 2).ToColor();
444 | 
445 |             else if (fillAmount < 0.5f) energyBar.color = HSBColor.Lerp(
446 |                 HSBColor.FromColor(energyConfig.Low),
447 |                 HSBColor.FromColor(energyConfig.Mid),
448 |                 fillAmount * 2).ToColor();
449 |         }
450 | 
451 |         private void UpdateComboPanel()
452 |         {
453 |             if (comboConfig.UseGradient)
454 |             {
455 |                 comboLines[0].gradient = true;
456 |                 comboLines[0].color = Color.white;
457 |                 comboLines[1].gradient = true;
458 |                 comboLines[1].color = Color.white;
459 | 
460 |                 comboLines[0].color0 = comboConfig.TopLeft;
461 |                 comboLines[0].color1 = comboConfig.TopRight;
462 | 
463 |                 if (comboConfig.MirrorBottomLine)
464 |                 {
465 |                     comboLines[1].color0 = comboConfig.TopRight;
466 |                     comboLines[1].color1 = comboConfig.TopLeft;
467 |                 }
468 |                 else
469 |                 {
470 |                     comboLines[1].color0 = comboConfig.BottomLeft;
471 |                     comboLines[1].color1 = comboConfig.BottomRight;
472 |                 }
473 |             }
474 |             else
475 |             {
476 |                 comboLines[0].gradient = false;
477 |                 comboLines[1].gradient = false;
478 | 
479 |                 comboLines[0].color = comboConfig.TopLine;
480 |                 comboLines[1].color = comboConfig.BottomLine;
481 |             }
482 | 
483 |             if (miscConfig.ItalicizeComboPanel)
484 |             {
485 |                 comboText.fontStyle = TMPro.FontStyles.Italic | TMPro.FontStyles.UpperCase;
486 |                 comboText.text = "COMBO";
487 |                 comboNumberText.fontStyle = TMPro.FontStyles.Italic;
488 |                 comboNumberText.transform.localPosition = new Vector3(-2.5f, 4);
489 |             }
490 |             else
491 |             {
492 |                 comboText.fontStyle = TMPro.FontStyles.UpperCase;
493 |                 comboNumberText.fontStyle = TMPro.FontStyles.UpperCase;
494 |                 comboNumberText.transform.localPosition = new Vector3(0, 4);
495 |             }
496 |         }
497 | 
498 |         private void UpdateProgressBar(float time)
499 |         {
500 |             progressPanelImages[1].color = progressConfig.BG.ColorWithAlpha(0.25f);
501 |             progressPanelImages[2].color = progressConfig.Handle;
502 | 
503 |             if (progressConfig.Mode == ProgressConfig.DisplayType.Fade)
504 |             {
505 |                 var x = (time - 0.5f) * 50;
506 |                 progressPanelImages[0].rectTransform.anchorMax = new Vector2(time, 1);
507 |                 progressPanelImages[2].transform.localPosition = new Vector3(x, 0, 0);
508 | 
509 |                 progressPanelImages[0].color = HSBColor.Lerp(
510 |                     HSBColor.FromColor(progressConfig.StartColor),
511 |                     HSBColor.FromColor(progressConfig.EndColor),
512 |                     time).ToColor();
513 |             }
514 | 
515 |             else
516 |             {
517 |                 progressPanelImages[0].rectTransform.anchorMax = new Vector2(0.5f, 1);
518 |                 progressPanelImages[2].transform.localPosition = Vector3.zero;
519 |                 progressPanelImages[0].color = progressConfig.Fill;
520 |             }
521 |         }
522 | 
523 |         private IEnumerator MultiplayerPositionPreviewCoroutine()
524 |         {
525 |             previewPositionIsFirst = false;
526 | 
527 |             positionPanel.positionText.text = "5";
528 |             positionPanel.positionText.color = positionConfig.Fifth;
529 |             positionPanel.playerCountText.color = positionConfig.UseStaticColorForStaticPanel ? positionConfig.StaticPanelColor : positionConfig.Fifth;
530 |             positionPanel.playerCountText.color = positionPanel.playerCountText.color.ColorWithAlpha(0.25f);
531 |             yield return POSITION_DELAY;
532 | 
533 |             positionText.text = "4";
534 |             positionText.color = positionConfig.Fourth;
535 |             playerCountText.color = positionConfig.UseStaticColorForStaticPanel ? positionConfig.StaticPanelColor : positionConfig.Fourth;
536 |             positionPanel.playerCountText.color = positionPanel.playerCountText.color.ColorWithAlpha(0.25f);
537 |             yield return POSITION_DELAY;
538 | 
539 |             positionText.text = "3";
540 |             positionText.color = positionConfig.Third;
541 |             playerCountText.color = positionConfig.UseStaticColorForStaticPanel ? positionConfig.StaticPanelColor : positionConfig.Third;
542 |             positionPanel.playerCountText.color = positionPanel.playerCountText.color.ColorWithAlpha(0.25f);
543 |             yield return POSITION_DELAY;
544 | 
545 |             positionText.text = "2";
546 |             positionText.color = positionConfig.Second;
547 |             playerCountText.color = positionConfig.UseStaticColorForStaticPanel ? positionConfig.StaticPanelColor : positionConfig.Second;
548 |             positionPanel.playerCountText.color = positionPanel.playerCountText.color.ColorWithAlpha(0.25f);
549 |             yield return POSITION_DELAY;
550 | 
551 |             positionText.text = "1";
552 |             positionText.color = positionConfig.First;
553 |             playerCountText.color = positionConfig.UseStaticColorForStaticPanel ? positionConfig.StaticPanelColor : positionConfig.First;
554 |             positionPanel.playerCountText.color = positionPanel.playerCountText.color.ColorWithAlpha(0.25f);
555 |             previewPositionIsFirst = true;
556 | 
557 |             if (!positionConfig.HideFirstPlaceAnimation)
558 |             {
559 |                 firstPlaceAnimationGO.SetActive(true);
560 |                 tweeningManager.RestartTween(positionPanelScaleTween, this);
561 |                 tweeningManager.RestartTween(positionPanelOpacityTween, this);
562 |             }
563 | 
564 |             yield return POSITION_DELAY;
565 |             firstPlaceAnimationGO.SetActive(false);
566 | 
567 |             yield return MultiplayerPositionPreviewCoroutine();
568 |         }
569 | 
570 |         private void UpdateImmediateRankPanel()
571 |         {
572 |             rankText.text = ConvertRankToText(rank);
573 | 
574 |             if (miscConfig.ItalicizeScore)
575 |             {
576 |                 scoreText.fontStyle = TMPro.FontStyles.Italic;
577 |                 scoreText.transform.localPosition = new Vector3(-1, 20);
578 |             }
579 |             else
580 |             {
581 |                 scoreText.fontStyle = TMPro.FontStyles.Normal;
582 |                 scoreText.transform.localPosition = new Vector3(0, 20);
583 |             }
584 | 
585 |             if (miscConfig.ItalicizeImmediateRank)
586 |             {
587 |                 percentText.fontStyle = TMPro.FontStyles.Italic;
588 |                 rankText.fontStyle = TMPro.FontStyles.Italic;
589 |                 rankText.transform.localPosition = new Vector3(-3, 0.5f);
590 |             }
591 |             else
592 |             {
593 |                 percentText.fontStyle = TMPro.FontStyles.Normal;
594 |                 rankText.fontStyle = TMPro.FontStyles.Normal;
595 |                 rankText.transform.localPosition = new Vector3(0, 0.5f);
596 |             }
597 | 
598 |             if (miscConfig.AllowRankColoring)
599 |                 rankText.color = ConvertRankToColor(rank);
600 |             else rankText.color = Color.white.ColorWithAlpha(0.5f);
601 |         }
602 | 
603 |         public void HandleRankLetterRequest(string rankString)
604 |         {
605 |             rank = rankString switch
606 |             {
607 |                 "SS" => Utilities.Utilities.RandomDecimal(90, 100, 2),
608 |                 "S" => Utilities.Utilities.RandomDecimal(80, 89.99, 2),
609 |                 "A" => Utilities.Utilities.RandomDecimal(65, 79.99, 2),
610 |                 "B" => Utilities.Utilities.RandomDecimal(50, 64.99, 2),
611 |                 "C" => Utilities.Utilities.RandomDecimal(35, 49.99, 2),
612 |                 "D" => Utilities.Utilities.RandomDecimal(20, 34.99, 2),
613 |                 _ => Utilities.Utilities.RandomDecimal(0, 19.99, 2)
614 |             };
615 | 
616 |             percentText.text = rank.ToString() + "%";
617 |             rankText.text = rankString;
618 |         }
619 | 
620 |         private string ConvertRankToText(decimal rank)
621 |         {
622 |             string result = rank switch
623 |             {
624 |                 > 90.00m => "SS",
625 |                 > 80.00m => "S",
626 |                 > 65.00m => "A",
627 |                 > 50.00m => "B",
628 |                 > 35.00m => "C",
629 |                 > 20.00m => "D",
630 |                 _ => "E"
631 |             };
632 | 
633 |             return result;
634 |         }
635 | 
636 |         private Color ConvertRankToColor(decimal rank)
637 |         {
638 |             Color result = rank switch
639 |             {
640 |                 > 90.00m => miscConfig.RankSSColor,
641 |                 > 80.00m => miscConfig.RankSColor,
642 |                 > 65.00m => miscConfig.RankAColor,
643 |                 > 50.00m => miscConfig.RankBColor,
644 |                 > 35.00m => miscConfig.RankCColor,
645 |                 > 20.00m => miscConfig.RankDColor,
646 |                 _ => miscConfig.RankEColor
647 |             };
648 | 
649 |             return result;
650 |         }
651 |     }
652 | }
653 | 


--------------------------------------------------------------------------------