path: root/Client/Assets/Scripts/XMainClient/XGame.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading;
using KKSG;
using ProtoBuf;
using UnityEngine;
using XMainClient.UI;
using XMainClient.UI.UICommon;
using XUpdater;
using XUtliPoolLib;

namespace XMainClient
{
	public class XGame : XSingleton<XGame>
	{
		public bool IsGMAccount
		{
			get
			{
				return this._isgmaccount;
			}
			set
			{
				this._isgmaccount = value;
			}
		}

		public bool ShowBuildLog
		{
			get
			{
				return this._show_build_log;
			}
			set
			{
				this._show_build_log = value;
			}
		}

		public ulong PlayerID
		{
			get
			{
				return this._player_id;
			}
			set
			{
				this._player_id = value;
			}
		}

		public bool CalcFps
		{
			get
			{
				return this._calc_fps;
			}
		}

		public float Fps
		{
			get
			{
				return this._fps;
			}
		}

		public float FpsAvg
		{
			get
			{
				return this._fpsAvg;
			}
		}

		public XStage CurrentStage
		{
			get
			{
				return this._stage;
			}
		}

		public bool StageReady
		{
			get
			{
				return this._stage != null && this._stage.IsEntered;
			}
		}

		internal XDocuments Doc
		{
			get
			{
				return this._doc;
			}
		}

		public int SyncModeValue
		{
			get
			{
				return this._nSyncMode;
			}
			set
			{
				this._nSyncMode = value;
				Physics.IgnoreLayerCollision(10, 10, this.SyncMode);
				Physics.IgnoreLayerCollision(21, 13, this.SyncMode);
			}
		}

		public bool SyncMode
		{
			get
			{
				return this._nSyncMode == 1;
			}
		}

		public static int RoleCount;

		private XStage _stage = null;

		private XStage _old_stage = null;

		private List<XBaseSingleton> _singletons = null;

		private XDocuments _doc = null;

		private int _nSyncMode = 0;

		private bool _show_build_log = true;

		private int _fps_count = 0;

		private float _fps = (float)XShell.TargetFrame;

		private float _fpsAvg = (float)XShell.TargetFrame;

		private float _fps_interval = 0.16667f;

		private bool _calc_fps = true;

		private float _fps_real_time = 0f;

		private int _fpsCalcCount = 0;

		private float _fpsAcc = 0f;

		private bool _isgmaccount = false;

		private ulong _player_id = 0UL;

		private int _millisecondsToWait = 0;

		private float _lastExitClickTime = 0f;

		private XTimerMgr.ElapsedEventHandler _fpsHandler = null;

		private XTimerMgr.ElapsedEventHandler _innerSwitchCb = null;

		public bool notLoadScene = true;

		public bool networkRun = true;

		public bool switchScene = false;

		public static bool EditorMode = false;

		public XGame()
		{
			this._singletons = new List<XBaseSingleton>();
			this._singletons.Add(XSingleton<BufferPoolMgr>.singleton);
			this._singletons.Add(XSingleton<ScriptCode>.singleton);
			XSingleton<XStringTable>.singleton.Uninit();
			this._singletons.Add(XSingleton<XStringTable>.singleton);
			this._singletons.Add(XSingleton<XInput>.singleton);
			this._singletons.Add(XSingleton<XServerTimeMgr>.singleton);
			this._singletons.Add(XSingleton<XGlobalConfig>.singleton);
			this._singletons.Add(XSingleton<XGameUI>.singleton);
			this._singletons.Add(XSingleton<XSceneMgr>.singleton);
			this._singletons.Add(XSingleton<XBuffTemplateManager>.singleton);
			this._singletons.Add(XSingleton<XAudioMgr>.singleton);
			this._singletons.Add(XSingleton<XSkillEffectMgr>.singleton);
			this._singletons.Add(XSingleton<XPostEffectMgr>.singleton);
			this._singletons.Add(XSingleton<XLevelFinishMgr>.singleton);
			this._singletons.Add(XSingleton<XCombat>.singleton);
			this._singletons.Add(XSingleton<XProfessionSkillMgr>.singleton);
			this._singletons.Add(XSingleton<XGameSysMgr>.singleton);
			this._singletons.Add(XSingleton<XOperationRecord>.singleton);
			this._singletons.Add(XSingleton<XLevelDoodadMgr>.singleton);
			this._singletons.Add(XSingleton<XTutorialMgr>.singleton);
			this._singletons.Add(XSingleton<XEntityMgr>.singleton);
			this._singletons.Add(XSingleton<XScene>.singleton);
			this._singletons.Add(XSingleton<XForbidWordMgr>.singleton);
			this._singletons.Add(XSingleton<XSkillFactory>.singleton);
			this._singletons.Add(XSingleton<XCutScene>.singleton);
			this._singletons.Add(XSingleton<XBulletMgr>.singleton);
			this._singletons.Add(XSingleton<XAttributeMgr>.singleton);
			this._singletons.Add(XSingleton<XEventMgr>.singleton);
			this._singletons.Add(XSingleton<XPowerPointCalculator>.singleton);
			this._singletons.Add(XSingleton<UIManager>.singleton);
			this._singletons.Add(XSingleton<XLevelSpawnMgr>.singleton);
			this._fpsHandler = new XTimerMgr.ElapsedEventHandler(this.CalculateFPS);
			this._innerSwitchCb = new XTimerMgr.ElapsedEventHandler(this.InnerSwitch);
			this._doc = new XDocuments();
		}

		public IEnumerator Awake()
		{
			XLinkTimeStamp.FetchBuildDateTime();
			this.TriggerFps();
			PtcRegister.RegistProtocol();
			XSingleton<XResourceLoaderMgr>.singleton.LoadServerCurve("Table/Curve");
			XSingleton<XClientNetwork>.singleton.Initialize();
			CVSReader.Init();
			int i = 0;
			int num;
			for (i = 0; i < this._singletons.Count; i = num + 1)
			{
				int tryCount = 0;
				while (!this._singletons[i].Init())
				{
					num = tryCount;
					tryCount = num + 1;
					bool flag = tryCount % 1000 == 0;
					if (flag)
					{
						Thread.Sleep(1);
					}
				}
				num = i;
			}
			GC.Collect();
			i = 0;
			XBagDocument.Execute(new OnLoadedCallback(XBagDocument.OnTableLoaded));
			while (!XBagDocument.AsyncLoader.IsDone)
			{
				num = i + 1;
				i = num;
				bool flag2 = num % 1000 == 0;
				if (flag2)
				{
					Thread.Sleep(1);
				}
			}
			this._doc.CtorLoad();
			this._doc.Initilize(0);
			Serializer.SetMultiThread(XSingleton<XGlobalConfig>.singleton.GetSettingEnum(ESettingConfig.EMultiThreadProtoBuf));
			Serializer.SetSkipProtoIgnore(XSingleton<XGlobalConfig>.singleton.GetSettingEnum(ESettingConfig.ESkipProtoIgnore));
			XAutoFade.MakeBlack(true);
			XOptionsDocument optDoc = XDocuments.GetSpecificDocument<XOptionsDocument>(XOptionsDocument.uuID);
			bool flag3 = optDoc != null;
			if (flag3)
			{
				int value = optDoc.GetValue(XOptionsDefine.OD_SMOOTH);
				XSingleton<XGameUI>.singleton.SetUIOptOption(false, value == 1, false, false);
			}
			bool settingEnum = XSingleton<XGlobalConfig>.singleton.GetSettingEnum(ESettingConfig.EApm);
			if (settingEnum)
			{
				XSingleton<XUpdater.XUpdater>.singleton.XPlatform.InitApm();
			}
			XResourceLoaderMgr.UseCurveTable = XSingleton<XGlobalConfig>.singleton.GetSettingEnum(ESettingConfig.ELoadCurveTable);
			XSingleton<XResourceLoaderMgr>.singleton.DelayLoad = XSingleton<XGlobalConfig>.singleton.GetSettingEnum(ESettingConfig.EDelayLoad);
			XFxMgr.FilterFarFx = XSingleton<XGlobalConfig>.singleton.GetSettingEnum(ESettingConfig.EFilterFarFx);
			yield return null;
			yield break;
		}

		public override bool Init()
		{
			XQualitySetting.InitResolution();
			bool flag = (int)Application.platform == 7 || (int)Application.platform == 0|| (int)Application.platform == 2;
			if (flag)
			{
				Application.targetFrameRate = 60;
			}
			else
			{
				Application.targetFrameRate = XShell.TargetFrame;
			}
			XAutoFade.FadeIn(0f, true);
			this.SwitchTo(EXStage.Login, 3u);
			return true;
		}

		public override void Uninit()
		{
			this.SwitchTo(EXStage.Null, 0u);
			this._doc.Uninitilize();
			for (int i = this._singletons.Count - 1; i >= 0; i--)
			{
				this._singletons[i].Uninit();
			}
			XSingleton<XClientNetwork>.singleton.Close(NetErrCode.Net_NoError);
			XSingleton<XInterfaceMgr>.singleton.Uninit();
			INativePlugin nativePlugin = XSingleton<XUpdater.XUpdater>.singleton.XPlatform.GetNativePlugin();
			bool flag = nativePlugin != null;
			if (flag)
			{
				nativePlugin.CloseHooks();
			}
		}

		public void UpdateNetwork()
		{
			bool flag = this.networkRun;
			if (flag)
			{
				XSingleton<XClientNetwork>.singleton.Update();
			}
		}

		public void PreUpdate(float fDeltaT)
		{
			bool flag = this.StageReady && this.notLoadScene;
			if (flag)
			{
				XSingleton<XInput>.singleton.Update();
				this._stage.PreUpdate(fDeltaT);
			}
		}

		public void Update(float fDeltaT)
		{
			bool flag = this.StageReady && this.notLoadScene;
			if (flag)
			{
				this._stage.Update(fDeltaT);
				this._doc.Update(fDeltaT);
				XSingleton<UIManager>.singleton.Update(fDeltaT);
			}
			bool calc_fps = this._calc_fps;
			if (calc_fps)
			{
				this._fps_count++;
			}
			bool key = Input.GetKey((KeyCode)284);
			if (key)
			{
				XSingleton<X3DTouchMgr>.singleton.OnProcess3DTouch("");
			}
		}

		private void CheckExit()
		{
			bool keyDown = Input.GetKeyDown((KeyCode)27);
			if (keyDown)
			{
				bool flag = Time.time - this._lastExitClickTime < float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("DoubleClickExitTime"));
				if (flag)
				{
					Application.Quit();
				}
				XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("EXIT_GAME_TIP"), "fece00");
				this._lastExitClickTime = Time.time;
			}
		}

		public void PostUpdate(float fDeltaT)
		{
			bool flag = this.StageReady && this.notLoadScene;
			if (flag)
			{
				this._stage.PostUpdate(fDeltaT);
				this._doc.PostUpdate(fDeltaT);
				XSingleton<UIManager>.singleton.PostUpdate(fDeltaT);
			}
		}

		public void SwitchTo(EXStage eStage, uint sceneID)
		{
			bool flag = sceneID == XSingleton<XScene>.singleton.SceneID && this.CurrentStage.Stage == eStage && sceneID != 3u && XSingleton<XScene>.singleton.SceneType != SceneType.SCENE_TOWER;
			if (flag)
			{
				XSingleton<XDebug>.singleton.AddLog("switch to the same scene id ", sceneID.ToString(), " with same stage.", null, null, null, XDebugColor.XDebug_None);
			}
			bool flag2 = eStage == EXStage.Null || sceneID == 0u;
			if (flag2)
			{
				this._old_stage = this._stage;
				this._old_stage.OnLeaveStage(EXStage.Null);
				this._old_stage.OnLeaveScene(false);
				XSingleton<XScene>.singleton.OnLeaveScene(false);
				this._old_stage = null;
			}
			else
			{
				int num = XFastEnumIntEqualityComparer<EXStage>.ToInt(eStage);
				uint num2 = (uint)(num << 24 | (int)sceneID);
				bool flag3 = this._stage == null || sceneID != XSingleton<XScene>.singleton.SceneID || XSingleton<XSceneMgr>.singleton.GetSceneSwitchToSelf(sceneID);
				if (flag3)
				{
					XSingleton<XScene>.singleton.UntriggerScene();
				}
				bool flag4 = (eStage == EXStage.World || eStage == EXStage.Hall) && XSingleton<XScene>.singleton.TurnToTransfer(sceneID);
				if (flag4)
				{
					XAutoFade.FadeOut(0.5f);
					XSingleton<XTimerMgr>.singleton.SetTimer(1f, this._innerSwitchCb, num2 | 2147483648u);
				}
				else
				{
					float sceneDelayTransfer = XSingleton<XSceneMgr>.singleton.GetSceneDelayTransfer(sceneID);
					bool flag5 = sceneDelayTransfer > 0f;
					if (flag5)
					{
						XAutoFade.FadeOut(sceneDelayTransfer);
						XSingleton<XTimerMgr>.singleton.SetTimer(sceneDelayTransfer + 0.03f, this._innerSwitchCb, num2);
					}
					else
					{
						this.InnerSwitch(num2);
					}
				}
			}
		}

		public XStage CreateSpecifiecStage(EXStage eStage)
		{
			XStage result;
			switch (eStage)
			{
			case EXStage.Login:
				result = XStage.CreateSpecificStage<XLoginStage>();
				break;
			case EXStage.SelectChar:
				result = XStage.CreateSpecificStage<XSelectcharStage>();
				break;
			case EXStage.World:
				result = XStage.CreateSpecificStage<XWorldStage>();
				break;
			case EXStage.Hall:
				result = XStage.CreateSpecificStage<XHallStage>();
				break;
			default:
				result = null;
				break;
			}
			return result;
		}

		public void TriggerFps()
		{
			bool calc_fps = this._calc_fps;
			if (calc_fps)
			{
				XSingleton<XTimerMgr>.singleton.SetGlobalTimer(this._fps_interval, this._fpsHandler, null);
			}
		}

		private void InnerSwitch(object o)
		{
			this.switchScene = true;
			uint num = (uint)o;
			bool flag = num >> 31 > 0u;
			uint num2 = num & 16777215u;
			EXStage exstage = (EXStage)(num >> 24 & 127u);
			bool flag2 = flag;
			if (flag2)
			{
				XAutoFade.MakeBlack(false);
			}
			bool flag3 = XSingleton<XScene>.singleton.SceneID == 100u;
			if (flag3)
			{
				XAutoFade.FadeIn(0.2f, false);
			}
			this._old_stage = this._stage;
			this._stage = ((this._old_stage != null && exstage == this._old_stage.Stage) ? this._old_stage : this.CreateSpecifiecStage(exstage));
			bool flag4 = this._old_stage != null;
			if (flag4)
			{
				this._old_stage.OnLeaveStage(this._stage.Stage);
				bool flag5 = num2 != XSingleton<XScene>.singleton.SceneID || XSingleton<XSceneMgr>.singleton.GetSceneSwitchToSelf(num2);
				if (flag5)
				{
					XSingleton<XGameUI>.singleton.m_uiTool.EnableUILoadingUpdate(false);
					this._old_stage.OnLeaveScene(flag);
					bool flag6 = XSingleton<XScene>.singleton.SceneID > 0u;
					if (flag6)
					{
						XSingleton<XScene>.singleton.OnLeaveScene(flag);
					}
					XSingleton<XScene>.singleton.LoadSceneAsync(num2, exstage, !flag, flag);
				}
				else
				{
					this.OnEnterStage();
					this.switchScene = false;
				}
			}
			else
			{
				XSingleton<XScene>.singleton.LoadSceneAsync(num2, exstage, true, false);
			}
		}

		private void LockFps(int goal)
		{
			float num = 1f / (float)goal - Time.smoothDeltaTime;
			bool flag = num > 0f;
			if (flag)
			{
				this._millisecondsToWait++;
			}
			else
			{
				this._millisecondsToWait--;
			}
			Thread.Sleep((int)Mathf.Clamp((float)this._millisecondsToWait, 0f, 1f / (float)goal * 1000f));
		}

		private void CalculateFPS(object o)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			this._fps = (float)this._fps_count / (realtimeSinceStartup - this._fps_real_time);
			this._fpsCalcCount++;
			this._fpsAcc += this._fps;
			bool flag = this._fpsCalcCount >= 20;
			if (flag)
			{
				this._fpsAvg = this._fpsAcc / (float)this._fpsCalcCount;
				this._fpsCalcCount = 0;
				this._fpsAcc = 0f;
			}
			bool flag2 = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.MainDoc != null;
			if (flag2)
			{
				bool flag3 = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.MainDoc.GetFpsState == XMainInterfaceDocument.GetFps.start;
				if (flag3)
				{
					DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.MainDoc.FpsStartTime = realtimeSinceStartup;
					DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.MainDoc.PeakFps = this._fps;
					DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.MainDoc.FpsCount = this._fps_count;
					DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.MainDoc.GetFpsState = XMainInterfaceDocument.GetFps.running;
				}
				else
				{
					bool flag4 = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.MainDoc.GetFpsState == XMainInterfaceDocument.GetFps.running;
					if (flag4)
					{
						DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.MainDoc.PeakFps = Math.Max(this._fps, DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.MainDoc.PeakFps);
						DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.MainDoc.FpsCount += this._fps_count;
					}
				}
			}
			this._fps_real_time = realtimeSinceStartup;
			this._fps_count = 0;
			XSingleton<XTimerMgr>.singleton.SetGlobalTimer(this._fps_interval, this._fpsHandler, null);
		}

		private void OnEnterStage()
		{
			this._stage.OnEnterStage((this._old_stage != null) ? this._old_stage.Stage : EXStage.Null);
		}

		public void OnEnterScene(uint sceneid, bool bTransfer = false)
		{
			bool bHall = XSingleton<XSceneMgr>.singleton.GetSceneType(sceneid) == SceneType.SCENE_HALL || XSingleton<XSceneMgr>.singleton.GetSceneType(sceneid) == SceneType.SCENE_GUILD_HALL || XSingleton<XSceneMgr>.singleton.GetSceneType(sceneid) == SceneType.SCENE_LEISURE;
			XSingleton<XScene>.singleton.GameCamera.PreInstall(GameObject.Find("Main Camera"), bHall);
			XSingleton<XScene>.singleton.OnEnterScene(sceneid, bTransfer);
			this._stage.OnEnterScene(sceneid, bTransfer);
			XSingleton<XScene>.singleton.GameCamera.Installed();
			XSingleton<XScene>.singleton.AssociatedCamera = XSingleton<XScene>.singleton.GameCamera.UnityCamera;
			XSingleton<XAIGeneralMgr>.singleton.InitAIMgr();
			this.OnEnterStage();
		}

		public string GetSyncModeString()
		{
			bool flag = this._nSyncMode == 0;
			string result;
			if (flag)
			{
				result = " Solo Mode ";
			}
			else
			{
				bool flag2 = this._nSyncMode == 1;
				if (flag2)
				{
					result = " OnLine Mode ";
				}
				else
				{
					bool flag3 = this._nSyncMode == 2;
					if (flag3)
					{
						result = " Mixed Mode ";
					}
					else
					{
						result = "Unknown";
					}
				}
			}
			return result;
		}

		public static void SetVisible(GameObject go, int layer)
		{
			go.layer = layer;
			for (int i = 0; i < go.transform.childCount; i++)
			{
				Transform child = go.transform.GetChild(i);
				XGame.SetVisible(child.gameObject, layer);
			}
		}
	}
}