using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mycopunk.UITweaks.MonoBehaviours;
using Mycopunk.UITweaks.Patches;
using Pigeon.Movement;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Mycopunk.UITweaks")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0")]
[assembly: AssemblyProduct("Mycopunk.UITweaks")]
[assembly: AssemblyTitle("Mycopunk.UITweaks")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace Mycopunk.UITweaks
{
public static class Logger
{
private static readonly ManualLogSource myLogs;
static Logger()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Expected O, but got Unknown
myLogs = new ManualLogSource("Cactus.UITweaks");
Logger.Sources.Add((ILogSource)(object)myLogs);
}
public static void Info(string message)
{
myLogs.LogInfo((object)message);
}
public static void Warn(string message)
{
myLogs.LogWarning((object)message);
}
public static void Error(string message)
{
myLogs.LogError((object)message);
}
public static void Fatal(string message)
{
myLogs.LogFatal((object)message);
}
public static void Debug(string message)
{
myLogs.LogDebug((object)message);
}
}
internal static class MyPluginInfo
{
internal const string PLUGIN_GUID = "Mycopunk.UITweaks";
internal const string PLUGIN_NAME = "Mycopunk.UITweaks";
internal const string PLUGIN_VERSION = "1.3.0";
}
[MycoMod(/*Could not decode attribute arguments.*/)]
[BepInPlugin("Mycopunk.UITweaks", "Mycopunk.UITweaks", "1.3.0")]
public class Plugin : BaseUnityPlugin
{
private ConfigEntry<bool> patchXP;
private ConfigEntry<bool> patchEndscreen;
private ConfigEntry<bool> patchHealth;
private ConfigEntry<bool> patchCooldowns;
private Harmony m_Harmony;
private void Awake()
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected O, but got Unknown
GetConfig();
m_Harmony = new Harmony("Mycopunk.UITweaks");
if (patchXP.Value)
{
m_Harmony.PatchAll(typeof(XP_Patches));
}
if (patchEndscreen.Value)
{
m_Harmony.PatchAll(typeof(EndScreen_Patches));
}
if (patchHealth.Value)
{
m_Harmony.PatchAll(typeof(HealthBar_Patches));
}
if (patchCooldowns.Value)
{
m_Harmony.PatchAll(typeof(Cooldown_Patches));
}
}
public void GetConfig()
{
patchXP = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "PatchXP", true, "Set false to disable numerical XP values");
patchEndscreen = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "PatchEndscreen", true, "Set false to disable end game stats");
patchHealth = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "PatchHealth", true, "Set false to disable numerical health values");
patchCooldowns = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "PatchCooldowns", true, "Set false to disable numerical cooldown values");
}
}
}
namespace Mycopunk.UITweaks.Patches
{
[HarmonyPatch]
internal class Cooldown_Patches
{
public static GameObject coolDownGO;
public static TextMeshProUGUI coolDownText;
public static Vector3 coolDownPosition = new Vector3(99.1806f, 64.116f, 0f);
public static Dictionary<string, TextMeshProUGUI> coolDownDict = new Dictionary<string, TextMeshProUGUI>();
public static Cooldown_CR cooldown_CR;
[HarmonyPatch("SelectCharacter")]
[HarmonyPatch(typeof(CharacterSelectWindow), new Type[] { typeof(Character) })]
[HarmonyPostfix]
internal static void CreateObject__Postfix(CharacterSelectWindow __instance)
{
if (Object.op_Implicit((Object)(object)coolDownGO))
{
foreach (TextMeshProUGUI value in coolDownDict.Values)
{
Object.Destroy((Object)(object)((Component)value).gameObject);
}
}
if (!Object.op_Implicit((Object)(object)cooldown_CR))
{
cooldown_CR = ((Component)Player.LocalPlayer.healthbar).gameObject.AddComponent<Cooldown_CR>();
}
coolDownDict.Clear();
cooldown_CR.MakeCooldowns();
}
[HarmonyPatch(typeof(JoinFriendsWindow), "QuitToMenu")]
[HarmonyPostfix]
internal static void DestroyGM__Postfix(JoinFriendsWindow __instance)
{
if (Object.op_Implicit((Object)(object)coolDownGO))
{
foreach (TextMeshProUGUI value in coolDownDict.Values)
{
Object.Destroy((Object)(object)((Component)value).gameObject);
}
}
coolDownDict.Clear();
Object.Destroy((Object)(object)cooldown_CR);
}
[HarmonyPatch(typeof(MatchmakingWindow), "JoinLobby")]
[HarmonyPostfix]
internal static void DestroyJoin__Postfix(MatchmakingWindow __instance)
{
if (Object.op_Implicit((Object)(object)coolDownGO))
{
foreach (TextMeshProUGUI value in coolDownDict.Values)
{
Object.Destroy((Object)(object)((Component)value).gameObject);
}
}
coolDownDict.Clear();
Object.Destroy((Object)(object)cooldown_CR);
}
[HarmonyPatch(typeof(AbilityRechargeUI), "OnCooldownChanged")]
[HarmonyPostfix]
internal static void GetCD__Postfix(AbilityRechargeUI __instance)
{
foreach (string key in coolDownDict.Keys)
{
if (key == ((Object)__instance.ability.AbilityIcon).name)
{
((TMP_Text)coolDownDict[key]).text = $"{__instance.prevCharge * 100f:F2}%";
break;
}
}
}
}
[HarmonyPatch]
internal class EndScreen_Patches
{
public static string playerName;
[HarmonyPatch(typeof(DropPod), "HasStats")]
[HarmonyPrefix]
internal static bool HasStats__Prefix(DropPod __instance, ref bool __result)
{
__result = true;
return false;
}
[HarmonyPatch(typeof(MissionRewardsWindow), "AfterClosed")]
[HarmonyPostfix]
internal static void SoloStats__Postfix(MissionRewardsWindow __instance)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
if ((int)__instance.missionState == 0 && GameManager.players.Count == 1)
{
GameManager.Instance.OpenPopupWindowFromPrefab((Window)(object)Global.Instance.MissionStatsWindow, false, true);
}
}
[HarmonyPatch(typeof(MissionStat), "Setup")]
[HarmonyPrefix]
internal static void StatSetup__Prefix(MissionStat __instance, Player player, ref MissionPlayerData data)
{
playerName = ((Object)player).name;
}
[HarmonyPatch(typeof(MissionPlayerData), "GetStatText")]
[HarmonyPostfix]
internal static void GetEndStats__Postfix(MissionPlayerData __instance, out string title, out string description)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
float damageDealt = __instance.damageDealt;
int enemiesKilled = __instance.enemiesKilled;
float appliedStatusEffect = __instance.appliedStatusEffect;
float damageTaken = __instance.damageTaken;
float num = __instance.deaths;
float friendlyFireDamageDealt = __instance.friendlyFireDamageDealt;
float healingDealt = __instance.healingDealt;
int playersRepaired = __instance.playersRepaired;
float num2 = __instance.targetsKilled;
float timeInAir = __instance.timeInAir;
float num3 = __instance.timesCorroded;
float num4 = __instance.timesIgnited;
float timeSliding = __instance.timeSliding;
int resourcesCollected = __instance.resourcesCollected;
int timesOverloaded = __instance.timesOverloaded;
int upgradesCollected = __instance.upgradesCollected;
title = string.Empty;
description = $"Damage Dealt: {damageDealt}\n" + $"Enemies Killed: {enemiesKilled}\n" + $"Elemental Stacks: {appliedStatusEffect}";
Logger.Info("\n________________________________________________________________Player: " + playerName + "\n" + $"Damage Dealt: {damageDealt}\n" + $"Enemies Killed: {enemiesKilled}\n" + $"Elemental Stacks: {appliedStatusEffect}\n" + $"Damage Taken: {damageTaken}\n" + $"Deaths: {num}\n" + $"Friendly Fire Dealt: {friendlyFireDamageDealt}\n" + $"Healing Dealt: {healingDealt}\n" + $"Players Repaired: {playersRepaired}\n" + $"Targets Killed: {num2}\n" + $"Time In Air: {timeInAir}\n" + $"Times Corroded: {num3}\n" + $"Times Ignited: {num4}\n" + $"Times Overloaded: {timesOverloaded}\n" + $"Time Sliding: {timeSliding}\n" + $"Resources Collected: {resourcesCollected}\n" + $"Upgrades Collected: {upgradesCollected}");
}
}
[HarmonyPatch]
internal class HealthBar_Patches
{
public static Health_MB health_MB;
public static TextMeshProUGUI healthText;
public static GameObject healthTextGO;
public static Player player;
[HarmonyPatch(typeof(Player), "Start")]
[HarmonyPrefix]
internal static void GetPlayer__Prefix(Player __instance)
{
if (((NetworkBehaviour)__instance).IsLocalPlayer)
{
player = __instance;
}
}
[HarmonyPatch("SelectCharacter")]
[HarmonyPatch(typeof(CharacterSelectWindow), new Type[] { typeof(Character) })]
[HarmonyPostfix]
internal static void CreateObject__Postfix(CharacterSelectWindow __instance)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Expected O, but got Unknown
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
if (((NetworkBehaviour)player).IsLocalPlayer && !Object.op_Implicit((Object)(object)healthTextGO))
{
Logger.Debug("Creating Health Text Object ------------------------------------------------------");
healthTextGO = new GameObject("HealthText");
health_MB = healthTextGO.AddComponent<Health_MB>();
healthTextGO.TryGetComponent<TextMeshProUGUI>(ref healthText);
healthTextGO.transform.rotation = Quaternion.Euler(0f, 0f, 0f);
healthTextGO.transform.localRotation = Quaternion.Euler(0f, 0f, 0f);
healthTextGO.layer = 5;
health_MB.health = player.health;
healthTextGO.SetActive(true);
}
}
[HarmonyPatch(typeof(Player), "OnSyncedHealthChanged")]
[HarmonyPostfix]
internal static void OwnerHealthChange__Postfix(Player __instance)
{
if (((NetworkBehaviour)__instance).IsLocalPlayer && (Object)(object)healthText != (Object)null)
{
health_MB.health = __instance.health;
health_MB.healthPercent = health_MB.health / __instance.maxHealth;
health_MB.isDamaged = true;
}
}
}
[HarmonyPatch]
internal class XP_Patches
{
[HarmonyPatch(typeof(GearData), "GetLevelString")]
[HarmonyPostfix]
internal static void NumericalXP__Postfix(GearData __instance, ref string __result)
{
if (__instance.level >= __instance.MaxLevel)
{
__result = "∞";
}
int num = __instance.NextLevelXPCost - __instance.levelXP;
__result = $"{TextBlocks.GetNumberString(__instance.level)} (NEXT LEVEL: {num})";
}
}
}
namespace Mycopunk.UITweaks.MonoBehaviours
{
internal class Cooldown_CR : MonoBehaviour
{
public void MakeCooldowns()
{
((MonoBehaviour)this).StartCoroutine(CooldownCoroutine());
}
public IEnumerator CooldownCoroutine()
{
if (!((NetworkBehaviour)Player.LocalPlayer).IsLocalPlayer)
{
yield break;
}
yield return (object)new WaitForSeconds(2f);
foreach (AbilityRechargeUI rechargeUI in PlayerLook.Instance.rechargeUIs)
{
Logger.Warn("Creating Cooldown Objects --------------------------------------------");
Logger.Warn("Cooldown Setup: " + ((Object)rechargeUI.ability.AbilityIcon).name);
Cooldown_Patches.coolDownGO = new GameObject("CoolDownText");
Cooldown_Patches.coolDownText = Cooldown_Patches.coolDownGO.AddComponent<TextMeshProUGUI>();
((TMP_Text)Cooldown_Patches.coolDownText).fontSize = 16f;
((TMP_Text)Cooldown_Patches.coolDownText).text = "100.00%";
((TMP_Text)Cooldown_Patches.coolDownText).outlineWidth = 0.01f;
((TMP_Text)Cooldown_Patches.coolDownText).outlineColor = Color32.op_Implicit(Color.black);
Cooldown_Patches.coolDownGO.transform.SetParent(((Component)rechargeUI).transform);
Cooldown_Patches.coolDownGO.transform.rotation = Quaternion.Euler(0f, 0f, 0f);
Cooldown_Patches.coolDownGO.transform.localRotation = Quaternion.Euler(0f, 0f, 0f);
Cooldown_Patches.coolDownGO.transform.localPosition = Cooldown_Patches.coolDownPosition;
Cooldown_Patches.coolDownGO.transform.localScale = Vector3.one;
Cooldown_Patches.coolDownGO.layer = 5;
Cooldown_Patches.coolDownGO.SetActive(true);
Cooldown_Patches.coolDownDict.Add(((Object)rechargeUI.ability.AbilityIcon).name, Cooldown_Patches.coolDownText);
}
}
}
internal class Health_MB : MonoBehaviour
{
public static TextMeshProUGUI text;
public float health;
public float healthPercent;
public Color healthColor = Color.white;
public static Vector3 position = new Vector3(8.0934f, -41.4283f, 0f);
public static Vector3 position2 = new Vector3(128.0934f, -41.4283f, 0f);
public static Quaternion rotation = Quaternion.Euler(0f, 0f, 0f);
public static Vector3 scale = new Vector3(1f, 1f, 1f);
public bool isDamaged;
public void Awake()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
GameObject val = GameObject.Find("Healthbar");
text = ((Component)this).gameObject.AddComponent<TextMeshProUGUI>();
((TMP_Text)text).fontSize = 24f;
((Graphic)text).color = Color.white;
((TMP_Text)text).rectTransform.sizeDelta = new Vector2(250f, 50f);
((Component)this).gameObject.transform.SetParent(val.transform);
((Component)this).gameObject.transform.rotation = rotation;
if (((NetworkBehaviour)HealthBar_Patches.player).IsLocalPlayer)
{
((Component)this).gameObject.transform.localPosition = position;
}
else
{
((Component)this).gameObject.transform.localPosition = position2;
}
((Component)this).gameObject.transform.localScale = scale;
((Component)text).gameObject.layer = 5;
((TMP_Text)text).text = $"100% ({Math.Round(health, 2):F2})";
((MaskableGraphic)text).maskable = false;
}
public void Update()
{
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
if (isDamaged)
{
((TMP_Text)text).text = $"{healthPercent * 100f:F2}% ({Math.Round(health, 2):F2})";
float num = Player.CalculateWeightedHealth(healthPercent);
((Graphic)text).color = Global.Instance.HealthGradient.Evaluate(num);
isDamaged = false;
}
if (((Component)Player.LocalPlayer.overhealthbar).gameObject.activeSelf)
{
((Graphic)text).color = Player.LocalPlayer.overhealthbar.color;
}
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
