Decompiled source of Five Nights at Freddys Sandbox BETA v0.9.0

Five_Nights_at_Freddys_Sandbox_BETA.dll

Decompiled 7 months ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using Atlas;
using BepInEx;
using BepInEx.Logging;
using FistVR;
using HarmonyLib;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: Debuggable(DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace theWNbotMods
{
	public class AC130TabletLeftHand : FVRInteractiveObject
	{
		[Header("平板主控制器")]
		public AC130TabletRightHand tabletController;

		[Header("干扰弹 Prefab")]
		public GameObject countermeasurePrefab;

		[Header("Debug 模拟输入")]
		public bool SimTrigger = false;

		public bool SimStickLeft = false;

		public bool SimStickRight = false;

		public bool SimStickUp = false;

		public bool SimStickDown = false;

		private Vector2 _lAxes;

		public override void UpdateInteraction(FVRViveHand hand)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			((FVRInteractiveObject)this).UpdateInteraction(hand);
			if ((int)hand.HandSource != 1)
			{
				return;
			}
			if ((int)hand.CMode == 3 || (int)hand.CMode == 1)
			{
				_lAxes = hand.Input.Secondary2AxisInputAxes;
			}
			else
			{
				_lAxes = hand.Input.TouchpadAxes;
			}
			if (SimStickLeft)
			{
				_lAxes.x = -1f;
				SimStickLeft = false;
			}
			if (SimStickRight)
			{
				_lAxes.x = 1f;
				SimStickRight = false;
			}
			if (SimStickUp)
			{
				_lAxes.y = 1f;
				SimStickUp = false;
			}
			if (SimStickDown)
			{
				_lAxes.y = -1f;
				SimStickDown = false;
			}
			if (_lAxes.x > 0.8f)
			{
				tabletController.CurrentIndex++;
			}
			else if (_lAxes.x < -0.8f)
			{
				tabletController.CurrentIndex--;
			}
			if (hand.Input.TriggerDown || SimTrigger)
			{
				if ((Object)(object)countermeasurePrefab != (Object)null)
				{
					countermeasurePrefab.SetActive(true);
				}
				SimTrigger = false;
			}
		}
	}
	public class AC130TabletRightHand : FVRPhysicalObject
	{
		[Header("炮艇控制器")]
		public OrbitalStrikeController[] strikeControllers;

		public GameObject[] cannonUIPrefabs;

		[Header("摄像头角度限制")]
		public Transform cameraPivot;

		public float yawLimit = 60f;

		public float pitchLimit = 30f;

		public float rotationSpeed = 2f;

		[Header("Debug 模拟输入")]
		public bool SimTrigger = false;

		public bool SimStickLeft = false;

		public bool SimStickRight = false;

		public bool SimStickUp = false;

		public bool SimStickDown = false;

		private Vector2 _rAxes;

		private int currentIndex = 0;

		public int CurrentIndex
		{
			get
			{
				return currentIndex;
			}
			set
			{
				currentIndex = Mathf.Clamp(value, 0, strikeControllers.Length - 1);
				UpdateUI();
			}
		}

		public override void UpdateInteraction(FVRViveHand hand)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: 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)
			((FVRPhysicalObject)this).UpdateInteraction(hand);
			if ((int)hand.HandSource != 2)
			{
				return;
			}
			if ((int)hand.CMode == 3 || (int)hand.CMode == 1)
			{
				_rAxes = hand.Input.Secondary2AxisInputAxes;
			}
			else
			{
				_rAxes = hand.Input.TouchpadAxes;
			}
			if (SimStickLeft)
			{
				_rAxes.x = -1f;
				SimStickLeft = false;
			}
			if (SimStickRight)
			{
				_rAxes.x = 1f;
				SimStickRight = false;
			}
			if (SimStickUp)
			{
				_rAxes.y = 1f;
				SimStickUp = false;
			}
			if (SimStickDown)
			{
				_rAxes.y = -1f;
				SimStickDown = false;
			}
			float num = Mathf.Clamp(cameraPivot.localEulerAngles.y + _rAxes.x * rotationSpeed, 0f - yawLimit, yawLimit);
			float num2 = Mathf.Clamp(cameraPivot.localEulerAngles.x - _rAxes.y * rotationSpeed, 0f - pitchLimit, pitchLimit);
			cameraPivot.localRotation = Quaternion.Euler(num2, num, 0f);
			if (!hand.Input.TriggerDown && !SimTrigger)
			{
				return;
			}
			if (strikeControllers != null && strikeControllers.Length > 0)
			{
				OrbitalStrikeController orbitalStrikeController = strikeControllers[currentIndex];
				if ((Object)(object)orbitalStrikeController != (Object)null)
				{
					orbitalStrikeController.shouldFire = true;
				}
			}
			SimTrigger = false;
		}

		public void UpdateUI()
		{
			for (int i = 0; i < cannonUIPrefabs.Length; i++)
			{
				if ((Object)(object)cannonUIPrefabs[i] != (Object)null)
				{
					cannonUIPrefabs[i].SetActive(i == currentIndex);
				}
			}
		}

		public void SetCurrentIndex(int index)
		{
			CurrentIndex = index;
		}
	}
	public class AirstrikeBinocular : FVRPhysicalObject
	{
		[Header("望远镜镜头中心(Ray 起点)")]
		public Transform RayOrigin;

		[Header("默认空袭 Prefab")]
		public GameObject defaultAirstrikePrefab;

		[Header("最大射程")]
		public float MaxDistance = 500f;

		[Header("可命中的层(地面、环境等)")]
		public LayerMask HitLayers;

		[Header("菜单 UI Canvas")]
		public GameObject menuCanvas;

		[Header("音效播放")]
		public AudioSource audioSource;

		private GameObject currentAirstrikePrefab;

		private AudioClip[] currentAirstrikeClips;

		[Header("调试信息")]
		[SerializeField]
		private string currentTypeName = "None";

		[Header("部署方向设置")]
		[SerializeField]
		private Vector3 rotationOffsetEuler = Vector3.zero;

		[Header("冷却时间设置")]
		[SerializeField]
		private float cooldownTime = 5f;

		private float lastDeployTime = -999f;

		[Header("调试开关")]
		[SerializeField]
		private bool debugTrigger = false;

		private void Start()
		{
			currentAirstrikePrefab = defaultAirstrikePrefab;
			currentTypeName = ((!((Object)(object)defaultAirstrikePrefab != (Object)null)) ? "None" : ((Object)defaultAirstrikePrefab).name);
			if ((Object)(object)menuCanvas != (Object)null)
			{
				menuCanvas.SetActive(false);
			}
			Debug.Log((object)("AirstrikeBinocular当前空袭类型: " + currentTypeName));
		}

		private void Update()
		{
			if (debugTrigger)
			{
				Debug.Log((object)("调试Inspector触发空袭 → " + currentTypeName));
				DeployAirstrike(null);
				debugTrigger = false;
			}
		}

		public void ToggleMenu(bool isOpen)
		{
			if ((Object)(object)menuCanvas != (Object)null)
			{
				menuCanvas.SetActive(isOpen);
			}
		}

		public void SetAirstrikeType(GameObject prefab, AudioClip[] clips)
		{
			currentAirstrikePrefab = prefab;
			currentAirstrikeClips = clips;
			currentTypeName = ((!((Object)(object)prefab != (Object)null)) ? "None" : ((Object)prefab).name);
			Debug.Log((object)("当前空袭类型切换为: " + currentTypeName));
		}

		public override void UpdateInteraction(FVRViveHand hand)
		{
			((FVRPhysicalObject)this).UpdateInteraction(hand);
			if (hand.Input.TriggerFloat > 0.8f)
			{
				DeployAirstrike(hand);
			}
		}

		public void DeployAirstrike(FVRViveHand hand)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_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_00bb: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (Time.time - lastDeployTime < cooldownTime)
			{
				Debug.Log((object)("冷却中,剩余时间: " + (cooldownTime - (Time.time - lastDeployTime)).ToString("F1") + " 秒"));
			}
			else if (Physics.Raycast(RayOrigin.position, RayOrigin.forward, ref val, MaxDistance, LayerMask.op_Implicit(HitLayers)))
			{
				Vector3 forward = RayOrigin.forward;
				forward.y = 0f;
				if (((Vector3)(ref forward)).sqrMagnitude < 0.001f)
				{
					forward = Vector3.forward;
				}
				Quaternion val2 = Quaternion.LookRotation(forward, Vector3.up);
				Quaternion val3 = val2 * Quaternion.Euler(rotationOffsetEuler);
				Object.Instantiate<GameObject>(currentAirstrikePrefab, ((RaycastHit)(ref val)).point, val3);
				Debug.Log((object)string.Concat("释放空袭: ", currentTypeName, " 于位置 ", ((RaycastHit)(ref val)).point, ",旋转: ", ((Quaternion)(ref val3)).eulerAngles));
				lastDeployTime = Time.time;
				if ((Object)(object)audioSource != (Object)null && currentAirstrikeClips != null && currentAirstrikeClips.Length > 0)
				{
					AudioClip val4 = currentAirstrikeClips[Random.Range(0, currentAirstrikeClips.Length)];
					audioSource.PlayOneShot(val4);
				}
				if ((Object)(object)hand != (Object)null)
				{
					hand.Buzz(hand.Buzzer.Buzz_OnHoverInteractive);
				}
			}
		}
	}
	public class AirstrikeDebugger : MonoBehaviour
	{
		[Header("移动速度")]
		public float moveSpeed = 5f;

		[Header("鼠标灵敏度")]
		public float mouseSensitivity = 2f;

		[Header("头部对象(联动 UILookAtPlayer)")]
		public Transform headTransform;

		private float rotationX = 0f;

		private float rotationY = 0f;

		private void Start()
		{
			Cursor.lockState = (CursorLockMode)1;
			Cursor.visible = false;
		}

		private void Update()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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)
			//IL_0060: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			float axis = Input.GetAxis("Horizontal");
			float axis2 = Input.GetAxis("Vertical");
			Vector3 val = (((Component)this).transform.right * axis + ((Component)this).transform.forward * axis2) * moveSpeed * Time.deltaTime;
			Transform transform = ((Component)this).transform;
			transform.position += val;
			float num = Input.GetAxis("Mouse X") * mouseSensitivity;
			float num2 = Input.GetAxis("Mouse Y") * mouseSensitivity;
			rotationY += num;
			rotationX -= num2;
			rotationX = Mathf.Clamp(rotationX, -80f, 80f);
			((Component)this).transform.rotation = Quaternion.Euler(rotationX, rotationY, 0f);
			if ((Object)(object)headTransform != (Object)null)
			{
				headTransform.position = ((Component)this).transform.position + Vector3.up * 1.6f;
				headTransform.rotation = ((Component)this).transform.rotation;
			}
		}
	}
	public class ChangeTypeWhenAwake : MonoBehaviour
	{
		public GameObject airstrikePrefab;

		public AudioClip[] airstrikeClips;

		public AirstrikeBinocular binocular;

		private void OnEnable()
		{
			if ((Object)(object)binocular != (Object)null && (Object)(object)airstrikePrefab != (Object)null)
			{
				binocular.SetAirstrikeType(airstrikePrefab, airstrikeClips);
			}
		}
	}
}
public class ScopeScript : MonoBehaviour
{
	[SerializeField]
	[Range(0f, 1f)]
	private float zoom;

	[SerializeField]
	private float minFOV;

	[SerializeField]
	private float maxFOV;

	[SerializeField]
	private Camera myCamera;

	[SerializeField]
	private Transform myCrossHair;

	[SerializeField]
	private float minCrossHairScale;

	[SerializeField]
	private float maxCrossHairScale;

	[SerializeField]
	private Material imageMat;

	[SerializeField]
	private float minDistortion;

	[SerializeField]
	private float maxDistortion;

	private void Start()
	{
	}

	private void Update()
	{
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		myCamera.fieldOfView = Mathf.Lerp(maxFOV, minFOV, zoom);
		float num = Mathf.Lerp(minCrossHairScale, maxCrossHairScale, zoom);
		myCrossHair.localScale = new Vector3(num, num, 1f);
		imageMat.SetFloat("_Constant", Mathf.Lerp(minDistortion, maxDistortion, zoom));
	}
}
namespace theWNbotMods
{
	public class scopeFocusScript : MonoBehaviour
	{
		[Header("眼睛位置(VR Head 或 Debug Head)")]
		[SerializeField]
		private Transform eye;

		[Header("瞄具参考点(通常是镜片中心)")]
		[SerializeField]
		private Transform eyeDistPos;

		[Header("聚焦参数")]
		[SerializeField]
		private float fadedDist = 0.2f;

		[SerializeField]
		private float maxAngle = 15f;

		[Header("材质控制")]
		[SerializeField]
		private Material focusMat;

		[SerializeField]
		private float minMult = 0f;

		[SerializeField]
		private float maxMult = 1f;

		private Vector2 posInput;

		private float circleCenterMovement;

		private void LateUpdate()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)eye == (Object)null) && !((Object)(object)eyeDistPos == (Object)null) && !((Object)(object)focusMat == (Object)null))
			{
				float num = Vector3.Distance(eyeDistPos.position, eye.position);
				float num2 = num / fadedDist;
				num2 = Mathf.Clamp(num2, minMult, maxMult);
				Vector3 val = ((Component)this).transform.position - eye.position;
				float num3 = Vector3.Angle(val, ((Component)this).transform.forward);
				circleCenterMovement = num3 / maxAngle;
				Vector3 val2 = ((Component)this).transform.InverseTransformDirection(val);
				Vector2 val3 = default(Vector2);
				((Vector2)(ref val3))..ctor(val2.x, val2.y);
				posInput = ((Vector2)(ref val3)).normalized * circleCenterMovement / 2f;
				focusMat.SetFloat("_Mult", num2);
				focusMat.SetFloat("_XPos", 0.5f + posInput.x);
				focusMat.SetFloat("_YPos", 0.5f + posInput.y);
			}
		}
	}
}
namespace FNAFModeScripts
{
	public class ChancetoNextStage : MonoBehaviour
	{
		[Serializable]
		public class StageData
		{
			[Header("每隔多少秒进行一次概率判定")]
			public float rollInterval = 5f;

			[Header("进入下一阶段的概率(0~1)")]
			[Range(0f, 1f)]
			public float chanceToAdvance = 0.2f;

			[Header("如果超过多少秒还没进入下一阶段 → 强制进入")]
			public float forceAdvanceTime = 20f;

			[Header("进入此阶段时激活的 Prefab")]
			public GameObject[] activatePrefabs;
		}

		[Header("阶段列表(按顺序执行)")]
		public StageData[] stages;

		[Header("Awake 时自动启动")]
		public bool autoStart = true;

		[Header("是否一次性只显示当前阶段的 Prefab")]
		public bool onlyShowCurrentStage = false;

		private int currentStage = 0;

		private void Awake()
		{
			if (autoStart)
			{
				StartStages();
			}
		}

		public void StartStages()
		{
			currentStage = 0;
			((MonoBehaviour)this).StartCoroutine(RunStages());
		}

		private IEnumerator RunStages()
		{
			while (currentStage < stages.Length)
			{
				StageData stage = stages[currentStage];
				if (onlyShowCurrentStage)
				{
					HideAllPrefabs();
				}
				ActivatePrefabs(stage.activatePrefabs);
				float elapsed = 0f;
				while (true)
				{
					if (elapsed < stage.forceAdvanceTime)
					{
						yield return (object)new WaitForSeconds(stage.rollInterval);
						elapsed += stage.rollInterval;
						float roll = Random.value;
						if (roll <= stage.chanceToAdvance)
						{
							currentStage++;
							break;
						}
						continue;
					}
					currentStage++;
					break;
				}
				yield return null;
			}
		}

		private void ActivatePrefabs(GameObject[] prefabs)
		{
			if (prefabs == null)
			{
				return;
			}
			foreach (GameObject val in prefabs)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.SetActive(true);
				}
			}
		}

		private void HideAllPrefabs()
		{
			StageData[] array = stages;
			foreach (StageData stageData in array)
			{
				if (stageData.activatePrefabs == null)
				{
					continue;
				}
				GameObject[] activatePrefabs = stageData.activatePrefabs;
				foreach (GameObject val in activatePrefabs)
				{
					if ((Object)(object)val != (Object)null)
					{
						val.SetActive(false);
					}
				}
			}
		}
	}
}
namespace theWNbotMods
{
	public class DelayedActive : MonoBehaviour
	{
		[Header("延迟多少秒后激活 Prefab")]
		public float delay = 1f;

		[Header("要激活的 Prefab 列表")]
		public GameObject[] prefabsToActivate;

		private void OnEnable()
		{
			((MonoBehaviour)this).StartCoroutine(ActivateAfterDelay());
		}

		private IEnumerator ActivateAfterDelay()
		{
			if (delay > 0f)
			{
				yield return (object)new WaitForSeconds(delay);
			}
			for (int i = 0; i < prefabsToActivate.Length; i++)
			{
				if ((Object)(object)prefabsToActivate[i] != (Object)null)
				{
					prefabsToActivate[i].SetActive(true);
				}
			}
		}
	}
}
namespace FNAFModeScripts
{
	public class EventDoorClose : MonoBehaviour
	{
		[Header("随机事件控制")]
		[Range(0f, 1f)]
		public float eventChance = 0.5f;

		[Header("门动画(Start / End Prefab)")]
		public Transform door;

		public GameObject doorOpenPrefab;

		public GameObject doorClosedPrefab;

		public float openAnimDuration = 0.6f;

		public float closeAnimDuration = 0.15f;

		private Vector3 openPos;

		private Quaternion openRot;

		private Vector3 closedPos;

		private Quaternion closedRot;

		private Coroutine animCoroutine;

		[Header("鬼脸(场景中隐藏物体)")]
		public GameObject ghostFaceObject;

		public float ghostDuration = 0.4f;

		[Header("音效")]
		public AudioSource audioSource;

		public AudioClip doorOpenSound;

		public AudioClip ghostSound;

		public AudioClip doorCloseSound;

		[Header("Trigger 引用")]
		public Collider openTrigger;

		public Collider scareTrigger;

		[Header("事件控制")]
		public bool oneTime = true;

		private bool opened = false;

		private bool scared = false;

		[Header("Debug 控制")]
		public bool debugOpen = false;

		public bool debugScare = false;

		private void Start()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			if (Random.value > eventChance)
			{
				((Component)this).gameObject.SetActive(false);
				return;
			}
			if ((Object)(object)doorOpenPrefab != (Object)null)
			{
				openPos = doorOpenPrefab.transform.localPosition;
				openRot = doorOpenPrefab.transform.localRotation;
			}
			if ((Object)(object)doorClosedPrefab != (Object)null)
			{
				closedPos = doorClosedPrefab.transform.localPosition;
				closedRot = doorClosedPrefab.transform.localRotation;
			}
			if ((Object)(object)ghostFaceObject != (Object)null)
			{
				ghostFaceObject.SetActive(false);
			}
		}

		private void Update()
		{
			if (debugOpen)
			{
				debugOpen = false;
				((MonoBehaviour)this).StartCoroutine(OpenDoor());
			}
			if (debugScare)
			{
				debugScare = false;
				((MonoBehaviour)this).StartCoroutine(ScareAndClose());
			}
		}

		private void OnTriggerEnter(Collider other)
		{
			if (!((Object)(object)((Component)other).transform != (Object)(object)GM.CurrentPlayerBody.Head))
			{
				if ((Object)(object)other == (Object)(object)openTrigger && !opened)
				{
					opened = true;
					((MonoBehaviour)this).StartCoroutine(OpenDoor());
				}
				if ((Object)(object)other == (Object)(object)scareTrigger && !scared)
				{
					scared = true;
					((MonoBehaviour)this).StartCoroutine(ScareAndClose());
				}
			}
		}

		private IEnumerator OpenDoor()
		{
			if ((Object)(object)audioSource != (Object)null && (Object)(object)doorOpenSound != (Object)null)
			{
				audioSource.PlayOneShot(doorOpenSound);
			}
			yield return ((MonoBehaviour)this).StartCoroutine(AnimateDoor(openPos, openRot, openAnimDuration));
		}

		private IEnumerator ScareAndClose()
		{
			if ((Object)(object)ghostFaceObject != (Object)null)
			{
				ghostFaceObject.SetActive(true);
			}
			if ((Object)(object)audioSource != (Object)null && (Object)(object)ghostSound != (Object)null)
			{
				audioSource.PlayOneShot(ghostSound);
			}
			yield return (object)new WaitForSeconds(ghostDuration);
			if ((Object)(object)ghostFaceObject != (Object)null)
			{
				ghostFaceObject.SetActive(false);
			}
			if ((Object)(object)audioSource != (Object)null && (Object)(object)doorCloseSound != (Object)null)
			{
				audioSource.PlayOneShot(doorCloseSound);
			}
			yield return ((MonoBehaviour)this).StartCoroutine(AnimateDoor(closedPos, closedRot, closeAnimDuration));
		}

		private IEnumerator AnimateDoor(Vector3 targetPos, Quaternion targetRot, float duration)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)door == (Object)null))
			{
				Vector3 startPos = door.localPosition;
				Quaternion startRot = door.localRotation;
				float t = 0f;
				while (t < duration)
				{
					float lerp = t / duration;
					door.localPosition = Vector3.Lerp(startPos, targetPos, lerp);
					door.localRotation = Quaternion.Lerp(startRot, targetRot, lerp);
					t += Time.deltaTime;
					yield return null;
				}
				door.localPosition = targetPos;
				door.localRotation = targetRot;
			}
		}
	}
	public class FNAFAnimatronicAI : MonoBehaviour
	{
		[Header("注释")]
		[TextArea(2, 5)]
		public string developerNote;

		[Header("移动概率(每小时 AI Level)")]
		[Range(0f, 20f)]
		public int AI_12AM = 20;

		[Range(0f, 20f)]
		public int AI_1AM = 20;

		[Range(0f, 20f)]
		public int AI_2AM = 20;

		[Range(0f, 20f)]
		public int AI_3AM = 20;

		[Range(0f, 20f)]
		public int AI_4AM = 20;

		[Range(0f, 20f)]
		public int AI_5AM = 20;

		[Header("AI Roll 时间范围 (秒)")]
		public float minRollTime = 1f;

		public float maxRollTime = 2f;

		private float rollTimer = 0f;

		private float nextRollTime = 0f;

		private int currentAILevel = 0;

		private FNAFWaypoint[] waypoints;

		private int currentIndex = 0;

		private bool aiActive = false;

		private void Start()
		{
			waypoints = ((Component)this).GetComponentsInChildren<FNAFWaypoint>(true);
			for (int i = 0; i < waypoints.Length; i++)
			{
				waypoints[i].index = i;
			}
			SetAllPosesInactive();
			ActivatePose(currentIndex);
			FNAFNightClock fNAFNightClock = Object.FindObjectOfType<FNAFNightClock>();
			if ((Object)(object)fNAFNightClock != (Object)null)
			{
				fNAFNightClock.OnHourChanged = (Action<int>)Delegate.Combine(fNAFNightClock.OnHourChanged, new Action<int>(SetAILevelByHour));
			}
			aiActive = true;
			if ((Object)(object)fNAFNightClock != (Object)null)
			{
				SetAILevelByHour(fNAFNightClock.currentHour);
			}
			else
			{
				SetAILevelByHour(12);
			}
			ScheduleNextRoll();
			TryMove();
			Debug.Log((object)(((Object)this).name + " AI Enable"));
		}

		private void Update()
		{
			if (aiActive)
			{
				rollTimer += Time.deltaTime;
				if (rollTimer >= nextRollTime)
				{
					rollTimer = 0f;
					ScheduleNextRoll();
					TryMove();
				}
			}
		}

		private void ScheduleNextRoll()
		{
			nextRollTime = Random.Range(minRollTime, maxRollTime);
		}

		private void SetAllPosesInactive()
		{
			for (int i = 0; i < waypoints.Length; i++)
			{
				if ((Object)(object)waypoints[i].Pose != (Object)null)
				{
					waypoints[i].Pose.SetActive(false);
				}
			}
		}

		private void ActivatePose(int index)
		{
			if ((Object)(object)waypoints[index].Pose != (Object)null)
			{
				waypoints[index].Pose.SetActive(true);
			}
		}

		private void TryMove()
		{
			int num = Random.Range(1, 21);
			Debug.Log((object)(((Object)this).name + " Roll = " + num + " / AI Level = " + currentAILevel));
			if (num < currentAILevel)
			{
				MoveToNextWaypoint();
			}
		}

		private void MoveToNextWaypoint()
		{
			FNAFWaypoint fNAFWaypoint = waypoints[currentIndex];
			if (fNAFWaypoint.nextPoints == null || fNAFWaypoint.nextPoints.Length == 0)
			{
				return;
			}
			int num = ChooseNextWaypoint(fNAFWaypoint);
			FNAFWaypoint fNAFWaypoint2 = waypoints[num];
			if (fNAFWaypoint2.isDoorNode && (Object)(object)fNAFWaypoint2.doorToCheck != (Object)null)
			{
				FNAFDoor component = fNAFWaypoint2.doorToCheck.GetComponent<FNAFDoor>();
				if (fNAFWaypoint2.breakDoor && (Object)(object)component != (Object)null)
				{
					component.ForceDoorBroken();
					Debug.Log((object)(((Object)this).name + " 把门破坏了!门无法关闭!"));
				}
				if ((Object)(object)component != (Object)null && component.currentState == FNAFDoor.DoorState.Closed)
				{
					Debug.Log((object)(((Object)this).name + " Door Closed, gets back"));
					if (fNAFWaypoint2.failReturnPoints != null && fNAFWaypoint2.failReturnPoints.Length > 0)
					{
						int num2 = Random.Range(0, fNAFWaypoint2.failReturnPoints.Length);
						num = fNAFWaypoint2.failReturnPoints[num2].index;
					}
					else
					{
						num = currentIndex;
					}
				}
			}
			waypoints[currentIndex].Pose.SetActive(false);
			currentIndex = num;
			waypoints[currentIndex].Pose.SetActive(true);
			Debug.Log((object)(((Object)this).name + " Move to waypoint: " + currentIndex));
			waypoints[currentIndex].TryPlaySound();
			waypoints[currentIndex].TriggerAttack();
			waypoints[currentIndex].StartForceMove();
		}

		private int ChooseNextWaypoint(FNAFWaypoint wp)
		{
			if (wp.nextPoints == null || wp.nextPoints.Length == 0)
			{
				return wp.index;
			}
			if (wp.nextPoints.Length == 1)
			{
				return wp.nextPoints[0].nextPoint.index;
			}
			int num = 0;
			for (int i = 0; i < wp.nextPoints.Length; i++)
			{
				num += wp.nextPoints[i].chance;
			}
			int num2 = Random.Range(0, num);
			int num3 = 0;
			for (int j = 0; j < wp.nextPoints.Length; j++)
			{
				num3 += wp.nextPoints[j].chance;
				if (num2 < num3)
				{
					return wp.nextPoints[j].nextPoint.index;
				}
			}
			return wp.nextPoints[0].nextPoint.index;
		}

		public void ForceMoveTo(int waypointIndex)
		{
			waypoints[currentIndex].Pose.SetActive(false);
			currentIndex = waypointIndex;
			waypoints[currentIndex].Pose.SetActive(true);
			Debug.Log((object)(((Object)this).name + " 强制移动到节点: " + currentIndex));
			waypoints[currentIndex].TryPlaySound();
			waypoints[currentIndex].TriggerAttack();
			waypoints[currentIndex].StartForceMove();
		}

		public void DeactivateAI()
		{
			aiActive = false;
			Debug.Log((object)(((Object)this).name + " AI Stopped"));
		}

		public void SetAILevelByHour(int hour)
		{
			switch (hour)
			{
			case 12:
				currentAILevel = AI_12AM;
				break;
			case 1:
				currentAILevel = AI_1AM;
				break;
			case 2:
				currentAILevel = AI_2AM;
				break;
			case 3:
				currentAILevel = AI_3AM;
				break;
			case 4:
				currentAILevel = AI_4AM;
				break;
			case 5:
				currentAILevel = AI_5AM;
				break;
			}
			Debug.Log((object)(((Object)this).name + " AI Level to: " + currentAILevel + "(Now Time: " + hour + "AM)"));
		}
	}
	public enum CameraSwitchInitialState
	{
		Off,
		On
	}
	public class FNAFCameraButton : MonoBehaviour
	{
		[Header("摄像头管理器引用")]
		public FNAFCameraManager cameraManager;

		[Header("对应摄像头索引(从 0 开始)")]
		public int cameraIndex = 0;

		[Header("开关动画")]
		public Transform switchHandle;

		public GameObject handleStartPrefab;

		public GameObject handleEndPrefab;

		public float animDuration = 0.15f;

		[Header("开关音效")]
		public AudioSource audioSource;

		public AudioClip toggleSound;

		private Vector3 startPos;

		private Vector3 endPos;

		private Quaternion startRot;

		private Quaternion endRot;

		private Coroutine animCoroutine;

		private AR15HandleSightFlipper flipper;

		private bool switchDown = false;

		[Header("初始状态")]
		public CameraSwitchInitialState initialState = CameraSwitchInitialState.Off;

		[Header("Debug 控制")]
		public bool debugTrigger = false;

		private bool lastFlipState;

		private void Start()
		{
			//IL_0068: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			flipper = ((Component)this).GetComponent<AR15HandleSightFlipper>();
			switchDown = initialState == CameraSwitchInitialState.On;
			lastFlipState = switchDown;
			if ((Object)(object)switchHandle != (Object)null && (Object)(object)handleStartPrefab != (Object)null && (Object)(object)handleEndPrefab != (Object)null)
			{
				startPos = handleStartPrefab.transform.localPosition;
				startRot = handleStartPrefab.transform.localRotation;
				endPos = handleEndPrefab.transform.localPosition;
				endRot = handleEndPrefab.transform.localRotation;
				switchHandle.localPosition = ((!switchDown) ? startPos : endPos);
				switchHandle.localRotation = ((!switchDown) ? startRot : endRot);
			}
			if ((Object)(object)flipper != (Object)null)
			{
				flipper.m_isLargeAperture = switchDown;
			}
		}

		private void Update()
		{
			if (debugTrigger)
			{
				debugTrigger = false;
				TriggerAction();
			}
			if ((Object)(object)flipper != (Object)null && flipper.m_isLargeAperture != lastFlipState)
			{
				lastFlipState = flipper.m_isLargeAperture;
				switchDown = lastFlipState;
				PlaySwitchAnimation(switchDown);
				PlayToggleSound();
				ActivateCamera();
			}
		}

		public void TriggerAction()
		{
			switchDown = !switchDown;
			PlaySwitchAnimation(switchDown);
			PlayToggleSound();
			ActivateCamera();
			Debug.Log((object)"[FNAFCameraButton] Button Triggered");
		}

		private void ActivateCamera()
		{
			if ((Object)(object)cameraManager != (Object)null)
			{
				cameraManager.SwitchToCamera(cameraIndex);
			}
		}

		private void PlayToggleSound()
		{
			if ((Object)(object)audioSource != (Object)null && (Object)(object)toggleSound != (Object)null)
			{
				audioSource.PlayOneShot(toggleSound);
			}
		}

		private void PlaySwitchAnimation(bool down)
		{
			if (animCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(animCoroutine);
			}
			animCoroutine = ((MonoBehaviour)this).StartCoroutine(AnimateSwitch(down));
		}

		private IEnumerator AnimateSwitch(bool down)
		{
			if (!((Object)(object)switchHandle == (Object)null))
			{
				Vector3 fromPos = switchHandle.localPosition;
				Quaternion fromRot = switchHandle.localRotation;
				Vector3 toPos = ((!down) ? startPos : endPos);
				Quaternion toRot = ((!down) ? startRot : endRot);
				float t = 0f;
				while (t < animDuration)
				{
					float lerp = t / animDuration;
					switchHandle.localPosition = Vector3.Lerp(fromPos, toPos, lerp);
					switchHandle.localRotation = Quaternion.Lerp(fromRot, toRot, lerp);
					t += Time.deltaTime;
					yield return null;
				}
				switchHandle.localPosition = toPos;
				switchHandle.localRotation = toRot;
			}
		}
	}
	public class FNAFCameraManager : MonoBehaviour, IFNAFPowerConsumer
	{
		[Header("屏幕元素")]
		public GameObject blackScreen;

		public List<GameObject> cameraViews;

		[Header("Cameras(与 Camera Views 一一对应的摄像头 Prefab)")]
		public List<GameObject> cameras;

		[Header("切换效果")]
		public float switchBlackTime = 0.15f;

		public AudioSource audioSource;

		public AudioClip switchSound;

		private int currentIndex = -1;

		private Coroutine switchRoutine;

		[Header("监控状态")]
		public bool cameraOff = true;

		public bool powerLocked = false;

		[Header("耗电设置")]
		public float cameraDrainRate = 0.2f;

		private void Start()
		{
			cameraOff = true;
			powerLocked = false;
			ShowOnlyBlackScreen();
			FNAFPowerManager fNAFPowerManager = Object.FindObjectOfType<FNAFPowerManager>();
			if ((Object)(object)fNAFPowerManager != (Object)null)
			{
				fNAFPowerManager.OnPowerDepleted = (Action)Delegate.Combine(fNAFPowerManager.OnPowerDepleted, new Action(ForceBlackout));
			}
		}

		private void ShowOnlyBlackScreen()
		{
			if ((Object)(object)blackScreen != (Object)null)
			{
				blackScreen.SetActive(true);
			}
			if (cameraViews != null)
			{
				for (int i = 0; i < cameraViews.Count; i++)
				{
					if ((Object)(object)cameraViews[i] != (Object)null)
					{
						cameraViews[i].SetActive(false);
					}
				}
			}
			if (cameras != null)
			{
				for (int j = 0; j < cameras.Count; j++)
				{
					if ((Object)(object)cameras[j] != (Object)null)
					{
						cameras[j].SetActive(false);
					}
				}
			}
			currentIndex = -1;
		}

		public void SwitchToCamera(int index)
		{
			if (!powerLocked && !cameraOff && cameraViews != null && index >= 0 && index < cameraViews.Count && index != currentIndex)
			{
				if (switchRoutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(switchRoutine);
				}
				switchRoutine = ((MonoBehaviour)this).StartCoroutine(SwitchRoutine(index));
			}
		}

		private IEnumerator SwitchRoutine(int targetIndex)
		{
			if ((Object)(object)audioSource != (Object)null && (Object)(object)switchSound != (Object)null)
			{
				audioSource.PlayOneShot(switchSound);
			}
			if ((Object)(object)blackScreen != (Object)null)
			{
				blackScreen.SetActive(true);
			}
			for (int i = 0; i < cameraViews.Count; i++)
			{
				if ((Object)(object)cameraViews[i] != (Object)null)
				{
					cameraViews[i].SetActive(false);
				}
			}
			if (cameras != null)
			{
				for (int j = 0; j < cameras.Count; j++)
				{
					if ((Object)(object)cameras[j] != (Object)null)
					{
						cameras[j].SetActive(false);
					}
				}
			}
			if (switchBlackTime > 0f)
			{
				yield return (object)new WaitForSeconds(switchBlackTime);
			}
			GameObject targetView = cameraViews[targetIndex];
			if ((Object)(object)targetView != (Object)null)
			{
				targetView.SetActive(true);
			}
			if (cameras != null && targetIndex < cameras.Count)
			{
				GameObject val = cameras[targetIndex];
				if ((Object)(object)val != (Object)null)
				{
					val.SetActive(true);
				}
			}
			if ((Object)(object)blackScreen != (Object)null)
			{
				blackScreen.SetActive(false);
			}
			currentIndex = targetIndex;
			switchRoutine = null;
		}

		public void TurnOffCamera()
		{
			if (powerLocked)
			{
				return;
			}
			cameraOff = true;
			if ((Object)(object)blackScreen != (Object)null)
			{
				blackScreen.SetActive(true);
			}
			if (cameraViews != null)
			{
				for (int i = 0; i < cameraViews.Count; i++)
				{
					if ((Object)(object)cameraViews[i] != (Object)null)
					{
						cameraViews[i].SetActive(false);
					}
				}
			}
			if (cameras != null)
			{
				for (int j = 0; j < cameras.Count; j++)
				{
					if ((Object)(object)cameras[j] != (Object)null)
					{
						cameras[j].SetActive(false);
					}
				}
			}
			currentIndex = -1;
		}

		public void TurnOnCamera()
		{
			if (!powerLocked)
			{
				cameraOff = false;
				if (currentIndex >= 0)
				{
					SwitchToCamera(currentIndex);
				}
				else if (cameraViews != null && cameraViews.Count > 0)
				{
					SwitchToCamera(0);
				}
			}
		}

		public void ForceBlackout()
		{
			powerLocked = true;
			cameraOff = true;
			if ((Object)(object)blackScreen != (Object)null)
			{
				blackScreen.SetActive(true);
			}
			if (cameraViews != null)
			{
				for (int i = 0; i < cameraViews.Count; i++)
				{
					if ((Object)(object)cameraViews[i] != (Object)null)
					{
						cameraViews[i].SetActive(false);
					}
				}
			}
			if (cameras != null)
			{
				for (int j = 0; j < cameras.Count; j++)
				{
					if ((Object)(object)cameras[j] != (Object)null)
					{
						cameras[j].SetActive(false);
					}
				}
			}
			currentIndex = -1;
		}

		public bool IsConsumingPower()
		{
			if (powerLocked)
			{
				return false;
			}
			if (cameraOff)
			{
				return false;
			}
			return true;
		}

		public float GetPowerDrainRate()
		{
			return cameraDrainRate;
		}
	}
	public class FNAFCameraOffSwitch : MonoBehaviour
	{
		[Header("监控管理器")]
		public FNAFCameraManager cameraManager;

		[Header("开关动画")]
		public Transform switchHandle;

		public GameObject handleStartPrefab;

		public GameObject handleEndPrefab;

		public float animDuration = 0.2f;

		private Vector3 startPos;

		private Vector3 endPos;

		private Quaternion startRot;

		private Quaternion endRot;

		private Coroutine animCoroutine;

		private AR15HandleSightFlipper flipper;

		[Header("音效")]
		public AudioSource audioSource;

		public AudioClip toggleSound;

		public AudioClip turnOffSound;

		public AudioClip turnOnSound;

		private bool switchDown = true;

		private bool isAnimating = false;

		[Header("Debug 控制")]
		public bool debugToggle = false;

		private void Start()
		{
			//IL_004d: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_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_00a0: 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)
			flipper = ((Component)this).GetComponent<AR15HandleSightFlipper>();
			if ((Object)(object)switchHandle != (Object)null && (Object)(object)handleStartPrefab != (Object)null && (Object)(object)handleEndPrefab != (Object)null)
			{
				startPos = handleStartPrefab.transform.localPosition;
				startRot = handleStartPrefab.transform.localRotation;
				endPos = handleEndPrefab.transform.localPosition;
				endRot = handleEndPrefab.transform.localRotation;
				switchHandle.localPosition = startPos;
				switchHandle.localRotation = startRot;
			}
			if ((Object)(object)flipper != (Object)null)
			{
				flipper.m_isLargeAperture = switchDown;
			}
		}

		private void Update()
		{
			if (debugToggle)
			{
				debugToggle = false;
				ToggleSwitch();
			}
			if ((!((Object)(object)cameraManager != (Object)null) || !cameraManager.cameraOff || !((Object)(object)flipper != (Object)null) || flipper.m_isLargeAperture != switchDown) && !isAnimating && (Object)(object)flipper != (Object)null && flipper.m_isLargeAperture != switchDown)
			{
				ToggleSwitch();
			}
		}

		private void ToggleSwitch()
		{
			if (isAnimating)
			{
				return;
			}
			switchDown = !switchDown;
			PlaySwitchAnimation(switchDown);
			if ((Object)(object)audioSource != (Object)null && (Object)(object)toggleSound != (Object)null)
			{
				audioSource.PlayOneShot(toggleSound);
			}
			if (switchDown)
			{
				if ((Object)(object)audioSource != (Object)null && (Object)(object)turnOffSound != (Object)null)
				{
					audioSource.PlayOneShot(turnOffSound);
				}
				if ((Object)(object)cameraManager != (Object)null)
				{
					cameraManager.TurnOffCamera();
				}
			}
			else
			{
				if ((Object)(object)audioSource != (Object)null && (Object)(object)turnOnSound != (Object)null)
				{
					audioSource.PlayOneShot(turnOnSound);
				}
				if ((Object)(object)cameraManager != (Object)null)
				{
					cameraManager.TurnOnCamera();
				}
			}
			if ((Object)(object)flipper != (Object)null)
			{
				flipper.m_isLargeAperture = switchDown;
			}
		}

		private void PlaySwitchAnimation(bool down)
		{
			if (animCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(animCoroutine);
			}
			isAnimating = true;
			animCoroutine = ((MonoBehaviour)this).StartCoroutine(AnimateSwitch(down));
		}

		private IEnumerator AnimateSwitch(bool down)
		{
			if (!((Object)(object)switchHandle == (Object)null))
			{
				Vector3 fromPos = switchHandle.localPosition;
				Quaternion fromRot = switchHandle.localRotation;
				Vector3 toPos = ((!down) ? startPos : endPos);
				Quaternion toRot = ((!down) ? startRot : endRot);
				float t = 0f;
				while (t < animDuration)
				{
					float lerp = t / animDuration;
					switchHandle.localPosition = Vector3.Lerp(fromPos, toPos, lerp);
					switchHandle.localRotation = Quaternion.Lerp(fromRot, toRot, lerp);
					t += Time.deltaTime;
					yield return null;
				}
				switchHandle.localPosition = toPos;
				switchHandle.localRotation = toRot;
				isAnimating = false;
			}
		}
	}
	public class FNAFDeskFan : MonoBehaviour, IFNAFPowerConsumer
	{
		[Header("旋转部件(扇叶)")]
		public Transform rotatePart;

		[Header("旋转设置")]
		public Vector3 rotationAxis = new Vector3(0f, 1f, 0f);

		public float rotationSpeed = 300f;

		[Header("音效")]
		public AudioSource fanAudioSource;

		[Header("输入开关(AR15 FlipSight)")]
		public AR15HandleSightFlipper flipper;

		[Header("电力系统")]
		public FNAFPowerManager powerManager;

		private bool fanEnabled = true;

		private void Update()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)flipper != (Object)null)
			{
				fanEnabled = flipper.m_isLargeAperture;
			}
			if ((Object)(object)powerManager != (Object)null && powerManager.IsPowerOut())
			{
				if ((Object)(object)fanAudioSource != (Object)null && fanAudioSource.isPlaying)
				{
					fanAudioSource.Stop();
				}
			}
			else if (fanEnabled)
			{
				if ((Object)(object)rotatePart != (Object)null)
				{
					rotatePart.Rotate(rotationAxis * rotationSpeed * Time.deltaTime);
				}
				if ((Object)(object)fanAudioSource != (Object)null && !fanAudioSource.isPlaying)
				{
					fanAudioSource.Play();
				}
			}
			else if ((Object)(object)fanAudioSource != (Object)null && fanAudioSource.isPlaying)
			{
				fanAudioSource.Stop();
			}
		}

		public bool IsConsumingPower()
		{
			return fanEnabled;
		}

		public float GetPowerDrainRate()
		{
			return 0.2f;
		}
	}
	public class FNAFDoor : MonoBehaviour, IFNAFPowerConsumer
	{
		public enum DoorState
		{
			Open,
			Closed
		}

		[Serializable]
		public class DoorAnimatedPart
		{
			public Transform target;

			public GameObject startPrefab;

			public GameObject endPrefab;

			public float delay = 0f;

			public float duration = 1f;

			[HideInInspector]
			public Vector3 startPos;

			[HideInInspector]
			public Vector3 endPos;

			[HideInInspector]
			public Quaternion startRot;

			[HideInInspector]
			public Quaternion endRot;

			[HideInInspector]
			public Vector3 startScale;

			[HideInInspector]
			public Vector3 endScale;

			[HideInInspector]
			public Coroutine runningCoroutine;
		}

		[Header("动画物体列表")]
		public List<DoorAnimatedPart> doorParts = new List<DoorAnimatedPart>();

		[Header("耗电设置")]
		public float powerDrainRate = 1f;

		[Header("门灯光提示")]
		public List<Light> doorLights = new List<Light>();

		public Color lightOpenColor = Color.green;

		public Color lightClosedColor = Color.red;

		[Header("门音效")]
		public AudioSource audioSource;

		public AudioClip openSound;

		public AudioClip closeSound;

		[Header("当前门状态(Output)")]
		public DoorState currentState = DoorState.Open;

		[Header("引用")]
		public FNAFPowerManager powerManager;

		public Action OnDoorClosedEvent;

		public Action OnDoorOpenedEvent;

		private bool lastPowerOut = false;

		private bool fakePowerOut = false;

		public void ForceDoorBroken()
		{
			fakePowerOut = true;
			OpenDoor();
		}

		private void Start()
		{
			//IL_0060: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_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_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_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)
			foreach (DoorAnimatedPart doorPart in doorParts)
			{
				if (!((Object)(object)doorPart.target == (Object)null) && !((Object)(object)doorPart.startPrefab == (Object)null) && !((Object)(object)doorPart.endPrefab == (Object)null))
				{
					doorPart.startPos = doorPart.startPrefab.transform.localPosition;
					doorPart.startRot = doorPart.startPrefab.transform.localRotation;
					doorPart.startScale = doorPart.startPrefab.transform.localScale;
					doorPart.endPos = doorPart.endPrefab.transform.localPosition;
					doorPart.endRot = doorPart.endPrefab.transform.localRotation;
					doorPart.endScale = doorPart.endPrefab.transform.localScale;
				}
			}
			UpdateLights();
		}

		private void Update()
		{
			bool flag = (Object)(object)powerManager != (Object)null && powerManager.IsPowerOut();
			if (flag && !lastPowerOut && currentState == DoorState.Closed && (Object)(object)audioSource != (Object)null && (Object)(object)openSound != (Object)null)
			{
				audioSource.PlayOneShot(openSound);
			}
			if ((flag || fakePowerOut) && currentState != 0)
			{
				OpenDoor();
			}
			lastPowerOut = flag;
		}

		public void TryCloseDoor()
		{
			if (!fakePowerOut && (!((Object)(object)powerManager != (Object)null) || !powerManager.IsPowerOut()))
			{
				CloseDoor();
			}
		}

		public void TryOpenDoor()
		{
			OpenDoor();
		}

		public void OpenDoor()
		{
			currentState = DoorState.Open;
			UpdateLights();
			PlaySound(openSound);
			if (OnDoorOpenedEvent != null)
			{
				OnDoorOpenedEvent();
			}
			foreach (DoorAnimatedPart doorPart in doorParts)
			{
				if (doorPart.runningCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(doorPart.runningCoroutine);
				}
				doorPart.runningCoroutine = ((MonoBehaviour)this).StartCoroutine(AnimatePart(doorPart, closing: false));
			}
		}

		public void CloseDoor()
		{
			currentState = DoorState.Closed;
			UpdateLights();
			PlaySound(closeSound);
			if (OnDoorClosedEvent != null)
			{
				OnDoorClosedEvent();
			}
			foreach (DoorAnimatedPart doorPart in doorParts)
			{
				if (doorPart.runningCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(doorPart.runningCoroutine);
				}
				doorPart.runningCoroutine = ((MonoBehaviour)this).StartCoroutine(AnimatePart(doorPart, closing: true));
			}
		}

		private IEnumerator AnimatePart(DoorAnimatedPart part, bool closing)
		{
			if (part.delay > 0f)
			{
				yield return (object)new WaitForSeconds(part.delay);
			}
			Vector3 startPos = part.target.localPosition;
			Quaternion startRot = part.target.localRotation;
			Vector3 startScale = part.target.localScale;
			Vector3 targetPos = ((!closing) ? part.startPos : part.endPos);
			Quaternion targetRot = ((!closing) ? part.startRot : part.endRot);
			Vector3 targetScale = ((!closing) ? part.startScale : part.endScale);
			float t = 0f;
			while (t < part.duration)
			{
				float lerp = t / part.duration;
				part.target.localPosition = Vector3.Lerp(startPos, targetPos, lerp);
				part.target.localRotation = Quaternion.Lerp(startRot, targetRot, lerp);
				part.target.localScale = Vector3.Lerp(startScale, targetScale, lerp);
				t += Time.deltaTime;
				yield return null;
			}
			part.target.localPosition = targetPos;
			part.target.localRotation = targetRot;
			part.target.localScale = targetScale;
		}

		private void UpdateLights()
		{
			//IL_0046: 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)
			foreach (Light doorLight in doorLights)
			{
				if (!((Object)(object)doorLight == (Object)null))
				{
					doorLight.color = ((currentState != DoorState.Closed) ? lightOpenColor : lightClosedColor);
				}
			}
		}

		private void PlaySound(AudioClip clip)
		{
			if ((!((Object)(object)powerManager != (Object)null) || !powerManager.IsPowerOut()) && (Object)(object)audioSource != (Object)null && (Object)(object)clip != (Object)null)
			{
				audioSource.PlayOneShot(clip);
			}
		}

		public bool IsConsumingPower()
		{
			return currentState == DoorState.Closed;
		}

		public float GetPowerDrainRate()
		{
			return powerDrainRate;
		}

		public bool IsDoorClosed()
		{
			return currentState == DoorState.Closed;
		}
	}
	public enum SwitchInitialState
	{
		Off,
		On
	}
	public class FNAFDoorSwitch : MonoBehaviour
	{
		[Header("门本体引用")]
		public FNAFDoor door;

		[Header("开关动画")]
		public Transform switchHandle;

		public GameObject handleStartPrefab;

		public GameObject handleEndPrefab;

		public float animDuration = 0.2f;

		[Header("开关音效")]
		public AudioSource switchAudioSource;

		public AudioClip switchToggleSound;

		public AudioClip switchOpenSound;

		public AudioClip switchCloseSound;

		private Vector3 startPos;

		private Vector3 endPos;

		private Quaternion startRot;

		private Quaternion endRot;

		private Coroutine animCoroutine;

		private AR15HandleSightFlipper flipper;

		private bool switchDown = false;

		[Header("初始开关状态(Play 前设置)")]
		public SwitchInitialState initialState = SwitchInitialState.Off;

		[Header("Debug 控制")]
		public bool debugForceOpen = false;

		public bool debugForceClose = false;

		public bool debugToggleSwitch = false;

		[Header("Debug:直接控制开关状态(On=关门 / Off=开门)")]
		[SerializeField]
		private bool debugSwitchState = false;

		private bool lastDebugSwitchState = false;

		private void PlayToggleSound()
		{
			if ((Object)(object)switchAudioSource != (Object)null && (Object)(object)switchToggleSound != (Object)null)
			{
				switchAudioSource.PlayOneShot(switchToggleSound);
			}
		}

		private void PlayOpenSound()
		{
			if ((Object)(object)switchAudioSource != (Object)null && (Object)(object)switchOpenSound != (Object)null)
			{
				switchAudioSource.PlayOneShot(switchOpenSound);
			}
		}

		private void PlayCloseSound()
		{
			if ((Object)(object)switchAudioSource != (Object)null && (Object)(object)switchCloseSound != (Object)null)
			{
				switchAudioSource.PlayOneShot(switchCloseSound);
			}
		}

		private void Start()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_00a5: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			flipper = ((Component)this).GetComponent<AR15HandleSightFlipper>();
			switchDown = initialState == SwitchInitialState.On;
			debugSwitchState = switchDown;
			lastDebugSwitchState = debugSwitchState;
			if ((Object)(object)switchHandle != (Object)null && (Object)(object)handleStartPrefab != (Object)null && (Object)(object)handleEndPrefab != (Object)null)
			{
				startPos = handleStartPrefab.transform.localPosition;
				startRot = handleStartPrefab.transform.localRotation;
				endPos = handleEndPrefab.transform.localPosition;
				endRot = handleEndPrefab.transform.localRotation;
				if (switchDown)
				{
					switchHandle.localPosition = endPos;
					switchHandle.localRotation = endRot;
				}
				else
				{
					switchHandle.localPosition = startPos;
					switchHandle.localRotation = startRot;
				}
			}
			if ((Object)(object)flipper != (Object)null)
			{
				flipper.m_isLargeAperture = switchDown;
			}
		}

		private void Update()
		{
			if (debugSwitchState != lastDebugSwitchState)
			{
				lastDebugSwitchState = debugSwitchState;
				switchDown = debugSwitchState;
				PlaySwitchAnimation(switchDown);
				PlayToggleSound();
				if (switchDown)
				{
					PlayCloseSound();
					door.TryCloseDoor();
				}
				else
				{
					PlayOpenSound();
					door.TryOpenDoor();
				}
			}
			if (debugForceOpen)
			{
				debugForceOpen = false;
				switchDown = false;
				debugSwitchState = false;
				PlaySwitchAnimation(down: false);
				PlayToggleSound();
				PlayOpenSound();
				door.TryOpenDoor();
			}
			if (debugForceClose)
			{
				debugForceClose = false;
				switchDown = true;
				debugSwitchState = true;
				PlaySwitchAnimation(down: true);
				PlayToggleSound();
				PlayCloseSound();
				door.TryCloseDoor();
			}
			if (debugToggleSwitch)
			{
				debugToggleSwitch = false;
				if ((Object)(object)flipper != (Object)null)
				{
					flipper.m_isLargeAperture = !flipper.m_isLargeAperture;
				}
				PlayToggleSound();
			}
			if ((Object)(object)flipper != (Object)null && flipper.m_isLargeAperture != switchDown)
			{
				switchDown = !switchDown;
				debugSwitchState = switchDown;
				PlaySwitchAnimation(switchDown);
				PlayToggleSound();
				if (switchDown)
				{
					PlayCloseSound();
					door.TryCloseDoor();
				}
				else
				{
					PlayOpenSound();
					door.TryOpenDoor();
				}
			}
		}

		private void PlaySwitchAnimation(bool down)
		{
			if (animCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(animCoroutine);
			}
			animCoroutine = ((MonoBehaviour)this).StartCoroutine(AnimateSwitch(down));
		}

		private IEnumerator AnimateSwitch(bool down)
		{
			if (!((Object)(object)switchHandle == (Object)null))
			{
				Vector3 fromPos = switchHandle.localPosition;
				Quaternion fromRot = switchHandle.localRotation;
				Vector3 toPos = ((!down) ? startPos : endPos);
				Quaternion toRot = ((!down) ? startRot : endRot);
				float t = 0f;
				while (t < animDuration)
				{
					float lerp = t / animDuration;
					switchHandle.localPosition = Vector3.Lerp(fromPos, toPos, lerp);
					switchHandle.localRotation = Quaternion.Lerp(fromRot, toRot, lerp);
					t += Time.deltaTime;
					yield return null;
				}
				switchHandle.localPosition = toPos;
				switchHandle.localRotation = toRot;
			}
		}
	}
	public class FNAFLightSwitch : MonoBehaviour, IFNAFPowerConsumer
	{
		[Header("灯光 Prefab(初始应为关闭状态)")]
		public GameObject lightObject;

		public AudioSource audioSource;

		public AudioClip lightOnSound;

		public AudioClip lightOffSound;

		[Header("AR15HandleSightFlipper 作为开关")]
		public AR15HandleSightFlipper flipSwitch;

		[Header("电量系统")]
		public float powerDrainPerSecond = 0.5f;

		[SerializeField]
		public bool isOn = false;

		[Header("闪烁效果 Flickering")]
		[Range(0f, 1f)]
		public float flickerChance = 0.05f;

		public float flickerCooldown = 0.05f;

		private float flickerTimer = 0f;

		[Header("初始灯光状态")]
		public bool startOn = false;

		[Header("Debug 控制")]
		public bool debugForceOn = false;

		public bool debugForceOff = false;

		[SerializeField]
		private bool powerOut = false;

		private bool lastFlipState = false;

		private FNAFPowerManager pm;

		private void Start()
		{
			pm = Object.FindObjectOfType<FNAFPowerManager>();
			if ((Object)(object)pm == (Object)null)
			{
				Debug.LogError((object)"[FNAFLightSwitch] 找不到 FNAFPowerManager,灯光无法正常工作!");
			}
			if (startOn)
			{
				TurnOn();
			}
			else
			{
				TurnOff();
			}
			if ((Object)(object)flipSwitch != (Object)null)
			{
				lastFlipState = flipSwitch.m_isLargeAperture;
			}
		}

		private void Update()
		{
			if ((Object)(object)pm == (Object)null)
			{
				return;
			}
			if (debugForceOn)
			{
				debugForceOn = false;
				TurnOn();
			}
			if (debugForceOff)
			{
				debugForceOff = false;
				TurnOff();
			}
			if (!powerOut && pm.IsPowerOut())
			{
				TriggerPowerOut();
			}
			if (powerOut)
			{
				return;
			}
			if ((Object)(object)flipSwitch != (Object)null && flipSwitch.m_isLargeAperture != lastFlipState)
			{
				lastFlipState = flipSwitch.m_isLargeAperture;
				if (isOn)
				{
					TurnOff();
				}
				else
				{
					TurnOn();
				}
			}
			if (!isOn)
			{
				return;
			}
			flickerTimer += Time.deltaTime;
			if (flickerTimer >= flickerCooldown)
			{
				flickerTimer = 0f;
				if (Random.value < flickerChance)
				{
					((MonoBehaviour)this).StartCoroutine(FlickerOnce());
				}
			}
		}

		private void TriggerPowerOut()
		{
			powerOut = true;
			isOn = false;
			if ((Object)(object)lightObject != (Object)null)
			{
				lightObject.SetActive(false);
			}
			if ((Object)(object)audioSource != (Object)null && (Object)(object)lightOffSound != (Object)null)
			{
				audioSource.PlayOneShot(lightOffSound);
			}
			if ((Object)(object)flipSwitch != (Object)null)
			{
				((Behaviour)flipSwitch).enabled = false;
			}
		}

		private void TurnOn()
		{
			if (!powerOut)
			{
				isOn = true;
				if ((Object)(object)lightObject != (Object)null)
				{
					lightObject.SetActive(true);
				}
				if ((Object)(object)audioSource != (Object)null && (Object)(object)lightOnSound != (Object)null)
				{
					audioSource.PlayOneShot(lightOnSound);
				}
			}
		}

		private void TurnOff()
		{
			isOn = false;
			if ((Object)(object)lightObject != (Object)null)
			{
				lightObject.SetActive(false);
			}
			if ((Object)(object)audioSource != (Object)null && (Object)(object)lightOffSound != (Object)null)
			{
				audioSource.PlayOneShot(lightOffSound);
			}
		}

		private IEnumerator FlickerOnce()
		{
			if (!powerOut && !((Object)(object)lightObject == (Object)null))
			{
				lightObject.SetActive(false);
				yield return (object)new WaitForSeconds(Random.Range(0.02f, 0.08f));
				lightObject.SetActive(true);
			}
		}

		public bool IsConsumingPower()
		{
			return isOn && !powerOut;
		}

		public float GetPowerDrainRate()
		{
			return powerDrainPerSecond;
		}
	}
	public class FNAFNightClock : MonoBehaviour
	{
		[Header("夜班时间设置")]
		public int startHour = 12;

		public int endHour = 6;

		public float realSecondsPerHour = 60f;

		[Header("当前游戏时间(只读)")]
		public int currentHour = 12;

		public float hourTimer = 0f;

		[Header("事件")]
		public Action<int> OnHourChanged;

		public Action OnNightCompleted;

		[Header("6AM 时要开启的隐藏 Prefabs")]
		public GameObject[] prefabsToEnableAtEnd;

		[Header("6AM 时要关闭的 Prefabs")]
		public GameObject[] prefabsToDisableAtEnd;

		private bool clockRunning = false;

		public bool IsRunning()
		{
			return clockRunning;
		}

		private void Start()
		{
			currentHour = startHour;
			hourTimer = 0f;
			clockRunning = false;
		}

		private void Update()
		{
			if (clockRunning)
			{
				hourTimer += Time.deltaTime;
				if (hourTimer >= realSecondsPerHour)
				{
					hourTimer = 0f;
					AdvanceHour();
				}
			}
		}

		private void AdvanceHour()
		{
			currentHour++;
			if (currentHour > 12 && currentHour < 100)
			{
				currentHour -= 12;
			}
			if (OnHourChanged != null)
			{
				OnHourChanged(currentHour);
			}
			if (currentHour != endHour)
			{
				return;
			}
			if (OnNightCompleted != null)
			{
				OnNightCompleted();
			}
			clockRunning = false;
			StopAllAI();
			GameObject[] array = prefabsToEnableAtEnd;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.SetActive(true);
				}
			}
			GameObject[] array2 = prefabsToDisableAtEnd;
			foreach (GameObject val2 in array2)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					val2.SetActive(false);
				}
			}
			Debug.Log((object)"[FNAFNightClock] 6AM 到达,开启隐藏 Prefabs 并关闭指定 Prefabs!");
		}

		public void StartClock()
		{
			clockRunning = true;
		}

		public void PauseClock()
		{
			clockRunning = false;
			FNAFAnimatronicAI[] array = Object.FindObjectsOfType<FNAFAnimatronicAI>();
			for (int i = 0; i < array.Length; i++)
			{
				array[i].DeactivateAI();
			}
		}

		public void ResetClock()
		{
			currentHour = startHour;
			hourTimer = 0f;
			clockRunning = false;
			StopAllAI();
		}

		private void StopAllAI()
		{
			FNAFAnimatronicAI[] array = Object.FindObjectsOfType<FNAFAnimatronicAI>();
			for (int i = 0; i < array.Length; i++)
			{
				array[i].DeactivateAI();
			}
		}
	}
	public class FNAFPowerManager : MonoBehaviour
	{
		[Header("电量设置")]
		public float maxPower = 100f;

		public float currentPower = 100f;

		[Header("电量动画")]
		public Transform powerBarTarget;

		public GameObject powerStartPrefab;

		public GameObject powerEndPrefab;

		private Vector3 startPos;

		private Vector3 endPos;

		private Vector3 startScale;

		private Vector3 endScale;

		[Header("耗电设备列表(添加脚本而不是空GameObject)")]
		public List<MonoBehaviour> powerConsumers = new List<MonoBehaviour>();

		private List<IFNAFPowerConsumer> consumerInterfaces = new List<IFNAFPowerConsumer>();

		[Header("每个设备的耗电占比(和 powerConsumers 一一对应)")]
		public List<float> consumerWeights = new List<float>();

		[Header("Debug控制")]
		public bool debugForceFullPower = false;

		public bool debugForceZeroPower = false;

		[SerializeField]
		private bool isPowerOut = false;

		public Action OnPowerDepleted;

		[Header("停电后启用的 Prefab 列表")]
		public GameObject[] enableOnBlackout;

		[Header("停电后禁用的 Prefab 列表")]
		public GameObject[] disableOnBlackout;

		[Header("停电音效")]
		public AudioClip blackoutSound;

		public AudioSource blackoutAudioSource;

		private bool blackoutTriggered = false;

		[Header("夜晚绑定")]
		public FNAFNightClock nightClock;

		[Header("用电指示器")]
		public Transform usageBarTarget;

		public GameObject usageStartPrefab;

		public GameObject usageEndPrefab;

		private Vector3 usageStartPos;

		private Vector3 usageEndPos;

		private Vector3 usageStartScale;

		private Vector3 usageEndScale;

		private void Start()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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_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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)powerStartPrefab != (Object)null)
			{
				startPos = powerStartPrefab.transform.localPosition;
				startScale = powerStartPrefab.transform.localScale;
			}
			if ((Object)(object)powerEndPrefab != (Object)null)
			{
				endPos = powerEndPrefab.transform.localPosition;
				endScale = powerEndPrefab.transform.localScale;
			}
			if ((Object)(object)usageStartPrefab != (Object)null)
			{
				usageStartPos = usageStartPrefab.transform.localPosition;
				usageStartScale = usageStartPrefab.transform.localScale;
			}
			if ((Object)(object)usageEndPrefab != (Object)null)
			{
				usageEndPos = usageEndPrefab.transform.localPosition;
				usageEndScale = usageEndPrefab.transform.localScale;
			}
			foreach (MonoBehaviour powerConsumer in powerConsumers)
			{
				if (powerConsumer is IFNAFPowerConsumer item)
				{
					consumerInterfaces.Add(item);
				}
				else
				{
					Debug.LogWarning((object)("[PowerManager] 你添加的对象没有实现 IFNAFPowerConsumer: " + ((Object)powerConsumer).name));
				}
			}
			OnPowerDepleted = (Action)Delegate.Combine(OnPowerDepleted, new Action(HandleBlackout));
		}

		private void Update()
		{
			if ((Object)(object)nightClock != (Object)null && !nightClock.IsRunning())
			{
				return;
			}
			if (debugForceFullPower)
			{
				debugForceFullPower = false;
				currentPower = maxPower;
				isPowerOut = false;
				blackoutTriggered = false;
				UpdatePowerBar();
				UpdateUsageBar(0f);
				return;
			}
			if (debugForceZeroPower)
			{
				debugForceZeroPower = false;
				currentPower = 0f;
				isPowerOut = true;
				UpdatePowerBar();
				UpdateUsageBar(1f);
				if (OnPowerDepleted != null)
				{
					OnPowerDepleted();
				}
				return;
			}
			float num = 0f;
			foreach (IFNAFPowerConsumer consumerInterface in consumerInterfaces)
			{
				if (consumerInterface.IsConsumingPower())
				{
					num += consumerInterface.GetPowerDrainRate() * Time.deltaTime;
				}
			}
			currentPower -= num;
			currentPower = Mathf.Clamp(currentPower, 0f, maxPower);
			UpdatePowerBar();
			float num2 = 0f;
			for (int i = 0; i < consumerInterfaces.Count; i++)
			{
				if (consumerInterfaces[i].IsConsumingPower())
				{
					float num3 = ((i >= consumerWeights.Count) ? 10f : consumerWeights[i]);
					num2 += num3;
				}
			}
			num2 = Mathf.Clamp(num2, 0f, 100f);
			UpdateUsageBar(num2 / 100f);
			if (currentPower <= 0f && !isPowerOut)
			{
				isPowerOut = true;
				if (OnPowerDepleted != null)
				{
					OnPowerDepleted();
				}
			}
			else if (currentPower > 0f)
			{
				isPowerOut = false;
			}
		}

		private void UpdatePowerBar()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)powerBarTarget == (Object)null))
			{
				float num = currentPower / maxPower;
				powerBarTarget.localPosition = Vector3.Lerp(endPos, startPos, num);
				powerBarTarget.localScale = Vector3.Lerp(endScale, startScale, num);
			}
		}

		private void UpdateUsageBar(float percent)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_003b: 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)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)usageBarTarget == (Object)null))
			{
				usageBarTarget.localPosition = Vector3.Lerp(usageEndPos, usageStartPos, percent);
				usageBarTarget.localScale = Vector3.Lerp(usageEndScale, usageStartScale, percent);
			}
		}

		public bool IsPowerOut()
		{
			return isPowerOut;
		}

		private void HandleBlackout()
		{
			if (blackoutTriggered)
			{
				return;
			}
			blackoutTriggered = true;
			GameObject[] array = enableOnBlackout;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.SetActive(true);
				}
			}
			GameObject[] array2 = disableOnBlackout;
			foreach (GameObject val2 in array2)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					val2.SetActive(false);
				}
			}
			if ((Object)(object)blackoutAudioSource != (Object)null && (Object)(object)blackoutSound != (Object)null)
			{
				blackoutAudioSource.PlayOneShot(blackoutSound);
			}
			Debug.Log((object)"[PowerManager] 停电触发:启用 enableOnBlackout + 禁用 disableOnBlackout + 播放音效");
		}
	}
	[Serializable]
	public class NextPointData
	{
		public FNAFWaypoint nextPoint;

		public int chance = 100;
	}
	public class FNAFWaypoint : MonoBehaviour
	{
		[HideInInspector]
		public int index;

		[Header("可以前往的路径点(含概率)")]
		public NextPointData[] nextPoints;

		[Header("是否为门前节点")]
		public bool isDoorNode = false;

		public GameObject doorToCheck;

		public bool breakDoor = false;

		public FNAFWaypoint[] failReturnPoints;

		[Header("是否为攻击节点")]
		public bool isAttackNode = false;

		public GameObject attackPrefabToEnable;

		[Header("到达此路径点时的音效(纯随机播放一个)")]
		public AudioClip[] randomSounds;

		[Header("强制移动设置")]
		public bool forceMove = false;

		public float forceMoveDelay = 2f;

		private bool hasStartedForceMove = false;

		public GameObject Pose => ((Component)this).gameObject;

		public void TryPlaySound()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (randomSounds != null && randomSounds.Length != 0)
			{
				int num = Random.Range(0, randomSounds.Length);
				AudioClip val = randomSounds[num];
				if ((Object)(object)val != (Object)null)
				{
					AudioSource.PlayClipAtPoint(val, ((Component)this).transform.position);
					Debug.Log((object)("[FNAFWaypoint] 路径点 " + index + " 随机播放音效: " + ((Object)val).name));
				}
			}
		}

		public void TriggerAttack()
		{
			if (isAttackNode)
			{
				if ((Object)(object)attackPrefabToEnable != (Object)null)
				{
					attackPrefabToEnable.SetActive(true);
					Debug.Log((object)("[FNAFWaypoint] 攻击节点触发,已启用死亡 Prefab: " + ((Object)attackPrefabToEnable).name));
				}
				else
				{
					Debug.LogWarning((object)"[FNAFWaypoint] 攻击节点没有绑定 attackPrefabToEnable!");
				}
			}
		}

		public void StartForceMove()
		{
			if (forceMove && !hasStartedForceMove)
			{
				hasStartedForceMove = true;
				((MonoBehaviour)this).Invoke("DoForceMove", forceMoveDelay);
				Debug.Log((object)("[FNAFWaypoint] 节点 " + index + " 已启动强制移动计时器," + forceMoveDelay + " 秒后进入下一个节点"));
			}
		}

		private void DoForceMove()
		{
			if (nextPoints == null || nextPoints.Length <= 0)
			{
				return;
			}
			int num = 0;
			NextPointData[] array = nextPoints;
			foreach (NextPointData nextPointData in array)
			{
				num += nextPointData.chance;
			}
			int num2 = Random.Range(0, num);
			FNAFWaypoint fNAFWaypoint = null;
			int num3 = 0;
			NextPointData[] array2 = nextPoints;
			foreach (NextPointData nextPointData2 in array2)
			{
				num3 += nextPointData2.chance;
				if (num2 < num3)
				{
					fNAFWaypoint = nextPointData2.nextPoint;
					break;
				}
			}
			if (!((Object)(object)fNAFWaypoint != (Object)null))
			{
				return;
			}
			Debug.Log((object)("[FNAFWaypoint] 节点 " + index + " 强制移动 → 下一个节点 " + fNAFWaypoint.index));
			if (fNAFWaypoint.isDoorNode && (Object)(object)fNAFWaypoint.doorToCheck != (Object)null)
			{
				FNAFDoor component = fNAFWaypoint.doorToCheck.GetComponent<FNAFDoor>();
				if (fNAFWaypoint.breakDoor && (Object)(object)component != (Object)null)
				{
					component.ForceDoorBroken();
					Debug.Log((object)("[FNAFWaypoint] 强制移动时破坏门: " + fNAFWaypoint.index));
				}
				if ((Object)(object)component != (Object)null && component.currentState == FNAFDoor.DoorState.Closed)
				{
					Debug.Log((object)"[FNAFWaypoint] 强制移动失败,门关闭 → 回退");
					if (fNAFWaypoint.failReturnPoints != null && fNAFWaypoint.failReturnPoints.Length > 0)
					{
						int num4 = Random.Range(0, fNAFWaypoint.failReturnPoints.Length);
						fNAFWaypoint = fNAFWaypoint.failReturnPoints[num4];
					}
					else
					{
						fNAFWaypoint = this;
					}
				}
			}
			FNAFAnimatronicAI componentInParent = ((Component)this).GetComponentInParent<FNAFAnimatronicAI>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				componentInParent.ForceMoveTo(fNAFWaypoint.index);
			}
		}
	}
	[RequireComponent(typeof(CharacterController))]
	public class FlatDebugController : MonoBehaviour
	{
		[Header("移动设置")]
		public float moveSpeed = 5f;

		public float lookSpeed = 2f;

		[Header("自定义交互球体")]
		public SphereCollider interactSphere;

		public LayerMask interactLayer;

		[Header("调试输入模拟")]
		public KeyCode triggerKey = (KeyCode)323;

		[Header("重力设置")]
		public float gravity = -9.81f;

		public float jumpHeight = 1.5f;

		private float pitch = 0f;

		private float verticalVelocity = 0f;

		private CharacterController controller;

		public Transform cameraPivot;

		private Camera cam;

		private void Start()
		{
			controller = ((Component)this).GetComponent<CharacterController>();
			cam = Camera.main;
			Cursor.lockState = (CursorLockMode)1;
		}

		private void Update()
		{
			HandleMovement();
			HandleMouseLook();
			HandleTrigger();
		}

		private void HandleMovement()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_003e: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			float axis = Input.GetAxis("Horizontal");
			float axis2 = Input.GetAxis("Vertical");
			Vector3 val = ((Component)this).transform.right * axis + ((Component)this).transform.forward * axis2;
			if (controller.isGrounded)
			{
				verticalVelocity = -1f;
				if (Input.GetButtonDown("Jump"))
				{
					verticalVelocity = Mathf.Sqrt(jumpHeight * -2f * gravity);
				}
			}
			else
			{
				verticalVelocity += gravity * Time.deltaTime;
			}
			val.y = verticalVelocity;
			controller.Move(val * moveSpeed * Time.deltaTime);
		}

		private void HandleMouseLook()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			float num = Input.GetAxis("Mouse X") * lookSpeed;
			float num2 = Input.GetAxis("Mouse Y") * lookSpeed;
			((Component)this).transform.Rotate(Vector3.up * num);
			pitch -= num2;
			pitch = Mathf.Clamp(pitch, -80f, 80f);
			cameraPivot.localRotation = Quaternion.Euler(pitch, 0f, 0f);
		}

		private void HandleTrigger()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (!Input.GetKeyDown(triggerKey) || !((Object)(object)interactSphere != (Object)null))
			{
				return;
			}
			Vector3 position = ((Component)interactSphere).transform.position;
			float num = interactSphere.radius * ((Component)interactSphere).transform.localScale.x;
			Collider[] array = Physics.OverlapSphere(position, num, LayerMask.op_Implicit(interactLayer));
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				AR15HandleSightFlipper component = ((Component)val).GetComponent<AR15HandleSightFlipper>();
				if ((Object)(object)component != (Object)null)
				{
					component.m_isLargeAperture = !component.m_isLargeAperture;
					Debug.Log((object)("[FlatDebugController] 模拟触发 AR15HandleSightFlipper → " + component.m_isLargeAperture));
				}
			}
		}

		private void OnDrawGizmosSelected()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)interactSphere != (Object)null)
			{
				Gizmos.color = Color.green;
				Vector3 position = ((Component)interactSphere).transform.position;
				float num = interactSphere.radius * ((Component)interactSphere).transform.localScale.x;
				Gizmos.DrawWireSphere(position, num);
			}
		}
	}
	public interface IFNAFPowerConsumer
	{
		bool IsConsumingPower();

		float GetPowerDrainRate();
	}
	public class MenuButton : MonoBehaviour
	{
		[Header("监听输入:AR15HandleSightFlipper")]
		public AR15HandleSightFlipper flipSwitch;

		[Header("要关闭的 Prefabs")]
		public GameObject[] prefabsToDisable;

		[Header("要开启的 Prefabs")]
		public GameObject[] prefabsToEnable;

		[Header("音效")]
		public AudioSource audioSource;

		public AudioClip triggerSound;

		[Header("Debug 控制")]
		public bool debugTrigger = false;

		private bool lastFlipState;

		private void Start()
		{
			if ((Object)(object)flipSwitch != (Object)null)
			{
				lastFlipState = flipSwitch.m_isLargeAperture;
			}
		}

		private void Update()
		{
			if (debugTrigger)
			{
				debugTrigger = false;
				TriggerAction();
			}
			if (!((Object)(object)flipSwitch == (Object)null) && flipSwitch.m_isLargeAperture != lastFlipState)
			{
				lastFlipState = flipSwitch.m_isLargeAperture;
				TriggerAction();
			}
		}

		public void TriggerAction()
		{
			if (prefabsToDisable != null)
			{
				GameObject[] array = prefabsToDisable;
				foreach (GameObject val in array)
				{
					if ((Object)(object)val != (Object)null)
					{
						val.SetActive(false);
					}
				}
			}
			if (prefabsToEnable != null)
			{
				GameObject[] array2 = prefabsToEnable;
				foreach (GameObject val2 in array2)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						val2.SetActive(true);
					}
				}
			}
			if ((Object)(object)audioSource != (Object)null && (Object)(object)triggerSound != (Object)null)
			{
				audioSource.PlayOneShot(triggerSound);
			}
			Debug.Log((object)"[MenuButton] Button Triggered");
		}
	}
	public class NightStartOnAwake : MonoBehaviour
	{
		[Header("夜晚时钟")]
		public FNAFNightClock nightClock;

		[Header("要激活的玩具 Prefabs(默认隐藏)")]
		public GameObject[] toyPrefabsToEnable;

		[Header("要关闭的 Prop Prefabs(可选)")]
		public GameObject[] propPrefabsToDisable;

		[Header("夜晚开始时要启用的 AI 脚本")]
		public FNAFAnimatronicAI[] aiScriptsToEnable;

		[Header("夜晚开始时要关闭的 AI 脚本")]
		public FNAFAnimatronicAI[] aiScriptsToDisable;

		private void Awake()
		{
			if ((Object)(object)nightClock != (Object)null)
			{
				nightClock.StartClock();
				Debug.Log((object)"[NightStartOnAwake] 夜晚开始!");
			}
			else
			{
				Debug.LogError((object)"[NightStartOnAwake] 没有绑定 NightClock!");
			}
			GameObject[] array = toyPrefabsToEnable;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.SetActive(true);
				}
			}
			GameObject[] array2 = propPrefabsToDisable;
			foreach (GameObject val2 in array2)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					val2.SetActive(false);
				}
			}
			FNAFAnimatronicAI[] array3 = aiScriptsToEnable;
			foreach (FNAFAnimatronicAI fNAFAnimatronicAI in array3)
			{
				if ((Object)(object)fNAFAnimatronicAI != (Object)null)
				{
					((Behaviour)fNAFAnimatronicAI).enabled = true;
					Debug.Log((object)("[NightStartOnAwake] 启用 AI 脚本: " + ((Object)fNAFAnimatronicAI).name));
				}
			}
			FNAFAnimatronicAI[] array4 = aiScriptsToDisable;
			foreach (FNAFAnimatronicAI fNAFAnimatronicAI2 in array4)
			{
				if ((Object)(object)fNAFAnimatronicAI2 != (Object)null)
				{
					((Behaviour)fNAFAnimatronicAI2).enabled = false;
					Debug.Log((object)("[NightStartOnAwake] 关闭 AI 脚本: " + ((Object)fNAFAnimatronicAI2).name));
				}
			}
		}
	}
	public class PrefabsOnOffAwake : MonoBehaviour
	{
		[Header("Awake 后延迟开启的 Prefab 列表")]
		public GameObject[] enablePrefabs;

		public float[] enableDelays;

		[Header("Awake 后延迟关闭的 Prefab 列表")]
		public GameObject[] disablePrefabs;

		public float[] disableDelays;

		private void Awake()
		{
			for (int i = 0; i < enablePrefabs.Length; i++)
			{
				float delay = ((i >= enableDelays.Length) ? 0f : enableDelays[i]);
				((MonoBehaviour)this).StartCoroutine(EnableAfterDelay(enablePrefabs[i], delay));
			}
			for (int j = 0; j < disablePrefabs.Length; j++)
			{
				float delay2 = ((j >= disableDelays.Length) ? 0f : disableDelays[j]);
				((MonoBehaviour)this).StartCoroutine(DisableAfterDelay(disablePrefabs[j], delay2));
			}
		}

		private IEnumerator EnableAfterDelay(GameObject obj, float delay)
		{
			if (delay > 0f)
			{
				yield return (object)new WaitForSeconds(delay);
			}
			if ((Object)(object)obj != (Object)null)
			{
				obj.SetActive(true);
			}
		}

		private IEnumerator DisableAfterDelay(GameObject obj, float delay)
		{
			if (delay > 0f)
			{
				yield return (object)new WaitForSeconds(delay);
			}
			if ((Object)(object)obj != (Object)null)
			{
				obj.SetActive(false);
			}
		}
	}
	public class RandomAppearance : MonoBehaviour
	{
		[Header("可随机激活的子物体列表")]
		public List<GameObject> targets = new List<GameObject>();

		[Header("随机间隔时间范围 (秒)")]
		public float minInterval = 0.1f;

		public float maxInterval = 0.5f;

		[Header("是否循环随机")]
		public bool loop = true;

		private float timer = 0f;

		private float nextInterval = 0f;

		private void Start()
		{
			ScheduleNext();
			DeactivateAll();
		}

		private void Update()
		{
			if (loop)
			{
				timer += Time.deltaTime;
				if (timer >= nextInterval)
				{
					timer = 0f;
					ScheduleNext();
					RandomToggle();
				}
			}
		}

		private void ScheduleNext()
		{
			nextInterval = Random.Range(minInterval, maxInterval);
		}

		private void RandomToggle()
		{
			if (targets != null && targets.Count != 0)
			{
				DeactivateAll();
				int index = Random.Range(0, targets.Count);
				if ((Object)(object)targets[index] != (Object)null)
				{
					targets[index].SetActive(true);
				}
			}
		}

		private void DeactivateAll()
		{
			foreach (GameObject target in targets)
			{
				if ((Object)(object)target != (Object)null)
				{
					target.SetActive(false);
				}
			}
		}
	}
	public class RestartSceneOnAwake : MonoBehaviour
	{
		[Header("延迟重启时间(秒)")]
		public float restartDelay = 0f;

		private void Awake()
		{
			//IL_0012: 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)
			if (restartDelay <= 0f)
			{
				Scene activeScene = SceneManager.GetActiveScene();
				SceneManager.LoadScene(((Scene)(ref activeScene)).name);
			}
			else
			{
				((MonoBehaviour)this).Invoke("RestartScene", restartDelay);
			}
		}

		private void RestartScene()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			SceneManager.LoadScene(((Scene)(ref activeScene)).name);
		}
	}
	[Serializable]
	public class RotateTarget
	{
		[Header("要旋转的对象")]
		public GameObject target;

		[Header("旋转轴选择")]
		public bool rotateX = false;

		public bool rotateY = true;

		public bool rotateZ = false;

		[Header("起始角度")]
		public float startAngle = 0f;

		[Header("结束角度")]
		public float endAngle = 90f;

		[Header("一次从起始到结束所需秒数")]
		public float durationSeconds = 2f;

		[Header("循环模式")]
		public bool isLoop = true;

		public bool oneWay = false;

		[Header("循环停留时间 (秒)")]
		public float pauseDuration = 0f;

		[Header("是否等待 NightClock 激活后再开始运作")]
		public bool waitForNightClock = false;

		[HideInInspector]
		public float timer = 0f;

		[HideInInspector]
		public bool forward = true;

		[HideInInspector]
		public bool stopped = false;

		[HideInInspector]
		public float pauseTimer = 0f;

		[HideInInspector]
		public bool isPausing = false;
	}
	public class RotateByTime : MonoBehaviour
	{
		[Header("旋转目标列表(可添加多个 Prefab)")]
		public RotateTarget[] rotateTargets;

		private FNAFNightClock clock;

		private void Start()
		{
			clock = Object.FindObjectOfType<FNAFNightClock>();
		}

		private void Update()
		{
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			RotateTarget[] array = rotateTargets;
			foreach (RotateTarget rotateTarget in array)
			{
				if ((Object)(object)rotateTarget.target == (Object)null || rotateTarget.stopped || (rotateTarget.waitForNightClock && ((Object)(object)clock == (Object)null || !clock.IsRunning())))
				{
					continue;
				}
				if (rotateTarget.isPausing)
				{
					rotateTarget.pauseTimer += Time.deltaTime;
					if (rotateTarget.pauseTimer >= rotateTarget.pauseDuration)
					{
						rotateTarget.isPausing = false;
						rotateTarget.pauseTimer = 0f;
						rotateTarget.forward = !rotateTarget.forward;
						rotateTarget.timer = 0f;
					}
					continue;
				}
				rotateTarget.timer += Time.deltaTime;
				float num = Mathf.Clamp01(rotateTarget.timer / rotateTarget.durationSeconds);
				float num2 = Mathf.Lerp(rotateTarget.startAngle, rotateTarget.endAngle, (!rotateTarget.forward) ? (1f - num) : num);
				Vector3 localEulerAngles = rotateTarget.target.transform.localEulerAngles;
				if (rotateTarget.rotateX)
				{
					localEulerAngles.x = num2;
				}
				if (rotateTarget.rotateY)
				{
					localEulerAngles.y = num2;
				}
				if (rotateTarget.rotateZ)
				{
					localEulerAngles.z = num2;
				}
				rotateTarget.target.transform.localEulerAngles = localEulerAngles;
				if (!(rotateTarget.timer >= rotateTarget.durationSeconds))
				{
					continue;
				}
				if (rotateTarget.isLoop)
				{
					if (rotateTarget.pauseDuration > 0f)
					{
						rotateTarget.isPausing = true;
						rotateTarget.pauseTimer = 0f;
					}
					else
					{
						rotateTarget.forward = !rotateTarget.forward;
						rotateTarget.timer = 0f;
					}
				}
				else if (rotateTarget.oneWay)
				{
					rotateTarget.stopped = true;
				}
				else
				{
					rotateTarget.stopped = true;
				}
			}
		}
	}
	public enum TabletInitialPage
	{
		Page1,
		Page2
	}
	public class TabletPageSwitch : MonoBehaviour
	{
		[Header("页面引用")]
		public GameObject page1;

		public GameObject page2;

		[Header("初始页面")]
		public TabletInitialPage initialPage = TabletInitialPage.Page1;

		[Header("音效设置")]
		public AudioSource audioSource;

		public AudioClip[] page1ToPage2Clips;

		public AudioClip[] page2ToPage1Clips;

		[Header("Debug 控制")]
		public bool debugToggle = false;

		private AR15HandleSightFlipper flipper;

		private bool isPage2 = false;

		private void Start()
		{
			flipper = ((Component)this).GetComponent<AR15HandleSightFlipper>();
			isPage2 = initialPage == TabletInitialPage.Page2;
			ApplyPageState();
			if ((Object)(object)flipper != (Object)null)
			{
				flipper.m_isLargeAperture = isPage2;
			}
		}

		private void Update()
		{
			if (debugToggle)
			{
				debugToggle = false;
				TogglePage();
			}
			if ((Object)(object)flipper != (Object)null && flipper.m_isLargeAperture != isPage2)
			{
				TogglePage();
			}
		}

		private void TogglePage()
		{
			bool goingToPage = !isPage2;
			isPage2 = !isPage2;
			PlayToggleSound(goingToPage);
			ApplyPageState();
			if ((Object)(object)flipper != (Object)null)
			{
				flipper.m_isLargeAperture = isPage2;
			}
		}

		private void PlayToggleSound(bool goingToPage2)
		{
			if (!((Object)(object)audioSource == (Object)null))
			{
				AudioClip[] array = ((!goingToPage2) ? page2ToPage1Clips : page1ToPage2Clips);
				if (array != null && array.Length > 0)
				{
					AudioClip val = array[Random.Range(0, array.Length)];
					audioSource.PlayOneShot(val);
				}
			}
		}

		private void ApplyPageState()
		{
			if ((Object)(object)page1 != (Object)null)
			{
				page1.SetActive(!isPage2);
			}
			if ((Object)(object)page2 != (Object)null)
			{
				page2.SetActive(isPage2);
			}
		}
	}
}
namespace theWNbotMods
{
	public class AR15FlipSightUniversalTrigger : MonoBehaviour
	{
		public enum AnimationType
		{
			OneWay,
			Lever,
			Button
		}

		[Serializable]
		public class AnimatedTarget
		{
			[Header("目标设置")]
			public Transform target;

			public GameObject startPrefab;

			public GameObject endPrefab;

			[Header("动画类型")]
			public AnimationType animationType = AnimationType.OneWay;

			[Header("动画参数")]
			public float delayBeforeStart = 0f;

			public float durationToEnd = 1f;

			public float delayBeforeReturn = 0f;

			public float durationToStart = 1f;

			[HideInInspector]
			public bool hasPlayed = false;

			[HideInInspector]
			public bool isAtEnd = false;

			[HideInInspector]
			public Vector3 startPos;

			[HideInInspector]
			public Vector3 endPos;

			[HideInInspector]
			public Vector3 startRot;

			[HideInInspector]
			public Vector3 endRot;

			[HideInInspector]
			public Vector3 startScale;

			[HideInInspector]
			public Vector3 endScale;
		}

		[Header("触发事件:生成 Prefab")]
		public GameObject prefabToSpawn;

		public Transform spawnPoint;

		[Header("动画目标列表")]
		public List<AnimatedTarget> animatedTargets = new List<AnimatedTarget>();

		private AR15HandleSightFlipper flipper;

		private bool lastState;

		private void Start()
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: 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_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: 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_012a: 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)
			flipper = ((Component)this).GetComponent<AR15HandleSightFlipper>();
			if ((Object)(object)flipper == (Object)null)
			{
				Debug.LogError((object)"[UniversalTrigger] 找不到 AR15HandleSightFlipper!");
				((Behaviour)this).enabled = false;
				return;
			}
			if ((Object)(object)spawnPoint == (Object)null)
			{
				spawnPoint = ((Component)this).transform;
			}
			foreach (AnimatedTarget animatedTarget in animatedTargets)
			{
				if ((Object)(object)animatedTarget.target == (Object)null || (Object)(object)animatedTarget.startPrefab == (Object)null || (Object)(object)animatedTarget.endPrefab == (Object)null)
				{
					Debug.LogWarning((object)"[UniversalTrigger] 有动画目标未设置完整!");
					continue;
				}
				animatedTarget.startPos = animatedTarget.startPrefab.transform.localPosition;
				animatedTarget.startRot = animatedTarget.startPrefab.transform.localEulerAngles;
				animatedTarget.startScale = animatedTarget.startPrefab.transform.localScale;
				animatedTarget.endPos = animatedTarget.endPrefab.transform.localPosition;
				animatedTarget.endRot = animatedTarget.endPrefab.transform.localEulerAngles;
				animatedTarget.endScale = animatedTarget.endPrefab.transform.localScale;
			}
			lastState = flipper.m_isLargeAperture;
		}

		private void Update()
		{
			if (flipper.m_isLargeAperture != lastState)
			{
				TriggerEvent();
				lastState = flipper.m_isLargeAperture;
			}
		}

		public void TriggerEvent()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)prefabToSpawn != (Object)null)
			{
				Object.Instantiate<GameObject>(prefabToSpawn, spawnPoint.position, spawnPoint.rotation);
			}
			foreach (AnimatedTarget animatedTarget in animatedTargets)
			{
				if ((Object)(object)animatedTarget.target == (Object)null)
				{
					continue;
				}
				switch (animatedTarget.animationType)
				{
				case AnimationType.OneWay:
					if (!animatedTarget.hasPlayed)
					{
						((MonoBehaviour)this).StartCoroutine(Animate(animatedTarget, toEnd: true));
						animatedTarget.hasPlayed = true;
					}
					break;
				case AnimationType.Lever:
					((MonoBehaviour)this).StartCoroutine(Animate(animatedTarget, !animatedTarget.isAtEnd));
					animatedTarget.isAtEnd = !animatedTarget.isAtEnd;
					break;
				case AnimationType.Button:
					((MonoBehaviour)this).StartCoroutine(Animate(animatedTarget, toEnd: true));
					((MonoBehaviour)this).StartCoroutine(Animate(animatedTarget, toEnd: false, animatedTarget.delayBeforeStart + animatedTarget.durationToEnd + animatedTarget.delayBeforeReturn));
					break;
				}
			}
		}

		private IEnumerator Animate(AnimatedTarget target, bool toEnd, float extraDelay = 0f)
		{
			float delay = ((!toEnd) ? target.delayBeforeReturn : target.delayBeforeStart);
			float duration = ((!toEnd) ? target.durat