TrueSyncManager.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;

namespace TrueSync {
    [AddComponentMenu("")]
    public class TrueSyncManager : MonoBehaviour {

        private const float JitterTimeFactor = 0.001f;

        private const string serverSettingsAssetFile = "TrueSyncGlobalConfig";

        private enum StartState { BEHAVIOR_INITIALIZED, FIRST_UPDATE, STARTED };

        private StartState startState;

        public GameObject[] playerPrefabs;

        public static TrueSyncConfig _TrueSyncGlobalConfig;

        public static TrueSyncConfig TrueSyncGlobalConfig {
            get {
                if (_TrueSyncGlobalConfig == null) {
                    _TrueSyncGlobalConfig = (TrueSyncConfig) Resources.Load(serverSettingsAssetFile, typeof(TrueSyncConfig));
                }

                return _TrueSyncGlobalConfig;
            }
        }

        public static TrueSyncConfig TrueSyncCustomConfig = null;

        public TrueSyncConfig customConfig;

        private Dictionary<int, List<GameObject>> gameOjectsSafeMap = new Dictionary<int, List<GameObject>>();

        private AbstractLockstep lockstep;

        private FP lockedTimeStep;

        private List<TrueSyncManagedBehaviour> generalBehaviours = new List<TrueSyncManagedBehaviour>();

        private Dictionary<byte, List<TrueSyncManagedBehaviour>> behaviorsByPlayer;

        private CoroutineScheduler scheduler;

        private List<TrueSyncManagedBehaviour> queuedBehaviours = new List<TrueSyncManagedBehaviour>();

        private Dictionary<ITrueSyncBehaviour, TrueSyncManagedBehaviour> mapBehaviorToManagedBehavior = new Dictionary<ITrueSyncBehaviour, TrueSyncManagedBehaviour>();

        private FP time = 0;

        public static FP DeltaTime {
            get {
                if (instance == null) {
                    return 0;
                }

                return instance.lockedTimeStep;
            }
        }

        public static FP Time {
            get {
                if (instance == null || instance.lockstep == null) {
                    return 0;
                }

                return instance.time;
            }
        }

        public static int Ticks {
            get {
                if (instance == null || instance.lockstep == null) {
                    return 0;
                }

                return instance.lockstep.Ticks;
            }
        }

        public static int LastSafeTick {
            get {
                if (instance == null || instance.lockstep == null) {
                    return 0;
                }

                return instance.lockstep.LastSafeTick;
            }
        }

        public static TSVector Gravity {
            get {
                if (instance == null) {
                    return TSVector.zero;
                }

                return instance.ActiveConfig.gravity3D;
            }
        }

        public static List<TSPlayerInfo> Players {
            get {
                if (instance == null || instance.lockstep == null) {
                    return null;
                }

                List<TSPlayerInfo> allPlayers = new List<TSPlayerInfo>();
                foreach (TSPlayer tsp in instance.lockstep.Players.Values) {
                    if (!tsp.dropped) {
                        allPlayers.Add(tsp.playerInfo);
                    }
                }

                return allPlayers;
            }
        }

        public static TSPlayerInfo LocalPlayer {
            get {
                if (instance == null || instance.lockstep == null) {
                    return null;
                }

                return instance.lockstep.LocalPlayer.playerInfo;
            }
        }

        public static TrueSyncConfig Config {
            get {
                if (instance == null) {
                    return null;
                }

                return instance.ActiveConfig;
            }
        }

        private static TrueSyncManager instance;

        private TrueSyncConfig ActiveConfig {
            get {
                if (TrueSyncCustomConfig != null) {
                    customConfig = TrueSyncCustomConfig;
                    TrueSyncCustomConfig = null;
                }

                if (customConfig != null) {
                    return customConfig;
                }

                return TrueSyncGlobalConfig;
            }
        }

        void Awake() {
            TrueSyncConfig currentConfig = ActiveConfig;
            lockedTimeStep = currentConfig.lockedTimeStep;

            StateTracker.Init(currentConfig.rollbackWindow);
            TSRandom.Init();

            if (currentConfig.physics2DEnabled || currentConfig.physics3DEnabled) {
                PhysicsManager.New(currentConfig);
                PhysicsManager.instance.LockedTimeStep = lockedTimeStep;
                PhysicsManager.instance.Init();
            }

            StateTracker.AddTracking(this, "time");
        }

        void Start() {
            instance = this;
            Application.runInBackground = true;

            ICommunicator communicator = null;
            if (!PhotonNetwork.connected || !PhotonNetwork.inRoom) {
                Debug.LogWarning("You are not connected to Photon. TrueSync will start in offline mode.");
            } else {
                communicator = new PhotonTrueSyncCommunicator(PhotonNetwork.networkingPeer);
            }

            TrueSyncConfig activeConfig = ActiveConfig;

            lockstep = AbstractLockstep.NewInstance(
                lockedTimeStep.AsFloat(),
                communicator,
                PhysicsManager.instance,
                activeConfig.syncWindow,
                activeConfig.panicWindow,
                activeConfig.rollbackWindow,
                OnGameStarted,
                OnGamePaused,
                OnGameUnPaused,
                OnGameEnded,
                OnPlayerDisconnection,
                OnStepUpdate,
                GetLocalData,
                ProvideInputData
            );

            if (ReplayRecord.replayMode == ReplayMode.LOAD_REPLAY) {
                ReplayPicker.replayToLoad.Load();

                ReplayRecord replayRecord = ReplayRecord.replayToLoad;
                if (replayRecord == null) {
                    Debug.LogError("Replay Record can't be loaded");
                    gameObject.SetActive(false);
                    return;
                } else {
                    lockstep.ReplayRecord = replayRecord;
                }
            }

            if (activeConfig.showStats) {
                this.gameObject.AddComponent<TrueSyncStats>().Lockstep = lockstep;
            }

            scheduler = new CoroutineScheduler(lockstep);

            if (ReplayRecord.replayMode != ReplayMode.LOAD_REPLAY) {
                if (communicator == null) {
                    lockstep.AddPlayer(0, "Local_Player", true);
                } else {
                    List<PhotonPlayer> players = new List<PhotonPlayer>(PhotonNetwork.playerList);
                    players.Sort(UnityUtils.playerComparer);

                    for (int index = 0, length = players.Count; index < length; index++) {
                        PhotonPlayer p = players[index];
                        lockstep.AddPlayer((byte) p.ID, p.NickName, p.IsLocal);
                    }
                }
            }

            TrueSyncBehaviour[] behavioursArray = FindObjectsOfType<TrueSyncBehaviour>();
            for (int index = 0, length = behavioursArray.Length; index < length; index++) {
                generalBehaviours.Add(NewManagedBehavior(behavioursArray[index]));
            }

            initBehaviors();
            initGeneralBehaviors(generalBehaviours, false);

            PhysicsManager.instance.OnRemoveBody(OnRemovedRigidBody);

            startState = StartState.BEHAVIOR_INITIALIZED;
        }

        private TrueSyncManagedBehaviour NewManagedBehavior(ITrueSyncBehaviour trueSyncBehavior) {
            TrueSyncManagedBehaviour result = new TrueSyncManagedBehaviour(trueSyncBehavior);
            mapBehaviorToManagedBehavior[trueSyncBehavior] = result;

            return result;
        }

        private void initBehaviors() {
            behaviorsByPlayer = new Dictionary<byte, List<TrueSyncManagedBehaviour>>();

            var playersEnum = lockstep.Players.GetEnumerator();
            while (playersEnum.MoveNext()) {
                TSPlayer p = playersEnum.Current.Value;

                List<TrueSyncManagedBehaviour> behaviorsInstatiated = new List<TrueSyncManagedBehaviour>();

                for (int index = 0, length = playerPrefabs.Length; index < length; index++) {
                    GameObject prefab = playerPrefabs[index];

                    GameObject prefabInst = Instantiate(prefab);
                    InitializeGameObject(prefabInst, prefabInst.transform.position.ToTSVector(), prefabInst.transform.rotation.ToTSQuaternion());

                    TrueSyncBehaviour[] behaviours = prefabInst.GetComponentsInChildren<TrueSyncBehaviour>();
                    for (int index2 = 0, length2 = behaviours.Length; index2 < length2; index2++) {
                        TrueSyncBehaviour behaviour = behaviours[index2];

                        behaviour.owner = p.playerInfo;
                        behaviour.localOwner = lockstep.LocalPlayer.playerInfo;
                        behaviour.numberOfPlayers = lockstep.Players.Count;

                        TrueSyncManagedBehaviour tsmb = NewManagedBehavior(behaviour);
                        tsmb.owner = behaviour.owner;
                        tsmb.localOwner = behaviour.localOwner;

                        behaviorsInstatiated.Add(tsmb);
                    }
                }

                behaviorsByPlayer.Add(p.ID, behaviorsInstatiated);
            }
        }

        private void initGeneralBehaviors(IEnumerable<TrueSyncManagedBehaviour> behaviours, bool realOwnerId) {
            List<TSPlayer> playersList = new List<TSPlayer>(lockstep.Players.Values);
            List<TrueSyncManagedBehaviour> itemsToRemove = new List<TrueSyncManagedBehaviour>();

            var behavioursEnum = behaviours.GetEnumerator();
            while (behavioursEnum.MoveNext()) {
                TrueSyncManagedBehaviour tsmb = behavioursEnum.Current;

                if (!(tsmb.trueSyncBehavior is TrueSyncBehaviour)) {
                    continue;
                }

                TrueSyncBehaviour bh = (TrueSyncBehaviour)tsmb.trueSyncBehavior;

                if (realOwnerId) {
                    bh.ownerIndex = bh.owner.Id;
                } else {
                    if (bh.ownerIndex >= 0 && bh.ownerIndex < playersList.Count) {
                        bh.ownerIndex = playersList[bh.ownerIndex].ID;
                    }
                }

                if (behaviorsByPlayer.ContainsKey((byte)bh.ownerIndex)) {
                    bh.owner = lockstep.Players[(byte)bh.ownerIndex].playerInfo;

                    behaviorsByPlayer[(byte)bh.ownerIndex].Add(tsmb);
                    itemsToRemove.Add(tsmb);
                } else {
                    bh.ownerIndex = -1;
                }

                bh.localOwner = lockstep.LocalPlayer.playerInfo;
                bh.numberOfPlayers = lockstep.Players.Count;

                tsmb.owner = bh.owner;
                tsmb.localOwner = bh.localOwner;
            }

            for (int index = 0, length = itemsToRemove.Count; index < length; index++) {
                generalBehaviours.Remove(itemsToRemove[index]);
            }
        }

        private void CheckQueuedBehaviours() {
            if (queuedBehaviours.Count > 0) {
                generalBehaviours.AddRange(queuedBehaviours);
                initGeneralBehaviors(queuedBehaviours, true);

                for (int index = 0, length = queuedBehaviours.Count; index < length; index++) {
                    TrueSyncManagedBehaviour tsmb = queuedBehaviours[index];

                    tsmb.SetGameInfo(lockstep.LocalPlayer.playerInfo, lockstep.Players.Count);
                    tsmb.OnSyncedStart();
                }

                queuedBehaviours.Clear();
            }
        }

        void Update() {
            if (lockstep != null && startState != StartState.STARTED) {
                if (startState == StartState.BEHAVIOR_INITIALIZED) {
                    startState = StartState.FIRST_UPDATE;
                } else if (startState == StartState.FIRST_UPDATE) {
                    lockstep.RunSimulation(true);
                    startState = StartState.STARTED;
                }
            }
        }

        public static void RunSimulation() {
            if (instance != null && instance.lockstep != null) {
                instance.lockstep.RunSimulation(false);
            }
        }

        public static void PauseSimulation() {
            if (instance != null && instance.lockstep != null) {
                instance.lockstep.PauseSimulation();
            }
        }

        public static void EndSimulation() {
            if (instance != null && instance.lockstep != null) {
                instance.lockstep.EndSimulation();
            }
        }

        public static void UpdateCoroutines() {
            if (instance != null && instance.lockstep != null) {
                instance.scheduler.UpdateAllCoroutines();
            }
        }

        public static void SyncedStartCoroutine(IEnumerator coroutine) {
            if (instance != null && instance.lockstep != null) {
                instance.scheduler.StartCoroutine(coroutine);
            }
        }

        public static GameObject SyncedInstantiate(GameObject prefab) {
            return SyncedInstantiate(prefab, prefab.transform.position.ToTSVector(), prefab.transform.rotation.ToTSQuaternion());
        }

        public static GameObject SyncedInstantiate(GameObject prefab, TSVector position, TSQuaternion rotation) {
            if (instance != null && instance.lockstep != null) {
                GameObject go = GameObject.Instantiate(prefab, position.ToVector(), rotation.ToQuaternion()) as GameObject;

                if (ReplayRecord.replayMode != ReplayMode.LOAD_REPLAY) {
                    AddGameObjectOnSafeMap(go);
                }

                MonoBehaviour[] monoBehaviours = go.GetComponentsInChildren<MonoBehaviour>();
                for (int index = 0, length = monoBehaviours.Length; index < length; index++) {
                    MonoBehaviour bh = monoBehaviours[index];

                    if (bh is ITrueSyncBehaviour) {
                        instance.queuedBehaviours.Add(instance.NewManagedBehavior((ITrueSyncBehaviour)bh));
                    }
                }

                InitializeGameObject(go, position, rotation);

                return go;
            }

            return null;
        }

        private static void AddGameObjectOnSafeMap(GameObject go) {

            Dictionary<int, List<GameObject>> safeMap = instance.gameOjectsSafeMap;

            int currentTick = TrueSyncManager.Ticks + 1;
            if (!safeMap.ContainsKey(currentTick)) {
                safeMap.Add(currentTick, new List<GameObject>());
            }

            safeMap[currentTick].Add(go);
        }

        private static void CheckGameObjectsSafeMap() {
            Dictionary<int, List<GameObject>> safeMap = instance.gameOjectsSafeMap;

            int currentTick = TrueSyncManager.Ticks + 1;
            if (safeMap.ContainsKey(currentTick)) {
                List<GameObject> gos = safeMap[currentTick];
                for (int i = 0, l = gos.Count; i < l; i++) {
                    GameObject go = gos[i];
                    if (go != null) {
                        Renderer rend = go.GetComponent<Renderer>();
                        if (rend != null) {
                            rend.enabled = false;
                        }

                        GameObject.Destroy(go);
                    }
                }

                gos.Clear();
            }

            safeMap.Remove(TrueSyncManager.LastSafeTick);
        }

        private static void InitializeGameObject(GameObject go, TSVector position, TSQuaternion rotation) {
            ICollider[] tsColliders = go.GetComponentsInChildren<ICollider>();
            if (tsColliders != null) {
                for (int index = 0, length = tsColliders.Length; index < length; index++) {
                    PhysicsManager.instance.AddBody(tsColliders[index]);
                }
            }

            TSTransform rootTSTransform = go.GetComponent<TSTransform>();
            if (rootTSTransform != null) {
                rootTSTransform.Initialize();

                rootTSTransform.position = position;
                rootTSTransform.rotation = rotation;
            }

            TSTransform[] tsTransforms = go.GetComponentsInChildren<TSTransform>();
            if (tsTransforms != null) {
                for (int index = 0, length = tsTransforms.Length; index < length; index++) {
                    TSTransform tsTransform = tsTransforms[index];

                    if (tsTransform != rootTSTransform) {
                        tsTransform.Initialize();
                    }
                }
            }

            TSTransform2D rootTSTransform2D = go.GetComponent<TSTransform2D>();
            if (rootTSTransform2D != null) {
                rootTSTransform2D.Initialize();

                rootTSTransform2D.position = new TSVector2(position.x, position.y);
                rootTSTransform2D.rotation = rotation.ToQuaternion().eulerAngles.z;
            }

            TSTransform2D[] tsTransforms2D = go.GetComponentsInChildren<TSTransform2D>();
            if (tsTransforms2D != null) {
                for (int index = 0, length = tsTransforms2D.Length; index < length; index++) {
                    TSTransform2D tsTransform2D = tsTransforms2D[index];

                    if (tsTransform2D != rootTSTransform2D) {
                        tsTransform2D.Initialize();
                    }
                }
            }
        }

        public static GameObject SyncedInstantiate(GameObject prefab, TSVector2 position, TSQuaternion rotation) {
            return SyncedInstantiate(prefab, new TSVector(position.x, position.y, 0), rotation);
        }

        public static void SyncedDestroy(GameObject gameObject) {
            if (instance != null && instance.lockstep != null) {
                SyncedDisableBehaviour(gameObject);

                TSCollider[] tsColliders = gameObject.GetComponentsInChildren<TSCollider>();
                if (tsColliders != null) {
                    for (int index = 0, length = tsColliders.Length; index < length; index++) {
                        TSCollider tsCollider = tsColliders[index];
                        DestroyTSRigidBody(tsCollider.gameObject, tsCollider.Body);
                    }
                }

                TSCollider2D[] tsColliders2D = gameObject.GetComponentsInChildren<TSCollider2D>();
                if (tsColliders2D != null) {
                    for (int index = 0, length = tsColliders2D.Length; index < length; index++) {
                        TSCollider2D tsCollider2D = tsColliders2D[index];
                        DestroyTSRigidBody(tsCollider2D.gameObject, tsCollider2D.Body);
                    }
                }
            }
        }

        public static void SyncedDisableBehaviour(GameObject gameObject) {
            MonoBehaviour[] monoBehaviours = gameObject.GetComponentsInChildren<MonoBehaviour>();

            for (int index = 0, length = monoBehaviours.Length; index < length; index++) {
                MonoBehaviour tsb = monoBehaviours[index];

                if (tsb is ITrueSyncBehaviour && instance.mapBehaviorToManagedBehavior.ContainsKey((ITrueSyncBehaviour)tsb)) {
                    instance.mapBehaviorToManagedBehavior[(ITrueSyncBehaviour)tsb].disabled = true;
                }
            }
        }

        private static void DestroyTSRigidBody(GameObject tsColliderGO, IBody body) {
            tsColliderGO.gameObject.SetActive(false);
            instance.lockstep.Destroy(body);
        }

        public static void RegisterITrueSyncBehaviour(ITrueSyncBehaviour trueSyncBehaviour) {
            if (instance != null && instance.lockstep != null) {
                instance.queuedBehaviours.Add(instance.NewManagedBehavior(trueSyncBehaviour));
            }
        }

        public static void RegisterIsReadyChecker(TrueSyncIsReady IsReadyChecker) {
            if (instance != null && instance.lockstep != null) {
                instance.lockstep.GameIsReady += IsReadyChecker;
            }
        }

        public static void RemovePlayer(int playerId) {
            if (instance != null && instance.lockstep != null) {
                List<TrueSyncManagedBehaviour> behaviorsList = instance.behaviorsByPlayer[(byte)playerId];

                for (int index = 0, length = behaviorsList.Count; index < length; index++) {
                    TrueSyncManagedBehaviour tsmb = behaviorsList[index];
                    tsmb.disabled = true;

                    TSCollider[] tsColliders = ((TrueSyncBehaviour)tsmb.trueSyncBehavior).gameObject.GetComponentsInChildren<TSCollider>();
                    if (tsColliders != null) {
                        for (int index2 = 0, length2 = tsColliders.Length; index2 < length2; index2++) {
                            TSCollider tsCollider = tsColliders[index2];

                            if (!tsCollider.Body.TSDisabled) {
                                DestroyTSRigidBody(tsCollider.gameObject, tsCollider.Body);
                            }
                        }
                    }

                    TSCollider2D[] tsCollider2Ds = ((TrueSyncBehaviour)tsmb.trueSyncBehavior).gameObject.GetComponentsInChildren<TSCollider2D>();
                    if (tsCollider2Ds != null) {
                        for (int index2 = 0, length2 = tsCollider2Ds.Length; index2 < length2; index2++) {
                            TSCollider2D tsCollider2D = tsCollider2Ds[index2];

                            if (!tsCollider2D.Body.TSDisabled) {
                                DestroyTSRigidBody(tsCollider2D.gameObject, tsCollider2D.Body);
                            }
                        }
                    }
                }
            }
        }

        private FP tsDeltaTime = 0;

        void FixedUpdate() {
            if (lockstep != null) {
                tsDeltaTime += UnityEngine.Time.deltaTime;

                if (tsDeltaTime >= (lockedTimeStep - JitterTimeFactor)) {
                    tsDeltaTime = 0;

                    instance.scheduler.UpdateAllCoroutines();
                    lockstep.Update();
                }
            }
        }

        InputDataBase ProvideInputData() {
            return new InputData();
        }

        void GetLocalData(InputDataBase playerInputData) {
            TrueSyncInput.CurrentInputData = (InputData) playerInputData;

            if (behaviorsByPlayer.ContainsKey(playerInputData.ownerID)) {
                List<TrueSyncManagedBehaviour> managedBehavioursByPlayer = behaviorsByPlayer[playerInputData.ownerID];
                for (int index = 0, length = managedBehavioursByPlayer.Count; index < length; index++) {
                    TrueSyncManagedBehaviour bh = managedBehavioursByPlayer[index];

                    if (bh != null && !bh.disabled) {
                        bh.OnSyncedInput();
                    }
                }
            }

            TrueSyncInput.CurrentInputData = null;
        }

        void OnStepUpdate(List<InputDataBase> allInputData) {
            time += lockedTimeStep;

            if (ReplayRecord.replayMode != ReplayMode.LOAD_REPLAY) {
                CheckGameObjectsSafeMap();
            }

            TrueSyncInput.SetAllInputs(null);

            for (int index = 0, length = generalBehaviours.Count; index < length; index++) {
                TrueSyncManagedBehaviour bh = generalBehaviours[index];

                if (bh != null && !bh.disabled) {
                    bh.OnPreSyncedUpdate();
                    instance.scheduler.UpdateAllCoroutines();
                }
            }

            for (int index = 0, length = allInputData.Count; index < length; index++) {
                InputDataBase playerInputData = allInputData[index];

                if (behaviorsByPlayer.ContainsKey(playerInputData.ownerID)) {
                    List<TrueSyncManagedBehaviour> managedBehavioursByPlayer = behaviorsByPlayer[playerInputData.ownerID];
                    for (int index2 = 0, length2 = managedBehavioursByPlayer.Count; index2 < length2; index2++) {
                        TrueSyncManagedBehaviour bh = managedBehavioursByPlayer[index2];

                        if (bh != null && !bh.disabled) {
                            bh.OnPreSyncedUpdate();
                            instance.scheduler.UpdateAllCoroutines();
                        }
                    }
                }
            }

            TrueSyncInput.SetAllInputs(allInputData);

            TrueSyncInput.CurrentSimulationData = null;
            for (int index = 0, length = generalBehaviours.Count; index < length; index++) {
                TrueSyncManagedBehaviour bh = generalBehaviours[index];

                if (bh != null && !bh.disabled) {
                    bh.OnSyncedUpdate();
                    instance.scheduler.UpdateAllCoroutines();
                }
            }

            for (int index = 0, length = allInputData.Count; index < length; index++) {
                InputDataBase playerInputData = allInputData[index];

                if (behaviorsByPlayer.ContainsKey(playerInputData.ownerID)) {
                    TrueSyncInput.CurrentSimulationData = (InputData) playerInputData;

                    List<TrueSyncManagedBehaviour> managedBehavioursByPlayer = behaviorsByPlayer[playerInputData.ownerID];
                    for (int index2 = 0, length2 = managedBehavioursByPlayer.Count; index2 < length2; index2++) {
                        TrueSyncManagedBehaviour bh = managedBehavioursByPlayer[index2];

                        if (bh != null && !bh.disabled) {
                            bh.OnSyncedUpdate();
                            instance.scheduler.UpdateAllCoroutines();
                        }
                    }
                }

                TrueSyncInput.CurrentSimulationData = null;
            }

            CheckQueuedBehaviours();
        }

        private void OnRemovedRigidBody(IBody body) {
            GameObject go = PhysicsManager.instance.GetGameObject(body);

            if (go != null) {
                List<TrueSyncBehaviour> behavioursToRemove = new List<TrueSyncBehaviour>(go.GetComponentsInChildren<TrueSyncBehaviour>());
                RemoveFromTSMBList(queuedBehaviours, behavioursToRemove);
                RemoveFromTSMBList(generalBehaviours, behavioursToRemove);

                var behaviorsByPlayerEnum = behaviorsByPlayer.GetEnumerator();
                while (behaviorsByPlayerEnum.MoveNext()) {
                    List<TrueSyncManagedBehaviour> listBh = behaviorsByPlayerEnum.Current.Value;
                    RemoveFromTSMBList(listBh, behavioursToRemove);
                }
            }
        }

        private void RemoveFromTSMBList(List<TrueSyncManagedBehaviour> tsmbList, List<TrueSyncBehaviour> behaviours) {
            List<TrueSyncManagedBehaviour> toRemove = new List<TrueSyncManagedBehaviour>();
            for (int index = 0, length = tsmbList.Count; index < length; index++) {
                TrueSyncManagedBehaviour tsmb = tsmbList[index];

                if ((tsmb.trueSyncBehavior is TrueSyncBehaviour) && behaviours.Contains((TrueSyncBehaviour)tsmb.trueSyncBehavior)) {
                    toRemove.Add(tsmb);
                }
            }

            for (int index = 0, length = toRemove.Count; index < length; index++) {
                TrueSyncManagedBehaviour tsmb = toRemove[index];
                tsmbList.Remove(tsmb);
            }
        }

        public static void CleanUp() {
            ResourcePool.CleanUpAll();
            StateTracker.CleanUp();
            instance = null;
        }

        void OnPlayerDisconnection(byte playerId) {
            TrueSyncManagedBehaviour.OnPlayerDisconnection(generalBehaviours, behaviorsByPlayer, playerId);
        }

        void OnGameStarted() {
            TrueSyncManagedBehaviour.OnGameStarted(generalBehaviours, behaviorsByPlayer);
            instance.scheduler.UpdateAllCoroutines();

            CheckQueuedBehaviours();
        }

        void OnGamePaused() {
            TrueSyncManagedBehaviour.OnGamePaused(generalBehaviours, behaviorsByPlayer);
            instance.scheduler.UpdateAllCoroutines();
        }

        void OnGameUnPaused() {
            TrueSyncManagedBehaviour.OnGameUnPaused(generalBehaviours, behaviorsByPlayer);
            instance.scheduler.UpdateAllCoroutines();
        }

        void OnGameEnded() {
            TrueSyncManagedBehaviour.OnGameEnded(generalBehaviours, behaviorsByPlayer);
            instance.scheduler.UpdateAllCoroutines();
        }

        void OnApplicationQuit() {
            EndSimulation();
        }

    }

}