From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../Assets/Scripts/XMainClient/XWeddingDocument.cs | 1466 ++++++++++++++++++++ 1 file changed, 1466 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/XWeddingDocument.cs (limited to 'Client/Assets/Scripts/XMainClient/XWeddingDocument.cs') diff --git a/Client/Assets/Scripts/XMainClient/XWeddingDocument.cs b/Client/Assets/Scripts/XMainClient/XWeddingDocument.cs new file mode 100644 index 00000000..3eda2d05 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XWeddingDocument.cs @@ -0,0 +1,1466 @@ +using System; +using System.Collections.Generic; +using KKSG; +using UILib; +using UnityEngine; +using XMainClient.UI; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XWeddingDocument : XDocComponent + { + public override uint ID + { + get + { + return XWeddingDocument.uuID; + } + } + + public static XWeddingDocument Doc + { + get + { + return XSingleton.singleton.Doc.GetXComponent(XWeddingDocument.uuID) as XWeddingDocument; + } + } + + public static WeddingLoverLiveness LoverLivenessTable + { + get + { + return XWeddingDocument.m_partnerLivenessTab; + } + } + + public List RecordList + { + get + { + return this.m_recordList; + } + } + + public List PartnerList + { + get + { + return this.m_PartnerList; + } + } + + public MarriageLevelInfo MarriageLevel + { + get + { + return this.m_MarriageLevel; + } + } + + public int MarriageLevelUp + { + get + { + return this.m_MarriageLevelUp; + } + } + + public bool IsHadLivenessRedPoint + { + get + { + return this.m_bIsHadLivenessRedPoint; + } + set + { + bool flag = this.m_bIsHadLivenessRedPoint != value; + if (flag) + { + this.m_bIsHadLivenessRedPoint = value; + DlgBase.singleton.SetRedPoint(TabIndex.Wedding, this.IsHadRedDot); + bool flag2 = this.View != null && this.View.IsVisible(); + if (flag2) + { + this.View.RefreshUIRedPoint(); + } + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_Friends, true); + bool flag3 = DlgBase.singleton.IsVisible(); + if (flag3) + { + DlgBase.singleton.UpdateRedpointUI(); + } + } + } + } + + public bool IsHadPrivilegeLevelUpRedPoint + { + get + { + return this.m_bLevelUpRedPoint; + } + set + { + bool flag = this.m_bLevelUpRedPoint != value; + if (flag) + { + this.m_bLevelUpRedPoint = value; + DlgBase.singleton.SetRedPoint(TabIndex.Wedding, this.IsHadRedDot); + bool flag2 = this.View != null && this.View.IsVisible(); + if (flag2) + { + this.View.RefreshUIRedPoint(); + } + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_Friends, true); + bool flag3 = DlgBase.singleton.IsVisible(); + if (flag3) + { + DlgBase.singleton.UpdateRedpointUI(); + } + } + } + } + + public bool IsHadRedDot + { + get + { + bool flag = !XSingleton.singleton.IsSystemOpened(XSysDefine.XSys_Wedding); + return !flag && (this.IsHadLivenessRedPoint || this.IsHadPrivilegeLevelUpRedPoint); + } + } + + public uint AllAttendPlayerCount + { + get + { + return this.m_AllAttendPlayerCount; + } + } + + public WeddingBrief CurrWeddingInfo + { + get + { + return this.m_CurrWeddingInfo; + } + } + + public List CanEnterWedding + { + get + { + return this.m_CanEnterWedding; + } + } + + public List CanApplyWedding + { + get + { + return this.m_CanApplyWedding; + } + } + + public int LeftDivorceTime + { + get + { + return this.m_LeftDivorceTime - (int)Time.realtimeSinceStartup; + } + set + { + this.m_LeftDivorceTime = value + (int)Time.realtimeSinceStartup; + } + } + + public ulong DivorceApplyID + { + get + { + return this.m_DivorceApplyID; + } + } + + public bool PermitStranger + { + get + { + return this.m_PermitStranger; + } + } + + public int CoupleOfflineTime + { + get + { + return this.m_CoupleOfflineTime; + } + } + + public ulong MyWeddingID + { + get + { + return this.m_MyWeddingID; + } + set + { + this.m_MyWeddingID = value; + } + } + + public bool HasApplyCandidate + { + get + { + return this._hasApplyCandidate; + } + set + { + this._hasApplyCandidate = value; + bool flag = DlgBase.singleton._WeddingHandler != null && DlgBase.singleton._WeddingHandler.IsVisible(); + if (flag) + { + DlgBase.singleton._WeddingHandler.RefreshInviteRedPoint(); + } + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("WeddingDocument"); + + public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader(); + + public static MarriageLevel MarriageLevelTable = new MarriageLevel(); + + private static WeddingLoverLiveness m_partnerLivenessTab = new WeddingLoverLiveness(); + + private List m_recordList = new List(); + + public static readonly int MaxAvata = 2; + + public FriendsWeddingHandler View; + + private List m_PartnerList = new List(); + + private MarriageLevelInfo m_MarriageLevel; + + private int m_MarriageLevelUp = 0; + + public static int MaxMarriageLevel; + + public uint CurrExp = 0u; + + private uint m_takeChest = 0u; + + public static uint MaxExp = 0u; + + private bool m_bIsHadLivenessRedPoint = false; + + private bool m_bLevelUpRedPoint = false; + + private List m_CanEnterWedding = new List(); + + private List m_CanApplyWedding = new List(); + + private MarriageStatus m_MyMarriageStatus = MarriageStatus.MarriageStatus_Null; + + private ulong m_NotifedWeddingID = 0UL; + + private ulong m_ApplyMarriageRoleID = 0UL; + + private int m_LeftDivorceTime = 0; + + private ulong m_DivorceApplyID = 0UL; + + private bool m_PermitStranger = false; + + private ulong m_MyWeddingID; + + private int m_CoupleOfflineTime = 0; + + private WeddingType m_WeddingType = WeddingType.WeddingType_Normal; + + private List m_FriendsWeddingRoleInfoList = new List(); + + private List m_GuildWeddingRoleInfoList = new List(); + + private List m_InvitedWeddingRoleInfoList = new List(); + + private List m_ApplyWeddingRoleInfoList = new List(); + + private List m_Marriagelist = new List(); + + private WeddingBrief m_CurrWeddingInfo = null; + + private NotifyType m_CacheNotify = NotifyType.None; + + private object m_CachedData = null; + + private uint m_AllAttendPlayerCount = 0u; + + private XRole _player1; + + private XRole _player2; + + private XMount _mount; + + private uint _weddingCarTimer = 0u; + + private bool _hasApplyCandidate = false; + + private Dictionary m_WeddingSceneLoverFx = new Dictionary(); + + public void ReqPartnerDetailInfo() + { + RpcC2M_GetMarriageRelation rpc = new RpcC2M_GetMarriageRelation(); + XSingleton.singleton.Send(rpc); + } + + public void OnGetPartDetailInfoBack(GetMarriageRelationRes oRes) + { + bool flag = oRes.error > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(oRes.error, "fece00"); + } + else + { + this.m_PartnerList = oRes.infos; + this.m_MarriageLevel = oRes.marriageLevel; + bool flag2 = this.View != null && this.View.IsVisible(); + if (flag2) + { + this.View.RefreshUi(); + } + } + } + + public RoleOutLookBrief GetTeamLoverRole() + { + for (int i = 0; i < this.m_PartnerList.Count; i++) + { + bool flag = this.m_PartnerList[i].roleid != XSingleton.singleton.XPlayerData.RoleID; + if (flag) + { + return this.m_PartnerList[i]; + } + } + return null; + } + + public void ReqPartnerLivenessInfo() + { + RpcC2M_GetMarriageLiveness rpc = new RpcC2M_GetMarriageLiveness(); + XSingleton.singleton.Send(rpc); + } + + public void OnGetPartnerLivenessInfo(GetMarriageLivenessRes oRes) + { + bool flag = oRes.result > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(oRes.result, "fece00"); + } + else + { + this.CurrExp = oRes.liveness; + this.m_takeChest = oRes.takedchest; + this.m_recordList.Clear(); + for (int i = 0; i < oRes.record.Count; i++) + { + this.m_recordList.Add(new LoverLivenessRecord(oRes.record[i])); + } + this.IsHadLivenessRedPoint = this.IsHadRedPoint(); + bool flag2 = DlgBase.singleton.IsVisible(); + if (flag2) + { + DlgBase.singleton.FillContent(); + } + } + } + + public void ReqTakePartnerChest(uint index) + { + RpcC2M_TakeMarriageChest rpcC2M_TakeMarriageChest = new RpcC2M_TakeMarriageChest(); + rpcC2M_TakeMarriageChest.oArg.index = index; + XSingleton.singleton.Send(rpcC2M_TakeMarriageChest); + } + + public void OnTakePartnerChestBack(int index, TakeMarriageChestRes oRes) + { + bool flag = oRes.result > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(oRes.result, "fece00"); + } + else + { + this.m_takeChest = oRes.takedchest; + this.IsHadLivenessRedPoint = this.IsHadRedPoint(); + bool flag2 = DlgBase.singleton.IsVisible(); + if (flag2) + { + DlgBase.singleton.ResetBoxRedDot(index - 1); + } + } + } + + public int FindNeedShowReward() + { + bool flag = this.CurrExp >= XWeddingDocument.MaxExp; + int result; + if (flag) + { + result = 0; + } + else + { + for (int i = 0; i < XWeddingDocument.m_partnerLivenessTab.Table.Length; i++) + { + bool flag2 = !this.IsChestOpened(i + 1); + if (flag2) + { + return i; + } + } + result = 0; + } + return result; + } + + public bool IsHadRedPoint() + { + for (int i = 0; i < XWeddingDocument.m_partnerLivenessTab.Table.Length; i++) + { + bool flag = !this.IsChestOpened(i + 1) && this.CurrExp >= XWeddingDocument.m_partnerLivenessTab.Table[i].liveness; + if (flag) + { + return true; + } + } + return false; + } + + public bool IsChestOpened(int index) + { + uint num = 1u << index; + return (this.m_takeChest & num) > 0u; + } + + public void OnMarriageNewPrivilegeNtf(int marriageLevelUp) + { + this.m_MarriageLevelUp = marriageLevelUp; + MarriageLevel.RowData byLevel = XWeddingDocument.MarriageLevelTable.GetByLevel(marriageLevelUp); + bool flag = byLevel != null; + if (flag) + { + bool flag2 = byLevel.PrerogativeID != 0u || byLevel.PrivilegeBuffs[0] > 0u; + if (flag2) + { + this.IsHadLivenessRedPoint = true; + } + } + bool flag3 = this.View != null && this.View.IsVisible(); + if (flag3) + { + this.View.CheckMarriageLevelUp(); + } + } + + public void GetMarriagePrivilege() + { + RpcC2M_GetMarriagePrivilege rpc = new RpcC2M_GetMarriagePrivilege(); + XSingleton.singleton.Send(rpc); + } + + public void OnGetMarriagePrivilege(ErrorCode error) + { + bool flag = error > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(error, "fece00"); + } + else + { + this.m_MarriageLevelUp = 0; + this.IsHadLivenessRedPoint = false; + } + } + + public void OnMarriageLevelValueChangeNtf(MarriageLevelValueNtfData data) + { + this.m_MarriageLevel = data.info; + bool flag = this.View != null && this.View.IsVisible(); + if (flag) + { + this.View.RefreshMarriageLevelValue(); + } + } + + protected override void EventSubscribe() + { + base.EventSubscribe(); + base.RegisterEvent(XEventDefine.XEvent_OnEntityCreated, new XComponent.XEventHandler(this.OnEntityCreate)); + base.RegisterEvent(XEventDefine.XEvent_OnEntityDeleted, new XComponent.XEventHandler(this.OnEntityDelete)); + } + + private bool OnEntityCreate(XEventArgs args) + { + XOnEntityCreatedArgs xonEntityCreatedArgs = args as XOnEntityCreatedArgs; + bool flag = XSingleton.singleton.SceneType == SceneType.SCENE_WEDDING && xonEntityCreatedArgs.entity != null && xonEntityCreatedArgs.entity.IsRole && xonEntityCreatedArgs.entity.Attributes != null; + if (flag) + { + bool flag2 = this.IsWeddingLover(xonEntityCreatedArgs.entity.Attributes.RoleID); + if (flag2) + { + this.CreateLoverSceneFx(xonEntityCreatedArgs.entity); + } + } + return true; + } + + private bool OnEntityDelete(XEventArgs args) + { + bool flag = XSingleton.singleton.SceneType == SceneType.SCENE_WEDDING; + if (flag) + { + XOnEntityDeletedArgs xonEntityDeletedArgs = args as XOnEntityDeletedArgs; + this.DeleteLoverSceneFx(xonEntityDeletedArgs.Id); + } + return true; + } + + private void CreateLoverSceneFx(XEntity entity) + { + XFx xfx; + bool flag = this.m_WeddingSceneLoverFx.TryGetValue(entity.Attributes.RoleID, out xfx) && xfx != null; + if (flag) + { + XSingleton.singleton.DestroyFx(xfx, true); + } + xfx = XSingleton.singleton.CreateFx(XSingleton.singleton.GetValue("WeddingSceneLoverFx"), null, true); + int renderLayer = LayerMask.NameToLayer("Role"); + xfx.SetRenderLayer(renderLayer); + xfx.Play(entity.MoveObj, Vector3.zero, Vector3.one, 1f, true, false, "", 0f); + this.m_WeddingSceneLoverFx[entity.Attributes.RoleID] = xfx; + } + + private void DeleteLoverSceneFx(ulong roleID) + { + XFx xfx; + bool flag = this.m_WeddingSceneLoverFx.TryGetValue(roleID, out xfx) && xfx != null; + if (flag) + { + XSingleton.singleton.DestroyFx(xfx, true); + this.m_WeddingSceneLoverFx[roleID] = null; + } + } + + private bool IsWeddingLover(ulong roleID) + { + bool flag = XWeddingDocument.Doc.CurrWeddingInfo != null && XWeddingDocument.Doc.CurrWeddingInfo.role1 != null && XWeddingDocument.Doc.CurrWeddingInfo.role2 != null; + return flag && (roleID == XWeddingDocument.Doc.CurrWeddingInfo.role1.roleid || roleID == XWeddingDocument.Doc.CurrWeddingInfo.role2.roleid); + } + + public MarriageStatus GetMyMarriageRelation() + { + return this.m_MyMarriageStatus; + } + + public WeddingType GetMyWeddingType() + { + return this.m_WeddingType; + } + + public List GetInviteRoleInfoList(WeddingInviteTab tab) + { + List result; + switch (tab) + { + case WeddingInviteTab.WeddingFriends: + result = this.m_FriendsWeddingRoleInfoList; + break; + case WeddingInviteTab.WeddingGuild: + result = this.m_GuildWeddingRoleInfoList; + break; + case WeddingInviteTab.WeddingInvited: + result = this.m_InvitedWeddingRoleInfoList; + break; + case WeddingInviteTab.WeddingApplyList: + result = this.m_ApplyWeddingRoleInfoList; + break; + default: + result = null; + break; + } + return result; + } + + public RoleOutLookBrief GetPartnerInfo() + { + bool flag = this.m_Marriagelist != null && this.m_Marriagelist.Count == 2; + RoleOutLookBrief result; + if (flag) + { + result = this.m_Marriagelist[1]; + } + else + { + result = null; + } + return result; + } + + public void ReqHoldWedding() + { + RpcC2M_HoldWedding rpc = new RpcC2M_HoldWedding(); + XSingleton.singleton.Send(rpc); + } + + public void OnHoldWedding(HoldWeddingRes oRes) + { + bool flag = oRes.result > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(oRes.result, "fece00"); + } + } + + public void EnterWedding(ulong weddingID) + { + bool flag = DlgBase.singleton.IsVisible(); + if (flag) + { + DlgBase.singleton.SetVisible(false, true); + } + RpcC2M_EnterWeddingScene rpcC2M_EnterWeddingScene = new RpcC2M_EnterWeddingScene(); + rpcC2M_EnterWeddingScene.oArg.weddingid = weddingID; + XSingleton.singleton.Send(rpcC2M_EnterWeddingScene); + } + + public void OnEnterWedding(EnterWeddingSceneRes oRes) + { + bool flag = oRes.result > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(oRes.result, "fece00"); + } + } + + public void OnWeddingLoadingInfoNtf(PtcG2C_WeddingLoadInfoNtf roPtc) + { + bool flag = roPtc.Data.info == null; + if (!flag) + { + this.m_CurrWeddingInfo = roPtc.Data.info; + } + } + + public void WeddingSceneOperator(WeddingOperType type) + { + RpcC2G_WeddingOperator rpcC2G_WeddingOperator = new RpcC2G_WeddingOperator(); + rpcC2G_WeddingOperator.oArg.type = type; + XSingleton.singleton.Send(rpcC2G_WeddingOperator); + } + + public void OnWeddingSceneOperator(WeddingOperatorArg oArg, WeddingOperatorRes oRes) + { + bool flag = oRes.result > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(oRes.result, "fece00"); + } + else + { + bool flag2 = !DlgBase.singleton.IsVisible() || DlgBase.singleton._WeddingHandler == null || !DlgBase.singleton._WeddingHandler.IsVisible(); + if (!flag2) + { + WeddingOperType type = oArg.type; + if (type - WeddingOperType.WeddingOper_Flower > 1) + { + if (type == WeddingOperType.WeddingOper_ApplyVows) + { + DlgBase.singleton._WeddingHandler.ApplyVowsSuss(); + } + } + else + { + DlgBase.singleton._WeddingHandler.CoolDownBtn(oArg.type); + } + } + } + } + + public void WeddingSceneEventNtf(PtcG2C_WeddingEventNtf roPtc) + { + bool flag = !DlgBase.singleton.IsVisible() || DlgBase.singleton._WeddingHandler == null || !DlgBase.singleton._WeddingHandler.IsVisible(); + if (!flag) + { + this.m_AllAttendPlayerCount = roPtc.Data.total_num; + XSingleton.singleton.AddLog("Wedding Attend Player Count:" + this.m_AllAttendPlayerCount, null, null, null, null, null, XDebugColor.XDebug_None); + switch (roPtc.Data.type) + { + case WeddingOperType.WeddingOper_Flower: + DlgBase.singleton._WeddingHandler.OnFlowerRain(); + break; + case WeddingOperType.WeddingOper_Fireworks: + DlgBase.singleton._WeddingHandler.OnFireworks(); + break; + case WeddingOperType.WeddingOper_ApplyVows: + DlgBase.singleton._WeddingHandler.ShowPartnerSwearNtf(roPtc.Data.rolename); + break; + case WeddingOperType.WeddingOper_DisAgreeVows: + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("WeddingSwearDisagree", new object[] + { + roPtc.Data.rolename + }), "fece00"); + break; + case WeddingOperType.WeddingOper_VowsPrepare: + XSingleton.singleton.ShowSystemTip(XSingleton.singleton.GetString("WeddingSwearAgree"), "fece00"); + DlgBase.singleton._WeddingHandler.OnVowsPrepare(); + break; + case WeddingOperType.WeddingOper_VowsStart: + this.PlayCutscene(XSingleton.singleton.GetValue("WeddingCutscenePath")); + break; + case WeddingOperType.WeddingOper_FlowerRewardOverMax: + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("WeddingFlowerRewardMax"), "fece00"); + break; + case WeddingOperType.WeddingOper_FireworksRewardOverMax: + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("WeddingFireworksRewardMax"), "fece00"); + break; + case WeddingOperType.WeddingOper_CandyRewardOverMax: + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("WeddingCandyRewardMax"), "fece00"); + break; + case WeddingOperType.WeddingOper_Candy: + DlgBase.singleton._WeddingHandler.OnCandyFx(); + break; + } + } + } + + public void PlayCutscene(string path) + { + XSingleton.singleton.Start(path, true, true); + } + + public void WeddingStateNtf(PtcG2C_WeddingStateNtf roPtc) + { + bool flag = DlgBase.singleton.IsVisible() && DlgBase.singleton._WeddingHandler != null && DlgBase.singleton._WeddingHandler.IsVisible(); + if (flag) + { + DlgBase.singleton._WeddingHandler.UpdateWeddingState(roPtc.Data.state, roPtc.Data.lefttime, roPtc.Data.vows); + DlgBase.singleton._WeddingHandler.UpdateHappiness(roPtc.Data.happyness); + } + } + + public void WeddingInviteOperate(WeddingInviteOperType type, ulong roleID = 0UL, ulong weddingID = 0UL) + { + RpcC2M_WeddingInviteOperator rpcC2M_WeddingInviteOperator = new RpcC2M_WeddingInviteOperator(); + rpcC2M_WeddingInviteOperator.oArg.type = type; + rpcC2M_WeddingInviteOperator.oArg.roleid = roleID; + rpcC2M_WeddingInviteOperator.oArg.weddingid = weddingID; + XSingleton.singleton.Send(rpcC2M_WeddingInviteOperator); + } + + public void OnWeddingInviteOperate(WeddingInviteOperatorArg oArg, WeddingInviteOperatorRes oRes) + { + bool flag = oRes.result > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(oRes.result, "fece00"); + bool flag2 = oArg.type == WeddingInviteOperType.Wedding_DisagreeApply || oArg.type == WeddingInviteOperType.Wedding_AgreeApply; + if (flag2) + { + for (int i = this.m_ApplyWeddingRoleInfoList.Count - 1; i >= 0; i--) + { + bool flag3 = this.m_ApplyWeddingRoleInfoList[i].roleID == oArg.roleid; + if (flag3) + { + this.m_ApplyWeddingRoleInfoList.RemoveAt(i); + break; + } + } + this.HasApplyCandidate = (this.m_ApplyWeddingRoleInfoList.Count > 0); + bool flag4 = DlgBase.singleton.IsVisible(); + if (flag4) + { + DlgBase.singleton.RefreshUI(); + } + } + } + else + { + bool flag5 = oArg.type == WeddingInviteOperType.Wedding_Apply; + if (flag5) + { + XSingleton.singleton.ShowSystemTip(XSingleton.singleton.GetString("WeddingApplySend"), "fece00"); + this.UpdateApplyWeddingState(oArg.weddingid, true); + } + bool flag6 = oArg.type == WeddingInviteOperType.Wedding_PermitStranger; + if (flag6) + { + this.m_PermitStranger = true; + } + bool flag7 = oArg.type == WeddingInviteOperType.Wedding_ForbidStranger; + if (flag7) + { + this.m_PermitStranger = false; + } + bool flag8 = oArg.type == WeddingInviteOperType.Wedding_Invite; + if (flag8) + { + WeddingRoleInfo weddingRoleInfo = null; + for (int j = this.m_FriendsWeddingRoleInfoList.Count - 1; j >= 0; j--) + { + bool flag9 = this.m_FriendsWeddingRoleInfoList[j].roleID == oArg.roleid; + if (flag9) + { + weddingRoleInfo = this.m_FriendsWeddingRoleInfoList[j]; + this.m_FriendsWeddingRoleInfoList.RemoveAt(j); + break; + } + } + for (int k = this.m_GuildWeddingRoleInfoList.Count - 1; k >= 0; k--) + { + bool flag10 = this.m_GuildWeddingRoleInfoList[k].roleID == oArg.roleid; + if (flag10) + { + weddingRoleInfo = this.m_GuildWeddingRoleInfoList[k]; + this.m_GuildWeddingRoleInfoList.RemoveAt(k); + break; + } + } + bool flag11 = weddingRoleInfo != null; + if (flag11) + { + this.m_InvitedWeddingRoleInfoList.Add(weddingRoleInfo); + } + bool flag12 = DlgBase.singleton.IsVisible(); + if (flag12) + { + DlgBase.singleton.RefreshUI(); + } + } + bool flag13 = oArg.type == WeddingInviteOperType.Wedding_AgreeApply; + if (flag13) + { + WeddingRoleInfo weddingRoleInfo2 = null; + for (int l = this.m_ApplyWeddingRoleInfoList.Count - 1; l >= 0; l--) + { + bool flag14 = this.m_ApplyWeddingRoleInfoList[l].roleID == oArg.roleid; + if (flag14) + { + weddingRoleInfo2 = this.m_ApplyWeddingRoleInfoList[l]; + this.m_ApplyWeddingRoleInfoList.RemoveAt(l); + break; + } + } + bool flag15 = weddingRoleInfo2 != null; + if (flag15) + { + this.m_InvitedWeddingRoleInfoList.Add(weddingRoleInfo2); + } + this.HasApplyCandidate = (this.m_ApplyWeddingRoleInfoList.Count > 0); + bool flag16 = DlgBase.singleton.IsVisible(); + if (flag16) + { + DlgBase.singleton.RefreshUI(); + } + } + bool flag17 = oArg.type == WeddingInviteOperType.Wedding_DisagreeApply; + if (flag17) + { + for (int m = this.m_ApplyWeddingRoleInfoList.Count - 1; m >= 0; m--) + { + bool flag18 = this.m_ApplyWeddingRoleInfoList[m].roleID == oArg.roleid; + if (flag18) + { + this.m_ApplyWeddingRoleInfoList.RemoveAt(m); + break; + } + } + this.HasApplyCandidate = (this.m_ApplyWeddingRoleInfoList.Count > 0); + bool flag19 = DlgBase.singleton.IsVisible(); + if (flag19) + { + DlgBase.singleton.RefreshUI(); + } + } + } + } + + public void WeddingInviteNtf(PtcM2C_WeddingInviteNtf roPtc) + { + bool flag = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag) + { + WeddingInviteOperType type = roPtc.Data.type; + if (type <= WeddingInviteOperType.Wedding_Apply) + { + if (type != WeddingInviteOperType.Wedding_Invite) + { + if (type == WeddingInviteOperType.Wedding_Apply) + { + this.HasApplyCandidate = true; + } + } + else + { + WeddingBrief weddinginfo = roPtc.Data.weddinginfo; + this.m_NotifedWeddingID = weddinginfo.weddingid; + XSingleton.singleton.ShowModalDialog(string.Format(XStringDefineProxy.GetString("WeddingInviteNotifyTip"), weddinginfo.role1.name, weddinginfo.role2.name), XStringDefineProxy.GetString("WeddingInviteBtnNow"), XStringDefineProxy.GetString("WeddingInviteBtnWait"), new ButtonClickEventHandler(this.ToSendToEnterScene)); + } + } + else if (type != WeddingInviteOperType.Wedding_CarCutScene) + { + if (type == WeddingInviteOperType.Wedding_Start) + { + XInvitationDocument specificDocument = XDocuments.GetSpecificDocument(XInvitationDocument.uuID); + NoticeTable.RowData noticeData = specificDocument.GetNoticeData(NoticeType.NT_Wedding_INVITE_WORLD); + bool flag2 = noticeData != null; + if (flag2) + { + List list = new List(); + ChatParam chatParam = new ChatParam(); + chatParam.link = new ChatParamLink(); + chatParam.link.id = noticeData.linkparam; + chatParam.link.param.Add(roPtc.Data.weddinginfo.weddingid); + chatParam.link.content = noticeData.linkcontent; + ChatParam chatParam2 = new ChatParam(); + chatParam2.role = new ChatParamRole(); + chatParam2.role.uniqueid = roPtc.Data.weddinginfo.role1.roleid; + chatParam2.role.name = roPtc.Data.weddinginfo.role1.name; + chatParam2.role.profession = roPtc.Data.weddinginfo.role1.profession; + ChatParam chatParam3 = new ChatParam(); + chatParam3.role = new ChatParamRole(); + chatParam3.role.uniqueid = roPtc.Data.weddinginfo.role2.roleid; + chatParam3.role.name = roPtc.Data.weddinginfo.role2.name; + chatParam3.role.profession = roPtc.Data.weddinginfo.role2.profession; + list.Add(chatParam2); + list.Add(chatParam3); + list.Add(chatParam); + DlgBase.singleton.SendChatContent(noticeData.info, (ChatChannelType)noticeData.channel, false, list, true, 0UL, 0f, false, false); + } + } + } + else + { + bool flag3 = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag3) + { + } + } + } + } + + private bool ToSendToEnterScene(IXUIButton button) + { + bool flag = this.m_NotifedWeddingID > 0UL; + if (flag) + { + this.EnterWedding(this.m_NotifedWeddingID); + } + XSingleton.singleton.CloseModalDlg(); + this.m_NotifedWeddingID = 0UL; + return true; + } + + public void GetAllWeddingInfo() + { + RpcC2M_GetAllWeddingInfo rpc = new RpcC2M_GetAllWeddingInfo(); + XSingleton.singleton.Send(rpc); + } + + public void OnGetAllWeddingInfo(GetAllWeddingInfoRes oRes) + { + bool flag = oRes.result > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(oRes.result, "fece00"); + } + else + { + this.m_CanEnterWedding.Clear(); + for (int i = 0; i < oRes.can_enter.Count; i++) + { + WeddingBriefInfo weddingBriefInfo = new WeddingBriefInfo(); + weddingBriefInfo.brief = oRes.can_enter[i]; + weddingBriefInfo.isApply = false; + this.m_CanEnterWedding.Add(weddingBriefInfo); + } + this.m_CanApplyWedding.Clear(); + for (int j = 0; j < oRes.can_apply.Count; j++) + { + WeddingBriefInfo weddingBriefInfo2 = new WeddingBriefInfo(); + weddingBriefInfo2.brief = oRes.can_apply[j]; + weddingBriefInfo2.isApply = oRes.is_apply[j]; + this.m_CanApplyWedding.Add(weddingBriefInfo2); + } + this.m_CanEnterWedding.Sort(new Comparison(XWeddingDocument.SortWeddingInfo)); + this.m_CanApplyWedding.Sort(new Comparison(XWeddingDocument.SortWeddingInfo)); + bool flag2 = DlgBase.singleton.IsVisible(); + if (flag2) + { + DlgBase.singleton.RefreshInfo(); + } + } + } + + private static int SortWeddingInfo(WeddingBriefInfo info1, WeddingBriefInfo info2) + { + bool flag = info1.brief.type != info2.brief.type; + int result; + if (flag) + { + result = info2.brief.type - info1.brief.type; + } + else + { + result = (int)(info1.brief.lefttime - info2.brief.lefttime); + } + return result; + } + + private void UpdateApplyWeddingState(ulong weddingid, bool isApply) + { + for (int i = 0; i < this.m_CanApplyWedding.Count; i++) + { + bool flag = this.m_CanApplyWedding[i].brief.weddingid == weddingid; + if (flag) + { + this.m_CanApplyWedding[i].isApply = true; + } + } + } + + public void GetWeddingInviteInfo() + { + RpcC2M_GetWeddingInviteInfo rpc = new RpcC2M_GetWeddingInviteInfo(); + XSingleton.singleton.Send(rpc); + } + + public void OnGetWeddingInviteInfo(GetWeddingInviteInfoRes oRes) + { + bool flag = oRes.result > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(oRes.result, "fece00"); + } + else + { + this.m_PermitStranger = oRes.permitstranger; + this.m_MyWeddingID = oRes.weddingid; + this.m_FriendsWeddingRoleInfoList.Clear(); + for (int i = 0; i < oRes.friends.Count; i++) + { + WeddingRoleBrief weddingRoleBrief = oRes.friends[i]; + this.m_FriendsWeddingRoleInfoList.Add(new WeddingRoleInfo + { + roleID = weddingRoleBrief.roleid, + name = weddingRoleBrief.name, + profession = weddingRoleBrief.profession, + level = weddingRoleBrief.level, + ppt = weddingRoleBrief.ppt, + guildName = weddingRoleBrief.guildname + }); + } + this.m_GuildWeddingRoleInfoList.Clear(); + for (int j = 0; j < oRes.guildmembers.Count; j++) + { + WeddingRoleBrief weddingRoleBrief2 = oRes.guildmembers[j]; + this.m_GuildWeddingRoleInfoList.Add(new WeddingRoleInfo + { + roleID = weddingRoleBrief2.roleid, + name = weddingRoleBrief2.name, + profession = weddingRoleBrief2.profession, + level = weddingRoleBrief2.level, + ppt = weddingRoleBrief2.ppt, + guildName = weddingRoleBrief2.guildname + }); + } + this.m_InvitedWeddingRoleInfoList.Clear(); + for (int k = 0; k < oRes.invitelist.Count; k++) + { + WeddingRoleBrief weddingRoleBrief3 = oRes.invitelist[k]; + this.m_InvitedWeddingRoleInfoList.Add(new WeddingRoleInfo + { + roleID = weddingRoleBrief3.roleid, + name = weddingRoleBrief3.name, + profession = weddingRoleBrief3.profession, + level = weddingRoleBrief3.level, + ppt = weddingRoleBrief3.ppt, + guildName = weddingRoleBrief3.guildname, + entered = oRes.invite_enter[k] + }); + } + this.m_ApplyWeddingRoleInfoList.Clear(); + for (int l = 0; l < oRes.applylist.Count; l++) + { + WeddingRoleBrief weddingRoleBrief4 = oRes.applylist[l]; + this.m_ApplyWeddingRoleInfoList.Add(new WeddingRoleInfo + { + roleID = weddingRoleBrief4.roleid, + name = weddingRoleBrief4.name, + profession = weddingRoleBrief4.profession, + level = weddingRoleBrief4.level, + ppt = weddingRoleBrief4.ppt, + guildName = weddingRoleBrief4.guildname + }); + } + this.HasApplyCandidate = (this.m_ApplyWeddingRoleInfoList.Count > 0); + bool flag2 = DlgBase.singleton.IsVisible(); + if (flag2) + { + DlgBase.singleton.RefreshUI(); + } + } + } + + public void SendMarriageRelationInfo() + { + RpcC2M_GetMarriageRelation rpc = new RpcC2M_GetMarriageRelation(); + XSingleton.singleton.Send(rpc); + } + + public void OnGetMarriageRelationInfo(GetMarriageRelationRes oRes) + { + bool flag = oRes.error == ErrorCode.ERR_SUCCESS; + if (flag) + { + this.m_Marriagelist = oRes.infos; + this.m_MyMarriageStatus = oRes.marriageStatus; + this.m_WeddingType = oRes.type; + this.LeftDivorceTime = oRes.leftDivorceTime; + this.m_DivorceApplyID = oRes.applyDivorceID; + this.m_CoupleOfflineTime = oRes.coupleOfflineTime; + XWeddingDramaOperate xweddingDramaOperate = this.IsNpcDialogVisible(); + bool flag2 = xweddingDramaOperate != null; + if (flag2) + { + xweddingDramaOperate.RefreshOperateStatus(); + } + } + } + + private XWeddingDramaOperate IsNpcDialogVisible() + { + bool flag = DlgBase.singleton.IsVisible(); + if (flag) + { + XDramaDocument specificDocument = XDocuments.GetSpecificDocument(XDramaDocument.uuID); + XDramaOperate openedOperate = specificDocument.GetOpenedOperate(XSysDefine.XSys_Wedding); + bool flag2 = openedOperate != null; + if (flag2) + { + XWeddingDramaOperate xweddingDramaOperate = openedOperate as XWeddingDramaOperate; + bool flag3 = xweddingDramaOperate != null; + if (flag3) + { + return xweddingDramaOperate; + } + } + } + return null; + } + + public void SendMarriageOp(MarriageOpType op, WeddingType type = WeddingType.WeddingType_Normal, ulong roleID = 0UL) + { + RpcC2M_MarriageRelationOp rpcC2M_MarriageRelationOp = new RpcC2M_MarriageRelationOp(); + rpcC2M_MarriageRelationOp.oArg.opType = op; + rpcC2M_MarriageRelationOp.oArg.type = type; + rpcC2M_MarriageRelationOp.oArg.destRoleID = roleID; + XSingleton.singleton.Send(rpcC2M_MarriageRelationOp); + } + + public void OnGetMarriageRelationOp(MarriageRelationOpArg oarg, MarriageRelationOpRes oRes) + { + bool flag = oRes.error == ErrorCode.ERR_SUCCESS && oarg.opType == MarriageOpType.MarriageOpType_MarryAgree; + if (flag) + { + bool flag2 = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag2) + { + DlgBase.singleton.SetVisible(false, true); + XSingleton.singleton.ShowModalDialog(string.Format(XSingleton.singleton.ReplaceReturn(XStringDefineProxy.GetString("MarriageSuccessTip")), oRes.oppoRoleName), XStringDefineProxy.GetString("PVPActivity_Go"), new ButtonClickEventHandler(XWeddingDocument.Doc.GoToNpc), 50); + return; + } + } + XWeddingDramaOperate xweddingDramaOperate = this.IsNpcDialogVisible(); + bool flag3 = xweddingDramaOperate != null; + if (flag3) + { + xweddingDramaOperate.RefreshMarriageOp(oarg, oRes); + } + } + + public void OnGetMarriageApplyNotify(PtcM2C_NotifyMarriageApply roPtc) + { + MarriageApplyInfo applyInfo = roPtc.Data.applyInfo; + bool flag = XSingleton.singleton.XPlayerData == null || XSingleton.singleton.CurrentStage.Stage != EXStage.Hall; + if (flag) + { + bool flag2 = applyInfo != null; + if (flag2) + { + this.m_CachedData = applyInfo; + this.m_CacheNotify = NotifyType.NotifyToApprove; + } + } + else + { + bool flag3 = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag3) + { + bool flag4 = applyInfo != null; + if (flag4) + { + this.m_ApplyMarriageRoleID = roPtc.Data.applyInfo.applyRoleID; + XSingleton.singleton.ShowModalDialog(string.Format(XStringDefineProxy.GetString("WeddingApplyTip"), applyInfo.applyName), XStringDefineProxy.GetString("COMMON_OK"), XStringDefineProxy.GetString("COMMON_CANCEL"), new ButtonClickEventHandler(this.ToAgreeMarriage), new ButtonClickEventHandler(this.ToRefuseMarriage), false, XTempTipDefine.OD_START, 50); + } + bool flag5 = roPtc.Data.response != null; + if (flag5) + { + bool isAgree = roPtc.Data.response.isAgree; + bool flag6 = isAgree; + if (flag6) + { + XSingleton.singleton.ShowModalDialog(string.Format(XSingleton.singleton.ReplaceReturn(XStringDefineProxy.GetString("MarriageSuccessTip")), roPtc.Data.response.roleName), XStringDefineProxy.GetString("PVPActivity_Go"), new ButtonClickEventHandler(this.GoToNpc), 50); + } + else + { + XSingleton.singleton.ShowSystemTip(string.Format(XStringDefineProxy.GetString("WeddingApplyBeenRefuse", new object[] + { + roPtc.Data.response.roleName + }), new object[0]), "fece00"); + } + } + } + } + } + + public bool GoToNpc(IXUIButton button) + { + DlgBase.singleton.SetVisible(false, true); + XSingleton.singleton.CloseModalDlg(); + XSingleton.singleton.LastNpc = XSingleton.singleton.GetNpc((uint)XSingleton.singleton.GetInt("LoveGoldNpcID")); + return true; + } + + public void OnGetMarriageDivorceNotify(PtcM2C_NotifyMarriageDivorceApply roPtc) + { + bool isApplyCancel = roPtc.Data.isApplyCancel; + if (isApplyCancel) + { + bool flag = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag) + { + string @string = XStringDefineProxy.GetString("WeddingMaintainSuccess"); + XSingleton.singleton.ShowModalDialog(@string, XStringDefineProxy.GetString("COMMON_OK")); + } + } + else + { + bool flag2 = XSingleton.singleton.CurrentStage.Stage != EXStage.Hall; + if (flag2) + { + this.m_CacheNotify = NotifyType.NotifyToBreak; + this.m_CachedData = roPtc.Data.leftTime; + } + else + { + string format = XSingleton.singleton.ReplaceReturn(XStringDefineProxy.GetString("WeddingBreakNotifyTip")); + XSingleton.singleton.ShowModalDialog(string.Format(format, XSingleton.singleton.TimeDuarationFormatString(roPtc.Data.leftTime, 5)), XStringDefineProxy.GetString("COMMON_OK")); + } + } + } + + public void SendWeddingCar() + { + RpcC2M_StartWeddingCar rpc = new RpcC2M_StartWeddingCar(); + XSingleton.singleton.Send(rpc); + } + + public void OnGetWeddingCarNtf(PtcG2C_WeddingCarNtf roPtc) + { + bool flag = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag) + { + int @int = XSingleton.singleton.GetInt("WeddingCarLocalOn"); + bool flag2 = @int > 0; + if (flag2) + { + this.StopWeddingCar(null); + this._weddingCarTimer = XSingleton.singleton.SetTimer((float)XSingleton.singleton.GetInt("WeddingPatrolTime"), new XTimerMgr.ElapsedEventHandler(this.StopWeddingCar), null); + UnitAppearance role = roPtc.Data.role1; + UnitAppearance role2 = roPtc.Data.role2; + XAttributes attributesWithAppearance = XSingleton.singleton.GetAttributesWithAppearance(role); + XRoleAttributes xroleAttributes = attributesWithAppearance as XRoleAttributes; + xroleAttributes.IsLocalFake = true; + XAttributes attributesWithAppearance2 = XSingleton.singleton.GetAttributesWithAppearance(role2); + xroleAttributes = (attributesWithAppearance2 as XRoleAttributes); + xroleAttributes.IsLocalFake = true; + List floatList = XSingleton.singleton.GetFloatList("WeddingcarParadeStart"); + this._player1 = XSingleton.singleton.CreateRole(attributesWithAppearance, new Vector3(floatList[0], floatList[1], floatList[2]), Quaternion.identity, false, false); + this._mount = XSingleton.singleton.CreateMount((uint)XSingleton.singleton.GetInt("WeddingCarID"), this._player1, true); + this._player2 = XSingleton.singleton.CreateRole(attributesWithAppearance2, new Vector3(floatList[0], floatList[1], floatList[2]), Quaternion.identity, false, false); + bool flag3 = this._player1.Mount.MountCopilot(this._player2); + XSingleton.singleton.AddLog(flag3.ToString(), null, null, null, null, null, XDebugColor.XDebug_None); + string value = XSingleton.singleton.GetValue("WeddingPatrolAITree"); + bool flag4 = this._player1.AI == null; + if (flag4) + { + this._player1.AI = (XSingleton.singleton.CreateComponent(this._player1, XAIComponent.uuID) as XAIComponent); + this._player1.AI.InitVariables(); + this._player1.AI.SetFixVariables(); + } + bool flag5 = this._player1.Nav == null; + if (flag5) + { + this._player1.Nav = (XSingleton.singleton.CreateComponent(this._player1, XNavigationComponent.uuID) as XNavigationComponent); + this._player1.Nav.Active(); + } + this._player1.AI.Patrol.InitNavPath(XSingleton.singleton.GetValue("WeddingPatrolPath"), XPatrol.PathType.PT_NORMAL); + this._player1.AI.SetBehaviorTree(value); + } + } + } + + private void StopWeddingCar(object param) + { + bool flag = this._weddingCarTimer > 0u; + if (flag) + { + XSingleton.singleton.KillTimer(this._weddingCarTimer); + this._weddingCarTimer = 0u; + this.DestroyFakeRoles(); + } + } + + private bool ToRefuseMarriage(IXUIButton button) + { + bool flag = this.m_ApplyMarriageRoleID > 0UL; + if (flag) + { + this.SendMarriageOp(MarriageOpType.MarriageOpType_MarryRefuse, WeddingType.WeddingType_Luxury, this.m_ApplyMarriageRoleID); + } + XSingleton.singleton.CloseModalDlg(); + this.m_ApplyMarriageRoleID = 0UL; + return true; + } + + private bool ToAgreeMarriage(IXUIButton button) + { + bool flag = this.m_ApplyMarriageRoleID > 0UL; + if (flag) + { + this.SendMarriageOp(MarriageOpType.MarriageOpType_MarryAgree, WeddingType.WeddingType_Luxury, this.m_ApplyMarriageRoleID); + } + XSingleton.singleton.CloseModalDlg(); + this.m_ApplyMarriageRoleID = 0UL; + return true; + } + + public static void Execute(OnLoadedCallback callback = null) + { + XWeddingDocument.AsyncLoader.AddTask("Table/WeddingLoverLiveness", XWeddingDocument.m_partnerLivenessTab, false); + XWeddingDocument.AsyncLoader.AddTask("Table/MarriageLevel", XWeddingDocument.MarriageLevelTable, false); + XWeddingDocument.AsyncLoader.Execute(callback); + } + + public static void OnTableLoaded() + { + bool flag = XWeddingDocument.m_partnerLivenessTab.Table.Length != 0; + if (flag) + { + XWeddingDocument.MaxExp = XWeddingDocument.m_partnerLivenessTab.Table[XWeddingDocument.m_partnerLivenessTab.Table.Length - 1].liveness; + } + bool flag2 = XWeddingDocument.MarriageLevelTable.Table.Length != 0; + if (flag2) + { + XWeddingDocument.MaxMarriageLevel = XWeddingDocument.MarriageLevelTable.Table[XWeddingDocument.MarriageLevelTable.Table.Length - 1].Level; + } + } + + protected override void OnReconnected(XReconnectedEventArgs arg) + { + } + + public override void OnEnterScene() + { + base.OnEnterScene(); + bool flag = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag) + { + NotifyType cacheNotify = this.m_CacheNotify; + if (cacheNotify != NotifyType.NotifyToBreak) + { + if (cacheNotify == NotifyType.NotifyToApprove) + { + MarriageApplyInfo marriageApplyInfo = this.m_CachedData as MarriageApplyInfo; + bool flag2 = marriageApplyInfo != null; + if (flag2) + { + this.m_ApplyMarriageRoleID = marriageApplyInfo.applyRoleID; + XSingleton.singleton.ShowModalDialog(string.Format(XStringDefineProxy.GetString("WeddingApplyTip"), marriageApplyInfo.applyName), XStringDefineProxy.GetString("COMMON_OK"), XStringDefineProxy.GetString("COMMON_CANCEL"), new ButtonClickEventHandler(this.ToAgreeMarriage), new ButtonClickEventHandler(this.ToRefuseMarriage), false, XTempTipDefine.OD_START, 50); + } + } + } + else + { + string format = XSingleton.singleton.ReplaceReturn(XStringDefineProxy.GetString("WeddingBreakNotifyTip")); + XSingleton.singleton.ShowModalDialog(string.Format(format, XSingleton.singleton.TimeDuarationFormatString((int)this.m_CachedData, 5)), XStringDefineProxy.GetString("COMMON_OK")); + } + this.m_CacheNotify = NotifyType.None; + } + } + + public override void OnLeaveScene() + { + this.StopWeddingCar(null); + } + + private void DestroyFakeRoles() + { + XPetDocument.TryMount(false, this._player1, (uint)XSingleton.singleton.GetInt("WeddingCarID"), true); + XSingleton.singleton.DestroyImmediate(this._player1); + this._player1 = null; + XSingleton.singleton.DestroyImmediate(this._player2); + this._player2 = null; + XSingleton.singleton.DestroyEntity(this._mount); + this._mount = null; + } + + public override void Update(float fDeltaT) + { + base.Update(fDeltaT); + bool flag = this._player1 != null; + if (flag) + { + this._player1.Update(fDeltaT); + } + bool flag2 = this._player2 != null; + if (flag2) + { + this._player2.Update(fDeltaT); + } + } + + public override void PostUpdate(float fDeltaT) + { + base.PostUpdate(fDeltaT); + bool flag = this._player1 != null; + if (flag) + { + this._player1.PostUpdate(fDeltaT); + } + bool flag2 = this._player2 != null; + if (flag2) + { + this._player2.PostUpdate(fDeltaT); + } + } + } +} -- cgit v1.1-26-g67d0