using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using AK.Wwise;
using EntityStates;
using EntityStates.FalseSonBoss;
using RoR2.CharacterSpeech;
using RoR2.Networking;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;

namespace RoR2;

[RequireComponent(typeof(EntityStateMachine))]
public class MeridianEventTriggerInteraction : NetworkBehaviour, IDisplayNameProvider
{
	public enum RingFallingState
	{
		None,
		OuterRingFalling,
		MiddleRingFalling
	}

	public class MeridianEventBaseState : EntityState
	{
		protected MeridianEventTriggerInteraction meridianEventTriggerInteraction => instance;
	}

	public class MeridianEventStart : MeridianEventBaseState
	{
		public static event Action OnMeridianEventStart;

		public override void OnEnter()
		{
			base.OnEnter();
			MeridianEventStart.OnMeridianEventStart?.Invoke();
			base.meridianEventTriggerInteraction.EventPPVolume.SetActive(value: true);
			base.meridianEventTriggerInteraction.HandleNodeGateActivation(0);
			if (NetworkServer.active)
			{
				base.meridianEventTriggerInteraction.CallRpcSetEventMaterials();
			}
			base.meridianEventTriggerInteraction.SetEventObjects();
			base.meridianEventTriggerInteraction.isHeadRotating = true;
			outer.SetNextState(new Phase1());
		}
	}

	public class FSBFEncounterBaseState : EntityState
	{
		protected ChildLocator childLocator;

		protected MeridianEventTriggerInteraction meridianEventTriggerInteraction => instance;

		public override void OnEnter()
		{
			base.OnEnter();
			childLocator = GetComponent<ChildLocator>();
		}

		public override void OnExit()
		{
			base.OnExit();
		}

		public void KillAllMonsters()
		{
			if (!NetworkServer.active)
			{
				return;
			}
			foreach (TeamComponent item in new List<TeamComponent>(TeamComponent.GetTeamMembers(TeamIndex.Monster)))
			{
				if ((bool)item)
				{
					HealthComponent component = item.GetComponent<HealthComponent>();
					if ((bool)component)
					{
						component.Suicide();
					}
				}
			}
		}
	}

	public abstract class FSBFPhaseBaseState : FSBFEncounterBaseState
	{
		[NonSerialized]
		public static bool readyToSpawnNextBossBody;

		[SerializeField]
		public float durationBeforeEnablingCombatEncounter;

		[SerializeField]
		public float durationBeforeRingsSpawn;

		[SerializeField]
		public GameObject speechControllerPrefab;

		[SerializeField]
		public GameObject spawnVFX;

		protected ScriptedCombatEncounter phaseScriptedCombatEncounter;

		protected GameObject phaseControllerObject;

		protected GameObject phaseControllerSubObjectContainer;

		protected BossGroup phaseBossGroup;

		private bool hasSpawned;

		private bool spawnedNextState;

		private const float minimumDurationPerPhase = 2f;

		private Run.FixedTimeStamp healthBarShowTime = Run.FixedTimeStamp.positiveInfinity;

		protected abstract EntityState nextState { get; }

		protected abstract string phaseControllerChildString { get; }

		protected virtual float healthBarShowDelay => 0f;

		public override void OnEnter()
		{
			base.OnEnter();
			if (!base.meridianEventTriggerInteraction.isFirstPhase)
			{
				speechControllerPrefab = base.meridianEventTriggerInteraction.falseSonBoss1PhaseSpeechController;
				base.meridianEventTriggerInteraction.isFirstPhase = true;
			}
			else if (!base.meridianEventTriggerInteraction.isFinalPhase)
			{
				speechControllerPrefab = base.meridianEventTriggerInteraction.falseSonBossEarlySpeechController;
			}
			else
			{
				speechControllerPrefab = base.meridianEventTriggerInteraction.falseSonBossLateSpeechController;
			}
			if ((bool)childLocator)
			{
				phaseControllerObject = childLocator.FindChild(phaseControllerChildString).gameObject;
				if ((bool)phaseControllerObject)
				{
					phaseScriptedCombatEncounter = phaseControllerObject.GetComponent<ScriptedCombatEncounter>();
					phaseBossGroup = phaseControllerObject.GetComponent<BossGroup>();
				}
			}
			healthBarShowTime = Run.FixedTimeStamp.now + healthBarShowDelay;
			if ((bool)DirectorCore.instance)
			{
				CombatDirector[] components = DirectorCore.instance.GetComponents<CombatDirector>();
				for (int i = 0; i < components.Length; i++)
				{
					components[i].enabled = false;
				}
			}
			if (NetworkServer.active && (object)phaseScriptedCombatEncounter != null)
			{
				phaseScriptedCombatEncounter.combatSquad.onMemberAddedServer += OnMemberAddedServer;
			}
		}

		public override void OnExit()
		{
			if (NetworkServer.active)
			{
				if ((object)phaseScriptedCombatEncounter != null)
				{
					phaseScriptedCombatEncounter.combatSquad.onMemberAddedServer -= OnMemberAddedServer;
				}
				if ((bool)phaseControllerSubObjectContainer)
				{
					phaseControllerSubObjectContainer.SetActive(value: false);
				}
			}
			if ((bool)phaseBossGroup)
			{
				phaseBossGroup.shouldDisplayHealthBarOnHud = false;
			}
			base.OnExit();
		}

		public override void FixedUpdate()
		{
			base.FixedUpdate();
			phaseBossGroup.shouldDisplayHealthBarOnHud = healthBarShowTime.hasPassed;
			if (!hasSpawned && readyToSpawnNextBossBody && base.fixedAge > durationBeforeEnablingCombatEncounter)
			{
				BeginEncounter();
			}
			else if (hasSpawned && readyToSpawnNextBossBody && !spawnedNextState && base.fixedAge > 2f + durationBeforeEnablingCombatEncounter && (bool)phaseScriptedCombatEncounter && phaseScriptedCombatEncounter.combatSquad.memberCount == 0)
			{
				spawnedNextState = true;
				outer.SetNextState(nextState);
			}
		}

		protected void BeginEncounter()
		{
			readyToSpawnNextBossBody = false;
			hasSpawned = true;
			PreEncounterBegin();
			if (NetworkServer.active)
			{
				phaseScriptedCombatEncounter.BeginEncounter();
			}
		}

		protected virtual void PreEncounterBegin()
		{
		}

		protected virtual void OnMemberAddedServer(CharacterMaster master)
		{
			if ((bool)speechControllerPrefab)
			{
				UnityEngine.Object.Instantiate(speechControllerPrefab, master.transform).GetComponent<CharacterSpeechController>().characterMaster = master;
			}
		}
	}

	public class Phase1 : FSBFPhaseBaseState
	{
		private bool spawnedEntryFX;

		private bool lightningStarted;

		protected override string phaseControllerChildString => "Phase1";

		protected override EntityState nextState => new Phase2();

		public override void FixedUpdate()
		{
			base.FixedUpdate();
			if (base.fixedAge > 15f && !lightningStarted)
			{
				lightningStarted = true;
				base.meridianEventTriggerInteraction.arenaGeode3.SetActive(value: true);
				base.meridianEventTriggerInteraction.arenaGeode4.SetActive(value: true);
			}
			if (!spawnedEntryFX && base.fixedAge > base.meridianEventTriggerInteraction.additionalEntryVFXDelay + durationBeforeEnablingCombatEncounter)
			{
				spawnedEntryFX = true;
				SetPlayersInvulnerable(b: false);
				EffectManager.SpawnEffect(base.meridianEventTriggerInteraction.falseSonEntryFX, new EffectData
				{
					origin = base.meridianEventTriggerInteraction.falseSonEntryFXPosition.position
				}, transmit: false);
				base.meridianEventTriggerInteraction.musicPhaseNone.SetActive(value: false);
				base.meridianEventTriggerInteraction.musicPhaseOne.SetActive(value: true);
			}
			if (spawnedEntryFX && base.meridianEventTriggerInteraction.meridianColumnsGameObject.activeInHierarchy && !base.meridianEventTriggerInteraction.meridianPlayableColumns.activeInHierarchy && base.fixedAge > base.meridianEventTriggerInteraction.additionalEntryVFXDelay + durationBeforeEnablingCombatEncounter + 3f)
			{
				base.meridianEventTriggerInteraction.meridianColumnsGameObject.SetActive(value: false);
				base.meridianEventTriggerInteraction.meridianPlayableColumns.SetActive(value: true);
			}
		}

		public override void OnEnter()
		{
			base.meridianEventTriggerInteraction.onFalseSonAppearance.SetActive(value: true);
			base.meridianEventTriggerInteraction.HandleNodeGateActivation(0);
			durationBeforeEnablingCombatEncounter = 7f;
			KillAllMonsters();
			base.OnEnter();
			FSBFPhaseBaseState.readyToSpawnNextBossBody = true;
			Util.PlaySound("Play_boss_falseson_VO_spawn", base.gameObject);
			base.meridianEventTriggerInteraction.Boundary1.SetActive(value: true);
			if (NetworkServer.active)
			{
				SetPlayersInvulnerable(b: true);
			}
		}

		protected override void OnMemberAddedServer(CharacterMaster master)
		{
			base.OnMemberAddedServer(master);
		}
	}

	public class Phase2 : FSBFPhaseBaseState
	{
		private bool startRingsFalling;

		protected override string phaseControllerChildString => "Phase2";

		protected override EntityState nextState => new Phase3();

		public override void FixedUpdate()
		{
			base.FixedUpdate();
			if (base.fixedAge > durationBeforeRingsSpawn && !startRingsFalling)
			{
				base.meridianEventTriggerInteraction.Boundary1.SetActive(value: false);
				base.meridianEventTriggerInteraction.Boundary2.SetActive(value: true);
				base.meridianEventTriggerInteraction.StartOuterRingFalling();
				base.meridianEventTriggerInteraction.arenaGeode3.SetActive(value: false);
				startRingsFalling = true;
			}
		}

		public override void OnEnter()
		{
			base.meridianEventTriggerInteraction.onEnteringPhase2.SetActive(value: true);
			base.meridianEventTriggerInteraction.HandleNodeGateActivation(1);
			base.meridianEventTriggerInteraction.phase2CombatDirector.SetActive(value: true);
			durationBeforeEnablingCombatEncounter = 1f;
			durationBeforeRingsSpawn = 1.75f;
			childLocator = GetComponent<ChildLocator>();
			phaseControllerObject = childLocator.FindChild(phaseControllerChildString).gameObject;
			Util.PlaySound("Play_boss_falseson_VO_spawn", base.gameObject);
			Util.PlaySound("Play_boss_falseson_VO_anger", base.gameObject);
			base.OnEnter();
			SetPlayersInvulnerable(b: false);
		}

		public override void OnExit()
		{
			base.meridianEventTriggerInteraction.isFinalPhase = true;
			base.meridianEventTriggerInteraction.phase2CombatDirector.SetActive(value: false);
			KillAllMonsters();
			base.OnExit();
		}

		protected override void OnMemberAddedServer(CharacterMaster master)
		{
			base.OnMemberAddedServer(master);
		}
	}

	public class Phase3 : FSBFPhaseBaseState
	{
		private bool startRingsFalling;

		protected override string phaseControllerChildString => "Phase3";

		protected override EntityState nextState => new MeridianEventCleared();

		public override void FixedUpdate()
		{
			base.FixedUpdate();
			if (base.fixedAge > durationBeforeRingsSpawn && !startRingsFalling)
			{
				base.meridianEventTriggerInteraction.Boundary2.SetActive(value: false);
				base.meridianEventTriggerInteraction.Boundary3.SetActive(value: true);
				base.meridianEventTriggerInteraction.StartMiddleRingFalling();
				base.meridianEventTriggerInteraction.arenaGeode4.SetActive(value: false);
				startRingsFalling = true;
			}
		}

		public override void OnEnter()
		{
			speechControllerPrefab = base.meridianEventTriggerInteraction.falseSonBossLateSpeechController;
			if (NetworkServer.active)
			{
				LightningStormController.SetStormStrikePattern(base.meridianEventTriggerInteraction.bossLightningStrikePattern);
				LightningStormController.SetStormActive(b: true);
			}
			base.meridianEventTriggerInteraction.onEnteringPhase3.SetActive(value: true);
			base.meridianEventTriggerInteraction.HandleNodeGateActivation(2);
			durationBeforeEnablingCombatEncounter = 1f;
			durationBeforeRingsSpawn = 1.75f;
			childLocator = GetComponent<ChildLocator>();
			phaseControllerObject = childLocator.FindChild(phaseControllerChildString).gameObject;
			GoldTitanManager.onGoldTitanSpawned += IsAurelionitePresent;
			Util.PlaySound("Play_boss_falseson_VO_spawn", base.gameObject);
			base.OnEnter();
		}

		public override void OnExit()
		{
			base.OnExit();
			GoldTitanManager.onGoldTitanSpawned -= IsAurelionitePresent;
		}

		protected override void OnMemberAddedServer(CharacterMaster master)
		{
			base.OnMemberAddedServer(master);
		}

		private void IsAurelionitePresent()
		{
			instance.isGoldTitanSpawned = true;
		}
	}

	public class MeridianEventCleared : MeridianEventBaseState
	{
		public override void OnEnter()
		{
			base.OnEnter();
			base.meridianEventTriggerInteraction.EventCompletePPVolume.SetActive(value: true);
			base.meridianEventTriggerInteraction.EventPPVolume.SetActive(value: false);
			base.meridianEventTriggerInteraction.shrineModel.SetActive(value: true);
			base.meridianEventTriggerInteraction.shrine.GetComponent<ShrineRebirthController>().stateMachine.SetNextStateToMain();
			base.meridianEventTriggerInteraction.finalPillars.SetActive(value: true);
			base.meridianEventTriggerInteraction.meridianRain.SetActive(value: false);
			base.meridianEventTriggerInteraction.meridianStormCloud.SetActive(value: false);
			base.meridianEventTriggerInteraction.eventClearedVFX.SetActive(value: true);
			base.meridianEventTriggerInteraction.arenaGeode1.SetActive(value: false);
			base.meridianEventTriggerInteraction.arenaGeode2.SetActive(value: false);
			base.meridianEventTriggerInteraction.bossFightAMB.Stop(base.gameObject);
			base.meridianEventTriggerInteraction.bossDefeatAMB.Post(base.gameObject);
			Util.PlaySound("Play_env_meridian_level_cleared", base.gameObject);
			if (!NetworkServer.active)
			{
				return;
			}
			GameObject[] destinationPortals = base.meridianEventTriggerInteraction.destinationPortals;
			for (int i = 0; i < destinationPortals.Length; i++)
			{
				destinationPortals[i].SetActive(value: true);
			}
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				if (!(instance == null))
				{
					CharacterBody body = instance.master.GetBody();
					if (!(body == null))
					{
						Util.CleanseBody(body, removeDebuffs: true, removeBuffs: false, removeCooldownBuffs: false, removeDots: false, removeStun: false, removeNearbyProjectiles: false);
					}
				}
			}
		}
	}

	[HideInInspector]
	public static Transform bossTransform;

	public string contextToken = "MERIDIAN_EVENTTRIGGER_CONTEXT";

	public string displayNameToken = "MERIDIAN_EVENTTRIGGER_NAME";

	public int minimumNumberToSpawnPerMonsterType;

	public int maximumNumberToSpawnBeforeSkipping;

	public GameObject eventGateStateObject;

	public GameObject eventGateStatePhase2Object;

	public GameObject eventGateStatePhase3Object;

	public CombatDirector combatDirectorWave1;

	public CombatDirector combatDirectorWave2;

	public SceneExitController sceneExitController;

	[Header("Post Process Volumes")]
	public GameObject EventPPVolume;

	public GameObject EventCompletePPVolume;

	public GameObject AfterEventCompletePPVolume;

	[Header("Destination Portals")]
	public GameObject[] destinationPortals;

	[Header("Colossus Head")]
	public GameObject colossusHead;

	public Transform colossusHeadFinalPosition;

	public float colossusHeadDuration = 420f;

	private bool isHeadRotating;

	[Header("False Son Core")]
	public GameObject falseSonCore;

	[Header("Game Objects to Modify")]
	public GameObjectsToModify[] gameObjectsToModify;

	[Header("Event Objects to Toggle")]
	public GameObject[] eventGameObjectsToToggle;

	[Header("Cleaered Objects to Toggle")]
	public GameObject[] clearedGameObjectsToToggle;

	[Header("False Son Boss Encounter")]
	public ScriptedCombatEncounter falseSonBossEncounter;

	public BossGroup falseSonBossGroup;

	public CombatDirector combatDirector;

	[Header("Teleport Locs")]
	public GameObject playerTPLoc1;

	public GameObject playerTPLoc2;

	public GameObject playerTPLoc3;

	public GameObject playerTPLoc4;

	private GameObject[] playerTPLocs = new GameObject[4];

	[Header("Cutscene")]
	public GameObject cutsceneCamera;

	public AK.Wwise.Event startSceneAMB;

	public AK.Wwise.Event bossFightAMB;

	public AK.Wwise.Event bossDefeatAMB;

	[Header("Boss Music Phases")]
	public GameObject musicPhaseNone;

	public GameObject musicPhaseOne;

	public GameObject musicPhaseTwo;

	public GameObject musicPhaseThree;

	public GameObject musicPhaseBossDead;

	[Header("Arena Setup")]
	public GameObject lightningStorm;

	public GameObject fog;

	public GameObject sceneBoundsOld;

	public GameObject sceneBoundsNew;

	public GameObject meridianColumnsGameObject;

	public GameObject meridianPlayableColumns;

	public LightningStrikePattern bossLightningStrikePattern;

	[Header("Phase 1 Spawn FX Data")]
	[SerializeField]
	[HideInInspector]
	public GameObject falseSonEntryFX;

	[SerializeField]
	public Transform falseSonEntryFXPosition;

	[SerializeField]
	public float additionalEntryVFXDelay;

	[Header("In-Scene Phase Transition VFX - should automatically disable itself")]
	public GameObject onFalseSonAppearance;

	public GameObject onEnteringPhase2;

	public GameObject onEnteringPhase3;

	[Space(20f)]
	public float ringFallOffTime = 50f;

	[HideInInspector]
	public int ringFallingState;

	private int localRingFallingState;

	[Header("Rings Locs")]
	public GameObject ringPiece1;

	public GameObject ringPiece2;

	public GameObject ringPiece3;

	public GameObject ringPiece4;

	public GameObject ringPiece5;

	public GameObject ringPiece6;

	public GameObject ringPiece7;

	public GameObject ringPiece8;

	public GameObject ringPiece9;

	public GameObject ringPiece10;

	public GameObject ringPiece1FinalPosition;

	public GameObject ringPiece2FinalPosition;

	public GameObject ringPiece3FinalPosition;

	public GameObject ringPiece4FinalPosition;

	public GameObject ringPiece5FinalPosition;

	public GameObject ringPiece6FinalPosition;

	public GameObject ringPiece7FinalPosition;

	public GameObject ringPiece8FinalPosition;

	public GameObject ringPiece9FinalPosition;

	public GameObject ringPiece10FinalPosition;

	[Header("Arena Finale")]
	public GameObject shrine;

	public GameObject shrineModel;

	public GameObject finalPillars;

	public GameObject eventClearedVFX;

	public GameObject meridianRain;

	public GameObject meridianStormCloud;

	[Header("Geode System")]
	public GameObject arenaGeode1;

	public GameObject arenaGeode2;

	public GameObject arenaGeode3;

	public GameObject arenaGeode4;

	[Header("Boss Bounds System")]
	public GameObject Boundary1;

	public GameObject Boundary2;

	public GameObject Boundary3;

	[Header("Boss Dialogue Prefabs")]
	public GameObject falseSonBossEarlySpeechController;

	public GameObject falseSonBossLateSpeechController;

	public GameObject falseSonBoss1PhaseSpeechController;

	[HideInInspector]
	public bool isFirstPhase;

	[HideInInspector]
	public bool isFinalPhase;

	[HideInInspector]
	public bool isGoldTitanSpawned;

	[Header("Monster Waves Combat Director Prefabs")]
	public GameObject phase2CombatDirector;

	private EntityStateMachine mainStateMachine;

	private bool triggerEventClear;

	[SyncVar(hook = "Client_HandleStartMeridianEvent")]
	public bool isTriggered;

	private static int kRpcRpcTeleportWithLocalAuthority;

	private static int kRpcRpcOnFalseSonDefeated;

	private static int kRpcRpcSetEventMaterials;

	public static MeridianEventTriggerInteraction instance { get; private set; }

	protected MeridianEventTriggerInteraction eventTriggerInteraction { get; private set; }

	public bool NetworkisTriggered
	{
		get
		{
			return isTriggered;
		}
		[param: In]
		set
		{
			if (NetworkServer.localClientActive && !base.syncVarHookGuard)
			{
				base.syncVarHookGuard = true;
				Client_HandleStartMeridianEvent(value);
				base.syncVarHookGuard = false;
			}
			SetSyncVar(value, ref isTriggered, 1u);
		}
	}

	public static event Action<MeridianEventTriggerInteraction> onDefeatedServerGlobal;

	public static event Action<MeridianEventTriggerInteraction, Interactor> onActivated;

	public static event Action onInstanceChangedGlobal;

	public string GetContextString(Interactor activator)
	{
		return Language.GetString(contextToken);
	}

	public override int GetNetworkChannel()
	{
		return QosChannelIndex.defaultReliable.intVal;
	}

	public Interactability GetInteractability(Interactor activator)
	{
		if (isTriggered)
		{
			return Interactability.Disabled;
		}
		return Interactability.Available;
	}

	public string GetDisplayName()
	{
		return Language.GetString(displayNameToken);
	}

	public bool ShouldIgnoreSpherecastForInteractibility(Interactor activator)
	{
		return false;
	}

	public bool ShouldShowOnScanner()
	{
		return !isTriggered;
	}

	private void Start()
	{
		eventTriggerInteraction = GetComponent<MeridianEventTriggerInteraction>();
	}

	public void OnEnable()
	{
		instance = SingletonHelper.Assign(instance, this);
		MeridianEventTriggerInteraction.onInstanceChangedGlobal?.Invoke();
		if (falseSonEntryFX == null)
		{
			AsyncOperationHandle<GameObject> asyncOperationHandle = LegacyResourcesAPI.LoadAsync<GameObject>("FalseSonBoss/FalseSonBossAppearVFX");
			asyncOperationHandle.Completed += delegate(AsyncOperationHandle<GameObject> result)
			{
				falseSonEntryFX = result.Result;
			};
		}
	}

	public void OnDisable()
	{
		instance = SingletonHelper.Unassign(instance, this);
		MeridianEventTriggerInteraction.onInstanceChangedGlobal?.Invoke();
	}

	[Server]
	public override void OnStartServer()
	{
		if (!NetworkServer.active)
		{
			Debug.LogWarning("[Server] function 'System.Void RoR2.MeridianEventTriggerInteraction::OnStartServer()' called on client");
			return;
		}
		base.OnStartServer();
		startSceneAMB.Post(base.gameObject);
	}

	public void OnTriggerEnter(Collider other)
	{
		if (NetworkServer.active && !isTriggered && other.TryGetComponent<CharacterBody>(out var component) && component.isPlayerControlled)
		{
			HandleInitializeMeridianEvent();
		}
	}

	public static void SetPlayersInvulnerable(bool b)
	{
		if (!NetworkServer.active)
		{
			return;
		}
		foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
		{
			if (instance == null)
			{
				continue;
			}
			CharacterBody body = instance.master.GetBody();
			if (!(body == null))
			{
				if (b)
				{
					body.AddTimedBuff(DLC2Content.Buffs.HiddenRejectAllDamage, 1.5f);
				}
				else if (body.HasBuff(DLC2Content.Buffs.HiddenRejectAllDamage))
				{
					body.RemoveBuff(DLC2Content.Buffs.HiddenRejectAllDamage);
				}
			}
		}
	}

	[Server]
	private void HandleInitializeMeridianEvent()
	{
		if (!NetworkServer.active)
		{
			Debug.LogWarning("[Server] function 'System.Void RoR2.MeridianEventTriggerInteraction::HandleInitializeMeridianEvent()' called on client");
			return;
		}
		LightningStormController.SetStormActive(b: false);
		combatDirector.enabled = false;
		playerTPLocs[0] = playerTPLoc1;
		playerTPLocs[1] = playerTPLoc2;
		playerTPLocs[2] = playerTPLoc3;
		playerTPLocs[3] = playerTPLoc4;
		int num = 0;
		int num2 = 0;
		int count = PlayerCharacterMasterController.instances.Count;
		bool flag = count > 4;
		foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
		{
			if (instance == null)
			{
				continue;
			}
			Vector3 vector;
			Quaternion rotation;
			if (flag)
			{
				int num3 = playerTPLocs.Length - 1;
				float num4 = (float)num2 / (float)(count - 1) * (float)num3;
				int num5 = Mathf.Clamp(Mathf.FloorToInt(num4), 0, num3 - 1);
				float t = num4 - (float)num5;
				Transform obj = playerTPLocs[num5].transform;
				Transform transform = playerTPLocs[num5 + 1].transform;
				vector = Vector3.Lerp(obj.position, transform.position, t);
				rotation = Quaternion.Lerp(obj.rotation, transform.rotation, t);
			}
			else
			{
				int num6 = num2;
				if (playerTPLocs[num6] == null)
				{
					num6 = num;
				}
				Transform obj2 = playerTPLocs[num6].transform;
				vector = obj2.position;
				rotation = obj2.rotation;
			}
			CharacterBody body = instance.master.GetBody();
			if (!(body == null))
			{
				body.currentVehicle?.EjectPassenger();
				if (Util.HasEffectiveAuthority(body.gameObject))
				{
					TeleportHelper.TeleportBody(body, vector);
				}
				else
				{
					CallRpcTeleportWithLocalAuthority(body.gameObject, vector, rotation);
				}
				num2++;
			}
		}
		NetworkisTriggered = true;
	}

	[ClientRpc]
	private void RpcTeleportWithLocalAuthority(GameObject playerObject, Vector3 position, Quaternion rotation)
	{
		if (Util.HasEffectiveAuthority(playerObject))
		{
			CharacterBody component = playerObject.GetComponent<CharacterBody>();
			if (component == null)
			{
				Debug.LogWarning("Received RPCTeleport request but the game object doesn't have a CharacterBody! " + playerObject.name, playerObject);
			}
			else
			{
				TeleportHelper.TeleportBody(component, position);
			}
		}
	}

	[Client]
	private void Client_HandleStartMeridianEvent(bool newValue)
	{
		if (!NetworkClient.active)
		{
			Debug.LogWarning("[Client] function 'System.Void RoR2.MeridianEventTriggerInteraction::Client_HandleStartMeridianEvent(System.Boolean)' called on server");
			return;
		}
		NetworkisTriggered = newValue;
		HandleStartMeridianEvent();
	}

	private void HandleStartMeridianEvent()
	{
		fog.SetActive(value: true);
		sceneBoundsOld.SetActive(value: false);
		sceneBoundsNew.SetActive(value: true);
		startSceneAMB.Stop(base.gameObject);
		bossFightAMB.Post(base.gameObject);
		musicPhaseNone.SetActive(value: true);
		cutsceneCamera.SetActive(value: true);
		Util.PlaySound("Play_env_meridian_activate_boss_cutscene", base.gameObject);
		LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
		if (firstLocalUser != null && firstLocalUser.cachedBody != null)
		{
			string bodyName = BodyCatalog.GetBodyName(firstLocalUser.cachedBody.bodyIndex);
			firstLocalUser.userProfile.HasAchievement(bodyName.Substring(0, bodyName.Length - 4) + "ClearMeridianEvent");
		}
		mainStateMachine.SetNextState(new MeridianEventStart());
	}

	private IEnumerator RotateHead()
	{
		float timeElapsed = 0f;
		while (timeElapsed < colossusHeadDuration)
		{
			colossusHead.transform.rotation = Quaternion.Lerp(colossusHead.transform.rotation, colossusHeadFinalPosition.rotation, timeElapsed / colossusHeadDuration);
			ringPiece1.transform.rotation = Quaternion.Lerp(ringPiece1.transform.rotation, ringPiece1FinalPosition.transform.rotation, timeElapsed / (colossusHeadDuration - 20f));
			ringPiece2.transform.rotation = Quaternion.Lerp(ringPiece2.transform.rotation, ringPiece2FinalPosition.transform.rotation, timeElapsed / (colossusHeadDuration - 22f));
			ringPiece3.transform.rotation = Quaternion.Lerp(ringPiece3.transform.rotation, ringPiece3FinalPosition.transform.rotation, timeElapsed / (colossusHeadDuration - 25f));
			ringPiece4.transform.rotation = Quaternion.Lerp(ringPiece4.transform.rotation, ringPiece4FinalPosition.transform.rotation, timeElapsed / (colossusHeadDuration - 26f));
			ringPiece5.transform.rotation = Quaternion.Lerp(ringPiece5.transform.rotation, ringPiece5FinalPosition.transform.rotation, timeElapsed / (colossusHeadDuration - 19f));
			ringPiece1.transform.position = Vector3.Lerp(ringPiece1.transform.position, ringPiece1FinalPosition.transform.position, timeElapsed / (colossusHeadDuration - 20f));
			ringPiece2.transform.position = Vector3.Lerp(ringPiece2.transform.position, ringPiece2FinalPosition.transform.position, timeElapsed / (colossusHeadDuration - 22f));
			ringPiece3.transform.position = Vector3.Lerp(ringPiece3.transform.position, ringPiece3FinalPosition.transform.position, timeElapsed / (colossusHeadDuration - 25f));
			ringPiece4.transform.position = Vector3.Lerp(ringPiece4.transform.position, ringPiece4FinalPosition.transform.position, timeElapsed / (colossusHeadDuration - 26f));
			ringPiece5.transform.position = Vector3.Lerp(ringPiece5.transform.position, ringPiece5FinalPosition.transform.position, timeElapsed / (colossusHeadDuration - 19f));
			ringPiece6.transform.rotation = Quaternion.Lerp(ringPiece6.transform.rotation, ringPiece6FinalPosition.transform.rotation, timeElapsed / colossusHeadDuration);
			ringPiece7.transform.rotation = Quaternion.Lerp(ringPiece7.transform.rotation, ringPiece7FinalPosition.transform.rotation, timeElapsed / colossusHeadDuration);
			ringPiece8.transform.rotation = Quaternion.Lerp(ringPiece8.transform.rotation, ringPiece8FinalPosition.transform.rotation, timeElapsed / colossusHeadDuration);
			ringPiece9.transform.rotation = Quaternion.Lerp(ringPiece9.transform.rotation, ringPiece9FinalPosition.transform.rotation, timeElapsed / colossusHeadDuration);
			ringPiece10.transform.rotation = Quaternion.Lerp(ringPiece10.transform.rotation, ringPiece10FinalPosition.transform.rotation, timeElapsed / colossusHeadDuration);
			ringPiece6.transform.position = Vector3.Lerp(ringPiece6.transform.position, ringPiece6FinalPosition.transform.position, timeElapsed / colossusHeadDuration);
			ringPiece7.transform.position = Vector3.Lerp(ringPiece7.transform.position, ringPiece7FinalPosition.transform.position, timeElapsed / colossusHeadDuration);
			ringPiece8.transform.position = Vector3.Lerp(ringPiece8.transform.position, ringPiece8FinalPosition.transform.position, timeElapsed / colossusHeadDuration);
			ringPiece9.transform.position = Vector3.Lerp(ringPiece9.transform.position, ringPiece9FinalPosition.transform.position, timeElapsed / colossusHeadDuration);
			ringPiece10.transform.position = Vector3.Lerp(ringPiece10.transform.position, ringPiece10FinalPosition.transform.position, timeElapsed / colossusHeadDuration);
			timeElapsed += Time.deltaTime;
			yield return null;
		}
	}

	private void StartOuterRingFalling()
	{
		ringFallingState = Mathf.Max(1, ringFallingState);
		Util.PlaySound("Play_env_meridian_level_ring_fall", base.gameObject);
	}

	private void StartMiddleRingFalling()
	{
		ringFallingState = Mathf.Max(2, ringFallingState);
		Util.PlaySound("Play_env_meridian_level_ring_fall", base.gameObject);
	}

	private IEnumerator OuterRingFalling()
	{
		float timeElapsed = 0f;
		while (timeElapsed < ringFallOffTime)
		{
			ringPiece6.transform.position = Vector3.Lerp(ringPiece6.transform.position, ringPiece6.transform.position - new Vector3(0f, 100f, 0f), timeElapsed / ringFallOffTime);
			ringPiece7.transform.position = Vector3.Lerp(ringPiece7.transform.position, ringPiece7.transform.position - new Vector3(0f, 230f, 0f), timeElapsed / ringFallOffTime);
			ringPiece8.transform.position = Vector3.Lerp(ringPiece8.transform.position, ringPiece8.transform.position - new Vector3(0f, 120f, 0f), timeElapsed / ringFallOffTime);
			ringPiece9.transform.position = Vector3.Lerp(ringPiece9.transform.position, ringPiece9.transform.position - new Vector3(0f, 350f, 0f), timeElapsed / ringFallOffTime);
			ringPiece10.transform.position = Vector3.Lerp(ringPiece10.transform.position, ringPiece10.transform.position - new Vector3(0f, 130f, 0f), timeElapsed / ringFallOffTime);
			timeElapsed += Time.deltaTime;
			yield return null;
		}
		ringPiece6.SetActive(value: false);
		ringPiece7.SetActive(value: false);
		ringPiece8.SetActive(value: false);
		ringPiece9.SetActive(value: false);
		ringPiece10.SetActive(value: false);
	}

	private IEnumerator MiddleRingFalling()
	{
		float timeElapsed = 0f;
		while (timeElapsed < ringFallOffTime)
		{
			ringPiece1.transform.position = Vector3.Lerp(ringPiece1.transform.position, ringPiece1.transform.position - new Vector3(0f, 120f, 0f), timeElapsed / ringFallOffTime);
			ringPiece2.transform.position = Vector3.Lerp(ringPiece2.transform.position, ringPiece2.transform.position - new Vector3(0f, 110f, 0f), timeElapsed / ringFallOffTime);
			ringPiece3.transform.position = Vector3.Lerp(ringPiece3.transform.position, ringPiece3.transform.position - new Vector3(0f, 350f, 0f), timeElapsed / ringFallOffTime);
			ringPiece4.transform.position = Vector3.Lerp(ringPiece4.transform.position, ringPiece4.transform.position - new Vector3(0f, 130f, 0f), timeElapsed / ringFallOffTime);
			ringPiece5.transform.position = Vector3.Lerp(ringPiece5.transform.position, ringPiece5.transform.position - new Vector3(0f, 470f, 0f), timeElapsed / ringFallOffTime);
			timeElapsed += Time.deltaTime;
			yield return null;
		}
		ringPiece1.SetActive(value: false);
		ringPiece2.SetActive(value: false);
		ringPiece3.SetActive(value: false);
		ringPiece4.SetActive(value: false);
		ringPiece5.SetActive(value: false);
	}

	public void TriggerEventClear()
	{
		triggerEventClear = true;
	}

	public void Update()
	{
		if (isHeadRotating)
		{
			StartCoroutine(RotateHead());
			cutsceneCamera.SetActive(value: true);
			isHeadRotating = false;
		}
		if (ringFallingState > localRingFallingState)
		{
			if (ringFallingState == 1)
			{
				StartCoroutine(OuterRingFalling());
			}
			else if (ringFallingState == 2)
			{
				StartCoroutine(MiddleRingFalling());
			}
			localRingFallingState = ringFallingState;
		}
		if (triggerEventClear && NetworkServer.active)
		{
			CallRpcOnFalseSonDefeated();
			triggerEventClear = false;
		}
	}

	private void Awake()
	{
		mainStateMachine = EntityStateMachine.FindByCustomName(base.gameObject, "Main");
		if (NetworkServer.active)
		{
			SkyJumpDeathState.falseSonDeathEvent += TriggerEventClear;
		}
		GameObject[] array = destinationPortals;
		for (int i = 0; i < array.Length; i++)
		{
			array[i].SetActive(value: false);
		}
	}

	[ClientRpc]
	private void RpcOnFalseSonDefeated()
	{
		EventCompletePPVolume.SetActive(value: true);
		EventPPVolume.SetActive(value: false);
		if (AfterEventCompletePPVolume != null)
		{
			AfterEventCompletePPVolume.SetActive(value: true);
		}
		SetIdleMaterials();
		SetClearedObjects();
	}

	private void Wave1OnDefeatedServer()
	{
		combatDirectorWave2.enabled = true;
		combatDirectorWave2.currentSpawnTarget = base.gameObject;
		combatDirectorWave2.monsterCredit += (int)(600f * Mathf.Pow(Run.instance.compensatedDifficultyCoefficient, 0.5f));
	}

	private void Wave2OnDefeatedServer()
	{
		mainStateMachine.SetNextState(new MeridianEventCleared());
	}

	private void SetEventObjects()
	{
		for (int i = 0; i < eventGameObjectsToToggle.Length; i++)
		{
			if (!(eventGameObjectsToToggle[i] == null))
			{
				bool activeInHierarchy = eventGameObjectsToToggle[i].activeInHierarchy;
				eventGameObjectsToToggle[i].SetActive(!activeInHierarchy);
			}
		}
	}

	private void HandleNodeGateActivation(int currentState)
	{
		eventGateStateObject.SetActive(currentState <= 0);
		eventGateStatePhase2Object.SetActive(currentState <= 1);
		eventGateStatePhase3Object.SetActive(currentState <= 2);
	}

	private void SetClearedObjects()
	{
		for (int i = 0; i < clearedGameObjectsToToggle.Length; i++)
		{
			if (!(clearedGameObjectsToToggle[i] == null))
			{
				bool activeInHierarchy = clearedGameObjectsToToggle[i].activeInHierarchy;
				clearedGameObjectsToToggle[i].SetActive(!activeInHierarchy);
			}
		}
	}

	[ClientRpc]
	private void RpcSetEventMaterials()
	{
		for (int i = 0; i < gameObjectsToModify.Length; i++)
		{
			GameObject[] objects = gameObjectsToModify[i].objects;
			foreach (GameObject gameObject in objects)
			{
				if (!(gameObject == null) && gameObject.TryGetComponent<Renderer>(out var component))
				{
					component.material = gameObjectsToModify[i].eventMaterial;
				}
			}
		}
	}

	private void SetIdleMaterials()
	{
		for (int i = 0; i < gameObjectsToModify.Length; i++)
		{
			GameObject[] objects = gameObjectsToModify[i].objects;
			foreach (GameObject gameObject in objects)
			{
				if (!(gameObject == null))
				{
					gameObject.GetComponent<Renderer>().material = gameObjectsToModify[i].idleMaterial;
				}
			}
		}
	}

	private void UNetVersion()
	{
	}

	protected static void InvokeRpcRpcTeleportWithLocalAuthority(NetworkBehaviour obj, NetworkReader reader)
	{
		if (!NetworkClient.active)
		{
			Debug.LogError("RPC RpcTeleportWithLocalAuthority called on server.");
		}
		else
		{
			((MeridianEventTriggerInteraction)obj).RpcTeleportWithLocalAuthority(reader.ReadGameObject(), reader.ReadVector3(), reader.ReadQuaternion());
		}
	}

	protected static void InvokeRpcRpcOnFalseSonDefeated(NetworkBehaviour obj, NetworkReader reader)
	{
		if (!NetworkClient.active)
		{
			Debug.LogError("RPC RpcOnFalseSonDefeated called on server.");
		}
		else
		{
			((MeridianEventTriggerInteraction)obj).RpcOnFalseSonDefeated();
		}
	}

	protected static void InvokeRpcRpcSetEventMaterials(NetworkBehaviour obj, NetworkReader reader)
	{
		if (!NetworkClient.active)
		{
			Debug.LogError("RPC RpcSetEventMaterials called on server.");
		}
		else
		{
			((MeridianEventTriggerInteraction)obj).RpcSetEventMaterials();
		}
	}

	public void CallRpcTeleportWithLocalAuthority(GameObject playerObject, Vector3 position, Quaternion rotation)
	{
		if (!NetworkServer.active)
		{
			Debug.LogError("RPC Function RpcTeleportWithLocalAuthority called on client.");
			return;
		}
		NetworkWriter networkWriter = new NetworkWriter();
		networkWriter.Write((short)0);
		networkWriter.Write((short)2);
		networkWriter.WritePackedUInt32((uint)kRpcRpcTeleportWithLocalAuthority);
		networkWriter.Write(GetComponent<NetworkIdentity>().netId);
		networkWriter.Write(playerObject);
		networkWriter.Write(position);
		networkWriter.Write(rotation);
		SendRPCInternal(networkWriter, 0, "RpcTeleportWithLocalAuthority");
	}

	public void CallRpcOnFalseSonDefeated()
	{
		if (!NetworkServer.active)
		{
			Debug.LogError("RPC Function RpcOnFalseSonDefeated called on client.");
			return;
		}
		NetworkWriter networkWriter = new NetworkWriter();
		networkWriter.Write((short)0);
		networkWriter.Write((short)2);
		networkWriter.WritePackedUInt32((uint)kRpcRpcOnFalseSonDefeated);
		networkWriter.Write(GetComponent<NetworkIdentity>().netId);
		SendRPCInternal(networkWriter, 0, "RpcOnFalseSonDefeated");
	}

	public void CallRpcSetEventMaterials()
	{
		if (!NetworkServer.active)
		{
			Debug.LogError("RPC Function RpcSetEventMaterials called on client.");
			return;
		}
		NetworkWriter networkWriter = new NetworkWriter();
		networkWriter.Write((short)0);
		networkWriter.Write((short)2);
		networkWriter.WritePackedUInt32((uint)kRpcRpcSetEventMaterials);
		networkWriter.Write(GetComponent<NetworkIdentity>().netId);
		SendRPCInternal(networkWriter, 0, "RpcSetEventMaterials");
	}

	static MeridianEventTriggerInteraction()
	{
		kRpcRpcTeleportWithLocalAuthority = -40849326;
		NetworkBehaviour.RegisterRpcDelegate(typeof(MeridianEventTriggerInteraction), kRpcRpcTeleportWithLocalAuthority, InvokeRpcRpcTeleportWithLocalAuthority);
		kRpcRpcOnFalseSonDefeated = 1048548329;
		NetworkBehaviour.RegisterRpcDelegate(typeof(MeridianEventTriggerInteraction), kRpcRpcOnFalseSonDefeated, InvokeRpcRpcOnFalseSonDefeated);
		kRpcRpcSetEventMaterials = 1585739;
		NetworkBehaviour.RegisterRpcDelegate(typeof(MeridianEventTriggerInteraction), kRpcRpcSetEventMaterials, InvokeRpcRpcSetEventMaterials);
		NetworkCRC.RegisterBehaviour("MeridianEventTriggerInteraction", 0);
	}

	public override bool OnSerialize(NetworkWriter writer, bool forceAll)
	{
		if (forceAll)
		{
			writer.Write(isTriggered);
			return true;
		}
		bool flag = false;
		if ((base.syncVarDirtyBits & (true ? 1u : 0u)) != 0)
		{
			if (!flag)
			{
				writer.WritePackedUInt32(base.syncVarDirtyBits);
				flag = true;
			}
			writer.Write(isTriggered);
		}
		if (!flag)
		{
			writer.WritePackedUInt32(base.syncVarDirtyBits);
		}
		return flag;
	}

	public override void OnDeserialize(NetworkReader reader, bool initialState)
	{
		if (initialState)
		{
			isTriggered = reader.ReadBoolean();
			return;
		}
		int num = (int)reader.ReadPackedUInt32();
		if (((uint)num & (true ? 1u : 0u)) != 0)
		{
			Client_HandleStartMeridianEvent(reader.ReadBoolean());
		}
	}

	public override void PreStartClient()
	{
	}
}