diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XWelfareDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XWelfareDocument.cs | 1794 |
1 files changed, 1794 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XWelfareDocument.cs b/Client/Assets/Scripts/XMainClient/XWelfareDocument.cs new file mode 100644 index 00000000..56b4bc30 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XWelfareDocument.cs @@ -0,0 +1,1794 @@ +using System;
+using System.Collections;
+using System.Collections.Generic;
+using KKSG;
+using UILib;
+using UnityEngine;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XWelfareDocument : XDocComponent, IComparer
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XWelfareDocument.uuID;
+ }
+ }
+
+ public static XWelfareDocument Doc
+ {
+ get
+ {
+ return XDocuments.GetSpecificDocument<XWelfareDocument>(XWelfareDocument.uuID);
+ }
+ }
+
+ public XWelfareView View { get; set; }
+
+ public bool FirstRewardBack
+ {
+ get
+ {
+ return this.m_firstRewardBack;
+ }
+ set
+ {
+ this.m_firstRewardBack = value;
+ }
+ }
+
+ public bool FirstMoneyTree
+ {
+ get
+ {
+ return this.m_firstMoneyTree;
+ }
+ set
+ {
+ this.m_firstMoneyTree = value;
+ }
+ }
+
+ public bool ServerPushRewardBack { get; set; }
+
+ public bool ServerPushMoneyTree { get; set; }
+
+ public MoneyTreeData WelfareMoneyTreeData
+ {
+ get
+ {
+ return this.m_MoneyTreeData;
+ }
+ }
+
+ public List<PayCard> PayCardInfo
+ {
+ get
+ {
+ return this._payCardInfo;
+ }
+ }
+
+ public List<ItemFindBackInfo2Client> FindBackInfo
+ {
+ get
+ {
+ return this.m_FindBackInfo;
+ }
+ }
+
+ public uint PayCardRemainTime
+ {
+ get
+ {
+ return this._payCardRemainTime;
+ }
+ }
+
+ public PayAileen PayGiftBagInfo
+ {
+ get
+ {
+ return this._payGiftBagInfo;
+ }
+ }
+
+ public uint RewardLittleGiftBag
+ {
+ get
+ {
+ return this._LittleGiftBag;
+ }
+ }
+
+ public PayMemberPrivilege PayMemberPrivilege
+ {
+ get
+ {
+ return this._payMemberPrivilege;
+ }
+ }
+
+ public List<PayMember> PayMemeberInfo
+ {
+ get
+ {
+ return this._payMemberInfo;
+ }
+ }
+
+ public uint VipLevel
+ {
+ get
+ {
+ return this._vipLevel;
+ }
+ }
+
+ public static PayAileenTable AileenTable
+ {
+ get
+ {
+ return XWelfareDocument._payAileenTable;
+ }
+ }
+
+ public static PayWelfareTable WelfareTable
+ {
+ get
+ {
+ return XWelfareDocument._welfareTable;
+ }
+ }
+
+ public static PayMemberTable PayMemberTable
+ {
+ get
+ {
+ return XWelfareDocument._payMemberTable;
+ }
+ }
+
+ public int LoginDayCount
+ {
+ get
+ {
+ return this.m_loginDayCount;
+ }
+ }
+
+ public bool HasBuyGrowthFund
+ {
+ get
+ {
+ return this.m_hasBuyGrowthFund;
+ }
+ }
+
+ public bool HasGetFirstRecharge
+ {
+ get
+ {
+ return this.m_rechargeFirstGift;
+ }
+ }
+
+ public List<uint> CurArgentaDailyIDList
+ {
+ get
+ {
+ return this._curArgentaDailyIDList;
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("WelfareDocument");
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ private static PayAileenTable _payAileenTable = new PayAileenTable();
+
+ private static PayWelfareTable _welfareTable = new PayWelfareTable();
+
+ private static PayFirst _payFirst = new PayFirst();
+
+ private static RechargeTable _RechargeTable = new RechargeTable();
+
+ private static ItemBackTable _rewardBackTable = new ItemBackTable();
+
+ private static PayMemberTable _payMemberTable = new PayMemberTable();
+
+ private static ArgentaDaily _argentaDaily = new ArgentaDaily();
+
+ private static ArgentaTask _argentaTask = new ArgentaTask();
+
+ private static Dictionary<int, RechargeTable.RowData> m_RechargeDic = new Dictionary<int, RechargeTable.RowData>();
+
+ private static Dictionary<int, PayFirst.RowData> m_PayDic = new Dictionary<int, PayFirst.RowData>();
+
+ private static Dictionary<MemberPrivilege, PayMemberTable.RowData> m_payMemberIDDic = new Dictionary<MemberPrivilege, PayMemberTable.RowData>();
+
+ private static Dictionary<string, List<PayAileenTable.RowData>> m_AileenTableDic = new Dictionary<string, List<PayAileenTable.RowData>>();
+
+ private Dictionary<XSysDefine, bool> _redpointState = new Dictionary<XSysDefine, bool>();
+
+ private Dictionary<XSysDefine, bool> m_clickDic = new Dictionary<XSysDefine, bool>();
+
+ private Dictionary<int, List<int>> m_growthFundDic = new Dictionary<int, List<int>>();
+
+ private Dictionary<MemberPrivilege, bool> m_MemberPrivilege = new Dictionary<MemberPrivilege, bool>();
+
+ private List<ItemFindBackInfo2Client> m_FindBackInfo = new List<ItemFindBackInfo2Client>();
+
+ private MoneyTreeData m_MoneyTreeData = new MoneyTreeData();
+
+ private int m_loginDayCount = 0;
+
+ private bool m_hasBuyGrowthFund = false;
+
+ private bool m_rechargeFirstGift = false;
+
+ private bool m_firstRewardBack = false;
+
+ private bool m_firstMoneyTree = false;
+
+ private static uint _memberPrivilegeFlag;
+
+ private static Dictionary<uint, string> _payMemberIcon = new Dictionary<uint, string>();
+
+ private List<PayCard> _payCardInfo;
+
+ private uint _payCardRemainTime;
+
+ private PayAileen _payGiftBagInfo;
+
+ private uint _LittleGiftBag = 1u;
+
+ private PayMemberPrivilege _payMemberPrivilege;
+
+ private List<PayMember> _payMemberInfo;
+
+ private uint _vipLevel;
+
+ public static readonly string MEMBER_PRIVILEGE_ATLAS = "common/Universal";
+
+ private List<uint> _curArgentaDailyIDList = new List<uint>();
+
+ public uint ActivityLeftTime = 0u;
+
+ public bool ArgentaMainInterfaceState = false;
+
+ public bool q = false;
+
+ private uint _rewardsLevel;
+
+ private bool _SholdOpenBackFlowTaskModal = false;
+
+ public void RegisterRedPoint(XSysDefine define, bool state, bool refresh = true)
+ {
+ bool flag = this._redpointState.ContainsKey(define);
+ if (flag)
+ {
+ this._redpointState[define] = state;
+ }
+ else
+ {
+ this._redpointState.Add(define, state);
+ }
+ this.RefreshRedPoint(define, refresh);
+ }
+
+ public bool GetRedPointState(XSysDefine define)
+ {
+ return this._redpointState.ContainsKey(define) && this._redpointState[define];
+ }
+
+ public void RegisterFirstClick(XSysDefine define, bool state, bool refresh = true)
+ {
+ bool flag = this.m_clickDic.ContainsKey(define);
+ if (flag)
+ {
+ this.m_clickDic[define] = state;
+ }
+ else
+ {
+ this.m_clickDic.Add(define, state);
+ }
+ this.RefreshRedPoint(define, refresh);
+ }
+
+ public bool GetFirstClick(XSysDefine define)
+ {
+ return !this.m_clickDic.ContainsKey(define) || this.m_clickDic[define];
+ }
+
+ public void RefreshRedPoint(XSysDefine define, bool refresh = true)
+ {
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(define, true);
+ bool flag = refresh && this.View != null && this.View.IsVisible();
+ if (flag)
+ {
+ this.View.RefreshRedpoint();
+ }
+ }
+
+ public bool GetRedPoint(XSysDefine define)
+ {
+ bool flag = define == XSysDefine.XSyS_Welfare_RewardBack;
+ bool result;
+ if (flag)
+ {
+ bool flag2 = this.View != null;
+ result = (flag2 && this.View.HadRewardBackRedPoint() && !this.GetFirstClick(define));
+ }
+ else
+ {
+ bool flag3 = define == XSysDefine.XSys_Welfare_MoneyTree;
+ if (flag3)
+ {
+ bool flag4 = this.View != null;
+ if (flag4)
+ {
+ result = this.View.HasMoneyTreeRedPoint();
+ }
+ else
+ {
+ result = this.ServerPushMoneyTree;
+ }
+ }
+ else
+ {
+ bool flag5 = define == XSysDefine.XSys_Welfare_KingdomPrivilege;
+ if (flag5)
+ {
+ result = (this.GetRedPoint(XSysDefine.XSys_Welfare_KingdomPrivilege_Adventurer) || this.GetRedPoint(XSysDefine.XSys_Welfare_KingdomPrivilege_Commerce) || this.GetRedPoint(XSysDefine.XSys_Welfare_KingdomPrivilege_Court));
+ }
+ else
+ {
+ bool flag6 = define == XSysDefine.XSys_Welfare_GiftBag;
+ if (flag6)
+ {
+ result = (this.GetRedPointState(define) || (this.IsSystemAvailable(XSysDefine.XSys_Welfare_GiftBag) && this._LittleGiftBag == 0u));
+ }
+ else
+ {
+ bool flag7 = define == XSysDefine.XSys_Welfare_NiceGirl;
+ if (flag7)
+ {
+ result = (this.GetRedPointState(define) || this.GetSpecialGiftRedPoint());
+ }
+ else
+ {
+ bool flag8 = define == XSysDefine.XSys_Welfare_YyMall;
+ if (flag8)
+ {
+ result = this.GetRedPointState(define);
+ }
+ else
+ {
+ bool flag9 = define == XSysDefine.XSys_Welfare_GiftBag || define == XSysDefine.XSys_Welfare_KingdomPrivilege || define == XSysDefine.XSys_Welfare_StarFund || define == XSysDefine.XSys_Welfare_FirstRechange || define == XSysDefine.XSys_Welfare_KingdomPrivilege_Adventurer || define == XSysDefine.XSys_Welfare_KingdomPrivilege_Commerce || define == XSysDefine.XSys_Welfare_KingdomPrivilege_Court || define == XSysDefine.XSys_Welfare_NiceGirl;
+ bool flag10 = !flag9 && XSingleton<XGameSysMgr>.singleton.IsSystemOpened(define) && !this.GetFirstClick(define);
+ result = (this.GetRedPointState(define) || flag10);
+ }
+ }
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ XWelfareDocument.AsyncLoader.AddTask("Table/PayAileen", XWelfareDocument._payAileenTable, false);
+ XWelfareDocument.AsyncLoader.AddTask("Table/PayWelfare", XWelfareDocument._welfareTable, false);
+ XWelfareDocument.AsyncLoader.AddTask("Table/Recharge/RechargeTable", XWelfareDocument._RechargeTable, false);
+ XWelfareDocument.AsyncLoader.AddTask("Table/Recharge/PayFirst", XWelfareDocument._payFirst, false);
+ XWelfareDocument.AsyncLoader.AddTask("Table/ItemBack", XWelfareDocument._rewardBackTable, false);
+ XWelfareDocument.AsyncLoader.AddTask("Table/PayMember", XWelfareDocument._payMemberTable, false);
+ XWelfareDocument.AsyncLoader.AddTask("Table/ArgentaDaily", XWelfareDocument._argentaDaily, false);
+ XWelfareDocument.AsyncLoader.AddTask("Table/ArgentaTask", XWelfareDocument._argentaTask, false);
+ XWelfareDocument.AsyncLoader.Execute(callback);
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.EventSubscribe();
+ base.RegisterEvent(XEventDefine.XEvent_ActivityTaskUpdate, new XComponent.XEventHandler(this.OnActivityUpdate));
+ }
+
+ public static void OnTableLoaded()
+ {
+ XWelfareDocument.m_RechargeDic.Clear();
+ XWelfareDocument.m_PayDic.Clear();
+ XWelfareDocument.m_payMemberIDDic.Clear();
+ XWelfareDocument.m_AileenTableDic.Clear();
+ int i = 0;
+ int num = XWelfareDocument._RechargeTable.Table.Length;
+ while (i < num)
+ {
+ RechargeTable.RowData rowData = XWelfareDocument._RechargeTable.Table[i];
+ XWelfareDocument.m_RechargeDic.Add(rowData.SystemID, rowData);
+ i++;
+ }
+ i = 0;
+ num = XWelfareDocument._payFirst.Table.Length;
+ while (i < num)
+ {
+ PayFirst.RowData rowData2 = XWelfareDocument._payFirst.Table[i];
+ XWelfareDocument.m_PayDic.Add(rowData2.SystemID, rowData2);
+ i++;
+ }
+ i = 0;
+ num = XWelfareDocument._payMemberTable.Table.Length;
+ while (i < num)
+ {
+ MemberPrivilege id = (MemberPrivilege)XWelfareDocument._payMemberTable.Table[i].ID;
+ XWelfareDocument.m_payMemberIDDic[id] = XWelfareDocument._payMemberTable.Table[i];
+ i++;
+ }
+ i = 0;
+ num = XWelfareDocument._payAileenTable.Table.Length;
+ while (i < num)
+ {
+ string paramID = XWelfareDocument._payAileenTable.Table[i].ParamID;
+ List<PayAileenTable.RowData> list;
+ bool flag = XWelfareDocument.m_AileenTableDic.TryGetValue(paramID, out list);
+ if (flag)
+ {
+ list.Add(XWelfareDocument._payAileenTable.Table[i]);
+ }
+ else
+ {
+ list = new List<PayAileenTable.RowData>();
+ list.Add(XWelfareDocument._payAileenTable.Table[i]);
+ XWelfareDocument.m_AileenTableDic[paramID] = list;
+ }
+ i++;
+ }
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ this._redpointState.Clear();
+ this.ServerPushRewardBack = false;
+ this.ServerPushMoneyTree = false;
+ this.ArgentaMainInterfaceState = true;
+ }
+
+ public void HideGiftBagBtn(string paramID)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Pay [HideGiftBagBtn] servicecode = " + paramID, null, null, null, null, null, XDebugColor.XDebug_None);
+ bool flag = this._payGiftBagInfo != null;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Pay [HideGiftBagBtn] 1", null, null, null, null, null, XDebugColor.XDebug_None);
+ for (int i = 0; i < this._payGiftBagInfo.AileenInfo.Count; i++)
+ {
+ XSingleton<XDebug>.singleton.AddLog(string.Concat(new object[]
+ {
+ "Pay [HideGiftBagBtn] 2 paramID = ",
+ this._payGiftBagInfo.AileenInfo[i].paramID,
+ ", weekDays = ",
+ this.PayGiftBagInfo.weekDays
+ }), null, null, null, null, null, XDebugColor.XDebug_None);
+ PayAileenTable.RowData giftBagTableData = XWelfareDocument.GetGiftBagTableData(this._payGiftBagInfo.AileenInfo[i].paramID, this.PayGiftBagInfo.weekDays);
+ bool flag2 = giftBagTableData != null;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Pay [HideGiftBagBtn] 3 servicecode = " + giftBagTableData.ServiceCode, null, null, null, null, null, XDebugColor.XDebug_None);
+ }
+ bool flag3 = giftBagTableData != null && giftBagTableData.ServiceCode == paramID;
+ if (flag3)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Pay [HideGiftBagBtn] 3 isBuy = true", null, null, null, null, null, XDebugColor.XDebug_None);
+ this._payGiftBagInfo.AileenInfo[i].isBuy = true;
+ break;
+ }
+ }
+ }
+ bool flag4 = this.View != null && this.View.IsVisible();
+ if (flag4)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Pay [HideGiftBagBtn] refreshData", null, null, null, null, null, XDebugColor.XDebug_None);
+ this.View.RefreshData();
+ }
+ }
+
+ public void ResetGiftBagBtnCD(int interval)
+ {
+ bool flag = this.View != null && this.View.IsVisible();
+ if (flag)
+ {
+ DlgHandlerBase handler = this.View.GetHandler(XSysDefine.XSys_Welfare_GiftBag);
+ bool flag2 = handler != null && handler.IsVisible();
+ if (flag2)
+ {
+ XWelfareGiftBagHandler xwelfareGiftBagHandler = handler as XWelfareGiftBagHandler;
+ bool flag3 = xwelfareGiftBagHandler != null;
+ if (flag3)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Pay [ResetGiftBagBtnCD] ResetGiftBagBtnCD", null, null, null, null, null, XDebugColor.XDebug_None);
+ xwelfareGiftBagHandler.ResetGiftBagBtnCD(interval);
+ }
+ }
+ }
+ }
+
+ public void ReqPayAllInfo()
+ {
+ XSingleton<XDebug>.singleton.AddLog("Pay [ReqPayAllInfo]", null, null, null, null, null, XDebugColor.XDebug_None);
+ RpcC2G_GetPayAllInfo rpc = new RpcC2G_GetPayAllInfo();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetPayAllInfo(GetPayAllInfoArg oArg, GetPayAllInfoRes oRes)
+ {
+ bool flag = oRes.errcode == ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ this.SetAllPayInfoData(oRes.info);
+ bool flag2 = this.View != null && this.View.IsVisible();
+ if (flag2)
+ {
+ this.View.RefreshData();
+ }
+ }
+ }
+
+ private void SetAllPayInfoData(PayAllInfo info)
+ {
+ bool flag = info == null;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Pay [SetAllPayInfoData] info == null", null, null, null, null, null);
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddLog("Pay [SetAllPayInfoData]", null, null, null, null, null, XDebugColor.XDebug_None);
+ this._payGiftBagInfo = info.aileen;
+ this._LittleGiftBag = info.rewardCoolTime;
+ this._payCardInfo = info.card;
+ this._vipLevel = info.vipLevel;
+ this.RegisterFirstClick(XSysDefine.XSys_Welfare_GiftBag, info.payAileenFirstClick, false);
+ this._payCardRemainTime = info.payCardRemainTime;
+ this.m_rechargeFirstGift = info.payFirstAward;
+ this.RegisterFirstClick(XSysDefine.XSys_Welfare_FirstRechange, info.payFirstAwardClick, false);
+ this.RegisterFirstClick(XSysDefine.XSys_Welfare_StarFund, info.growthFundClick, false);
+ this.RegisterFirstClick(XSysDefine.XSyS_Welfare_RewardBack, this.m_firstRewardBack, false);
+ this.m_hasBuyGrowthFund = info.buyGrowthFund;
+ this.m_loginDayCount = (int)info.totalLoginDays;
+ this.m_growthFundDic[1] = info.growthFundLevelInfo;
+ this.m_growthFundDic[2] = info.growthFundLoginInfo;
+ this.CalculateGrowthFundRedPoint(false);
+ this.CalculateRechargetFirstRedPoint(false);
+ this.CalculateRewardBackRedPoint();
+ this._payMemberInfo = info.payMemberInfo;
+ this.RegisterPayMemberClick(info.payMemberInfo);
+ this.CheckMemberPrivilegeType(this._payMemberInfo);
+ XWelfareDocument.SetMemberPrivilegeIcon(this._payMemberInfo);
+ }
+ }
+
+ public void OnGetPayMemberPrivilege(PayMemberPrivilege data)
+ {
+ this._payMemberPrivilege = data;
+ }
+
+ public int GetPayMemberReviveLeftCount()
+ {
+ bool flag = this._payMemberPrivilege == null;
+ int result;
+ if (flag)
+ {
+ result = 0;
+ }
+ else
+ {
+ int num = 0;
+ for (int i = 0; i < XWelfareDocument._payMemberTable.Table.Length; i++)
+ {
+ bool flag2 = this.IsOwnMemberPrivilege((MemberPrivilege)XWelfareDocument._payMemberTable.Table[i].ID);
+ if (flag2)
+ {
+ num += XWelfareDocument._payMemberTable.Table[i].ReviveCount;
+ }
+ }
+ result = num - this._payMemberPrivilege.usedReviveCount;
+ }
+ return result;
+ }
+
+ private void CheckMemberPrivilegeType(List<PayMember> info)
+ {
+ this.m_MemberPrivilege.Clear();
+ XWelfareDocument._memberPrivilegeFlag = 0u;
+ for (int i = 0; i < info.Count; i++)
+ {
+ MemberPrivilege id = (MemberPrivilege)info[i].ID;
+ this.m_MemberPrivilege[id] = (info[i].ExpireTime > 0);
+ bool flag = info[i].ExpireTime > 0;
+ if (flag)
+ {
+ XWelfareDocument._memberPrivilegeFlag += (uint)Math.Pow(2.0, (double)info[i].ID);
+ }
+ }
+ }
+
+ public bool IsOwnMemberPrivilege(MemberPrivilege type)
+ {
+ bool flag2;
+ bool flag = this.m_MemberPrivilege.TryGetValue(type, out flag2);
+ return flag && flag2;
+ }
+
+ public PayMemberTable.RowData GetMemberPrivilegeConfig(MemberPrivilege type)
+ {
+ PayMemberTable.RowData rowData;
+ bool flag = XWelfareDocument.m_payMemberIDDic.TryGetValue(type, out rowData);
+ PayMemberTable.RowData result;
+ if (flag)
+ {
+ result = rowData;
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ private static void SetMemberPrivilegeIcon(List<PayMember> info)
+ {
+ XWelfareDocument._payMemberIcon.Clear();
+ string[] andSeparateValue = XSingleton<XGlobalConfig>.singleton.GetAndSeparateValue("WelfareMemberPrivilegeIconName", XGlobalConfig.ListSeparator);
+ for (int i = 0; i < andSeparateValue.Length; i++)
+ {
+ string[] array = andSeparateValue[i].Split(new char[]
+ {
+ '='
+ });
+ bool flag = array.Length != 2;
+ if (!flag)
+ {
+ uint key = uint.Parse(array[0]);
+ XWelfareDocument._payMemberIcon[key] = array[1];
+ }
+ }
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshSelfMemberPrivilegeIcon();
+ }
+
+ public static string GetMemberPrivilegeIconString(uint value)
+ {
+ bool flag = !XWelfareDocument._payMemberIcon.ContainsKey(value);
+ string result;
+ if (flag)
+ {
+ result = "";
+ }
+ else
+ {
+ result = XLabelSymbolHelper.FormatImage(XWelfareDocument.MEMBER_PRIVILEGE_ATLAS, XWelfareDocument._payMemberIcon[value]);
+ }
+ return result;
+ }
+
+ public static string GetSelfMemberPrivilegeIconString()
+ {
+ bool flag = !XWelfareDocument._payMemberIcon.ContainsKey(XWelfareDocument._memberPrivilegeFlag);
+ string result;
+ if (flag)
+ {
+ result = "";
+ }
+ else
+ {
+ result = XLabelSymbolHelper.FormatImage(XWelfareDocument.MEMBER_PRIVILEGE_ATLAS, XWelfareDocument._payMemberIcon[XWelfareDocument._memberPrivilegeFlag]);
+ }
+ return result;
+ }
+
+ public static string GetSelfMemberPrivilegeIconName()
+ {
+ bool flag = !XWelfareDocument._payMemberIcon.ContainsKey(XWelfareDocument._memberPrivilegeFlag);
+ string result;
+ if (flag)
+ {
+ result = "";
+ }
+ else
+ {
+ result = XWelfareDocument._payMemberIcon[XWelfareDocument._memberPrivilegeFlag];
+ }
+ return result;
+ }
+
+ public string GetMemberPrivilegeIcon(MemberPrivilege type)
+ {
+ uint key = (uint)Math.Pow(2.0, XFastEnumIntEqualityComparer<MemberPrivilege>.ToInt(type));
+ string text;
+ bool flag = XWelfareDocument._payMemberIcon.TryGetValue(key, out text);
+ string result;
+ if (flag)
+ {
+ result = text;
+ }
+ else
+ {
+ result = "";
+ }
+ return result;
+ }
+
+ public void PayAllInfoNtf(PayAllInfo info)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Pay [PayAllInfoNtf]", null, null, null, null, null, XDebugColor.XDebug_None);
+ this.CheckPayMemberResult(info);
+ this.SetAllInfoMessage(info);
+ this.SetAllPayInfoData(info);
+ bool flag = this.View != null && this.View.IsVisible();
+ if (flag)
+ {
+ this.View.RefreshRedpoint();
+ this.View.RefreshData();
+ }
+ XChatDocument specificDocument = XDocuments.GetSpecificDocument<XChatDocument>(XChatDocument.uuID);
+ specificDocument.RefreshSelfMemberPriviligeInfo(XWelfareDocument._memberPrivilegeFlag);
+ XMainInterfaceDocument specificDocument2 = XDocuments.GetSpecificDocument<XMainInterfaceDocument>(XMainInterfaceDocument.uuID);
+ specificDocument2.RefreshVirtualItem(6);
+ }
+
+ private void SetAllInfoMessage(PayAllInfo info)
+ {
+ bool flag = info.payType == XFastEnumIntEqualityComparer<PayParamType>.ToInt(PayParamType.PAY_PARAM_GROWTH_FUND);
+ if (flag)
+ {
+ RechargeTable.RowData rowData = null;
+ bool flag2 = info.buyGrowthFund && !this.m_hasBuyGrowthFund && this.TryGetGrowthFundConf(XSysDefine.XSys_Welfare_StarFund, out rowData);
+ if (flag2)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("WELFARE_GROWTHFUND_ERRORCODE", new object[]
+ {
+ rowData.Diamond
+ }), "fece00");
+ }
+ }
+ }
+
+ public void ReqPayClick(PayParamType type, XSysDefine define = XSysDefine.XSys_None)
+ {
+ bool flag = define == XSysDefine.XSys_None;
+ if (!flag)
+ {
+ bool flag2 = false;
+ bool flag3 = this.m_clickDic.TryGetValue(define, out flag2) && flag2;
+ if (!flag3)
+ {
+ bool flag4 = define == XSysDefine.XSys_Welfare_KingdomPrivilege;
+ if (flag4)
+ {
+ foreach (KeyValuePair<MemberPrivilege, PayMemberTable.RowData> keyValuePair in XWelfareDocument.m_payMemberIDDic)
+ {
+ bool flag5 = XSingleton<XGameSysMgr>.singleton.IsSystemOpen(keyValuePair.Value.SystemID);
+ if (flag5)
+ {
+ RpcC2G_PayClick rpcC2G_PayClick = new RpcC2G_PayClick();
+ rpcC2G_PayClick.oArg.buttonType = XFastEnumIntEqualityComparer<PayParamType>.ToInt(PayParamType.PAY_PARAM_MEMBER);
+ rpcC2G_PayClick.oArg.memberid = XFastEnumIntEqualityComparer<MemberPrivilege>.ToInt(keyValuePair.Key);
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_PayClick);
+ }
+ }
+ }
+ else
+ {
+ RpcC2G_PayClick rpcC2G_PayClick2 = new RpcC2G_PayClick();
+ rpcC2G_PayClick2.oArg.buttonType = XFastEnumIntEqualityComparer<PayParamType>.ToInt(type);
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_PayClick2);
+ }
+ }
+ }
+ }
+
+ public void RefreshFirstClickTabRedpoint(PayClickArg oArg, PayClickRes oRes)
+ {
+ bool flag = oRes.errcode == ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ bool flag2 = oArg.buttonType == XFastEnumIntEqualityComparer<PayParamType>.ToInt(PayParamType.PAY_PARAM_CARD);
+ if (!flag2)
+ {
+ bool flag3 = oArg.buttonType == XFastEnumIntEqualityComparer<PayParamType>.ToInt(PayParamType.PAY_PARAM_AILEEN);
+ if (flag3)
+ {
+ this.RegisterRedPoint(XSysDefine.XSys_Welfare_GiftBag, false, false);
+ this.RegisterFirstClick(XSysDefine.XSys_Welfare_GiftBag, true, true);
+ }
+ else
+ {
+ bool flag4 = oArg.buttonType == XFastEnumIntEqualityComparer<PayParamType>.ToInt(PayParamType.PAY_PARAM_GROWTH_FUND);
+ if (flag4)
+ {
+ this.RegisterFirstClick(XSysDefine.XSys_Welfare_StarFund, true, true);
+ }
+ else
+ {
+ bool flag5 = oArg.buttonType == XFastEnumIntEqualityComparer<PayParamType>.ToInt(PayParamType.PAY_PARAM_FIRSTAWARD);
+ if (flag5)
+ {
+ this.RegisterFirstClick(XSysDefine.XSys_Welfare_FirstRechange, true, true);
+ }
+ else
+ {
+ bool flag6 = oArg.buttonType == XFastEnumIntEqualityComparer<PayParamType>.ToInt(PayParamType.PAY_PARAM_MEMBER);
+ if (flag6)
+ {
+ foreach (KeyValuePair<MemberPrivilege, PayMemberTable.RowData> keyValuePair in XWelfareDocument.m_payMemberIDDic)
+ {
+ bool flag7 = keyValuePair.Key == (MemberPrivilege)oArg.memberid;
+ if (flag7)
+ {
+ this.RegisterRedPoint((XSysDefine)keyValuePair.Value.SystemID, false, false);
+ this.RegisterFirstClick((XSysDefine)keyValuePair.Value.SystemID, true, true);
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ public bool IsSystemAvailable(XSysDefine sys)
+ {
+ if (sys != XSysDefine.XSys_ReceiveEnergy && sys != XSysDefine.XSys_Reward_Login)
+ {
+ switch (sys)
+ {
+ case XSysDefine.XSys_Welfare_GiftBag:
+ return XSingleton<XGameSysMgr>.singleton.IsSystemOpened(XSysDefine.XSys_Welfare_GiftBag) && this.PayGiftBagInfo != null && this.PayGiftBagInfo.AileenInfo.Count > 0;
+ case XSysDefine.XSys_Welfare_StarFund:
+ case XSysDefine.XSys_Welfare_FirstRechange:
+ case XSysDefine.XSyS_Welfare_RewardBack:
+ case XSysDefine.XSys_Welfare_MoneyTree:
+ case XSysDefine.XSys_Welfare_NiceGirl:
+ case XSysDefine.XSys_Welfare_YyMall:
+ goto IL_BD;
+ case XSysDefine.XSys_Welfare_KingdomPrivilege:
+ return XSingleton<XGameSysMgr>.singleton.IsSystemOpened(XSysDefine.XSys_Welfare_KingdomPrivilege_Court) || XSingleton<XGameSysMgr>.singleton.IsSystemOpened(XSysDefine.XSys_Welfare_KingdomPrivilege_Adventurer) || XSingleton<XGameSysMgr>.singleton.IsSystemOpened(XSysDefine.XSys_Welfare_KingdomPrivilege_Commerce);
+ }
+ return false;
+ }
+ IL_BD:
+ return XSingleton<XGameSysMgr>.singleton.IsSystemOpened(sys);
+ }
+
+ public bool GetTabRedpointState(XSysDefine type)
+ {
+ return this.GetRedPoint(type);
+ }
+
+ private void RefreshData()
+ {
+ bool flag = this.View != null && this.View.IsVisible();
+ if (flag)
+ {
+ this.View.RefreshData();
+ }
+ }
+
+ public bool IsGiftBagItem(int itemID)
+ {
+ for (int i = 0; i < XWelfareDocument._payAileenTable.Table.Length; i++)
+ {
+ bool flag = XWelfareDocument._payAileenTable.Table[i].LevelSealGiftID != null;
+ if (flag)
+ {
+ for (int j = 0; j < XWelfareDocument._payAileenTable.Table[i].LevelSealGiftID.Length; j++)
+ {
+ bool flag2 = itemID == XWelfareDocument._payAileenTable.Table[i].LevelSealGiftID[j];
+ if (flag2)
+ {
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ public void GetCardDailyDiamond(uint type)
+ {
+ RpcC2G_PayCardAward rpcC2G_PayCardAward = new RpcC2G_PayCardAward();
+ rpcC2G_PayCardAward.oArg.type = (int)type;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_PayCardAward);
+ }
+
+ public void OnGetCardDailyDiamond(PayCardAwardArg oArg, PayCardAwardRes oRes)
+ {
+ bool flag = oRes.errcode == ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ for (int i = 0; i < this._payCardInfo.Count; i++)
+ {
+ bool flag2 = (ulong)this._payCardInfo[i].type == (ulong)((long)oArg.type);
+ if (flag2)
+ {
+ this._payCardInfo.RemoveAt(i);
+ this._payCardInfo.Add(oRes.info);
+ break;
+ }
+ }
+ bool flag3 = false;
+ for (int j = 0; j < this._payCardInfo.Count; j++)
+ {
+ bool flag4 = !this._payCardInfo[j].isGet;
+ if (flag4)
+ {
+ flag3 = true;
+ break;
+ }
+ }
+ bool flag5 = !flag3;
+ if (flag5)
+ {
+ }
+ bool flag6 = this.View != null && this.View.IsVisible();
+ if (flag6)
+ {
+ this.View.RefreshData();
+ }
+ }
+ }
+
+ public static PayCardTable.RowData GetPayCardConfig(uint type)
+ {
+ XRechargeDocument specificDocument = XDocuments.GetSpecificDocument<XRechargeDocument>(XRechargeDocument.uuID);
+ for (int i = 0; i < specificDocument.PayCardReader.Table.Length; i++)
+ {
+ bool flag = (long)specificDocument.PayCardReader.Table[i].Type == (long)((ulong)type);
+ if (flag)
+ {
+ return specificDocument.PayCardReader.Table[i];
+ }
+ }
+ return null;
+ }
+
+ public static int GetGiftBagTableIndex(string patamID)
+ {
+ for (int i = 0; i < XWelfareDocument._payAileenTable.Table.Length; i++)
+ {
+ bool flag = XWelfareDocument._payAileenTable.Table[i].ParamID == patamID;
+ if (flag)
+ {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ public static PayAileenTable.RowData GetGiftBagTableData(string paramID, uint weekDay)
+ {
+ List<PayAileenTable.RowData> list;
+ bool flag = XWelfareDocument.m_AileenTableDic.TryGetValue(paramID, out list);
+ if (flag)
+ {
+ for (int i = 0; i < list.Count; i++)
+ {
+ bool flag2 = (long)list[i].Days == (long)((ulong)weekDay);
+ if (flag2)
+ {
+ return list[i];
+ }
+ }
+ }
+ return null;
+ }
+
+ public void GetLittleGiftBag()
+ {
+ RpcC2G_GetPayReward rpc = new RpcC2G_GetPayReward();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetLittleGiftBox(GetPayRewardArg oArg, GetPayRewardRes oRes)
+ {
+ bool flag = oRes.errorcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.errorcode, "fece00");
+ }
+ else
+ {
+ this._LittleGiftBag = oRes.cdTime;
+ this.RefreshRedPoint(XSysDefine.XSys_Welfare_GiftBag, true);
+ bool flag2 = this.View != null && this.View.IsVisible();
+ if (flag2)
+ {
+ this.View.RefreshData();
+ }
+ }
+ }
+
+ public bool TryGetGrowthFundConf(XSysDefine define, out RechargeTable.RowData rowData)
+ {
+ return XWelfareDocument.m_RechargeDic.TryGetValue(XFastEnumIntEqualityComparer<XSysDefine>.ToInt(define), out rowData);
+ }
+
+ public bool HasGrowthFundGet(int type, int value)
+ {
+ return this.m_growthFundDic.ContainsKey(type) && this.m_growthFundDic[type].Contains(value);
+ }
+
+ public void GetGrowthFundAward(int type, int value)
+ {
+ RpcC2G_GrowthFundAward rpcC2G_GrowthFundAward = new RpcC2G_GrowthFundAward();
+ rpcC2G_GrowthFundAward.oArg.type = type;
+ rpcC2G_GrowthFundAward.oArg.value = value;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_GrowthFundAward);
+ }
+
+ public int GetGrowthFundLength()
+ {
+ int num = 0;
+ List<int> list;
+ bool flag = this.m_growthFundDic.TryGetValue(1, out list);
+ if (flag)
+ {
+ num += list.Count;
+ }
+ bool flag2 = this.m_growthFundDic.TryGetValue(2, out list);
+ if (flag2)
+ {
+ num += list.Count;
+ }
+ return num;
+ }
+
+ public void OnGetGrowthFundAward(GrowthFundAwardArg oArg, GrowthFundAwardRes oRes)
+ {
+ bool flag = oRes.errcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.errcode, "fece00");
+ }
+ else
+ {
+ List<int> list;
+ bool flag2 = this.m_growthFundDic.TryGetValue(1, out list);
+ if (flag2)
+ {
+ int i = 0;
+ int count = oRes.growthFundLevelInfo.Count;
+ while (i < count)
+ {
+ bool flag3 = list.IndexOf(oRes.growthFundLevelInfo[i]) == -1;
+ if (flag3)
+ {
+ list.Add(oRes.growthFundLevelInfo[i]);
+ }
+ i++;
+ }
+ }
+ bool flag4 = this.m_growthFundDic.TryGetValue(2, out list);
+ if (flag4)
+ {
+ int i = 0;
+ int count = oRes.growthFundLoginInfo.Count;
+ while (i < count)
+ {
+ bool flag5 = list.IndexOf(oRes.growthFundLoginInfo[i]) == -1;
+ if (flag5)
+ {
+ list.Add(oRes.growthFundLoginInfo[i]);
+ }
+ i++;
+ }
+ }
+ this.CalcaulateGrowthFundMessage(oArg.type, oArg.value);
+ this.CalculateGrowthFundRedPoint(true);
+ this.RefreshData();
+ }
+ }
+
+ private void CalcaulateGrowthFundMessage(int type, int key)
+ {
+ bool flag = false;
+ int num = 0;
+ RechargeTable.RowData rowData;
+ bool flag2 = this.TryGetGrowthFundConf(XSysDefine.XSys_Welfare_StarFund, out rowData);
+ if (flag2)
+ {
+ bool flag3 = this.GetGrowthFundLength() == rowData.RoleLevels.Count + rowData.LoginDays.Count;
+ bool flag4 = type == 1;
+ if (flag4)
+ {
+ int i = 0;
+ int count = rowData.RoleLevels.Count;
+ while (i < count)
+ {
+ bool flag5 = rowData.RoleLevels[i, 0] == key;
+ if (flag5)
+ {
+ num = rowData.RoleLevels[i, 1];
+ flag = true;
+ break;
+ }
+ i++;
+ }
+ }
+ else
+ {
+ bool flag6 = type == 2;
+ if (flag6)
+ {
+ int i = 0;
+ int count = rowData.LoginDays.Count;
+ while (i < count)
+ {
+ bool flag7 = rowData.LoginDays[i, 0] == key;
+ if (flag7)
+ {
+ num = rowData.LoginDays[i, 1];
+ flag = true;
+ break;
+ }
+ i++;
+ }
+ }
+ }
+ }
+ bool flag8 = flag;
+ if (flag8)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("WELFARE_GROWTHFUND_ERRORCODE1", new object[]
+ {
+ num
+ }), "fece00");
+ }
+ }
+
+ private void CalculateGrowthFundRedPoint(bool refresh = true)
+ {
+ bool flag = !this.m_hasBuyGrowthFund;
+ if (flag)
+ {
+ this.RegisterRedPoint(XSysDefine.XSys_Welfare_StarFund, false, refresh);
+ }
+ else
+ {
+ RechargeTable.RowData rowData;
+ bool flag2 = this.TryGetGrowthFundConf(XSysDefine.XSys_Welfare_StarFund, out rowData);
+ if (flag2)
+ {
+ uint level = XSingleton<XAttributeMgr>.singleton.XPlayerData.Level;
+ int i = 0;
+ int count = rowData.RoleLevels.Count;
+ while (i < count)
+ {
+ bool flag3 = !this.HasGrowthFundGet(1, rowData.RoleLevels[i, 0]) && (long)rowData.RoleLevels[i, 0] <= (long)((ulong)level);
+ if (flag3)
+ {
+ this.RegisterRedPoint(XSysDefine.XSys_Welfare_StarFund, true, refresh);
+ return;
+ }
+ i++;
+ }
+ i = 0;
+ count = rowData.LoginDays.Count;
+ while (i < count)
+ {
+ bool flag4 = !this.HasGrowthFundGet(2, rowData.LoginDays[i, 0]) && rowData.LoginDays[i, 0] <= this.m_loginDayCount;
+ if (flag4)
+ {
+ this.RegisterRedPoint(XSysDefine.XSys_Welfare_StarFund, true, refresh);
+ return;
+ }
+ i++;
+ }
+ }
+ this.RegisterRedPoint(XSysDefine.XSys_Welfare_StarFund, false, refresh);
+ }
+ }
+
+ public bool HasFullFirstRecharge()
+ {
+ bool result = false;
+ PayFirst.RowData rowData;
+ bool flag = this.TryGetPayFirstData(XSysDefine.XSys_Welfare_FirstRechange, out rowData);
+ if (flag)
+ {
+ int money = rowData.Money;
+ XRechargeDocument specificDocument = XDocuments.GetSpecificDocument<XRechargeDocument>(XRechargeDocument.uuID);
+ result = ((float)money <= specificDocument.TotalPay * 100f);
+ }
+ return result;
+ }
+
+ public bool TryGetPayFirstData(XSysDefine define, out PayFirst.RowData rowData)
+ {
+ int key = XFastEnumIntEqualityComparer<XSysDefine>.ToInt(define);
+ return XWelfareDocument.m_PayDic.TryGetValue(key, out rowData);
+ }
+
+ public void GetPayFirstAward()
+ {
+ RpcC2G_PayFirstAward rpc = new RpcC2G_PayFirstAward();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetPayFirstAward(PayFirstAwardRes oRes)
+ {
+ bool flag = oRes.errcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.errcode, "fece00");
+ }
+ else
+ {
+ this.CalculateRechargetFirstRedPoint(true);
+ this.RefreshData();
+ }
+ }
+
+ public bool GetCanRechargeFirst()
+ {
+ return XSingleton<XGameSysMgr>.singleton.IsSystemOpened(XSysDefine.XSys_Welfare_FirstRechange) && !this.m_rechargeFirstGift && this.HasFullFirstRecharge();
+ }
+
+ private void CalculateRechargetFirstRedPoint(bool refresh = true)
+ {
+ bool canRechargeFirst = this.GetCanRechargeFirst();
+ this.RegisterRedPoint(XSysDefine.XSys_Welfare_FirstRechange, this.GetCanRechargeFirst(), refresh);
+ }
+
+ public static ItemBackTable.RowData GetRewardBackByIndex(int index)
+ {
+ for (int i = 0; i < XWelfareDocument._rewardBackTable.Table.Length; i++)
+ {
+ bool flag = XWelfareDocument._rewardBackTable.Table[i].ID == index;
+ if (flag)
+ {
+ return XWelfareDocument._rewardBackTable.Table[i];
+ }
+ }
+ return null;
+ }
+
+ private void CalculateRewardBackRedPoint()
+ {
+ bool flag = this.View != null && this.View.IsVisible();
+ if (flag)
+ {
+ this.View.RefreshRedpoint();
+ this.RegisterRedPoint(XSysDefine.XSyS_Welfare_RewardBack, this.View.HadRewardBackRedPoint(), true);
+ }
+ }
+
+ public void ReqRewardInfo()
+ {
+ bool flag = !XSingleton<XGameSysMgr>.singleton.IsSystemOpened(XSysDefine.XSyS_Welfare_RewardBack);
+ if (!flag)
+ {
+ RpcC2G_ItemFindBackInfo rpc = new RpcC2G_ItemFindBackInfo();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ XSuperRiskDocument doc = XSuperRiskDocument.Doc;
+ bool flag2 = XSingleton<XGameSysMgr>.singleton.IsSystemOpened(XSysDefine.XSys_SuperRisk);
+ if (flag2)
+ {
+ RiskMapFile.RowData mapIdByIndex = doc.GetMapIdByIndex(0);
+ bool flag3 = mapIdByIndex != null && (ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level >= (ulong)((long)mapIdByIndex.NeedLevel);
+ if (flag3)
+ {
+ doc.ReqMapDynamicInfo(1, false, true);
+ }
+ }
+ }
+ }
+
+ public void ReqMoneyTreeInfo()
+ {
+ RpcC2G_GoldClick rpcC2G_GoldClick = new RpcC2G_GoldClick();
+ rpcC2G_GoldClick.oArg.type = 0u;
+ rpcC2G_GoldClick.oArg.count = 1u;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_GoldClick);
+ }
+
+ public void OnRefreshRewardBack()
+ {
+ bool flag = this.View != null && this.View.IsLoaded() && this.View.IsVisible();
+ if (flag)
+ {
+ this.RefreshData();
+ }
+ }
+
+ public void OnGetRewardInfo(ItemFindBackInfoRes oRes)
+ {
+ this.m_FindBackInfo = oRes.backInfo;
+ bool flag = this.View != null && this.View.IsVisible();
+ if (flag)
+ {
+ this.View.RefreshRewardBackData();
+ this.View.OnGetRewardInfo(oRes);
+ }
+ this.CalculateRewardBackRedPoint();
+ }
+
+ public void ReqRewardFindBack(ItemFindBackType type, int count)
+ {
+ RpcC2G_ItemFindBack rpcC2G_ItemFindBack = new RpcC2G_ItemFindBack();
+ rpcC2G_ItemFindBack.oArg.id = type;
+ rpcC2G_ItemFindBack.oArg.findBackCount = count;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_ItemFindBack);
+ }
+
+ public void OnGetRewardFindBack(ItemFindBackArg oArg)
+ {
+ int num = oArg.findBackCount;
+ int num2 = 0;
+ for (int i = 0; i < this.m_FindBackInfo.Count; i++)
+ {
+ bool flag = this.m_FindBackInfo[i].id == oArg.id;
+ if (flag)
+ {
+ bool flag2 = oArg.backType == 1;
+ if (flag2)
+ {
+ num2 = XWelfareDocument.GetRewardBackByIndex(XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.DICE_BACK)).ItemDragonCoin[0, 1];
+ }
+ else
+ {
+ num2 = XWelfareDocument.GetRewardBackByIndex(XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.DICE_BACK)).ItemGold[0, 1];
+ }
+ bool flag3 = this.m_FindBackInfo[i].findBackCount >= num;
+ if (flag3)
+ {
+ this.m_FindBackInfo[i].findBackCount -= num;
+ break;
+ }
+ num -= this.m_FindBackInfo[i].findBackCount;
+ this.m_FindBackInfo[i].findBackCount = 0;
+ }
+ }
+ this.RefreshData();
+ this.CalculateRewardBackRedPoint();
+ bool flag4 = oArg.id == ItemFindBackType.DICE_BACK;
+ if (flag4)
+ {
+ string text = string.Format("[{0}]{1}", XSingleton<UiUtility>.singleton.GetItemQualityRGB((int)XBagDocument.GetItemConf(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.DICE)).ItemQuality).ToString(), XSingleton<UiUtility>.singleton.ChooseProfString(XBagDocument.GetItemConf(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.DICE)).ItemName, 0u));
+ string text2 = string.Format("{0}[ffffff]x{1}", XStringDefineProxy.GetString("GET_ITEM", new object[]
+ {
+ text
+ }), (oArg.findBackCount * num2).ToString());
+ XSingleton<UiUtility>.singleton.ShowSystemTip(text2, "fece00");
+ }
+ }
+
+ public void OnPtcFindItemBack()
+ {
+ bool flag = !this.m_firstRewardBack;
+ if (flag)
+ {
+ this.ServerPushRewardBack = true;
+ XSingleton<XGameSysMgr>.singleton.SetSysRedPointState(XSysDefine.XSyS_Welfare_RewardBack, true);
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_Welfare, true);
+ }
+ }
+
+ public void OnPtcFirstNotify(bool first)
+ {
+ if (first)
+ {
+ bool flag = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_HALL;
+ if (flag)
+ {
+ bool flag2 = DlgBase<XWelfareView, XWelfareBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<XWelfareView, XWelfareBehaviour>.singleton.RefershRewardBack();
+ }
+ DlgBase<XWelfareView, XWelfareBehaviour>.singleton.Show(XSysDefine.XSyS_Welfare_RewardBack);
+ }
+ }
+ }
+
+ public void OnPtcMoneyTree()
+ {
+ bool flag = !this.m_firstMoneyTree;
+ if (flag)
+ {
+ this.ServerPushMoneyTree = true;
+ XSingleton<XGameSysMgr>.singleton.SetSysRedPointState(XSysDefine.XSys_Welfare_MoneyTree, true);
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_Welfare, true);
+ }
+ }
+
+ private void RegisterPayMemberClick(List<PayMember> info)
+ {
+ for (int i = 0; i < info.Count; i++)
+ {
+ int id = info[i].ID;
+ for (int j = 0; j < XWelfareDocument._payMemberTable.Table.Length; j++)
+ {
+ bool flag = id == XWelfareDocument._payMemberTable.Table[j].ID;
+ if (flag)
+ {
+ int systemID = XWelfareDocument._payMemberTable.Table[j].SystemID;
+ this.RegisterFirstClick((XSysDefine)systemID, info[i].isClick, false);
+ }
+ }
+ }
+ }
+
+ private void CheckPayMemberResult(PayAllInfo info)
+ {
+ bool flag = this._payMemberInfo == null;
+ if (!flag)
+ {
+ bool flag2 = info.payType == 6;
+ if (flag2)
+ {
+ for (int i = 0; i < this._payMemberInfo.Count; i++)
+ {
+ for (int j = 0; j < info.payMemberInfo.Count; j++)
+ {
+ bool flag3 = this._payMemberInfo[i].ID == info.payMemberInfo[j].ID;
+ if (flag3)
+ {
+ PayMember payMember = this._payMemberInfo[i];
+ PayMember payMember2 = info.payMemberInfo[j];
+ bool flag4 = payMember.ExpireTime != 0 && payMember2.ExpireTime > payMember.ExpireTime;
+ if (flag4)
+ {
+ PayMemberTable.RowData info2;
+ bool flag5 = XWelfareDocument.m_payMemberIDDic.TryGetValue((MemberPrivilege)this._payMemberInfo[i].ID, out info2);
+ if (flag5)
+ {
+ DlgBase<XWelfareKingdomPrivilegeRenewView, XWelfareKingdomPrivilegeRenewBehaviour>.singleton.Show(info2, true, payMember2.ExpireTime);
+ break;
+ }
+ }
+ else
+ {
+ bool flag6 = payMember.ExpireTime == 0 && payMember2.ExpireTime > 0;
+ if (flag6)
+ {
+ PayMemberTable.RowData info3;
+ bool flag7 = XWelfareDocument.m_payMemberIDDic.TryGetValue((MemberPrivilege)this._payMemberInfo[i].ID, out info3);
+ if (flag7)
+ {
+ DlgBase<XWelfareKingdomPrivilegeDetailView, XWelfareKingdomPrivilegeDetailBehaviour>.singleton.ShowDetail(info3, false);
+ break;
+ }
+ }
+ else
+ {
+ bool flag8 = payMember.ExpireTime > 0 && payMember2.ExpireTime == 0;
+ if (flag8)
+ {
+ PayMemberTable.RowData rowData;
+ bool flag9 = XWelfareDocument.m_payMemberIDDic.TryGetValue((MemberPrivilege)this._payMemberInfo[i].ID, out rowData);
+ if (flag9)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("PAY_KINGDOM_OUT_OF_DATE", new object[]
+ {
+ rowData.Name
+ }), "fece00");
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ public void OnGetMoneyTreeInfo(uint type, uint count, GoldClickRes res)
+ {
+ bool flag = res.freeallcount == 0u || res.allcount == 0u;
+ if (flag)
+ {
+ bool flag2 = type == 1u;
+ if (flag2)
+ {
+ this.m_MoneyTreeData.free_count += 1u;
+ this.m_MoneyTreeData.left_time = res.freetimeleft;
+ this.m_MoneyTreeData.req_time = Time.time;
+ }
+ else
+ {
+ bool flag3 = type == 2u;
+ if (flag3)
+ {
+ this.m_MoneyTreeData.count += count;
+ }
+ }
+ }
+ else
+ {
+ this.m_MoneyTreeData.free_count = res.freecount;
+ this.m_MoneyTreeData.free_all_count = res.freeallcount;
+ this.m_MoneyTreeData.count = res.count;
+ this.m_MoneyTreeData.all_count = res.allcount;
+ this.m_MoneyTreeData.left_time = res.freetimeleft;
+ this.m_MoneyTreeData.req_time = Time.time;
+ this.m_MoneyTreeData.result = res.results;
+ }
+ bool flag4 = this.View != null && this.View.IsVisible();
+ if (flag4)
+ {
+ this.View.OnGetMoneyTreeInfo(type, count, res);
+ }
+ }
+
+ public ArgentaDaily.RowData GetArgentDailyDataByIndex(int index)
+ {
+ bool flag = index < XWelfareDocument._argentaDaily.Table.Length;
+ ArgentaDaily.RowData result;
+ if (flag)
+ {
+ result = XWelfareDocument._argentaDaily.Table[index];
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ public int GetArgentDailyDataCount()
+ {
+ return XWelfareDocument._argentaDaily.Table.Length;
+ }
+
+ public ArgentaTask.RowData GetArgentTaskDataByIndex(int index)
+ {
+ bool flag = index < XWelfareDocument._argentaTask.Table.Length;
+ ArgentaTask.RowData result;
+ if (flag)
+ {
+ result = XWelfareDocument._argentaTask.Table[index];
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ public void SendArgentaActivityInfo(uint type, uint taskid)
+ {
+ RpcC2G_ArgentaActivity rpcC2G_ArgentaActivity = new RpcC2G_ArgentaActivity();
+ rpcC2G_ArgentaActivity.oArg.type = type;
+ rpcC2G_ArgentaActivity.oArg.id = taskid;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_ArgentaActivity);
+ }
+
+ public void OnGetArgentaActivityInfo(ArgentaActivityArg oArg, ArgentaActivityRes oRes)
+ {
+ bool flag = oArg.type == 1u;
+ if (flag)
+ {
+ this._curArgentaDailyIDList = oRes.getRewardIDs;
+ this.ActivityLeftTime = oRes.leftTime + (uint)Time.realtimeSinceStartup;
+ this._rewardsLevel = oRes.level;
+ }
+ else
+ {
+ this.CurArgentaDailyIDList.Add(oArg.id);
+ this.SortArgentDailyData();
+ bool flag2 = this.IsDailyAllGetted();
+ bool flag3 = flag2;
+ if (flag3)
+ {
+ this.RegisterRedPoint(XSysDefine.XSys_Welfare_NiceGirl, !flag2, true);
+ }
+ }
+ bool flag4 = this.View != null && this.View.IsLoaded() && this.View.IsVisible();
+ if (flag4)
+ {
+ this.RefreshData();
+ }
+ bool bState = this.GetRedPointState(XSysDefine.XSys_Welfare_NiceGirl) || this.GetSpecialGiftRedPoint();
+ XSingleton<XGameSysMgr>.singleton.SetSysRedPointState(XSysDefine.XSys_Welfare_NiceGirl, bState);
+ this.RefreshRedPoint(XSysDefine.XSys_Welfare_NiceGirl, true);
+ }
+
+ public bool IsDailyAllGetted()
+ {
+ bool result = true;
+ for (int i = 0; i < XWelfareDocument._argentaDaily.Table.Length; i++)
+ {
+ ArgentaDaily.RowData rowData = XWelfareDocument._argentaDaily.Table[i];
+ bool flag = !this._curArgentaDailyIDList.Contains(rowData.ID);
+ if (flag)
+ {
+ result = false;
+ break;
+ }
+ }
+ return result;
+ }
+
+ public bool IsNiceGirlTasksFinished()
+ {
+ return this.IsAllSpecialGiftTaskFinished() && !this.GetDailyGiftRedPoint();
+ }
+
+ public bool GetSpecialGiftRedPoint()
+ {
+ List<SpActivityTask> activityTaskListByType = XTempActivityDocument.Doc.GetActivityTaskListByType(7u);
+ bool flag = activityTaskListByType != null;
+ if (flag)
+ {
+ for (int i = 0; i < activityTaskListByType.Count; i++)
+ {
+ bool flag2 = activityTaskListByType[i].state == 1u;
+ if (flag2)
+ {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ public bool IsAllSpecialGiftTaskFinished()
+ {
+ List<SpActivityTask> activityTaskListByType = XTempActivityDocument.Doc.GetActivityTaskListByType(7u);
+ bool flag = activityTaskListByType != null;
+ if (flag)
+ {
+ for (int i = 0; i < activityTaskListByType.Count; i++)
+ {
+ bool flag2 = activityTaskListByType[i].state != 2u;
+ if (flag2)
+ {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ public bool GetDailyGiftRedPoint()
+ {
+ return this.GetRedPointState(XSysDefine.XSys_Welfare_NiceGirl);
+ }
+
+ public SeqListRef<uint>? GetArgentTaskRewards(uint taskid)
+ {
+ for (int i = 0; i < XWelfareDocument._argentaTask.Table.Length; i++)
+ {
+ ArgentaTask.RowData rowData = XWelfareDocument._argentaTask.Table[i];
+ bool flag = this._rewardsLevel >= rowData.LevelRange[0] && this._rewardsLevel <= rowData.LevelRange[1];
+ if (flag)
+ {
+ bool flag2 = rowData.TaskID == taskid;
+ if (flag2)
+ {
+ return new SeqListRef<uint>?(rowData.Reward);
+ }
+ }
+ }
+ return null;
+ }
+
+ public void RefreshYYMallRedPoint()
+ {
+ this.RegisterRedPoint(XSysDefine.XSys_Welfare_YyMall, false, true);
+ }
+
+ public void SetBackFlowOpenSystem(List<uint> openIds, List<uint> closedIds)
+ {
+ }
+
+ public void SetBackFlowModal()
+ {
+ this._SholdOpenBackFlowTaskModal = true;
+ }
+
+ public void CallBackFlowModal()
+ {
+ bool sholdOpenBackFlowTaskModal = this._SholdOpenBackFlowTaskModal;
+ if (sholdOpenBackFlowTaskModal)
+ {
+ this._SholdOpenBackFlowTaskModal = false;
+ XSingleton<UiUtility>.singleton.ShowModalDialog(XStringDefineProxy.GetString("BackFlowTaskGift"), XStringDefineProxy.GetString("PVPActivity_Go"), new ButtonClickEventHandler(this.ShowBackFlowTask), 50);
+ }
+ }
+
+ private bool ShowBackFlowTask(IXUIButton button)
+ {
+ XSingleton<UiUtility>.singleton.CloseModalDlg();
+ SeqList<int> sequenceList = XSingleton<XGlobalConfig>.singleton.GetSequenceList("BackFlowTaskConfig", true);
+ XSingleton<XInput>.singleton.LastNpc = XSingleton<XEntityMgr>.singleton.GetNpc((uint)sequenceList[0, 1]);
+ return true;
+ }
+
+ private void SortArgentDailyData()
+ {
+ Array.Sort(XWelfareDocument._argentaDaily.Table, this);
+ }
+
+ public int Compare(object x, object y)
+ {
+ ArgentaDaily.RowData rowData = x as ArgentaDaily.RowData;
+ ArgentaDaily.RowData rowData2 = x as ArgentaDaily.RowData;
+ bool flag = this._curArgentaDailyIDList.Contains(rowData.ID);
+ bool flag2 = this._curArgentaDailyIDList.Contains(rowData2.ID);
+ bool flag3 = flag && !flag2;
+ int result;
+ if (flag3)
+ {
+ result = 1;
+ }
+ else
+ {
+ bool flag4 = !flag && flag2;
+ if (flag4)
+ {
+ result = -1;
+ }
+ else
+ {
+ result = (int)(rowData.ID - rowData2.ID);
+ }
+ }
+ return result;
+ }
+
+ private bool OnActivityUpdate(XEventArgs e)
+ {
+ XActivityTaskUpdatedArgs xactivityTaskUpdatedArgs = e as XActivityTaskUpdatedArgs;
+ bool flag = xactivityTaskUpdatedArgs != null;
+ if (flag)
+ {
+ bool flag2 = xactivityTaskUpdatedArgs.xActID == 7u;
+ if (flag2)
+ {
+ bool flag3 = this.View != null && this.View.IsLoaded() && this.View.IsVisible();
+ if (flag3)
+ {
+ this.RefreshData();
+ }
+ bool bState = this.GetRedPointState(XSysDefine.XSys_Welfare_NiceGirl) || this.GetSpecialGiftRedPoint();
+ XSingleton<XGameSysMgr>.singleton.SetSysRedPointState(XSysDefine.XSys_Welfare_NiceGirl, bState);
+ this.RefreshRedPoint(XSysDefine.XSys_Welfare_NiceGirl, true);
+ }
+ }
+ return true;
+ }
+
+ public int GetPrivilegeFreeRefreshCount(MemberPrivilege privilege)
+ {
+ int num = 0;
+ PayMemberTable.RowData memberPrivilegeConfig = this.GetMemberPrivilegeConfig(privilege);
+ bool flag = memberPrivilegeConfig != null;
+ if (flag)
+ {
+ num += memberPrivilegeConfig.ShopRefresh;
+ }
+ return num;
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ }
+
+ public override void OnEnterSceneFinally()
+ {
+ base.OnEnterSceneFinally();
+ }
+ }
+}
|