Decompiled source of Brain Classes v1.0.11

plugins/BrainClasses.dll

Decompiled a month ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.Utils;
using Photon.Pun;
using SimulationChamber;
using ToggleCardsCategories;
using UnboundLib.Cards;
using UnityEngine;
using WeaponsManager;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(/*Could not decode attribute arguments.*/)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class CardHolder : MonoBehaviour
{
	public List<CardInfo> cards;

	public List<CardInfo> hiddenCards;

	internal void RegisterCards()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		Enumerator<CardInfo> enumerator = cards.GetEnumerator();
		try
		{
			while (enumerator.MoveNext())
			{
				CardInfo current = enumerator.Current;
				CustomCard.RegisterUnityCard(((Component)current).gameObject, Plugin.modInitials, current.cardName, true, (Action<CardInfo>)null);
			}
		}
		finally
		{
			((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
		}
		Enumerator<CardInfo> enumerator2 = hiddenCards.GetEnumerator();
		try
		{
			while (enumerator2.MoveNext())
			{
				CardInfo current2 = enumerator2.Current;
				CustomCard.RegisterUnityCard(((Component)current2).gameObject, Plugin.modInitials, current2.cardName, false, (Action<CardInfo>)null);
				Cards.instance.AddHiddenCard(current2);
			}
		}
		finally
		{
			((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
		}
	}
}
public class Coffee : MonoBehaviour
{
	private void Start()
	{
		((Component)((Component)this).GetComponentInParent<Player>()).GetComponentInChildren<CupheadSetup>().sMeter.IncreaseRate();
	}
}
public class CupheadSetup : MonoBehaviour
{
	public List<CardInfo> cards;

	private Player owner;

	private int random_number;

	public GameObject SMeter;

	private GameObject superMeterObj;

	public SuperMeter sMeter;

	public void Start()
	{
		owner = ((Component)this).GetComponentInParent<Player>();
		random_number = Random.Range(0, cards.Count);
		Cards.instance.AddCardToPlayer(owner, cards[random_number], false, "", 2f, 2f, true);
	}
}
public class Roundabout : MonoBehaviour
{
	private MoveTransform move;

	private float bull_timer;

	private Vector3 bullet_xspd;

	private bool going_right;

	private void Start()
	{
		//IL_0020: 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_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: 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)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		move = ((Component)this).GetComponentInParent<MoveTransform>();
		bull_timer = 0.3f;
		MoveTransform obj = move;
		bullet_xspd = (obj.velocity += Vector3.left * 1f);
		if (bullet_xspd.x < 0f)
		{
			going_right = true;
		}
	}

	private void FixedUpdate()
	{
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: 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_002a: 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_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		bull_timer -= Time.deltaTime;
		if (going_right)
		{
			MoveTransform obj = move;
			obj.velocity += Vector3.left * bull_timer;
		}
		else
		{
			MoveTransform obj2 = move;
			obj2.velocity += Vector3.right * bull_timer;
		}
	}
}
public class Arrows : MonoBehaviour
{
	private void Start()
	{
	}
}
public enum ExGuns : Enum
{
	None,
	PeaEX,
	ChaserEX,
	LobberEX,
	SpreadEX,
	RoundEX,
	ConvergeEX,
	CrackEX,
	TwistEX,
	ChargeEX
}
public class EX : MonoBehaviour
{
	private Player player;

	private WeaponManager weaponManager;

	public static Dictionary<ExGuns, SimulatedGun> exSimulatedGuns = new Dictionary<ExGuns, SimulatedGun>();

	private AudioSource gunAudio;

	public AudioClip peaSound;

	public AudioClip chaserSound;

	public AudioClip lobberSound;

	public AudioClip spreadSound;

	public AudioClip roundSound;

	public AudioClip convergeSound;

	public AudioClip crackSound;

	public AudioClip twistSound;

	public AudioClip chargeSound;

	public void Start()
	{
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: 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)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: 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)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0119: Unknown result type (might be due to invalid IL or missing references)
		//IL_0135: Unknown result type (might be due to invalid IL or missing references)
		player = ((Component)this).GetComponentInParent<Player>();
		gunAudio = ((Component)this).gameObject.AddComponent<AudioSource>();
		weaponManager = ((Component)this).gameObject.GetComponentInParent<WeaponManager>();
		((Component)this).GetComponentInParent<ChildRPC>().childRPCsInt.Add("EXShootGun", (Action<int>)RPCA_EXShootGun);
		exSimulatedGuns[ExGuns.PeaEX] = new GameObject("PeaEX").AddComponent<SimulatedGun>();
		exSimulatedGuns[ExGuns.ChaserEX] = new GameObject("ChaserEX").AddComponent<SimulatedGun>();
		exSimulatedGuns[ExGuns.LobberEX] = new GameObject("LobberEX").AddComponent<SimulatedGun>();
		exSimulatedGuns[ExGuns.SpreadEX] = new GameObject("SpreadEX").AddComponent<SimulatedGun>();
		exSimulatedGuns[ExGuns.RoundEX] = new GameObject("RoundEX").AddComponent<SimulatedGun>();
		exSimulatedGuns[ExGuns.ConvergeEX] = new GameObject("ConvergeEX").AddComponent<SimulatedGun>();
		exSimulatedGuns[ExGuns.CrackEX] = new GameObject("CrackEX").AddComponent<SimulatedGun>();
		exSimulatedGuns[ExGuns.TwistEX] = new GameObject("TwistEX").AddComponent<SimulatedGun>();
		exSimulatedGuns[ExGuns.ChargeEX] = new GameObject("ChargeEX").AddComponent<SimulatedGun>();
	}

	public bool ExUsed()
	{
		ExGuns exGun = GetExGun();
		if (exGun != ExGuns.None)
		{
			((Component)this).GetComponentInParent<ChildRPC>().CallFunction("EXShootGun", (int)exGun);
			return true;
		}
		return false;
	}

	private void RPCA_EXShootGun(int enumIndex)
	{
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_013f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0332: Unknown result type (might be due to invalid IL or missing references)
		//IL_033f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_0461: Unknown result type (might be due to invalid IL or missing references)
		//IL_0471: Unknown result type (might be due to invalid IL or missing references)
		//IL_0240: Unknown result type (might be due to invalid IL or missing references)
		//IL_0250: Unknown result type (might be due to invalid IL or missing references)
		//IL_040f: Unknown result type (might be due to invalid IL or missing references)
		//IL_041f: Unknown result type (might be due to invalid IL or missing references)
		SimulatedGun val = exSimulatedGuns[(ExGuns)enumIndex];
		val.CopyGunStatsExceptActions(player.data.weaponHandler.gun);
		val.CopyAttackAction(player.data.weaponHandler.gun);
		val.CopyShootProjectileAction(player.data.weaponHandler.gun);
		if (player.data.view.IsMine || PhotonNetwork.OfflineMode)
		{
			switch ((ExGuns)enumIndex)
			{
			case ExGuns.PeaEX:
				val.SimulatedAttack(player.playerID, ((Component)this).transform.position, player.data.aimDirection, 1f, 5f, (Transform)null, false);
				gunAudio.PlayOneShot(peaSound, 3f);
				break;
			case ExGuns.ChaserEX:
				val.SimulatedAttack(player.playerID, ((Component)this).transform.position, player.data.aimDirection, 1f, 3f, (Transform)null, false);
				gunAudio.PlayOneShot(chaserSound, 1f);
				break;
			case ExGuns.LobberEX:
				((Gun)val).gravity = ((Gun)val).gravity * 2f;
				val.SimulatedAttack(player.playerID, ((Component)this).transform.position, player.data.aimDirection, 1f, 4f, (Transform)null, false);
				gunAudio.PlayOneShot(lobberSound, 1f);
				break;
			case ExGuns.RoundEX:
				val.SimulatedAttack(player.playerID, ((Component)this).transform.position, player.data.aimDirection, 1f, 3f, (Transform)null, false);
				gunAudio.PlayOneShot(roundSound, 1.2f);
				break;
			case ExGuns.TwistEX:
				val.SimulatedAttack(player.playerID, ((Component)this).transform.position, player.data.aimDirection, 1f, 3f, (Transform)null, false);
				gunAudio.PlayOneShot(twistSound, 0.5f);
				break;
			case ExGuns.SpreadEX:
			{
				((Gun)val).numberOfProjectiles = 1;
				((Gun)val).spread = 1f;
				((Gun)val).evenSpread = 1f;
				((Gun)val).gravity = ((Gun)val).gravity * 0f;
				((Gun)val).destroyBulletAfter = 0f;
				float x = ((Component)this).transform.position.x;
				float y = ((Component)this).transform.position.y;
				float z = ((Component)this).transform.position.z;
				Vector3 val2 = default(Vector3);
				((Vector3)(ref val2))..ctor(x, y, z);
				Vector3 val3 = default(Vector3);
				((Vector3)(ref val3))..ctor(0f - x, y, z);
				Vector3 val4 = default(Vector3);
				((Vector3)(ref val4))..ctor(x, 0f - y, z);
				Vector3 val5 = default(Vector3);
				((Vector3)(ref val5))..ctor(0f - x, 0f - y, z);
				val.SimulatedAttack(player.playerID, val2, player.data.aimDirection, 1f, 5f, (Transform)null, false);
				gunAudio.PlayOneShot(spreadSound, 1.5f);
				break;
			}
			case ExGuns.ConvergeEX:
				((Gun)val).projectileSpeed = ((Gun)val).projectileSpeed * 1.35f;
				((Gun)val).spread = ((Gun)val).spread * 0f;
				((Gun)val).evenSpread = ((Gun)val).evenSpread * 0f;
				val.SimulatedAttack(player.playerID, ((Component)this).transform.position, player.data.aimDirection, 1f, 2f, (Transform)null, false);
				gunAudio.PlayOneShot(convergeSound, 0.8f);
				break;
			case ExGuns.ChargeEX:
				val.SimulatedAttack(player.playerID, ((Component)this).transform.position, player.data.aimDirection, 1f, 4f, (Transform)null, false);
				gunAudio.PlayOneShot(chargeSound, 0.5f);
				break;
			case ExGuns.CrackEX:
				val.SimulatedAttack(player.playerID, ((Component)this).transform.position, player.data.aimDirection, 1f, 3f, (Transform)null, false);
				gunAudio.PlayOneShot(crackSound, 0.5f);
				break;
			}
		}
	}

	private ExGuns GetExGun()
	{
		if (Object.op_Implicit((Object)(object)weaponManager.GetWeapon("PeashooterGun")) && (Object)(object)weaponManager.GetWeapon("PeashooterGun") == (Object)(object)player.data.weaponHandler.gun)
		{
			return ExGuns.PeaEX;
		}
		if (Object.op_Implicit((Object)(object)weaponManager.GetWeapon("ChaserGun")) && (Object)(object)weaponManager.GetWeapon("ChaserGun") == (Object)(object)player.data.weaponHandler.gun)
		{
			return ExGuns.ChaserEX;
		}
		if (Object.op_Implicit((Object)(object)weaponManager.GetWeapon("LobberGun")) && (Object)(object)weaponManager.GetWeapon("LobberGun") == (Object)(object)player.data.weaponHandler.gun)
		{
			return ExGuns.LobberEX;
		}
		if (Object.op_Implicit((Object)(object)weaponManager.GetWeapon("SpreadGun")) && (Object)(object)weaponManager.GetWeapon("SpreadGun") == (Object)(object)player.data.weaponHandler.gun)
		{
			return ExGuns.SpreadEX;
		}
		if (Object.op_Implicit((Object)(object)weaponManager.GetWeapon("RoundGun")) && (Object)(object)weaponManager.GetWeapon("RoundGun") == (Object)(object)player.data.weaponHandler.gun)
		{
			return ExGuns.RoundEX;
		}
		if (Object.op_Implicit((Object)(object)weaponManager.GetWeapon("ConvergeGun")) && (Object)(object)weaponManager.GetWeapon("ConvergeGun") == (Object)(object)player.data.weaponHandler.gun)
		{
			return ExGuns.ConvergeEX;
		}
		if (Object.op_Implicit((Object)(object)weaponManager.GetWeapon("CrackshotGun")) && (Object)(object)weaponManager.GetWeapon("CrackshotGun") == (Object)(object)player.data.weaponHandler.gun)
		{
			return ExGuns.CrackEX;
		}
		if (Object.op_Implicit((Object)(object)weaponManager.GetWeapon("TwistUpGun")) && (Object)(object)weaponManager.GetWeapon("TwistUpGun") == (Object)(object)player.data.weaponHandler.gun)
		{
			return ExGuns.TwistEX;
		}
		if (Object.op_Implicit((Object)(object)weaponManager.GetWeapon("ChargeGun")) && (Object)(object)weaponManager.GetWeapon("ChargeGun") == (Object)(object)player.data.weaponHandler.gun)
		{
			return ExGuns.ChargeEX;
		}
		return ExGuns.None;
	}

	private void OnDestroy()
	{
		((Component)this).GetComponentInParent<ChildRPC>().childRPCsInt.Remove("EXShootGun");
	}
}
public class EX_Guns : MonoBehaviour
{
	private Player player;

	private Gun gun;

	public SimulatedGun[] savedGuns = (SimulatedGun[])(object)new SimulatedGun[2];

	public static GameObject _stopRecursionObj;

	public static GameObject StopRecursionObj
	{
		get
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			if ((Object)(object)_stopRecursionObj == (Object)null)
			{
				_stopRecursionObj = new GameObject("A_StopRecursion", (Type[])(object)new Type[1] { typeof(StopRecursion) });
				Object.DontDestroyOnLoad((Object)(object)_stopRecursionObj);
			}
			return _stopRecursionObj;
		}
	}

	public static ObjectsToSpawn[] StopRecursionSpawn => (ObjectsToSpawn[])(object)new ObjectsToSpawn[1]
	{
		new ObjectsToSpawn
		{
			AddToProjectile = StopRecursionObj
		}
	};

	public void Start()
	{
		//IL_006e: 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)
		player = ((Component)this).GetComponentInParent<Player>();
		gun = player.data.weaponHandler.gun;
		Gun obj = gun;
		obj.ShootPojectileAction = (Action<GameObject>)(object)Delegate.Combine((Delegate)(object)obj.ShootPojectileAction, (Delegate)(object)new Action<GameObject>(OnShootProjectileAction));
		if ((Object)(object)savedGuns[0] == (Object)null)
		{
			savedGuns[0] = new GameObject("PeaEX").AddComponent<SimulatedGun>();
		}
		if ((Object)(object)savedGuns[1] == (Object)null)
		{
			savedGuns[1] = new GameObject("Y-Gun").AddComponent<SimulatedGun>();
		}
	}

	public void OnShootProjectileAction(GameObject obj)
	{
		//IL_0187: Unknown result type (might be due to invalid IL or missing references)
		//IL_019d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0219: Unknown result type (might be due to invalid IL or missing references)
		//IL_0229: Unknown result type (might be due to invalid IL or missing references)
		//IL_023e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0282: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0320: Unknown result type (might be due to invalid IL or missing references)
		if (obj.GetComponentsInChildren<StopRecursion>().Length == 0)
		{
			SimulatedGun val = savedGuns[0];
			val.CopyGunStatsExceptActions(gun);
			val.CopyAttackAction(gun);
			val.CopyShootProjectileAction(gun);
			((Gun)val).ShootPojectileAction = (Action<GameObject>)(object)Delegate.Remove((Delegate)(object)((Gun)val).ShootPojectileAction, (Delegate)(object)new Action<GameObject>(OnShootProjectileAction));
			((Gun)val).numberOfProjectiles = 1;
			((Gun)val).bursts = 0;
			((Gun)val).spread = 0f;
			((Gun)val).evenSpread = 0f;
			((Gun)val).objectsToSpawn = Enumerable.ToArray<ObjectsToSpawn>(Enumerable.Concat<ObjectsToSpawn>((IEnumerable<ObjectsToSpawn>)(object)((Gun)val).objectsToSpawn, (IEnumerable<ObjectsToSpawn>)(object)StopRecursionSpawn));
			SimulatedGun val2 = savedGuns[1];
			val2.CopyGunStatsExceptActions(gun);
			val2.CopyAttackAction(gun);
			val2.CopyShootProjectileAction(gun);
			((Gun)val2).ShootPojectileAction = (Action<GameObject>)(object)Delegate.Remove((Delegate)(object)((Gun)val2).ShootPojectileAction, (Delegate)(object)new Action<GameObject>(OnShootProjectileAction));
			((Gun)val2).numberOfProjectiles = 1;
			((Gun)val2).bursts = 0;
			((Gun)val2).spread = 0f;
			((Gun)val2).evenSpread = 0f;
			((Gun)val2).gravity = ((Gun)val2).gravity * -1f;
			((Gun)val2).objectsToSpawn = Enumerable.ToArray<ObjectsToSpawn>(Enumerable.Concat<ObjectsToSpawn>((IEnumerable<ObjectsToSpawn>)(object)((Gun)val2).objectsToSpawn, (IEnumerable<ObjectsToSpawn>)(object)StopRecursionSpawn));
			if (player.data.view.IsMine || PhotonNetwork.OfflineMode)
			{
				val.SimulatedAttack(player.playerID, new Vector3(obj.transform.position.x * -1f, obj.transform.position.y, 0f), new Vector3(player.data.input.aimDirection.x * -1f, player.data.input.aimDirection.y, 0f), 1f, 1f, (Transform)null, false);
				val2.SimulatedAttack(player.playerID, new Vector3(obj.transform.position.x, obj.transform.position.y * -1f, 0f), new Vector3(player.data.input.aimDirection.x, player.data.input.aimDirection.y * -1f, 0f), 1f, 1f, (Transform)null, false);
				val2.SimulatedAttack(player.playerID, new Vector3(obj.transform.position.x * -1f, obj.transform.position.y * -1f, 0f), new Vector3(player.data.input.aimDirection.x * -1f, player.data.input.aimDirection.y * -1f, 0f), 1f, 1f, (Transform)null, false);
			}
		}
	}

	public void OnDestroy()
	{
		Gun obj = gun;
		obj.ShootPojectileAction = (Action<GameObject>)(object)Delegate.Remove((Delegate)(object)obj.ShootPojectileAction, (Delegate)(object)new Action<GameObject>(OnShootProjectileAction));
		Object.Destroy((Object)(object)savedGuns[0]);
		Object.Destroy((Object)(object)savedGuns[1]);
	}
}
public class Parry : MonoBehaviour
{
	private void Start()
	{
	}

	private void Update()
	{
	}
}
public class SuperMeter : MonoBehaviour
{
	public float super_rate;

	private float filled_amount = 0f;

	private Vector3 bottom_pos = new Vector3(0f, -766f);

	private Vector3 top_pos = new Vector3(0f, 0f);

	private bool SuperUnlocked = false;

	public List<GameObject> ex;

	public GameObject empty_ex;

	public Player player;

	public EX EX;

	private void Start()
	{
		GameObject val = Object.Instantiate<GameObject>(empty_ex);
		EX = ((Component)player).GetComponentInChildren<EX>();
		super_rate = 0.1f;
	}

	private void Update()
	{
		if (Input.GetKeyUp((KeyCode)306) && filled_amount >= 1f)
		{
			if (filled_amount == 5f && SuperUnlocked)
			{
				SuperUsed();
			}
			else
			{
				ExUsed();
			}
		}
		ExFilling();
		VisualUpdate();
	}

	public void ExGain()
	{
		filled_amount += 0.4f;
	}

	private void VisualUpdate()
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < 5; i++)
		{
			if (filled_amount < (float)i)
			{
				ex[i].transform.localPosition = bottom_pos;
			}
			else if (filled_amount > (float)(i + 1))
			{
				ex[i].transform.localPosition = top_pos;
			}
			else
			{
				ex[i].transform.localPosition = (1f - (filled_amount - (float)i)) * bottom_pos;
			}
		}
	}

	private void ParryHit()
	{
	}

	private void ExFilling()
	{
		filled_amount += super_rate * Time.deltaTime;
		if (filled_amount > 5f)
		{
			filled_amount = 5f;
		}
	}

	public void IncreaseRate()
	{
		super_rate *= 1.33f;
		MonoBehaviour.print((object)"Increase rate being called");
		MonoBehaviour.print((object)super_rate);
	}

	private void ExUsed()
	{
		if (EX.ExUsed())
		{
			filled_amount -= 1f;
		}
		MonoBehaviour.print((object)EX.ExUsed());
	}

	private void SuperUsed()
	{
		filled_amount = 0f;
	}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("brain.classes.mod", "Brain Classes", "1.0.11")]
[BepInProcess("Rounds.exe")]
public class Plugin : BaseUnityPlugin
{
	internal static string modInitials = "BC";

	internal static AssetBundle asset;

	private void Awake()
	{
		asset = AssetUtils.LoadAssetBundleFromResources("brainassets", typeof(Plugin).Assembly);
		ToggleCardsCategoriesManager.instance.RegisterCategories(modInitials);
	}

	private void Start()
	{
		asset.LoadAsset<GameObject>("ModCards").GetComponent<CardHolder>().RegisterCards();
	}
}