Decompiled source of CybergrindDeathcam v1.0.5

plugins/CybergrindDeathcam/CybergrindDeathcam.dll

Decompiled 4 months ago
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using CybergrindDeathcam.Components;
using CybergrindDeathcam.Utils;
using HarmonyLib;
using PluginConfig.API;
using PluginConfig.API.Fields;
using TMPro;
using UKEnemyIdentifier.Components;
using UKEnemyIdentifier.Utils;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("CybergrindDeathcam")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("CybergrindDeathcam")]
[assembly: AssemblyCopyright("Copyright © 2025 Flazhik")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("941412EE-5088-40AB-834A-40CA7F856E4B")]
[assembly: AssemblyFileVersion("1.0.5.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.5.0")]
namespace CybergrindDeathcam
{
	public class AssetsManager : MonoSingleton<AssetsManager>
	{
		private const BindingFlags Flags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		private static Dictionary<string, Object> _prefabs = new Dictionary<string, Object>();

		private AssetBundle bundle;

		public void LoadAssets()
		{
			bundle = AssetBundle.LoadFromMemory(Resources.CybergrindDeathcam);
		}

		public void RegisterPrefabs()
		{
			string[] allAssetNames = bundle.GetAllAssetNames();
			foreach (string text in allAssetNames)
			{
				_prefabs.Add(text, bundle.LoadAsset<Object>(text));
			}
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			for (int i = 0; i < types.Length; i++)
			{
				CheckType(types[i]);
			}
		}

		private static void CheckType(IReflect type)
		{
			type.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).ToList().ForEach(ProcessField);
		}

		private static void ProcessField(FieldInfo field)
		{
			if (!field.FieldType.IsArray && field.IsStatic)
			{
				PrefabAsset customAttribute = field.GetCustomAttribute<PrefabAsset>();
				if (customAttribute != null)
				{
					field.SetValue(null, _prefabs[customAttribute.Path]);
				}
			}
		}

		public static Object GetAsset(string assetName)
		{
			return _prefabs[assetName];
		}
	}
	[BepInProcess("ULTRAKILL.exe")]
	[BepInPlugin("dev.flazhik.cybergrinddeathcam", "CybergrindDeathcam", "1.0.5")]
	public class CybergrindDeathcam : BaseUnityPlugin
	{
		public static BoolField UseCampaignDeathSequence;

		public static BoolField SkipLeaderboards;

		public static IntField LeaderboardsSkipThreshold;

		public static IntField AlwaysShowLeaderboardsStartingFrom;

		private static PluginConfigurator _config;

		private static Harmony _harmony;

		private static void SetupConfig()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			_config = PluginConfigurator.Create("CybergrindDeathcam", "dev.flazhik.cybergrinddeathcam");
			UseCampaignDeathSequence = new BoolField(_config.rootPanel, "Enable campaign death screen", "deathcam.campaign-death-sequence", false);
			SkipLeaderboards = new BoolField(_config.rootPanel, "Skip Cyber Grind leaderboards", "deathcam.skip-leaderboards", false);
			LeaderboardsSkipThreshold = new IntField(_config.rootPanel, "Don't skip if PB is <= N waves away", "deathcam.threshold", 5);
			AlwaysShowLeaderboardsStartingFrom = new IntField(_config.rootPanel, "Don't skip starting from wave", "deathcam.always-show-starting-from", 999);
			SkipLeaderboards.onValueChange += new BoolValueChangeEventDelegate(ManageSkipFields);
			SkipLeaderboards.TriggerValueChangeEvent();
			_config.SetIconWithURL("file://" + Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "icon.png"));
		}

		private static void ManageSkipFields(BoolValueChangeEvent e)
		{
			bool value = e.value;
			((ConfigField)LeaderboardsSkipThreshold).hidden = !value;
			((ConfigField)AlwaysShowLeaderboardsStartingFrom).hidden = !value;
		}

		private void Awake()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			MonoSingleton<AssetsManager>.Instance.LoadAssets();
			MonoSingleton<AssetsManager>.Instance.RegisterPrefabs();
			_harmony = new Harmony("dev.flazhik.cybergrinddeathcam");
			SetupConfig();
			_harmony.PatchAll();
			SceneManager.sceneLoaded += delegate
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Expected O, but got Unknown
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Expected O, but got Unknown
				MonoSingleton<EnemyIdentifierManager>.Instance.OnPlayerHurt -= new PlayerHurtEventDelegate(OnHit);
				if (SceneHelper.CurrentScene == "Endless")
				{
					MonoSingleton<EnemyIdentifierManager>.Instance.OnPlayerHurt += new PlayerHurtEventDelegate(OnHit);
				}
			};
		}

		private static void OnHit(PlayerHurtEvent e)
		{
			if (e.PlayerIsKilled)
			{
				DeathCam deathCam = ((Component)MonoSingleton<NewMovement>.Instance).gameObject.AddComponent<DeathCam>();
				deathCam.killer = e.EnemyId;
				((Behaviour)deathCam).enabled = true;
			}
		}
	}
	internal static class PluginInfo
	{
		public const string GUID = "dev.flazhik.cybergrinddeathcam";

		public const string NAME = "CybergrindDeathcam";

		public const string VERSION = "1.0.5";
	}
	[AttributeUsage(AttributeTargets.Field)]
	public class PrefabAsset : Attribute
	{
		public string Path { get; }

		public PrefabAsset(string path = "")
		{
			Path = path;
		}
	}
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					resourceMan = new ResourceManager("CybergrindDeathcam.Resources", typeof(Resources).Assembly);
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static byte[] CybergrindDeathcam => (byte[])ResourceManager.GetObject("CybergrindDeathcam", resourceCulture);

		internal Resources()
		{
		}
	}
}
namespace CybergrindDeathcam.Utils
{
	public static class EnemyIdentifierExtension
	{
		public static GameObject GetObject(this EnemyIdentifier value)
		{
			return FirstNonNull((IEnumerable<MonoBehaviour>)(object)new MonoBehaviour[5]
			{
				(MonoBehaviour)value.zombie,
				(MonoBehaviour)value.drone,
				(MonoBehaviour)value.machine,
				(MonoBehaviour)value.spider,
				(MonoBehaviour)value.statue
			});
		}

		private static GameObject FirstNonNull(IEnumerable<MonoBehaviour> values)
		{
			return (from m in values
				where (Object)(object)m != (Object)null
				select ((Component)m).gameObject).FirstOrDefault();
		}
	}
	public static class ReflectionUtils
	{
		private const BindingFlags BindingFlagsFields = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		public static object GetPrivate<T>(T instance, Type classType, string field)
		{
			return classType.GetField(field, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetValue(instance);
		}

		public static IEnumerable<CodeInstruction> IL(params (OpCode, object)[] instructions)
		{
			return ((IEnumerable<(OpCode, object)>)instructions).Select((Func<(OpCode, object), CodeInstruction>)(((OpCode, object) i) => new CodeInstruction(i.Item1, i.Item2))).ToList();
		}
	}
}
namespace CybergrindDeathcam.Patches
{
	[HarmonyPatch(typeof(DeathSequence))]
	public class DeathSequencePatch
	{
		private const string CyberRankCanvasPath = "/Player/FinishCanvas (1)";

		private const string BlackScreenCanvasPath = "/Canvas/BlackScreen";

		[HarmonyPostfix]
		[HarmonyPatch(typeof(DeathSequence), "EndSequence")]
		public static void DeathSequence_EndSequence_Postfix()
		{
			if (!(SceneHelper.CurrentScene != "Endless"))
			{
				MusicManager instance = MonoSingleton<MusicManager>.Instance;
				MonoSingleton<TimeController>.Instance.timeScale = 0f;
				GameObject obj = GameObject.Find("/Player/FinishCanvas (1)");
				FinalCyberRank component = ((Component)obj.transform.Find("Panel")).GetComponent<FinalCyberRank>();
				Transform transform = GameObject.Find("/Canvas/BlackScreen").transform;
				((Component)transform.Find("YouDiedText")).gameObject.SetActive(false);
				((Component)transform.Find("LaughingSkull")).gameObject.SetActive(false);
				DeathCam component2 = ((Component)MonoSingleton<NewMovement>.Instance).gameObject.GetComponent<DeathCam>();
				if ((Object)(object)component2 == (Object)null || !component2.skipLeaderboards)
				{
					component.Appear();
					instance.forcedOff = true;
					instance.StopMusic();
				}
				else
				{
					GameProgressSaver.AddMoney(component.totalPoints);
					SceneHelper.RestartScene();
				}
				obj.transform.parent = GameObject.Find("/Canvas").transform;
			}
		}
	}
	[HarmonyPatch(typeof(FinalCyberRank))]
	public static class FinalCyberRankPatch
	{
		[HarmonyTranspiler]
		[HarmonyPatch(typeof(FinalCyberRank), "Update")]
		public static IEnumerable<CodeInstruction> FinalCyberRank_Update_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> list = instructions.ToList();
			for (int i = 0; i < list.Count; i++)
			{
				if (InjectionPoint(list[i]))
				{
					DisableCybergrindTimeFreeze(list, i);
					break;
				}
			}
			return list;
		}

		private static bool InjectionPoint(CodeInstruction instruction)
		{
			if (instruction.opcode == OpCodes.Call)
			{
				return CodeInstructionExtensions.OperandIs(instruction, (MemberInfo)AccessTools.Method(typeof(Time), "set_timeScale", new Type[1] { typeof(float) }, (Type[])null));
			}
			return false;
		}

		private static void DisableCybergrindTimeFreeze(List<CodeInstruction> instructions, int index)
		{
			instructions.RemoveRange(index - 22, 23);
		}
	}
}
namespace CybergrindDeathcam.Components
{
	public class DeathCam : MonoBehaviour
	{
		[PrefabAsset("assets/ui/elements/notification.prefab")]
		private static GameObject _notificationPrefab;

		[PrefabAsset("assets/audio/deathcam_sfx.mp3")]
		private static AudioClip _deathcamSfx;

		private static AudioSource _audioSource;

		private const float RisingDistance = 10f;

		private const float RisingTime = 0.1f;

		private const float PointCameraAtKillerTime = 0.02f;

		private const float ZoomInRate = 0.04f;

		private const float TimeFreezeRate = 0.4f;

		private const float DistanceToKillerThreshold = 0.5f;

		private const string CanvasPath = "/Player/FinishCanvas (1)";

		public EnemyIdentifier killer;

		public bool skipLeaderboards;

		private DeathcamState _state;

		private GameObject _killerObj;

		private float _killerHeight;

		public FinalCyberRank finalCyberRank;

		private NewMovement _nm;

		private TimeController _timeController;

		private Vector3 _riseToPosition;

		private Vector3 _risingVelocity;

		private float _distanceToKiller;

		private void Awake()
		{
			((Behaviour)this).enabled = false;
		}

		private void Start()
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			_timeController = MonoSingleton<TimeController>.Instance;
			finalCyberRank = GameObject.Find("/Player/FinishCanvas (1)/Panel").GetComponent<FinalCyberRank>();
			_state = DeathcamState.FocusingOnKiller;
			_timeController.controlTimeScale = false;
			if (CybergrindDeathcam.SkipLeaderboards.value)
			{
				CyberRankData bestCyber = GameProgressSaver.GetBestCyber();
				int @int = MonoSingleton<PrefsManager>.Instance.GetInt("difficulty", 0);
				bool flag = bestCyber.preciseWavesByDifficulty[@int] - finalCyberRank.savedWaves <= (float)CybergrindDeathcam.LeaderboardsSkipThreshold.value;
				bool flag2 = (float)CybergrindDeathcam.AlwaysShowLeaderboardsStartingFrom.value <= finalCyberRank.savedWaves;
				skipLeaderboards = !flag2 && !flag;
			}
			if (CybergrindDeathcam.UseCampaignDeathSequence.value)
			{
				((Component)MonoSingleton<NewMovement>.Instance.deathSequence).gameObject.SetActive(true);
			}
			else if (!((Object)(object)killer == (Object)null))
			{
				_nm = ((Component)this).gameObject.GetComponent<NewMovement>();
				_audioSource = ((Component)this).gameObject.AddComponent<AudioSource>();
				_audioSource.clip = _deathcamSfx;
				_riseToPosition = ((Component)_nm).transform.position + new Vector3(0f, 10f, 0f);
				_killerObj = killer.GetObject();
				_killerHeight = GetKillerHeight();
				((MonoBehaviour)this).StartCoroutine(DeathCamRoutine());
				EnableNoclip();
			}
		}

		private void Update()
		{
			if (CybergrindDeathcam.UseCampaignDeathSequence.value)
			{
				return;
			}
			if ((double)_timeController.timeScale > 0.0)
			{
				if (KillerIsDeadOrUnknown())
				{
					MoveTimescaleTowards(0f, skipLeaderboards ? 0.2f : 0.01f);
				}
				else
				{
					switch (_state)
					{
					case DeathcamState.FocusingOnKiller:
						MoveTimescaleTowards(0f, 0.01f);
						FocusOnKiller();
						return;
					case DeathcamState.ZoomIn:
						ZoomIn();
						return;
					case DeathcamState.TimeFreeze:
						break;
					default:
						throw new ArgumentOutOfRangeException("Invalid Deathcam state");
					}
					if ((double)_timeController.timeScale > 0.0)
					{
						MoveTimescaleTowards(0f, 0.4f);
					}
				}
				Time.timeScale = _timeController.timeScale * _timeController.timeScaleModifier;
			}
			else
			{
				if (skipLeaderboards)
				{
					GameProgressSaver.AddMoney(finalCyberRank.totalPoints);
					SceneHelper.RestartScene();
				}
				((MonoBehaviour)this).StartCoroutine(ScheduleEndgameScreen(KillerIsDeadOrUnknown() ? 0f : 2f));
			}
		}

		private IEnumerator ScheduleEndgameScreen(float delay)
		{
			yield return (object)new WaitForSecondsRealtime(delay);
			DisplayEndgameScreen();
		}

		private IEnumerator DeathCamRoutine()
		{
			yield return (object)new WaitForSecondsRealtime(2f);
			ShowNotification();
			_audioSource.Play();
			_state = DeathcamState.ZoomIn;
		}

		private void EnableNoclip()
		{
			((Component)_nm).GetComponent<Rigidbody>().isKinematic = true;
			((Behaviour)((Component)_nm).GetComponent<KeepInBounds>()).enabled = false;
		}

		private void FocusOnKiller()
		{
			//IL_0014: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (!KillerIsDeadOrUnknown())
			{
				if (Math.Abs(((Component)_nm).transform.position.y - _riseToPosition.y) > float.Epsilon)
				{
					((Component)_nm).transform.position = Vector3.SmoothDamp(((Component)_nm).transform.position, _riseToPosition, ref _risingVelocity, 0.1f);
				}
				Quaternion val = Quaternion.LookRotation(_killerObj.transform.position - ((Component)_nm.cc.cam).transform.position);
				((Component)_nm.cc.cam).transform.rotation = Quaternion.Lerp(((Component)_nm.cc.cam).transform.rotation, val, 0.02f);
			}
		}

		private void ZoomIn()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_0080: 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_00ab: 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_00b5: 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_00b7: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_00c0: 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_00c7: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			_distanceToKiller = Vector3.Distance(_killerObj.transform.position, ((Component)_nm.cc.cam).transform.position);
			if (KillerIsDeadOrUnknown())
			{
				_state = DeathcamState.TimeFreeze;
				return;
			}
			float num = _killerHeight * DeathcamDistanceCoefficient();
			Vector3 position = _killerObj.transform.position;
			Vector3 position2 = ((Component)_nm.cc.cam).transform.position;
			Vector3 val = num * ((position - position2) / _distanceToKiller) - new Vector3(0f, _killerHeight / 4f, 0f);
			Vector3 val2 = position - position2;
			Vector3 val3 = position - val;
			if (Vector3.Distance(position2, val3) < 0.5f)
			{
				_state = DeathcamState.TimeFreeze;
				return;
			}
			Quaternion val4 = Quaternion.LookRotation(val2);
			((Component)_nm.cc.cam).transform.rotation = Quaternion.Lerp(((Component)_nm.cc.cam).transform.rotation, val4, 0.04f);
			((Component)_nm.cc.cam).transform.position = Vector3.Lerp(position2, val3, 0.04f);
			_distanceToKiller = Vector3.Distance(position, ((Component)_nm.cc.cam).transform.position);
		}

		private float GetKillerHeight()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0052: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			EnemySimplifier[] componentsInChildren = _killerObj.GetComponentsInChildren<EnemySimplifier>();
			if (componentsInChildren.Length == 0)
			{
				return 0f;
			}
			Renderer val = (Renderer)ReflectionUtils.GetPrivate<EnemySimplifier>(componentsInChildren[0], typeof(EnemySimplifier), "meshrenderer");
			Guttertank val2 = default(Guttertank);
			if (_killerObj.TryGetComponent<Guttertank>(ref val2))
			{
				return 6f;
			}
			if (!((Object)(object)val == (Object)null))
			{
				Bounds bounds = val.bounds;
				return ((Bounds)(ref bounds)).size.y;
			}
			return 0f;
		}

		private void MoveTimescaleTowards(float target, float maxDelta)
		{
			_timeController.timeScale = Mathf.MoveTowards(_timeController.timeScale, target, Time.unscaledDeltaTime * (_timeController.timeScale + maxDelta));
		}

		private bool KillerIsDeadOrUnknown()
		{
			if (!((Object)(object)_killerObj == (Object)null) && !((Object)(object)killer == (Object)null))
			{
				return killer.dead;
			}
			return true;
		}

		private float DeathcamDistanceCoefficient()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected I4, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			EnemyType enemyType = killer.enemyType;
			if ((int)enemyType <= 7)
			{
				switch ((int)enemyType)
				{
				default:
					if ((int)enemyType != 7)
					{
						break;
					}
					return 3.5f;
				case 0:
					return 0.6f;
				case 4:
					return 0.6f;
				case 2:
					return 0.6f;
				case 1:
				case 3:
					break;
				}
			}
			else
			{
				if ((int)enemyType == 31)
				{
					return 0.7f;
				}
				if ((int)enemyType == 33)
				{
					return 1.3f;
				}
			}
			return 1f;
		}

		private void ShowNotification()
		{
			GameObject val = GameObject.Find("/Player/FinishCanvas (1)");
			GameObject obj = Object.Instantiate<GameObject>(_notificationPrefab, val.transform);
			obj.transform.SetSiblingIndex(0);
			((TMP_Text)((Component)obj.transform.Find("KillerName")).GetComponent<TextMeshProUGUI>()).text = EnemyIdentifierExtension.GetEnemyName(killer).ToUpper();
		}

		private void DisplayEndgameScreen()
		{
			finalCyberRank.Appear();
			MonoSingleton<MusicManager>.Instance.forcedOff = true;
			MonoSingleton<MusicManager>.Instance.StopMusic();
		}
	}
	public enum DeathcamState
	{
		FocusingOnKiller,
		ZoomIn,
		TimeFreeze
	}
}