using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using REPOLib;
using REPOLib.Modules;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("GoopUpgrades")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("GoopUpgrades")]
[assembly: AssemblyCopyright("Copyright © GoopSwagger 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("809fa50d-9398-446b-86a3-eaa45523ae0b")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.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]
[Microsoft.CodeAnalysis.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]
[Microsoft.CodeAnalysis.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 GoopUpgrades
{
[BepInPlugin("GoopSwagger.GoopUpgrades", "GoopUpgrades", "1.0.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class GoopUpgradesPlugin : BaseUnityPlugin
{
[HarmonyPatch(typeof(PlayerTumble))]
public static class Patch_PlayerTumble
{
[HarmonyPatch("HitEnemy")]
[HarmonyPostfix]
private static void HitEnemyPostfix(PlayerTumble __instance)
{
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
if (!SemiFunc.IsMasterClientOrSingleplayer() || instance.upgradeTumbleBlast == null)
{
return;
}
int level = instance.upgradeTumbleBlast.GetLevel(SemiFunc.PlayerGetSteamID(__instance.playerAvatar));
if (level > 0)
{
TumbleBlastExplosion(level, __instance.playerAvatar.playerAvatarVisuals.colorIndex, ((Component)__instance.playerAvatar).transform.position);
if (GameManager.Multiplayer())
{
tumbleBlastExplosionEvent.RaiseEvent((object)new object[3]
{
level,
__instance.playerAvatar.playerAvatarVisuals.colorIndex,
((Component)__instance.playerAvatar).transform.position
}, NetworkingEvents.RaiseOthers, SendOptions.SendReliable);
}
}
}
}
[HarmonyPatch(typeof(SemiFunc))]
public static class Patch_SemiFunc
{
[HarmonyPatch("UIHideHealth")]
[HarmonyPostfix]
private static void UIHideHealthPostfix()
{
if ((Object)(object)ShieldUI.instance != (Object)null)
{
((SemiUI)ShieldUI.instance).Hide();
}
}
}
[HarmonyPatch(typeof(PlayerHealth))]
public static class Patch_PlayerHealth
{
[HarmonyPatch("Awake")]
[HarmonyPostfix]
public static void AwakePostfix(PlayerHealth __instance)
{
if ((Object)(object)((Component)__instance).GetComponent<PlayerShield>() == (Object)null)
{
((Component)__instance).gameObject.AddComponent<PlayerShield>();
}
}
[HarmonyPatch("Start")]
[HarmonyPostfix]
public static void StartPostfix(PlayerHealth __instance)
{
PlayerShield component = ((Component)__instance).GetComponent<PlayerShield>();
try
{
if ((Object)(object)component != (Object)null && instance.upgradeShield != null && (Object)(object)__instance.playerAvatar != (Object)null)
{
int num = (component.shieldMax = (component.shieldValue = 10 * instance.upgradeShield.GetLevel(SemiFunc.PlayerGetSteamID(__instance.playerAvatar))));
if (GameManager.Multiplayer())
{
__instance.photonView.RPC("UpdateShieldRPC", (RpcTarget)1, new object[3] { num, num, false });
}
}
}
catch (NullReferenceException)
{
}
}
[HarmonyPatch("Hurt")]
[HarmonyPrefix]
private static void HurtPrefix(PlayerHealth __instance, ref int damage, bool savingGrace, int enemyIndex = -1)
{
if (damage > 0)
{
PlayerShield component = ((Component)__instance).GetComponent<PlayerShield>();
component.regenerationTimer = 15f;
if (savingGrace && component.shieldValue > 0 && __instance.health > 0)
{
damage = component.DamageShield(__instance, damage);
}
}
}
[HarmonyPatch("HurtOther")]
[HarmonyPrefix]
private static void HurtOtherPrefix(PlayerHealth __instance, ref int damage, bool savingGrace, int enemyIndex = -1)
{
if (damage > 0)
{
((Component)__instance).GetComponent<PlayerShield>().regenerationTimer = 15f;
}
}
}
[HarmonyPatch(typeof(PlayerAvatar))]
public static class Patch_PlayerAvatar
{
[HarmonyPatch("Revive")]
[HarmonyPostfix]
public static void RevivePostfix(PlayerAvatar __instance)
{
PlayerShield component = ((Component)((Component)__instance).GetComponent<PlayerHealth>()).GetComponent<PlayerShield>();
if (instance.upgradeShield != null && (Object)(object)__instance != (Object)null)
{
component.regenerationTimer = 15f;
component.shieldValue = 0;
}
}
}
[HarmonyPatch(typeof(EnergyUI))]
public static class Patch_EnergyUI
{
private static bool offset;
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void StartPostfix(EnergyUI __instance)
{
offset = false;
}
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void UpdatePostfix(EnergyUI __instance)
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)PlayerController.instance == (Object)null) && PlayerController.instance.playerSteamID != null && instance.upgradeShield != null)
{
int level = instance.upgradeShield.GetLevel(PlayerController.instance.playerSteamID);
if (level > 0 && !offset)
{
((SemiUI)__instance).showPosition = ((SemiUI)__instance).showPosition + new Vector2(0f, -31f);
((SemiUI)__instance).hidePosition = ((SemiUI)__instance).hidePosition + new Vector2(0f, -31f);
offset = true;
}
else if (level <= 0 && offset)
{
((SemiUI)__instance).showPosition = ((SemiUI)__instance).showPosition - new Vector2(0f, -31f);
((SemiUI)__instance).hidePosition = ((SemiUI)__instance).hidePosition - new Vector2(0f, -31f);
offset = false;
}
}
}
}
[HarmonyPatch(typeof(OverchargeUI))]
public static class Patch_OverchargeUI
{
private static bool offset;
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void StartPostfix(OverchargeUI __instance)
{
offset = false;
}
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void UpdatePostfix(OverchargeUI __instance)
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)PlayerController.instance == (Object)null) && PlayerController.instance.playerSteamID != null && instance.upgradeShield != null)
{
int level = instance.upgradeShield.GetLevel(PlayerController.instance.playerSteamID);
if (level > 0 && !offset)
{
((SemiUI)__instance).showPosition = ((SemiUI)__instance).showPosition + new Vector2(0f, -31f);
((SemiUI)__instance).hidePosition = ((SemiUI)__instance).hidePosition + new Vector2(0f, -31f);
offset = true;
}
else if (level <= 0 && offset)
{
((SemiUI)__instance).showPosition = ((SemiUI)__instance).showPosition - new Vector2(0f, -31f);
((SemiUI)__instance).hidePosition = ((SemiUI)__instance).hidePosition - new Vector2(0f, -31f);
offset = false;
}
}
}
}
public static GoopUpgradesPlugin instance;
public const string PluginGUID = "GoopSwagger.GoopUpgrades";
public const string PluginName = "GoopUpgrades";
public const string PluginAuthor = "GoopSwagger";
public const string PluginVersion = "1.0.1";
public const float SHIELD_CHARGE_DELAY = 15f;
public const int SHIELD_PER_UPGRADE = 10;
public static bool ignoreShield;
public PlayerUpgrade upgradeTumbleBlast;
public PlayerUpgrade upgradeShield;
private AssetBundle assetBundle;
public static NetworkedEvent tumbleBlastExplosionEvent;
private void Awake()
{
//IL_0035: 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_007c: Expected O, but got Unknown
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Expected O, but got Unknown
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Expected O, but got Unknown
if ((Object)(object)instance == (Object)null)
{
instance = this;
}
((BaseUnityPlugin)this).Logger.LogInfo((object)"You've got yourself a winner here...");
new Harmony("GoopSwagger.GoopUpgrades").PatchAll();
string text = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "goopupgrades");
string text2 = "Upgrades";
ConfigEntry<bool> enableTumbleBlast = ((BaseUnityPlugin)instance).Config.Bind<bool>(new ConfigDefinition(text2, "Enable Tumble Blast"), true, (ConfigDescription)null);
ConfigEntry<bool> enableShield = ((BaseUnityPlugin)instance).Config.Bind<bool>(new ConfigDefinition(text2, "Enable Shield"), true, (ConfigDescription)null);
BundleLoader.LoadBundle(text, (Action<AssetBundle>)delegate(AssetBundle assetBundle)
{
instance.assetBundle = assetBundle;
if (enableTumbleBlast.Value)
{
GameObject upgradeItem = assetBundle.LoadAsset<GameObject>("Item Upgrade Player Tumble Blast");
upgradeTumbleBlast = Upgrade(upgradeItem, "Tumble Blast", "TumbleBlast", 2, null);
}
if (enableShield.Value)
{
GameObject upgradeItem2 = assetBundle.LoadAsset<GameObject>("Item Upgrade Player Shield");
upgradeShield = Upgrade(upgradeItem2, "Shield", "Shield", 1, delegate(PlayerAvatar player, int value)
{
((SemiUI)EnergyUI.instance).Update();
if (SemiFunc.IsMasterClientOrSingleplayer())
{
PlayerShield component = ((Component)player.playerHealth).GetComponent<PlayerShield>();
if ((Object)(object)component != (Object)null)
{
component.shieldValue += 10;
component.shieldMax += 10;
if (GameManager.Multiplayer())
{
player.playerHealth.photonView.RPC("UpdateShieldRPC", (RpcTarget)1, new object[3] { component.shieldValue, component.shieldMax, false });
}
}
}
});
}
}, false);
SceneManager.sceneLoaded += OnSceneLoaded;
tumbleBlastExplosionEvent = new NetworkedEvent("Tumble Blast Explosion", (Action<EventData>)HandleTumbleBlastExplosionEvent);
}
private static void HandleTumbleBlastExplosionEvent(EventData eventData)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
int level = (int)((object[])eventData.CustomData)[0];
int colorIndex = (int)((object[])eventData.CustomData)[1];
Vector3 position = (Vector3)((object[])eventData.CustomData)[2];
TumbleBlastExplosion(level, colorIndex, position);
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
InitializeShieldUI();
}
private void InitializeShieldUI()
{
if ((Object)(object)instance.assetBundle != (Object)null)
{
GameObject val = GameObject.Find("Game Hud");
if ((Object)(object)val != (Object)null && (Object)(object)val.transform.Find("Shield") == (Object)null)
{
Object.Instantiate<GameObject>(instance.assetBundle.LoadAsset<GameObject>("Shield")).transform.SetParent(val.transform, false);
}
}
}
private static PlayerUpgrade Upgrade(GameObject upgradeItem, string upgradeName, string upgradeId, int maxAmountInShop, Action<PlayerAvatar, int> upgradeAction)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
Item val = ScriptableObject.CreateInstance<Item>();
val.itemType = (itemType)3;
val.emojiIcon = (emojiIcon)11;
val.itemVolume = (itemVolume)6;
string text2 = (((Object)val).name = "Item Upgrade Player " + upgradeName);
string name = text2;
val.itemName = upgradeName + " Upgrade";
val.maxAmount = 10;
val.maxAmountInShop = maxAmountInShop;
val.maxPurchaseAmount = 0;
val.maxPurchase = val.maxPurchaseAmount > 0;
Value val2 = ScriptableObject.CreateInstance<Value>();
val2.valueMin = 2250f;
val2.valueMax = 3000f;
val.value = val2;
((Object)upgradeItem).name = name;
ItemAttributes component = upgradeItem.GetComponent<ItemAttributes>();
component.item = val;
REPOLibItemUpgrade component2 = upgradeItem.GetComponent<REPOLibItemUpgrade>();
AccessTools.Field(typeof(REPOLibItemUpgrade), "_upgradeId").SetValue(component2, upgradeId);
Items.RegisterItem(component);
return Upgrades.RegisterUpgrade(upgradeId, val, (Action<PlayerAvatar, int>)null, upgradeAction);
}
private static void TumbleBlastExplosion(int level, int colorIndex, Vector3 position)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Expected O, but got Unknown
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
ExplosionPreset obj = instance.assetBundle.LoadAsset<ExplosionPreset>("Tumble Blast Preset");
GameObject obj2 = Resources.Load<GameObject>("Effects/Part Prefab Explosion");
float num = 1.2f + (float)(level - 1) * 0.2f;
ParticlePrefabExplosion component = Object.Instantiate<GameObject>(obj2, position, Quaternion.identity).GetComponent<ParticlePrefabExplosion>();
component.forceMultiplier = 5f;
component.explosionSize = ((num > 1.8f) ? 1.8f : num);
component.explosionDamage = 20 + (level - 1) * 15;
component.explosionDamageEnemy = 40 + (level - 1) * 15;
component.lightColorOverTime = new Gradient();
ColorOverLifetimeModule colorOverLifetime = component.particleFire.colorOverLifetime;
((ColorOverLifetimeModule)(ref colorOverLifetime)).color = MinMaxGradient.op_Implicit(AssetManager.instance.playerColors[colorIndex]);
colorOverLifetime = component.particleSmoke.colorOverLifetime;
component.particleFire.Play();
component.particleSmoke.Play();
((Behaviour)component.light).enabled = true;
obj.explosionSoundSmall.Play(position, 1f, 1f, 1f, 1f);
}
}
public class PlayerShield : MonoBehaviour, IPunObservable
{
private PhotonView photonView;
public int shieldValue;
public int shieldMax;
public float regenerationTimer;
private PlayerHealth playerHealth => NestedComponentUtilities.GetParentComponent<PlayerHealth>(((Component)this).transform);
public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
{
throw new NotImplementedException();
}
private void Awake()
{
photonView = ((Component)this).GetComponentInParent<PhotonView>();
}
private void Update()
{
if (SemiFunc.IsMasterClientOrSingleplayer() && regenerationTimer > 0f)
{
regenerationTimer -= Time.deltaTime;
while (regenerationTimer <= 0f && shieldValue < shieldMax)
{
regenerationTimer += 1.2f;
shieldValue++;
}
if (GameManager.Multiplayer())
{
photonView.RPC("UpdateShieldRPC", (RpcTarget)1, new object[3] { shieldValue, shieldMax, false });
}
}
}
public int DamageShield(PlayerHealth playerHealth, int damage)
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Invalid comparison between Unknown and I4
if (playerHealth.invincibleTimer > 0f || damage <= 0 || (GameManager.Multiplayer() && !photonView.IsMine) || playerHealth.playerAvatar.deadSet || playerHealth.godMode || (int)GameDirector.instance.currentState != 2)
{
return damage;
}
regenerationTimer = 15f;
int num = shieldValue - damage;
if (num < 0)
{
shieldValue = 0;
if (GameManager.Multiplayer())
{
photonView.RPC("UpdateShieldRPC", (RpcTarget)1, new object[3] { shieldValue, shieldMax, false });
}
return -num;
}
if (damage >= 25)
{
CameraGlitch.Instance.PlayLongHurt();
}
else
{
CameraGlitch.Instance.PlayShortHurt();
}
shieldValue = num;
if (GameManager.Multiplayer())
{
photonView.RPC("UpdateShieldRPC", (RpcTarget)1, new object[3] { shieldValue, shieldMax, true });
}
return 0;
}
[PunRPC]
public void UpdateShieldRPC(int shieldValue, int shieldMax, bool effect, PhotonMessageInfo _info = default(PhotonMessageInfo))
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
if (!SemiFunc.MasterAndOwnerOnlyRPC(_info, photonView))
{
return;
}
if (effect)
{
playerHealth.materialEffect = true;
if (!playerHealth.playerAvatar.deadSet)
{
playerHealth.materialEffectLerp = 0f;
}
if (shieldValue < this.shieldValue)
{
if (shieldValue > 0)
{
playerHealth.hurtOther.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
}
playerHealth.hurtFreeze = true;
foreach (Material instancedMaterial in playerHealth.instancedMaterials)
{
if ((Object)(object)instancedMaterial != (Object)(object)playerHealth.eyeMaterial && (Object)(object)instancedMaterial != (Object)(object)playerHealth.pupilMaterial)
{
instancedMaterial.SetColor(playerHealth.materialHurtColor, new Color(0.25f, 0.5f, 1f));
}
}
}
}
if (shieldValue < this.shieldValue)
{
regenerationTimer = 15f;
}
this.shieldValue = shieldValue;
this.shieldMax = shieldMax;
}
}
public class ShieldUI : SemiUI
{
public TextMeshProUGUI Text;
public static ShieldUI instance;
public TextMeshProUGUI textEnergyMax;
public Vector3 maxEnergyBasePosition;
public float maxEnergyPrevOffset;
public int shieldValue;
public int shieldPrev;
public override void Start()
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
((SemiUI)this).Start();
Text = ((Component)this).GetComponent<TextMeshProUGUI>();
instance = this;
textEnergyMax = ((Component)((Component)this).transform.Find("ShieldMax")).GetComponent<TextMeshProUGUI>();
maxEnergyBasePosition = ((TMP_Text)textEnergyMax).transform.localPosition;
}
public override void Update()
{
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: 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)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_015e: Unknown result type (might be due to invalid IL or missing references)
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
((SemiUI)this).Update();
if (!PlayerAvatar.instance.isDisabled)
{
if (GoopUpgradesPlugin.instance.upgradeShield == null || GoopUpgradesPlugin.instance.upgradeShield.GetLevel(SemiFunc.PlayerGetSteamID(PlayerAvatar.instance)) == 0)
{
((SemiUI)this).Hide();
}
}
else
{
((SemiUI)this).Hide();
}
if (base.isHidden || !((Object)(object)PlayerAvatar.instance.playerHealth != (Object)null))
{
return;
}
PlayerShield component = ((Component)PlayerAvatar.instance.playerHealth).GetComponent<PlayerShield>();
if (!Object.op_Implicit((Object)(object)component))
{
return;
}
shieldValue = component.shieldValue;
if (shieldValue != shieldPrev)
{
((SemiUI)this).SemiUISpringShakeY(4f, 5f, 0.25f);
Color val = Color.white;
if (shieldValue < shieldPrev)
{
val = Color.red;
}
((SemiUI)this).SemiUITextFlashColor(val, 0.2f);
((SemiUI)this).SemiUISpringScale(0.3f, 5f, 0.125f);
shieldPrev = shieldValue;
}
((TMP_Text)Text).text = component.shieldValue.ToString();
float num = ((((TMP_Text)Text).text.Length > 3) ? ((float)(((TMP_Text)Text).text.Length - 3) * 20f) : 0f);
((TMP_Text)textEnergyMax).transform.localPosition = maxEnergyBasePosition + new Vector3(num, 0f, 0f);
((TMP_Text)textEnergyMax).text = "<b><color=blue>/</color></b>" + component.shieldMax;
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
