diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/Guild/XGuildRedPacketDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/Guild/XGuildRedPacketDocument.cs | 644 |
1 files changed, 644 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/Guild/XGuildRedPacketDocument.cs b/Client/Assets/Scripts/XMainClient/Guild/XGuildRedPacketDocument.cs new file mode 100644 index 00000000..21c3288f --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Guild/XGuildRedPacketDocument.cs @@ -0,0 +1,644 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XGuildRedPacketDocument : XDocComponent, ILogSource
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XGuildRedPacketDocument.uuID;
+ }
+ }
+
+ public XGuildRedPacketView GuildRedPacketView { get; set; }
+
+ public List<XGuildRedPacketBrief> PacketList
+ {
+ get
+ {
+ return this.m_PacketList;
+ }
+ }
+
+ public XGuildRedPacketDetail PacketDetail
+ {
+ get
+ {
+ return this.m_PacketDetail;
+ }
+ }
+
+ public XGuildCheckInBonusInfo GuildBonus
+ {
+ get
+ {
+ return this.m_guildBonus;
+ }
+ }
+
+ public List<XGuildRedPackageSendBrief> GuildBonusSendList
+ {
+ get
+ {
+ return this.m_GuildBonusSendBriefList;
+ }
+ }
+
+ public bool bHasAvailableRedPacket
+ {
+ get
+ {
+ return this._bHasAvailableRedPacket;
+ }
+ set
+ {
+ this._bHasAvailableRedPacket = value;
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_GuildRedPacket, true);
+ bool flag = DlgBase<XGuildSignRedPackageView, XGuildSignRedPackageBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XGuildSignRedPackageView, XGuildSignRedPackageBehaviour>.singleton.RefreshRedPoint();
+ }
+ }
+ }
+
+ public bool bHasAvailableFixedRedPoint
+ {
+ get
+ {
+ return this._bHasAvailableFixedRedPoint;
+ }
+ set
+ {
+ this._bHasAvailableFixedRedPoint = value;
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_GuildBoon_FixedRedPacket, true);
+ bool flag = DlgBase<XGuildSignRedPackageView, XGuildSignRedPackageBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XGuildSignRedPackageView, XGuildSignRedPackageBehaviour>.singleton.RefreshRedPoint();
+ }
+ }
+ }
+
+ public int bHasShowIconRedPacket
+ {
+ get
+ {
+ return this._bHasShowIconRedPacket;
+ }
+ set
+ {
+ bool flag = this._bHasShowIconRedPacket != value;
+ if (flag)
+ {
+ this._bHasShowIconRedPacket = value;
+ this._showIconTimer = (double)((this._bHasShowIconRedPacket > 0) ? 300 : 0);
+ SceneType sceneType = XSingleton<XSceneMgr>.singleton.GetSceneType(XSingleton<XScene>.singleton.SceneID);
+ bool flag2 = sceneType == SceneType.SCENE_HALL || sceneType == SceneType.SCENE_GUILD_HALL;
+ if (flag2)
+ {
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_GuildBoon_RedPacket, true);
+ }
+ }
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("GuildRedPacketDocument");
+
+ private static GuildBonusTable m_BonusReader = new GuildBonusTable();
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ private List<XGuildRedPacketBrief> m_PacketList = new List<XGuildRedPacketBrief>();
+
+ private List<GuildBonusBriefInfo> m_bonusBriefInfos = new List<GuildBonusBriefInfo>();
+
+ private XGuildRedPacketDetail m_PacketDetail = new XGuildRedPacketDetail();
+
+ private XGuildCheckInBonusInfo m_guildBonus = new XGuildCheckInBonusInfo();
+
+ private List<XGuildRedPackageSendBrief> m_GuildBonusSendBriefList = new List<XGuildRedPackageSendBrief>();
+
+ private bool _bHasAvailableRedPacket = false;
+
+ private bool _bHasAvailableFixedRedPoint = false;
+
+ private int _bHasShowIconRedPacket = 0;
+
+ private double _showIconTimer = 0.0;
+
+ public override void Update(float fDeltaT)
+ {
+ base.Update(fDeltaT);
+ bool flag = this._showIconTimer > (double)fDeltaT;
+ if (flag)
+ {
+ this._showIconTimer -= (double)fDeltaT;
+ bool flag2 = this._showIconTimer <= 0.0;
+ if (flag2)
+ {
+ this._showIconTimer = 0.0;
+ this.bHasShowIconRedPacket = 0;
+ }
+ }
+ bool flag3 = this.m_guildBonus == null;
+ if (!flag3)
+ {
+ this.m_guildBonus.timeofday += (double)fDeltaT;
+ bool flag4 = this.m_guildBonus.leftAskBonusTime > 0.0;
+ if (flag4)
+ {
+ this.m_guildBonus.leftAskBonusTime -= (double)fDeltaT;
+ }
+ else
+ {
+ this.m_guildBonus.leftAskBonusTime = 0.0;
+ }
+ }
+ }
+
+ private void OnShowIconTimer(object o)
+ {
+ this.bHasShowIconRedPacket = 0;
+ }
+
+ public bool CheckLeader(ulong uid)
+ {
+ return this.m_PacketDetail.leaderID == uid;
+ }
+
+ public bool CheckLuckest(ulong uid)
+ {
+ return this.m_PacketDetail.luckestID == uid;
+ }
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ XGuildRedPacketDocument.AsyncLoader.AddTask("Table/GuildBonus", XGuildRedPacketDocument.m_BonusReader, false);
+ XGuildRedPacketDocument.AsyncLoader.Execute(callback);
+ }
+
+ public static GuildBonusTable.RowData GetRedPacketConfig(uint id)
+ {
+ for (int i = 0; i < XGuildRedPacketDocument.m_BonusReader.Table.Length; i++)
+ {
+ bool flag = XGuildRedPacketDocument.m_BonusReader.Table[i].GuildBonusID == id;
+ if (flag)
+ {
+ return XGuildRedPacketDocument.m_BonusReader.Table[i];
+ }
+ }
+ return null;
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ this._bHasAvailableRedPacket = false;
+ this._bHasShowIconRedPacket = 0;
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.EventSubscribe();
+ base.RegisterEvent(XEventDefine.XEvent_InGuildStateChanged, new XComponent.XEventHandler(this.OnInGuildStateChanged));
+ }
+
+ protected bool OnInGuildStateChanged(XEventArgs args)
+ {
+ XInGuildStateChangedEventArgs xinGuildStateChangedEventArgs = args as XInGuildStateChangedEventArgs;
+ bool flag = !xinGuildStateChangedEventArgs.bIsEnter;
+ if (flag)
+ {
+ this.bHasAvailableRedPacket = false;
+ }
+ return true;
+ }
+
+ public List<ILogData> GetLogList()
+ {
+ return this.m_PacketDetail.logList;
+ }
+
+ public void CheckAvailableRedPackets()
+ {
+ bool bHasAvailableRedPacket = false;
+ for (int i = 0; i < this.m_PacketList.Count; i++)
+ {
+ bool flag = this.m_PacketList[i].fetchState == FetchState.FS_CAN_FETCH;
+ if (flag)
+ {
+ bHasAvailableRedPacket = true;
+ break;
+ }
+ }
+ this.bHasAvailableRedPacket = bHasAvailableRedPacket;
+ }
+
+ public void GetGuildCheckInBonusInfo()
+ {
+ RpcC2G_GuildCheckInBonusInfo rpc = new RpcC2G_GuildCheckInBonusInfo();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGuildCheckInBonusInfo(GuildCheckInBonusInfoRes oRes)
+ {
+ bool flag = oRes.errorcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.errorcode, "fece00");
+ }
+ else
+ {
+ this.m_guildBonus.isCheckIn = oRes.isCheckedIn;
+ this.m_guildBonus.guildMemberNum = oRes.guildMemberNum;
+ this.m_guildBonus.checkInNumber = oRes.checkInNum;
+ this.m_guildBonus.onLineNum = oRes.onlineNum;
+ this.m_guildBonus.leftAskBonusTime = (double)oRes.leftAskBonusTime;
+ this.m_guildBonus.timeofday = (double)oRes.timeofday;
+ this.m_guildBonus.SetBonusBrief(oRes.checkInBonusInfo);
+ bool flag2 = DlgBase<XGuildSignRedPackageView, XGuildSignRedPackageBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<XGuildSignRedPackageView, XGuildSignRedPackageBehaviour>.singleton.RefreshSignInfo();
+ }
+ }
+ }
+
+ public void GetSendGuildBonus()
+ {
+ RpcC2G_SendGuildBonus rpc = new RpcC2G_SendGuildBonus();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnSendGuildBonus(SendGuildBonusRes sRes)
+ {
+ bool flag = sRes.errorcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(sRes.errorcode, "fece00");
+ }
+ else
+ {
+ XInvitationDocument specificDocument = XDocuments.GetSpecificDocument<XInvitationDocument>(XInvitationDocument.uuID);
+ specificDocument.SendOpenSysInvitation(XSysDefine.XSys_GuildBoon_RedPacket, new ulong[0]);
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("INVITATION_SENT_NOTIFICATION"), "fece00");
+ this.GetGuildCheckInBonusInfo();
+ }
+ }
+
+ public void SendGuildBonusSendList()
+ {
+ RpcC2M_GetGuildBonusSendList rpc = new RpcC2M_GetGuildBonusSendList();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void ReceiveGuildBonusSendList(GetGuildBonusSendListRes res)
+ {
+ bool flag = res.error > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowErrorCode(res.error);
+ }
+ else
+ {
+ this.m_GuildBonusSendBriefList.Clear();
+ int i = 0;
+ int count = res.sendList.Count;
+ while (i < count)
+ {
+ XGuildRedPackageSendBrief xguildRedPackageSendBrief = new XGuildRedPackageSendBrief();
+ xguildRedPackageSendBrief.SendData(res.sendList[i]);
+ this.m_GuildBonusSendBriefList.Add(xguildRedPackageSendBrief);
+ i++;
+ }
+ this.m_GuildBonusSendBriefList.Sort();
+ this.UpdateSelfSend();
+ bool flag2 = DlgBase<GuildFiexdRedPackageView, GuildFiexdRedPackageBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<GuildFiexdRedPackageView, GuildFiexdRedPackageBehaviour>.singleton.Refresh();
+ }
+ }
+ }
+
+ public void SendGuildBonusInSend(uint bonusID)
+ {
+ RpcC2M_SendGuildBonusInSendList rpcC2M_SendGuildBonusInSendList = new RpcC2M_SendGuildBonusInSendList();
+ rpcC2M_SendGuildBonusInSendList.oArg.bonusID = bonusID;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_SendGuildBonusInSendList);
+ }
+
+ public void ReceiveGuildBonusInSend(SendGuildBonusInSendListArg arg, SendGuildBonusInSendListRes res)
+ {
+ bool flag = res.error > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowErrorCode(res.error);
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("INVITATION_SENT_NOTIFICATION"), "fece00");
+ bool flag2 = false;
+ int i = 0;
+ int count = this.m_GuildBonusSendBriefList.Count;
+ while (i < count)
+ {
+ bool flag3 = this.m_GuildBonusSendBriefList[i].uid == (ulong)arg.bonusID;
+ if (flag3)
+ {
+ flag2 = true;
+ this.m_GuildBonusSendBriefList.RemoveAt(i);
+ break;
+ }
+ i++;
+ }
+ this.UpdateSelfSend();
+ this.ReqFetch(arg.bonusID);
+ bool flag4 = flag2 && DlgBase<GuildFiexdRedPackageView, GuildFiexdRedPackageBehaviour>.singleton.IsVisible();
+ if (flag4)
+ {
+ DlgBase<GuildFiexdRedPackageView, GuildFiexdRedPackageBehaviour>.singleton.Refresh();
+ }
+ }
+ }
+
+ private void UpdateSelfSend()
+ {
+ bool bHasAvailableFixedRedPoint = false;
+ int i = 0;
+ int count = this.m_GuildBonusSendBriefList.Count;
+ while (i < count)
+ {
+ bool flag = this.m_GuildBonusSendBriefList[i].senderType == BonusSender.Bonus_Self;
+ if (flag)
+ {
+ bHasAvailableFixedRedPoint = true;
+ break;
+ }
+ i++;
+ }
+ this.bHasAvailableFixedRedPoint = bHasAvailableFixedRedPoint;
+ }
+
+ public void ReqList()
+ {
+ RpcC2G_GetGuildBonusList rpc = new RpcC2G_GetGuildBonusList();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetList(GetGuildBonusListResult oRes)
+ {
+ bool flag = oRes.errorcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.errorcode, "fece00");
+ }
+ else
+ {
+ int num = oRes.bonusList.Count - this.m_PacketList.Count;
+ for (int i = 0; i < num; i++)
+ {
+ this.m_PacketList.Add(new XGuildRedPacketBrief());
+ }
+ bool flag2 = num < 0;
+ if (flag2)
+ {
+ this.m_PacketList.RemoveRange(this.m_PacketList.Count + num, -num);
+ }
+ for (int j = 0; j < this.m_PacketList.Count; j++)
+ {
+ this.m_PacketList[j].SetData(oRes.bonusList[j]);
+ }
+ this.m_PacketList.Sort();
+ this.CheckAvailableRedPackets();
+ bool flag3 = this.GuildRedPacketView != null && this.GuildRedPacketView.IsVisible();
+ if (flag3)
+ {
+ this.GuildRedPacketView.Refresh(true);
+ }
+ }
+ }
+
+ public void ReqDetail(uint uid)
+ {
+ bool flag = uid == 0u;
+ if (!flag)
+ {
+ RpcC2G_GetGuildBonusDetailInfo rpcC2G_GetGuildBonusDetailInfo = new RpcC2G_GetGuildBonusDetailInfo();
+ rpcC2G_GetGuildBonusDetailInfo.oArg.bonusID = uid;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_GetGuildBonusDetailInfo);
+ }
+ }
+
+ public void OnGetDetail(GetGuildBonusDetailInfoResult oRes)
+ {
+ bool flag = oRes.errorcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.errorcode, "fece00");
+ }
+ else
+ {
+ bool flag2 = oRes.bonusInfo == null;
+ if (flag2)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.errorcode, "fece00");
+ XSingleton<XDebug>.singleton.AddErrorLog("RedPackage bonus is null", oRes.leaderID.ToString(), null, null, null, null);
+ }
+ else
+ {
+ this.m_PacketDetail.brif.SetData(oRes.bonusInfo);
+ this.m_PacketDetail.brif.typeid = oRes.bonusContentType;
+ this.m_PacketDetail.itemTotalCount = (int)oRes.bonusNum;
+ this.m_PacketDetail.content = oRes.content;
+ this.m_PacketDetail.leaderID = oRes.leaderID;
+ this.m_PacketDetail.luckestID = oRes.luckestID;
+ this.m_PacketDetail.canThank = oRes.canThank;
+ this.m_PacketDetail.getCount = oRes.getBonusRoleList.Count;
+ int num = oRes.getBonusRoleList.Count - this.m_PacketDetail.logList.Count;
+ for (int i = 0; i < num; i++)
+ {
+ this.m_PacketDetail.logList.Add(new XGuildRedPacketLog());
+ }
+ bool flag3 = num < 0;
+ if (flag3)
+ {
+ this.m_PacketDetail.logList.RemoveRange(this.m_PacketDetail.logList.Count + num, -num);
+ }
+ uint num2 = 0u;
+ for (int j = 0; j < this.m_PacketDetail.logList.Count; j++)
+ {
+ XGuildRedPacketLog xguildRedPacketLog = this.m_PacketDetail.logList[j] as XGuildRedPacketLog;
+ xguildRedPacketLog.SetData(oRes.getBonusRoleList[j]);
+ num2 += oRes.getBonusRoleList[j].getNum;
+ xguildRedPacketLog.itemid = this.m_PacketDetail.brif.itemid;
+ }
+ this.m_PacketDetail.getTotalCount = num2;
+ this.m_PacketDetail.logList.Sort();
+ bool flag4 = DlgBase<XGuildRedPacketDetailView, GuildRedPackageDetailBehaviour>.singleton.IsVisible();
+ if (flag4)
+ {
+ DlgBase<XGuildRedPacketDetailView, GuildRedPackageDetailBehaviour>.singleton.Refresh();
+ }
+ }
+ }
+ }
+
+ public void SetCanThank(bool thank = false)
+ {
+ this.m_PacketDetail.canThank = thank;
+ bool flag = DlgBase<XGuildRedPacketDetailView, GuildRedPackageDetailBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XGuildRedPacketDetailView, GuildRedPackageDetailBehaviour>.singleton.Refresh();
+ }
+ }
+
+ public void ReqFetch(uint uid)
+ {
+ RpcC2G_GetGuildBonusReward rpcC2G_GetGuildBonusReward = new RpcC2G_GetGuildBonusReward();
+ rpcC2G_GetGuildBonusReward.oArg.bonusID = uid;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_GetGuildBonusReward);
+ }
+
+ public void OnFetch(GetGuildBonusRewardArg oArg, GetGuildBonusRewardResult oRes)
+ {
+ bool flag = oRes.errorcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.errorcode, "fece00");
+ bool flag2 = this.GuildRedPacketView != null && this.GuildRedPacketView.IsVisible();
+ if (flag2)
+ {
+ this.GuildRedPacketView.ShowResult(null);
+ }
+ }
+ else
+ {
+ XGuildRedPacketBrief xguildRedPacketBrief = null;
+ for (int i = 0; i < this.m_PacketList.Count; i++)
+ {
+ bool flag3 = this.m_PacketList[i].uid == (ulong)oArg.bonusID;
+ if (flag3)
+ {
+ xguildRedPacketBrief = this.m_PacketList[i];
+ xguildRedPacketBrief.fetchState = FetchState.FS_ALREADY_FETCH;
+ xguildRedPacketBrief.fetchedCount += 1u;
+ break;
+ }
+ }
+ this.CheckAvailableRedPackets();
+ DlgBase<XGuildRedPacketDetailView, GuildRedPackageDetailBehaviour>.singleton.ShowEffect(true, oArg.bonusID);
+ bool flag4 = this.GuildRedPacketView != null && this.GuildRedPacketView.IsVisible();
+ if (flag4)
+ {
+ this.ReqList();
+ this.GuildRedPacketView.Refresh(false);
+ this.GuildRedPacketView.ShowResult(xguildRedPacketBrief);
+ }
+ }
+ }
+
+ public void SendGuildBonuesLeft()
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("SendGuildBonuesLeft", null, null, null, null, null);
+ RpcC2G_GetGuildBonusLeft rpc = new RpcC2G_GetGuildBonusLeft();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void ReceiveGuildBonusLeft(GetGuildBonusLeftRes res)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("ReceiveGuildBonusLeft", null, null, null, null, null);
+ bool flag = res.errorCode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(res.errorCode, "fece00");
+ }
+ else
+ {
+ this.m_bonusBriefInfos.Clear();
+ this.m_bonusBriefInfos.AddRange(res.bonusInfos);
+ this.bHasShowIconRedPacket = this.m_bonusBriefInfos.Count;
+ }
+ }
+
+ public void ReqGetLast()
+ {
+ uint num = 0u;
+ bool flag = this.m_bonusBriefInfos.Count > 0;
+ if (flag)
+ {
+ int sendTime = this.m_bonusBriefInfos[0].sendTime;
+ num = this.m_bonusBriefInfos[0].bonusID;
+ int i = 1;
+ int count = this.m_bonusBriefInfos.Count;
+ while (i < count)
+ {
+ bool flag2 = this.m_bonusBriefInfos[i].sendTime > sendTime;
+ if (flag2)
+ {
+ sendTime = this.m_bonusBriefInfos[i].sendTime;
+ num = this.m_bonusBriefInfos[i].bonusID;
+ }
+ i++;
+ }
+ }
+ bool flag3 = num > 0u;
+ if (flag3)
+ {
+ this.ReqFetch(num);
+ this.ReceiveGuildBonusGetAll(num);
+ }
+ }
+
+ public void ReceiveGuildBonusGetAll(uint bonusID)
+ {
+ bool flag = false;
+ int i = 0;
+ int count = this.m_bonusBriefInfos.Count;
+ while (i < count)
+ {
+ bool flag2 = this.m_bonusBriefInfos[i].bonusID == bonusID;
+ if (flag2)
+ {
+ flag = true;
+ this.m_bonusBriefInfos.RemoveAt(i);
+ break;
+ }
+ i++;
+ }
+ bool flag3 = flag;
+ if (flag3)
+ {
+ this.bHasShowIconRedPacket = this.m_bonusBriefInfos.Count;
+ }
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ bool flag = this.GuildRedPacketView != null && this.GuildRedPacketView.IsVisible();
+ if (flag)
+ {
+ this.ReqList();
+ }
+ bool flag2 = DlgBase<XGuildSignRedPackageView, XGuildSignRedPackageBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ this.GetGuildCheckInBonusInfo();
+ }
+ bool flag3 = DlgBase<GuildFiexdRedPackageView, GuildFiexdRedPackageBehaviour>.singleton.IsVisible();
+ if (flag3)
+ {
+ this.SendGuildBonusSendList();
+ }
+ }
+ }
+}
|