diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XWeddingDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XWeddingDocument.cs | 1466 |
1 files changed, 1466 insertions, 0 deletions
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<XGame>.singleton.Doc.GetXComponent(XWeddingDocument.uuID) as XWeddingDocument;
+ }
+ }
+
+ public static WeddingLoverLiveness LoverLivenessTable
+ {
+ get
+ {
+ return XWeddingDocument.m_partnerLivenessTab;
+ }
+ }
+
+ public List<LoverLivenessRecord> RecordList
+ {
+ get
+ {
+ return this.m_recordList;
+ }
+ }
+
+ public List<RoleOutLookBrief> 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<XFriendsView, XFriendsBehaviour>.singleton.SetRedPoint(TabIndex.Wedding, this.IsHadRedDot);
+ bool flag2 = this.View != null && this.View.IsVisible();
+ if (flag2)
+ {
+ this.View.RefreshUIRedPoint();
+ }
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_Friends, true);
+ bool flag3 = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.IsVisible();
+ if (flag3)
+ {
+ DlgBase<XFriendsView, XFriendsBehaviour>.singleton.UpdateRedpointUI();
+ }
+ }
+ }
+ }
+
+ public bool IsHadPrivilegeLevelUpRedPoint
+ {
+ get
+ {
+ return this.m_bLevelUpRedPoint;
+ }
+ set
+ {
+ bool flag = this.m_bLevelUpRedPoint != value;
+ if (flag)
+ {
+ this.m_bLevelUpRedPoint = value;
+ DlgBase<XFriendsView, XFriendsBehaviour>.singleton.SetRedPoint(TabIndex.Wedding, this.IsHadRedDot);
+ bool flag2 = this.View != null && this.View.IsVisible();
+ if (flag2)
+ {
+ this.View.RefreshUIRedPoint();
+ }
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_Friends, true);
+ bool flag3 = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.IsVisible();
+ if (flag3)
+ {
+ DlgBase<XFriendsView, XFriendsBehaviour>.singleton.UpdateRedpointUI();
+ }
+ }
+ }
+ }
+
+ public bool IsHadRedDot
+ {
+ get
+ {
+ bool flag = !XSingleton<XGameSysMgr>.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<WeddingBriefInfo> CanEnterWedding
+ {
+ get
+ {
+ return this.m_CanEnterWedding;
+ }
+ }
+
+ public List<WeddingBriefInfo> 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<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler != null && DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.IsVisible();
+ if (flag)
+ {
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.RefreshInviteRedPoint();
+ }
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("WeddingDocument");
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ public static MarriageLevel MarriageLevelTable = new MarriageLevel();
+
+ private static WeddingLoverLiveness m_partnerLivenessTab = new WeddingLoverLiveness();
+
+ private List<LoverLivenessRecord> m_recordList = new List<LoverLivenessRecord>();
+
+ public static readonly int MaxAvata = 2;
+
+ public FriendsWeddingHandler View;
+
+ private List<RoleOutLookBrief> m_PartnerList = new List<RoleOutLookBrief>();
+
+ 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<WeddingBriefInfo> m_CanEnterWedding = new List<WeddingBriefInfo>();
+
+ private List<WeddingBriefInfo> m_CanApplyWedding = new List<WeddingBriefInfo>();
+
+ 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<WeddingRoleInfo> m_FriendsWeddingRoleInfoList = new List<WeddingRoleInfo>();
+
+ private List<WeddingRoleInfo> m_GuildWeddingRoleInfoList = new List<WeddingRoleInfo>();
+
+ private List<WeddingRoleInfo> m_InvitedWeddingRoleInfoList = new List<WeddingRoleInfo>();
+
+ private List<WeddingRoleInfo> m_ApplyWeddingRoleInfoList = new List<WeddingRoleInfo>();
+
+ private List<RoleOutLookBrief> m_Marriagelist = new List<RoleOutLookBrief>();
+
+ 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<ulong, XFx> m_WeddingSceneLoverFx = new Dictionary<ulong, XFx>();
+
+ public void ReqPartnerDetailInfo()
+ {
+ RpcC2M_GetMarriageRelation rpc = new RpcC2M_GetMarriageRelation();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetPartDetailInfoBack(GetMarriageRelationRes oRes)
+ {
+ bool flag = oRes.error > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.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<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag)
+ {
+ return this.m_PartnerList[i];
+ }
+ }
+ return null;
+ }
+
+ public void ReqPartnerLivenessInfo()
+ {
+ RpcC2M_GetMarriageLiveness rpc = new RpcC2M_GetMarriageLiveness();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetPartnerLivenessInfo(GetMarriageLivenessRes oRes)
+ {
+ bool flag = oRes.result > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.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<LoversLivenessDlg, LoversLivenessBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<LoversLivenessDlg, LoversLivenessBehaviour>.singleton.FillContent();
+ }
+ }
+ }
+
+ public void ReqTakePartnerChest(uint index)
+ {
+ RpcC2M_TakeMarriageChest rpcC2M_TakeMarriageChest = new RpcC2M_TakeMarriageChest();
+ rpcC2M_TakeMarriageChest.oArg.index = index;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_TakeMarriageChest);
+ }
+
+ public void OnTakePartnerChestBack(int index, TakeMarriageChestRes oRes)
+ {
+ bool flag = oRes.result > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.result, "fece00");
+ }
+ else
+ {
+ this.m_takeChest = oRes.takedchest;
+ this.IsHadLivenessRedPoint = this.IsHadRedPoint();
+ bool flag2 = DlgBase<LoversLivenessDlg, LoversLivenessBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<LoversLivenessDlg, LoversLivenessBehaviour>.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<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetMarriagePrivilege(ErrorCode error)
+ {
+ bool flag = error > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.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<XScene>.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<XScene>.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<XFxMgr>.singleton.DestroyFx(xfx, true);
+ }
+ xfx = XSingleton<XFxMgr>.singleton.CreateFx(XSingleton<XGlobalConfig>.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<XFxMgr>.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<WeddingRoleInfo> GetInviteRoleInfoList(WeddingInviteTab tab)
+ {
+ List<WeddingRoleInfo> 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<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnHoldWedding(HoldWeddingRes oRes)
+ {
+ bool flag = oRes.result > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.result, "fece00");
+ }
+ }
+
+ public void EnterWedding(ulong weddingID)
+ {
+ bool flag = DlgBase<DramaDlg, DramaDlgBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<DramaDlg, DramaDlgBehaviour>.singleton.SetVisible(false, true);
+ }
+ RpcC2M_EnterWeddingScene rpcC2M_EnterWeddingScene = new RpcC2M_EnterWeddingScene();
+ rpcC2M_EnterWeddingScene.oArg.weddingid = weddingID;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_EnterWeddingScene);
+ }
+
+ public void OnEnterWedding(EnterWeddingSceneRes oRes)
+ {
+ bool flag = oRes.result > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.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<XClientNetwork>.singleton.Send(rpcC2G_WeddingOperator);
+ }
+
+ public void OnWeddingSceneOperator(WeddingOperatorArg oArg, WeddingOperatorRes oRes)
+ {
+ bool flag = oRes.result > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.result, "fece00");
+ }
+ else
+ {
+ bool flag2 = !DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.IsVisible() || DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler == null || !DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.IsVisible();
+ if (!flag2)
+ {
+ WeddingOperType type = oArg.type;
+ if (type - WeddingOperType.WeddingOper_Flower > 1)
+ {
+ if (type == WeddingOperType.WeddingOper_ApplyVows)
+ {
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.ApplyVowsSuss();
+ }
+ }
+ else
+ {
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.CoolDownBtn(oArg.type);
+ }
+ }
+ }
+ }
+
+ public void WeddingSceneEventNtf(PtcG2C_WeddingEventNtf roPtc)
+ {
+ bool flag = !DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.IsVisible() || DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler == null || !DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.IsVisible();
+ if (!flag)
+ {
+ this.m_AllAttendPlayerCount = roPtc.Data.total_num;
+ XSingleton<XDebug>.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<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.OnFlowerRain();
+ break;
+ case WeddingOperType.WeddingOper_Fireworks:
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.OnFireworks();
+ break;
+ case WeddingOperType.WeddingOper_ApplyVows:
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.ShowPartnerSwearNtf(roPtc.Data.rolename);
+ break;
+ case WeddingOperType.WeddingOper_DisAgreeVows:
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("WeddingSwearDisagree", new object[]
+ {
+ roPtc.Data.rolename
+ }), "fece00");
+ break;
+ case WeddingOperType.WeddingOper_VowsPrepare:
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("WeddingSwearAgree"), "fece00");
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.OnVowsPrepare();
+ break;
+ case WeddingOperType.WeddingOper_VowsStart:
+ this.PlayCutscene(XSingleton<XGlobalConfig>.singleton.GetValue("WeddingCutscenePath"));
+ break;
+ case WeddingOperType.WeddingOper_FlowerRewardOverMax:
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("WeddingFlowerRewardMax"), "fece00");
+ break;
+ case WeddingOperType.WeddingOper_FireworksRewardOverMax:
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("WeddingFireworksRewardMax"), "fece00");
+ break;
+ case WeddingOperType.WeddingOper_CandyRewardOverMax:
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("WeddingCandyRewardMax"), "fece00");
+ break;
+ case WeddingOperType.WeddingOper_Candy:
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.OnCandyFx();
+ break;
+ }
+ }
+ }
+
+ public void PlayCutscene(string path)
+ {
+ XSingleton<XCutScene>.singleton.Start(path, true, true);
+ }
+
+ public void WeddingStateNtf(PtcG2C_WeddingStateNtf roPtc)
+ {
+ bool flag = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.IsVisible() && DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler != null && DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.IsVisible();
+ if (flag)
+ {
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._WeddingHandler.UpdateWeddingState(roPtc.Data.state, roPtc.Data.lefttime, roPtc.Data.vows);
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.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<XClientNetwork>.singleton.Send(rpcC2M_WeddingInviteOperator);
+ }
+
+ public void OnWeddingInviteOperate(WeddingInviteOperatorArg oArg, WeddingInviteOperatorRes oRes)
+ {
+ bool flag = oRes.result > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.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<XWeddingInviteView, XWeddingInviteBehavior>.singleton.IsVisible();
+ if (flag4)
+ {
+ DlgBase<XWeddingInviteView, XWeddingInviteBehavior>.singleton.RefreshUI();
+ }
+ }
+ }
+ else
+ {
+ bool flag5 = oArg.type == WeddingInviteOperType.Wedding_Apply;
+ if (flag5)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.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<XWeddingInviteView, XWeddingInviteBehavior>.singleton.IsVisible();
+ if (flag12)
+ {
+ DlgBase<XWeddingInviteView, XWeddingInviteBehavior>.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<XWeddingInviteView, XWeddingInviteBehavior>.singleton.IsVisible();
+ if (flag16)
+ {
+ DlgBase<XWeddingInviteView, XWeddingInviteBehavior>.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<XWeddingInviteView, XWeddingInviteBehavior>.singleton.IsVisible();
+ if (flag19)
+ {
+ DlgBase<XWeddingInviteView, XWeddingInviteBehavior>.singleton.RefreshUI();
+ }
+ }
+ }
+ }
+
+ public void WeddingInviteNtf(PtcM2C_WeddingInviteNtf roPtc)
+ {
+ bool flag = XSingleton<XGame>.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<UiUtility>.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>(XInvitationDocument.uuID);
+ NoticeTable.RowData noticeData = specificDocument.GetNoticeData(NoticeType.NT_Wedding_INVITE_WORLD);
+ bool flag2 = noticeData != null;
+ if (flag2)
+ {
+ List<ChatParam> list = new List<ChatParam>();
+ 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<XChatView, XChatBehaviour>.singleton.SendChatContent(noticeData.info, (ChatChannelType)noticeData.channel, false, list, true, 0UL, 0f, false, false);
+ }
+ }
+ }
+ else
+ {
+ bool flag3 = XSingleton<XGame>.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<UiUtility>.singleton.CloseModalDlg();
+ this.m_NotifedWeddingID = 0UL;
+ return true;
+ }
+
+ public void GetAllWeddingInfo()
+ {
+ RpcC2M_GetAllWeddingInfo rpc = new RpcC2M_GetAllWeddingInfo();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetAllWeddingInfo(GetAllWeddingInfoRes oRes)
+ {
+ bool flag = oRes.result > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.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<WeddingBriefInfo>(XWeddingDocument.SortWeddingInfo));
+ this.m_CanApplyWedding.Sort(new Comparison<WeddingBriefInfo>(XWeddingDocument.SortWeddingInfo));
+ bool flag2 = DlgBase<WeddingEnterApplyView, WeddingEnterApplyBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<WeddingEnterApplyView, WeddingEnterApplyBehaviour>.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<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetWeddingInviteInfo(GetWeddingInviteInfoRes oRes)
+ {
+ bool flag = oRes.result > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.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<XWeddingInviteView, XWeddingInviteBehavior>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<XWeddingInviteView, XWeddingInviteBehavior>.singleton.RefreshUI();
+ }
+ }
+ }
+
+ public void SendMarriageRelationInfo()
+ {
+ RpcC2M_GetMarriageRelation rpc = new RpcC2M_GetMarriageRelation();
+ XSingleton<XClientNetwork>.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<DramaDlg, DramaDlgBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ XDramaDocument specificDocument = XDocuments.GetSpecificDocument<XDramaDocument>(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<XClientNetwork>.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<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;
+ if (flag2)
+ {
+ DlgBase<DramaDlg, DramaDlgBehaviour>.singleton.SetVisible(false, true);
+ XSingleton<UiUtility>.singleton.ShowModalDialog(string.Format(XSingleton<UiUtility>.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<XAttributeMgr>.singleton.XPlayerData == null || XSingleton<XGame>.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<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;
+ if (flag3)
+ {
+ bool flag4 = applyInfo != null;
+ if (flag4)
+ {
+ this.m_ApplyMarriageRoleID = roPtc.Data.applyInfo.applyRoleID;
+ XSingleton<UiUtility>.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<UiUtility>.singleton.ShowModalDialog(string.Format(XSingleton<UiUtility>.singleton.ReplaceReturn(XStringDefineProxy.GetString("MarriageSuccessTip")), roPtc.Data.response.roleName), XStringDefineProxy.GetString("PVPActivity_Go"), new ButtonClickEventHandler(this.GoToNpc), 50);
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(string.Format(XStringDefineProxy.GetString("WeddingApplyBeenRefuse", new object[]
+ {
+ roPtc.Data.response.roleName
+ }), new object[0]), "fece00");
+ }
+ }
+ }
+ }
+ }
+
+ public bool GoToNpc(IXUIButton button)
+ {
+ DlgBase<DramaDlg, DramaDlgBehaviour>.singleton.SetVisible(false, true);
+ XSingleton<UiUtility>.singleton.CloseModalDlg();
+ XSingleton<XInput>.singleton.LastNpc = XSingleton<XEntityMgr>.singleton.GetNpc((uint)XSingleton<XGlobalConfig>.singleton.GetInt("LoveGoldNpcID"));
+ return true;
+ }
+
+ public void OnGetMarriageDivorceNotify(PtcM2C_NotifyMarriageDivorceApply roPtc)
+ {
+ bool isApplyCancel = roPtc.Data.isApplyCancel;
+ if (isApplyCancel)
+ {
+ bool flag = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;
+ if (flag)
+ {
+ string @string = XStringDefineProxy.GetString("WeddingMaintainSuccess");
+ XSingleton<UiUtility>.singleton.ShowModalDialog(@string, XStringDefineProxy.GetString("COMMON_OK"));
+ }
+ }
+ else
+ {
+ bool flag2 = XSingleton<XGame>.singleton.CurrentStage.Stage != EXStage.Hall;
+ if (flag2)
+ {
+ this.m_CacheNotify = NotifyType.NotifyToBreak;
+ this.m_CachedData = roPtc.Data.leftTime;
+ }
+ else
+ {
+ string format = XSingleton<UiUtility>.singleton.ReplaceReturn(XStringDefineProxy.GetString("WeddingBreakNotifyTip"));
+ XSingleton<UiUtility>.singleton.ShowModalDialog(string.Format(format, XSingleton<UiUtility>.singleton.TimeDuarationFormatString(roPtc.Data.leftTime, 5)), XStringDefineProxy.GetString("COMMON_OK"));
+ }
+ }
+ }
+
+ public void SendWeddingCar()
+ {
+ RpcC2M_StartWeddingCar rpc = new RpcC2M_StartWeddingCar();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetWeddingCarNtf(PtcG2C_WeddingCarNtf roPtc)
+ {
+ bool flag = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;
+ if (flag)
+ {
+ int @int = XSingleton<XGlobalConfig>.singleton.GetInt("WeddingCarLocalOn");
+ bool flag2 = @int > 0;
+ if (flag2)
+ {
+ this.StopWeddingCar(null);
+ this._weddingCarTimer = XSingleton<XTimerMgr>.singleton.SetTimer((float)XSingleton<XGlobalConfig>.singleton.GetInt("WeddingPatrolTime"), new XTimerMgr.ElapsedEventHandler(this.StopWeddingCar), null);
+ UnitAppearance role = roPtc.Data.role1;
+ UnitAppearance role2 = roPtc.Data.role2;
+ XAttributes attributesWithAppearance = XSingleton<XEntityMgr>.singleton.GetAttributesWithAppearance(role);
+ XRoleAttributes xroleAttributes = attributesWithAppearance as XRoleAttributes;
+ xroleAttributes.IsLocalFake = true;
+ XAttributes attributesWithAppearance2 = XSingleton<XEntityMgr>.singleton.GetAttributesWithAppearance(role2);
+ xroleAttributes = (attributesWithAppearance2 as XRoleAttributes);
+ xroleAttributes.IsLocalFake = true;
+ List<float> floatList = XSingleton<XGlobalConfig>.singleton.GetFloatList("WeddingcarParadeStart");
+ this._player1 = XSingleton<XEntityMgr>.singleton.CreateRole(attributesWithAppearance, new Vector3(floatList[0], floatList[1], floatList[2]), Quaternion.identity, false, false);
+ this._mount = XSingleton<XEntityMgr>.singleton.CreateMount((uint)XSingleton<XGlobalConfig>.singleton.GetInt("WeddingCarID"), this._player1, true);
+ this._player2 = XSingleton<XEntityMgr>.singleton.CreateRole(attributesWithAppearance2, new Vector3(floatList[0], floatList[1], floatList[2]), Quaternion.identity, false, false);
+ bool flag3 = this._player1.Mount.MountCopilot(this._player2);
+ XSingleton<XDebug>.singleton.AddLog(flag3.ToString(), null, null, null, null, null, XDebugColor.XDebug_None);
+ string value = XSingleton<XGlobalConfig>.singleton.GetValue("WeddingPatrolAITree");
+ bool flag4 = this._player1.AI == null;
+ if (flag4)
+ {
+ this._player1.AI = (XSingleton<XComponentMgr>.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<XComponentMgr>.singleton.CreateComponent(this._player1, XNavigationComponent.uuID) as XNavigationComponent);
+ this._player1.Nav.Active();
+ }
+ this._player1.AI.Patrol.InitNavPath(XSingleton<XGlobalConfig>.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<XTimerMgr>.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<UiUtility>.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<UiUtility>.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<XGame>.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<UiUtility>.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<UiUtility>.singleton.ReplaceReturn(XStringDefineProxy.GetString("WeddingBreakNotifyTip"));
+ XSingleton<UiUtility>.singleton.ShowModalDialog(string.Format(format, XSingleton<UiUtility>.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<XGlobalConfig>.singleton.GetInt("WeddingCarID"), true);
+ XSingleton<XEntityMgr>.singleton.DestroyImmediate(this._player1);
+ this._player1 = null;
+ XSingleton<XEntityMgr>.singleton.DestroyImmediate(this._player2);
+ this._player2 = null;
+ XSingleton<XEntityMgr>.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);
+ }
+ }
+ }
+}
|