using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BetterHeals.Config;
using BetterHeals.Patches;
using HarmonyLib;
using Photon.Pun;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("TeamHeals")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("TeamHeals")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("8b363090-6f7a-451a-92a9-ed78838c26e0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BetterHeals
{
[BepInPlugin("MrBytesized.REPO.BetterHeals", "Better Heals", "2.1.0")]
public class TeamHealsPlugin : BaseUnityPlugin
{
private const string mod_guid = "MrBytesized.REPO.BetterHeals";
private const string mod_name = "Better Heals";
private const string mod_version = "2.1.0";
private readonly Harmony harmony = new Harmony("MrBytesized.REPO.BetterHeals");
private static TeamHealsPlugin instance;
internal static ManualLogSource Log;
internal static readonly FieldRef<ItemHealthPack, ItemToggle> item_toggle_ref = AccessTools.FieldRefAccess<ItemHealthPack, ItemToggle>("itemToggle");
internal static readonly FieldRef<ItemToggle, int> player_photon_id_ref = AccessTools.FieldRefAccess<ItemToggle, int>("playerTogglePhotonID");
internal static readonly FieldRef<PlayerHealth, int> health_ref = AccessTools.FieldRefAccess<PlayerHealth, int>("health");
internal static readonly FieldRef<PlayerHealth, int> max_health_ref = AccessTools.FieldRefAccess<PlayerHealth, int>("maxHealth");
private (ConfigEntry<bool> configEntry, Action enablePatch, Action disablePatch, string description)[] patchArray;
private void Awake()
{
if ((Object)(object)instance == (Object)null)
{
instance = this;
}
Configuration.Init(((BaseUnityPlugin)this).Config);
Log = Logger.CreateLogSource("MrBytesized.REPO.BetterHeals");
Log.LogInfo((object)"Team Heals mod has been activated");
harmony.PatchAll(typeof(TeamHealsPlugin));
harmony.PatchAll(typeof(PunManagerPatch));
Log.LogInfo((object)"PunManager patch applied.");
harmony.PatchAll(typeof(ItemHealthPackPatch));
Log.LogInfo((object)"ItemHealthPack patch applied.");
patchArray = new(ConfigEntry<bool>, Action, Action, string)[5]
{
(Configuration.EnableCustomReviveHealthPatch, delegate
{
harmony.PatchAll(typeof(PlayerReviveHealthPatch));
}, delegate
{
harmony.Unpatch((MethodBase)AccessTools.Method(typeof(PlayerAvatar), "ReviveRPC", (Type[])null, (Type[])null), AccessTools.Method(typeof(PlayerReviveHealthPatch), "ReviveRPC_Postfix", (Type[])null, (Type[])null));
}, "Custom Revive Health"),
(Configuration.EnableExtractionHealPatch, delegate
{
harmony.PatchAll(typeof(ExtractionPointHealPatch));
}, delegate
{
harmony.Unpatch((MethodBase)AccessTools.Method(typeof(ExtractionPoint), "StateSet", (Type[])null, (Type[])null), AccessTools.Method(typeof(ExtractionPointHealPatch), "StateSet_Postfix", (Type[])null, (Type[])null));
}, "Extraction Heal"),
(Configuration.EnableHealthRegenPatch, delegate
{
harmony.PatchAll(typeof(HealthRegenPatch));
}, delegate
{
harmony.Unpatch((MethodBase)AccessTools.Method(typeof(LevelGenerator), "GenerateDone", (Type[])null, (Type[])null), AccessTools.Method(typeof(HealthRegenPatch), "Start_Postfix", (Type[])null, (Type[])null));
}, "Health Regeneration"),
(Configuration.EnableFullHealthAtStartPatch, delegate
{
harmony.PatchAll(typeof(FullHealthAtStartPatch));
}, delegate
{
harmony.Unpatch((MethodBase)AccessTools.Method(typeof(LevelGenerator), "GenerateDone", (Type[])null, (Type[])null), AccessTools.Method(typeof(FullHealthAtStartPatch), "GenerateDone_Postfix", (Type[])null, (Type[])null));
}, "Full Health At Start"),
(Configuration.EnableTeamHealthPackPatch, delegate
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Expected O, but got Unknown
harmony.Patch((MethodBase)AccessTools.Method(typeof(ItemHealthPack), "UsedRPC", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(ItemHealthPackPatch), "TeamHealthPackSync", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}, delegate
{
harmony.Unpatch((MethodBase)AccessTools.Method(typeof(ItemHealthPack), "UsedRPC", (Type[])null, (Type[])null), AccessTools.Method(typeof(ItemHealthPackPatch), "TeamHealthPackSync", (Type[])null, (Type[])null));
}, "Health Pack Team Healing")
};
(ConfigEntry<bool>, Action, Action, string)[] array = patchArray;
for (int i = 0; i < array.Length; i++)
{
var (configEntry, enablePatch, disablePatch, description) = array[i];
UpdatePatchFromConfig(configEntry, enablePatch, disablePatch, description);
configEntry.SettingChanged += delegate
{
UpdatePatchFromConfig(configEntry, enablePatch, disablePatch, description);
};
}
}
private void UpdatePatchFromConfig(ConfigEntry<bool> configEntry, Action enablePatch, Action disablePatch, string description)
{
if (configEntry.Value)
{
enablePatch();
Log.LogInfo((object)(description + " patch enabled."));
}
else
{
disablePatch();
Log.LogInfo((object)(description + " patch disabled."));
}
}
}
}
namespace BetterHeals.Patches
{
internal static class ExtractionPointHealPatch
{
[HarmonyPostfix]
[HarmonyPatch(typeof(ExtractionPoint), "StateSet")]
private static void StateSet_Postfix(ExtractionPoint __instance, State newState)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Invalid comparison between Unknown and I4
if ((int)newState != 7 || SemiFunc.RunIsShop() || !PhotonNetwork.IsMasterClient)
{
return;
}
int num = Configuration.ExtractionHealAmount.Value;
foreach (PlayerAvatar player in GameDirector.instance.PlayerList)
{
if ((Object)(object)player != (Object)null && (Object)(object)player.playerHealth != (Object)null)
{
if (Configuration.EnableFullReviveHealth.Value)
{
int num2 = TeamHealsPlugin.health_ref.Invoke(player.playerHealth);
num = TeamHealsPlugin.max_health_ref.Invoke(player.playerHealth) - num2;
}
FieldInfo field = typeof(PlayerHealth).GetField("health", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
int num3 = ((!(field != null)) ? 1 : ((int)field.GetValue(player.playerHealth)));
FieldInfo field2 = typeof(PlayerAvatar).GetField("isDisabled", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
bool flag = field2 != null && (bool)field2.GetValue(player);
if (num3 > 0 && !flag)
{
player.playerHealth.HealOther(num, true);
}
}
}
TeamHealsPlugin.Log.LogInfo((object)$"All alive players healed to {num} after extraction.");
}
}
internal static class FullHealthAtStartPatch
{
[HarmonyPatch(typeof(LevelGenerator), "GenerateDone")]
[HarmonyPostfix]
private static void GenerateDone_Postfix()
{
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
RunManager instance = RunManager.instance;
if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.levelCurrent == (Object)(object)instance.levelMainMenu) && !((Object)(object)instance.levelCurrent == (Object)(object)instance.levelLobbyMenu) && !((Object)(object)instance.levelCurrent == (Object)(object)instance.levelLobby) && !((Object)(object)instance.levelCurrent == (Object)(object)instance.levelShop) && !((Object)(object)instance.levelCurrent == (Object)(object)instance.levelRecording) && !((Object)(object)instance.levelCurrent == (Object)(object)instance.levelSplashScreen) && PhotonNetwork.IsMasterClient)
{
new GameObject("HealCoroutineRunner").AddComponent<HealRunner>();
}
}
}
public class HealRunner : MonoBehaviour
{
[CompilerGenerated]
private sealed class <HealAllPlayersToFull>d__1 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public HealRunner <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <HealAllPlayersToFull>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Expected O, but got Unknown
int num = <>1__state;
HealRunner healRunner = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
case 1:
{
<>1__state = -1;
TeamHealsPlugin.Log.LogInfo((object)"Proceeding to heal all players to full health.");
if ((Object)(object)GameDirector.instance == (Object)null || GameDirector.instance.PlayerList == null)
{
TeamHealsPlugin.Log.LogWarning((object)"GameDirector.instance or PlayerList is null.");
Object.Destroy((Object)(object)((Component)healRunner).gameObject);
return false;
}
List<PlayerAvatar> playerList = GameDirector.instance.PlayerList;
FieldInfo field = typeof(PlayerHealth).GetField("health", BindingFlags.Instance | BindingFlags.NonPublic);
FieldInfo field2 = typeof(PlayerHealth).GetField("maxHealth", BindingFlags.Instance | BindingFlags.NonPublic);
if (field == null || field2 == null)
{
TeamHealsPlugin.Log.LogError((object)"Could not find health or maxHealth fields via reflection.");
Object.Destroy((Object)(object)((Component)healRunner).gameObject);
return false;
}
foreach (PlayerAvatar item in playerList)
{
if ((Object)(object)item != (Object)null && (Object)(object)item.playerHealth != (Object)null)
{
int num2 = (int)field.GetValue(item.playerHealth);
int num3 = (int)field2.GetValue(item.playerHealth);
int num4 = num3 - num2;
TeamHealsPlugin.Log.LogInfo((object)$"Player {item.photonView.Owner.NickName} current health: {num2}, max health: {num3}, calculated heal amount: {num4}");
if (num4 > 0)
{
item.playerHealth.HealOther(num4, true);
TeamHealsPlugin.Log.LogInfo((object)$"Healed player {item.photonView.Owner.NickName} to full health: {num3}");
}
}
}
Object.Destroy((Object)(object)((Component)healRunner).gameObject);
return false;
}
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private void Awake()
{
((MonoBehaviour)this).StartCoroutine(HealAllPlayersToFull());
}
[IteratorStateMachine(typeof(<HealAllPlayersToFull>d__1))]
private IEnumerator HealAllPlayersToFull()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <HealAllPlayersToFull>d__1(0)
{
<>4__this = this
};
}
}
public class RegenUpdater : MonoBehaviour
{
private float updateThrottle;
public void Init()
{
}
private void Update()
{
RunManager instance = RunManager.instance;
if ((Object)(object)instance == (Object)null || (Object)(object)instance.levelCurrent == (Object)(object)instance.levelMainMenu || (Object)(object)instance.levelCurrent == (Object)(object)instance.levelLobbyMenu || (Object)(object)instance.levelCurrent == (Object)(object)instance.levelLobby || (Object)(object)instance.levelCurrent == (Object)(object)instance.levelShop || (Object)(object)instance.levelCurrent == (Object)(object)instance.levelRecording || (Object)(object)instance.levelCurrent == (Object)(object)instance.levelSplashScreen || !Configuration.EnableHealthRegenPatch.Value)
{
return;
}
updateThrottle += Time.deltaTime;
if (updateThrottle < (float)Configuration.CustomRegenIntervalAmount.Value)
{
return;
}
updateThrottle = 0f;
int value = Configuration.HealthRegenAmount.Value;
foreach (PlayerAvatar player in GameDirector.instance.PlayerList)
{
if ((Object)(object)player.playerHealth != (Object)null && TeamHealsPlugin.health_ref.Invoke(player.playerHealth) > 0)
{
player.playerHealth.HealOther(value, false);
}
}
TeamHealsPlugin.Log.LogInfo((object)$"Players healed by regeneration: {value}");
}
}
internal static class HealthRegenPatch
{
[HarmonyPatch(typeof(LevelGenerator), "GenerateDone")]
[HarmonyPostfix]
private static void Start_Postfix(PlayerController __instance)
{
RunManager instance = RunManager.instance;
if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.levelCurrent == (Object)(object)instance.levelMainMenu) && !((Object)(object)instance.levelCurrent == (Object)(object)instance.levelLobbyMenu) && !((Object)(object)instance.levelCurrent == (Object)(object)instance.levelLobby) && !((Object)(object)instance.levelCurrent == (Object)(object)instance.levelShop) && !((Object)(object)instance.levelCurrent == (Object)(object)instance.levelRecording) && !((Object)(object)instance.levelCurrent == (Object)(object)instance.levelSplashScreen) && (!GameManager.Multiplayer() || PhotonNetwork.IsMasterClient) && (Object)(object)__instance != (Object)null)
{
GameObject gameObject = ((Component)__instance).gameObject;
if ((Object)(object)gameObject.GetComponent<RegenUpdater>() == (Object)null)
{
gameObject.AddComponent<RegenUpdater>().Init();
TeamHealsPlugin.Log.LogInfo((object)("RegenUpdater attached to " + ((Object)__instance).name + "."));
}
}
}
}
internal static class ItemHealthPackPatch
{
[HarmonyPostfix]
[HarmonyPatch(typeof(ItemHealthPack), "Start")]
private static void OverrideHealAmount(ItemHealthPack __instance)
{
float num = (float)Math.Round(Configuration.HealAmountMultiplier.Value, 4);
if (num == 1f)
{
TeamHealsPlugin.Log.LogInfo((object)"Heal amount multiplier is 1. No changes made to health pack heal amount.");
}
else
{
__instance.healAmount = (int)Math.Ceiling((float)__instance.healAmount * num);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(ItemAttributes), "Start")]
private static void OverrideHealthPackName(ItemAttributes __instance)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Invalid comparison between Unknown and I4
if (!((Object)(object)__instance.item != (Object)null) || (int)__instance.item.itemType != 8)
{
return;
}
ItemHealthPack component = ((Component)__instance).GetComponent<ItemHealthPack>();
if ((Object)(object)component != (Object)null)
{
int healAmount = component.healAmount;
FieldInfo field = typeof(ItemAttributes).GetField("itemName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
string text = (string)field.GetValue(__instance);
if (!string.IsNullOrEmpty(text))
{
string text2 = Regex.Replace(text, "\\(\\d+\\)", $"({healAmount})");
field.SetValue(__instance, text2);
TeamHealsPlugin.Log.LogInfo((object)("Health pack name changed from '" + text + "' to '" + text2 + "'"));
}
else
{
TeamHealsPlugin.Log.LogWarning((object)"itemName value is null or empty in ItemAttributes.Start postfix.");
}
}
else
{
TeamHealsPlugin.Log.LogWarning((object)"itemName field not found in ItemAttributes.");
}
}
else
{
TeamHealsPlugin.Log.LogWarning((object)"ItemHealthPack component not found on ItemAttributes.");
}
}
private static void TeamHealthPackSync(ItemHealthPack __instance)
{
ItemToggle val = TeamHealsPlugin.item_toggle_ref.Invoke(__instance);
PlayerAvatar val2 = SemiFunc.PlayerAvatarGetFromPhotonID(TeamHealsPlugin.player_photon_id_ref.Invoke(val));
List<PlayerAvatar> list = SemiFunc.PlayerGetAll();
foreach (PlayerAvatar item in list)
{
if (item.photonView.ViewID != val2.photonView.ViewID)
{
if (Configuration.EnableEqualSplitTeamHealth.Value)
{
item.playerHealth.HealOther(__instance.healAmount / list.Count, true);
}
else
{
item.playerHealth.HealOther(__instance.healAmount, true);
}
TeamHealsPlugin.Log.LogInfo((object)($"Healed player {item.photonView.ViewID} for {__instance.healAmount} HP " + $"(used by {val2.photonView.ViewID})"));
}
}
TeamHealsPlugin.Log.LogInfo((object)$"Health pack used by player {val2.photonView.ViewID} healed all teammates");
}
}
internal static class PlayerReviveHealthPatch
{
[HarmonyPatch(typeof(PlayerAvatar), "ReviveRPC")]
[HarmonyPostfix]
private static void ReviveRPC_Postfix(PlayerAvatar __instance)
{
int num = Configuration.CustomReviveHealthAmount.Value - 1;
if (__instance.photonView.IsMine)
{
if (Configuration.EnableFullReviveHealth.Value)
{
int num2 = TeamHealsPlugin.health_ref.Invoke(__instance.playerHealth);
num = TeamHealsPlugin.max_health_ref.Invoke(__instance.playerHealth) - num2;
}
__instance.playerHealth.HealOther(num, true);
TeamHealsPlugin.Log.LogInfo((object)$"Player revived with custom health: {num}");
}
}
}
[HarmonyPatch(typeof(PunManager), "ShopPopulateItemVolumes")]
internal class PunManagerPatch
{
private static readonly FieldRef<PunManager, ShopManager> shop_manager_ref = AccessTools.FieldRefAccess<PunManager, ShopManager>("shopManager");
public static bool Prefix(PunManager __instance)
{
List<Item> list = new HashSet<Item>(shop_manager_ref.Invoke(__instance).potentialItemHealthPacks).Distinct().ToList();
for (int i = 0; i < list.Count; i++)
{
string itemName = Regex.Replace(list[i].itemName, "\\d+", delegate(Match match)
{
int num = int.Parse(match.Value);
return ((int)Math.Ceiling((float)num * Configuration.HealAmountMultiplier.Value)).ToString();
});
list[i].itemName = itemName;
}
return true;
}
}
}
namespace BetterHeals.Config
{
internal class Configuration
{
public static ConfigEntry<bool> EnableFullHealthAtStartPatch;
public static ConfigEntry<bool> EnableTeamHealthPackPatch;
public static ConfigEntry<bool> EnableEqualSplitTeamHealth;
public static ConfigEntry<bool> EnableHealthRegenPatch;
public static ConfigEntry<int> HealthRegenAmount;
public static ConfigEntry<int> CustomRegenIntervalAmount;
public static ConfigEntry<float> HealAmountMultiplier;
public static ConfigEntry<bool> EnableCustomReviveHealthPatch;
public static ConfigEntry<int> CustomReviveHealthAmount;
public static ConfigEntry<bool> EnableFullReviveHealth;
public static ConfigEntry<bool> EnableExtractionHealPatch;
public static ConfigEntry<bool> EnableExtractionFullHeal;
public static ConfigEntry<int> ExtractionHealAmount;
public static void Init(ConfigFile config)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Expected O, but got Unknown
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Expected O, but got Unknown
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_012c: Expected O, but got Unknown
//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
//IL_01c6: Expected O, but got Unknown
HealAmountMultiplier = config.Bind<float>("General Health Settings", "HealthPackAmountMultiplier", 1f, new ConfigDescription("Multiplier applied to the health pack healing", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()));
EnableFullHealthAtStartPatch = config.Bind<bool>("General Health Settings", "EnableFullHealthAtStart", false, "If enabled, players will start the match with full health");
EnableHealthRegenPatch = config.Bind<bool>("General Health Settings", "EnableHealthRegen", false, "If enabled, players will slowly regenerate health over time");
HealthRegenAmount = config.Bind<int>("General Health Settings", "HealthRegenAmount", 10, new ConfigDescription("The amount of health players will regenerate each interval if the Health Regeneration patch is enabled", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20), Array.Empty<object>()));
CustomRegenIntervalAmount = config.Bind<int>("General Health Settings", "CustomRegenIntervalAmount", 60, new ConfigDescription("The interval in seconds at which players will regenerate health if the Health Regeneration patch is enabled", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 120), Array.Empty<object>()));
EnableExtractionHealPatch = config.Bind<bool>("General Health Settings", "EnableExtractionHeal", true, "Enable the patch that heals alive players after extraction is completed");
EnableExtractionFullHeal = config.Bind<bool>("General Health Settings", "ExtractionFullHeal", false, "If enabled, players will be healed to full health upon extraction regardless of the ExtractionHealAmount setting");
ExtractionHealAmount = config.Bind<int>("General Health Settings", "ExtractionHealAmount", 20, new ConfigDescription("The health that alive players receive after extraction is completed", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 200), Array.Empty<object>()));
EnableTeamHealthPackPatch = config.Bind<bool>("Team Health Settings", "EnableTeamHealthPack", true, "Enable the patch that allows health packs to heal all teammates");
EnableEqualSplitTeamHealth = config.Bind<bool>("Team Health Settings", "EnableEqualSplitTeamHealth", false, "If enabled, health packs will split their healing amount equally among all teammates");
EnableCustomReviveHealthPatch = config.Bind<bool>("Team Health Settings", "EnableCustomReviveHealth", true, "Enable the patch that sets a custom value to the health received when a player is revived");
EnableFullReviveHealth = config.Bind<bool>("Team Health Settings", "FullReviveHealth", false, "If enabled, players will be revived with full health regardless of the CustomReviveHealthAmount setting");
CustomReviveHealthAmount = config.Bind<int>("Team Health Settings", "CustomReviveHealthAmount", 20, new ConfigDescription("The health that a player receives upon revival", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
}
}
}
