diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/UI/XWelfareRewardBackHandler.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/UI/XWelfareRewardBackHandler.cs | 1134 |
1 files changed, 1134 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/UI/XWelfareRewardBackHandler.cs b/Client/Assets/Scripts/XMainClient/UI/XWelfareRewardBackHandler.cs new file mode 100644 index 00000000..1bce253f --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/UI/XWelfareRewardBackHandler.cs @@ -0,0 +1,1134 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using UILib;
+using UnityEngine;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient.UI
+{
+ internal class XWelfareRewardBackHandler : DlgHandlerBase
+ {
+ protected override string FileName
+ {
+ get
+ {
+ return "GameSystem/Welfare/RewardBackFrame";
+ }
+ }
+
+ private IXUILabel mTipName;
+
+ private IXUIPanel mPanelHint;
+
+ private IXUISprite mTemplate;
+
+ private IXUISprite mNormalFind;
+
+ private IXUISprite mPerfectFind;
+
+ private bool mIsNormalFind = false;
+
+ private bool mIsToolFind = false;
+
+ private IXUISprite mCloseDoFind;
+
+ private IXUIScrollView mScrollView;
+
+ private IXUISprite mButtonsContent;
+
+ private IXUISprite mAilin;
+
+ private IXUILabel mFindBackName;
+
+ private IXUILabel mFindBackInfoLabel;
+
+ private IXUILabel mFindBackNum;
+
+ private IXUIButton mFindBackSub;
+
+ private IXUIButton mFindBackAdd;
+
+ private IXUILabel mCostNum;
+
+ private IXUISprite mMoneyType;
+
+ private IXUIButton mDoFindBack;
+
+ private IXUIButton mCancelFindBack;
+
+ private IXUISprite mItemTemplate;
+
+ private IXUIInput mNumberInput;
+
+ private XUIPool mRewardBackPool = new XUIPool(XSingleton<XGameUI>.singleton.m_uiTool);
+
+ private XUIPool mRewardItemPool = new XUIPool(XSingleton<XGameUI>.singleton.m_uiTool);
+
+ private Dictionary<int, FindBackData> mFindBackInfo = new Dictionary<int, FindBackData>();
+
+ private XWelfareDocument _doc;
+
+ private int mWanFindNum = 0;
+
+ private int mFindMax = 0;
+
+ private int mFindID = 0;
+
+ private FindBackData mCurData = null;
+
+ private int mMaxFatige = 225000;
+
+ private int mFullFatige = 200000;
+
+ private bool mHasInfo = false;
+
+ private int mBackItem2DragonCoin = 5;
+
+ protected override void Init()
+ {
+ base.Init();
+ this._doc = XDocuments.GetSpecificDocument<XWelfareDocument>(XWelfareDocument.uuID);
+ this.mTipName = (base.PanelObject.transform.Find("tipname").GetComponent("XUILabel") as IXUILabel);
+ this.mPanelHint = (base.PanelObject.transform.Find("PanelHint").GetComponent("XUIPanel") as IXUIPanel);
+ this.mTemplate = (base.PanelObject.transform.Find("Reward/RightView/ActivityTpl").GetComponent("XUISprite") as IXUISprite);
+ this.mRewardBackPool.SetupPool(this.mTemplate.parent.gameObject, this.mTemplate.gameObject, 5u, false);
+ this.mNormalFind = (base.PanelObject.transform.Find("buttons/SelectNormal").GetComponent("XUISprite") as IXUISprite);
+ this.mPerfectFind = (base.PanelObject.transform.Find("buttons/SelectPerfect").GetComponent("XUISprite") as IXUISprite);
+ this.mCloseDoFind = (base.PanelObject.transform.Find("PanelHint/back").GetComponent("XUISprite") as IXUISprite);
+ this.mScrollView = (base.PanelObject.transform.Find("Reward/RightView").GetComponent("XUIScrollView") as IXUIScrollView);
+ this.mButtonsContent = (base.PanelObject.transform.Find("buttons").GetComponent("XUISprite") as IXUISprite);
+ this.mAilin = (base.PanelObject.transform.Find("ailin").GetComponent("XUISprite") as IXUISprite);
+ this.mFindBackName = (base.PanelObject.transform.Find("PanelHint/findname").GetComponent("XUILabel") as IXUILabel);
+ this.mFindBackInfoLabel = (base.PanelObject.transform.Find("PanelHint/findinfo").GetComponent("XUILabel") as IXUILabel);
+ this.mFindBackNum = (base.PanelObject.transform.Find("PanelHint/Count/number").GetComponent("XUILabel") as IXUILabel);
+ this.mFindBackSub = (base.PanelObject.transform.Find("PanelHint/Count/Sub").GetComponent("XUIButton") as IXUIButton);
+ this.mFindBackAdd = (base.PanelObject.transform.Find("PanelHint/Count/Add").GetComponent("XUIButton") as IXUIButton);
+ this.mCostNum = (base.PanelObject.transform.Find("PanelHint/MoneyNum").GetComponent("XUILabel") as IXUILabel);
+ this.mMoneyType = (base.PanelObject.transform.Find("PanelHint/MoneyNum/icon").GetComponent("XUISprite") as IXUISprite);
+ this.mDoFindBack = (base.PanelObject.transform.Find("PanelHint/BtnOK").GetComponent("XUIButton") as IXUIButton);
+ this.mCancelFindBack = (base.PanelObject.transform.Find("PanelHint/BtnNO").GetComponent("XUIButton") as IXUIButton);
+ this.mItemTemplate = (base.PanelObject.transform.Find("PanelHint/ItemTemplate").GetComponent("XUISprite") as IXUISprite);
+ this.mRewardItemPool.SetupPool(this.mPanelHint.gameObject, this.mItemTemplate.gameObject, 3u, false);
+ this.mNumberInput = (base.PanelObject.transform.Find("PanelHint/Count").GetComponent("XUIInput") as IXUIInput);
+ }
+
+ protected override void OnShow()
+ {
+ base.OnShow();
+ this.mPanelHint.SetVisible(false);
+ this.mWanFindNum = 0;
+ this.mFindMax = 0;
+ this.mFindID = 0;
+ int.TryParse(XSingleton<XGlobalConfig>.singleton.GetValue("FindBackTicketExchangeDragon"), out this.mBackItem2DragonCoin);
+ }
+
+ public override void RegisterEvent()
+ {
+ base.RegisterEvent();
+ this.mNormalFind.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnFindTypeClick));
+ this.mNormalFind.ID = 0UL;
+ this.mPerfectFind.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnFindTypeClick));
+ this.mPerfectFind.ID = 1UL;
+ this.mCloseDoFind.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnCloseFindBorad));
+ this.mFindBackSub.RegisterClickEventHandler(new ButtonClickEventHandler(this.SubFindCount));
+ this.mFindBackAdd.RegisterClickEventHandler(new ButtonClickEventHandler(this.AddFindCount));
+ this.mDoFindBack.RegisterClickEventHandler(new ButtonClickEventHandler(this.DoFindBack));
+ this.mCancelFindBack.RegisterClickEventHandler(new ButtonClickEventHandler(this.CancelFindBack));
+ this.mNumberInput.RegisterChangeEventHandler(new InputChangeEventHandler(this.InputChangeEventHandler));
+ }
+
+ private int compare(ItemFindBackInfo2Client a, ItemFindBackInfo2Client b)
+ {
+ return b.dayTime.CompareTo(a.dayTime);
+ }
+
+ private int compareids(int a, int b)
+ {
+ bool flag = this.mFindBackInfo[a].maxfindback == 0 && this.mFindBackInfo[b].maxfindback == 0;
+ int result;
+ if (flag)
+ {
+ result = b.CompareTo(a);
+ }
+ else
+ {
+ bool flag2 = this.mFindBackInfo[a].maxfindback == 0;
+ if (flag2)
+ {
+ result = 1;
+ }
+ else
+ {
+ bool flag3 = this.mFindBackInfo[b].maxfindback == 0;
+ if (flag3)
+ {
+ result = -1;
+ }
+ else
+ {
+ bool flag4 = this.GetFindBackCost(this.mFindBackInfo[a], true) == 0 && this.GetFindBackCost(this.mFindBackInfo[a], false) == 0 && this.GetFindBackCost(this.mFindBackInfo[b], true) == 0 && this.GetFindBackCost(this.mFindBackInfo[b], false) == 0;
+ if (flag4)
+ {
+ result = b.CompareTo(a);
+ }
+ else
+ {
+ bool flag5 = this.GetFindBackCost(this.mFindBackInfo[a], true) == 0 && this.GetFindBackCost(this.mFindBackInfo[a], false) == 0;
+ if (flag5)
+ {
+ result = -1;
+ }
+ else
+ {
+ bool flag6 = this.GetFindBackCost(this.mFindBackInfo[b], true) == 0 && this.GetFindBackCost(this.mFindBackInfo[b], false) == 0;
+ if (flag6)
+ {
+ result = 1;
+ }
+ else
+ {
+ bool flag7 = this.HasExpFindBack(this.mFindBackInfo[a]) && this.HasExpFindBack(this.mFindBackInfo[b]);
+ if (flag7)
+ {
+ result = b.CompareTo(a);
+ }
+ else
+ {
+ bool flag8 = this.HasExpFindBack(this.mFindBackInfo[a]);
+ if (flag8)
+ {
+ result = -1;
+ }
+ else
+ {
+ bool flag9 = this.HasExpFindBack(this.mFindBackInfo[b]);
+ if (flag9)
+ {
+ result = 1;
+ }
+ else
+ {
+ bool flag10 = this.HasDiceBack(this.mFindBackInfo[a]) || this.HasDiceBack(this.mFindBackInfo[b]);
+ if (flag10)
+ {
+ int num = int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("RiskDiceMaxNum"));
+ bool flag11 = XSuperRiskDocument.Doc.LeftDiceTime >= num;
+ if (flag11)
+ {
+ bool flag12 = this.HasDiceBack(this.mFindBackInfo[a]);
+ if (flag12)
+ {
+ return 1;
+ }
+ return -1;
+ }
+ }
+ result = b.CompareTo(a);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ private void InitBackData()
+ {
+ bool flag = this._doc == null;
+ if (flag)
+ {
+ this._doc = XDocuments.GetSpecificDocument<XWelfareDocument>(XWelfareDocument.uuID);
+ }
+ List<ItemFindBackInfo2Client> findBackInfo = this._doc.FindBackInfo;
+ this.mFindBackInfo.Clear();
+ this.mHasInfo = false;
+ bool flag2 = findBackInfo != null;
+ if (flag2)
+ {
+ for (int i = 0; i < findBackInfo.Count; i++)
+ {
+ bool flag3 = findBackInfo[i].dragonCoinFindBackItems.Count != 0 || findBackInfo[i].goldCoinFindBackItems.Count != 0;
+ if (flag3)
+ {
+ this.mHasInfo = true;
+ }
+ }
+ }
+ bool flag4 = !this.mHasInfo;
+ if (flag4)
+ {
+ bool flag5 = base.IsVisible();
+ if (flag5)
+ {
+ this.mButtonsContent.SetVisible(false);
+ this.mAilin.SetVisible(true);
+ this.mTipName.SetVisible(false);
+ }
+ }
+ else
+ {
+ bool flag6 = base.IsVisible();
+ if (flag6)
+ {
+ this.mButtonsContent.SetVisible(true);
+ this.mAilin.SetVisible(false);
+ }
+ findBackInfo.Sort(new Comparison<ItemFindBackInfo2Client>(this.compare));
+ for (int j = 0; j < findBackInfo.Count; j++)
+ {
+ int num = XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(findBackInfo[j].id);
+ bool flag7 = this.mFindBackInfo.ContainsKey(num);
+ if (flag7)
+ {
+ this.mFindBackInfo[num].findbackinfo.Add(findBackInfo[j]);
+ }
+ else
+ {
+ FindBackData findBackData = new FindBackData();
+ findBackData.findbackinfo.Add(findBackInfo[j]);
+ this.mFindBackInfo[num] = findBackData;
+ findBackData.findid = num;
+ this.mFindBackInfo[num].isfind = false;
+ this.mFindBackInfo[num].findindex = 0;
+ }
+ this.mFindBackInfo[num].maxfindback += findBackInfo[j].findBackCount;
+ for (int k = 0; k < findBackInfo[j].goldCoinFindBackItems.Count; k++)
+ {
+ int itemID = (int)findBackInfo[j].goldCoinFindBackItems[k].itemID;
+ bool flag8 = findBackInfo[j].findBackCount == 0 && !this.mFindBackInfo[num].isfind;
+ if (flag8)
+ {
+ this.mFindBackInfo[num].findindex++;
+ }
+ bool flag9 = findBackInfo[j].findBackCount != 0;
+ if (flag9)
+ {
+ this.mFindBackInfo[num].isfind = true;
+ }
+ bool flag10 = !this.mFindBackInfo[num].goldItemCount.ContainsKey(itemID);
+ if (flag10)
+ {
+ this.mFindBackInfo[num].goldItemCount[itemID] = new List<int>();
+ }
+ this.mFindBackInfo[num].goldItemCount[itemID].Add((int)findBackInfo[j].goldCoinFindBackItems[k].itemCount);
+ }
+ List<KeyValuePair<int, List<int>>> list = new List<KeyValuePair<int, List<int>>>(this.mFindBackInfo[num].goldItemCount);
+ list.Sort((KeyValuePair<int, List<int>> s1, KeyValuePair<int, List<int>> s2) => s1.Key.CompareTo(s2.Key));
+ this.mFindBackInfo[num].goldItemCount.Clear();
+ for (int l = 0; l < list.Count; l++)
+ {
+ this.mFindBackInfo[num].goldItemCount[list[l].Key] = list[l].Value;
+ }
+ bool flag11 = findBackInfo[j].id == ItemFindBackType.NestBack;
+ bool flag12 = flag11;
+ if (flag12)
+ {
+ ItemBackTable.RowData rewardBackByIndex = XWelfareDocument.GetRewardBackByIndex(num);
+ bool flag13 = rewardBackByIndex != null;
+ if (flag13)
+ {
+ for (int m = 0; m < (int)rewardBackByIndex.ItemDragonCoin.count; m++)
+ {
+ bool flag14 = !this.mFindBackInfo[num].dragonCoinItemCount.ContainsKey(rewardBackByIndex.ItemDragonCoin[m, 0]);
+ if (flag14)
+ {
+ this.mFindBackInfo[num].dragonCoinItemCount[rewardBackByIndex.ItemDragonCoin[m, 0]] = new List<int>();
+ }
+ this.mFindBackInfo[num].dragonCoinItemCount[rewardBackByIndex.ItemDragonCoin[m, 0]].Add(rewardBackByIndex.ItemDragonCoin[m, 1]);
+ }
+ }
+ }
+ else
+ {
+ for (int n = 0; n < findBackInfo[j].dragonCoinFindBackItems.Count; n++)
+ {
+ int itemID2 = (int)findBackInfo[j].dragonCoinFindBackItems[n].itemID;
+ bool flag15 = !this.mFindBackInfo[num].dragonCoinItemCount.ContainsKey(itemID2);
+ if (flag15)
+ {
+ this.mFindBackInfo[num].dragonCoinItemCount[itemID2] = new List<int>();
+ }
+ this.mFindBackInfo[num].dragonCoinItemCount[itemID2].Add((int)findBackInfo[j].dragonCoinFindBackItems[n].itemCount);
+ }
+ }
+ list = new List<KeyValuePair<int, List<int>>>(this.mFindBackInfo[num].dragonCoinItemCount);
+ list.Sort((KeyValuePair<int, List<int>> s1, KeyValuePair<int, List<int>> s2) => s1.Key.CompareTo(s2.Key));
+ this.mFindBackInfo[num].dragonCoinItemCount.Clear();
+ for (int num2 = 0; num2 < list.Count; num2++)
+ {
+ this.mFindBackInfo[num].dragonCoinItemCount[list[num2].Key] = list[num2].Value;
+ }
+ }
+ }
+ }
+
+ public bool HasRedPoint()
+ {
+ List<int> list = new List<int>(this.mFindBackInfo.Keys);
+ int i = 0;
+ while (i < this.mFindBackInfo.Count)
+ {
+ bool flag = XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.FATIGUE_GET) <= list[i] && XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.FATIGUE_BUY) >= list[i];
+ if (!flag)
+ {
+ goto IL_61;
+ }
+ bool flag2 = (int)XBagDocument.BagDoc.GetVirtualItemCount(ItemEnum.FATIGUE) >= this.mFullFatige;
+ if (!flag2)
+ {
+ goto IL_61;
+ }
+ IL_DF:
+ i++;
+ continue;
+ IL_61:
+ bool flag3 = list[i] == XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.DICE_BACK);
+ if (flag3)
+ {
+ int num = int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("RiskDiceMaxNum"));
+ bool flag4 = XSuperRiskDocument.Doc.LeftDiceTime >= num;
+ if (flag4)
+ {
+ goto IL_DF;
+ }
+ }
+ bool flag5 = this.mFindBackInfo[list[i]].maxfindback > 0;
+ if (flag5)
+ {
+ return !this._doc.GetFirstClick(XSysDefine.XSyS_Welfare_RewardBack);
+ }
+ goto IL_DF;
+ }
+ return false;
+ }
+
+ public override void RefreshData()
+ {
+ this.InitBackData();
+ bool flag = !base.IsVisible();
+ if (!flag)
+ {
+ this.mRewardBackPool.ReturnAll(false);
+ bool flag2 = XSingleton<XAttributeMgr>.singleton.XPlayerData == null;
+ if (!flag2)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Findback info num: ", this.mFindBackInfo.Count.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ List<int> list = new List<int>(this.mFindBackInfo.Keys);
+ int num = 0;
+ uint level = XSingleton<XAttributeMgr>.singleton.XPlayerData.Level;
+ XLevelSealDocument specificDocument = XDocuments.GetSpecificDocument<XLevelSealDocument>(XLevelSealDocument.uuID);
+ ulong itemCount = XBagDocument.BagDoc.GetItemCount(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.FINDBACK_ITEM));
+ bool flag3 = list.Count > 1;
+ if (flag3)
+ {
+ list.Sort(new Comparison<int>(this.compareids));
+ }
+ for (int i = 0; i < this.mFindBackInfo.Count; i++)
+ {
+ bool flag4 = ((this.mIsNormalFind && this.mFindBackInfo[list[i]].goldItemCount.Count == 0) || (!this.mIsNormalFind && this.mFindBackInfo[list[i]].dragonCoinItemCount.Count == 0)) && (this.GetFindBackCost(this.mFindBackInfo[list[i]], true) != 0 || this.GetFindBackCost(this.mFindBackInfo[list[i]], false) != 0);
+ if (!flag4)
+ {
+ bool flag5 = (level == 32u || level == 40u || level == 50u) && specificDocument.IsInLevelSeal() && list[i] == 4;
+ if (!flag5)
+ {
+ GameObject gameObject = this.mRewardBackPool.FetchGameObject(false);
+ gameObject.transform.localPosition = new Vector3(this.mRewardBackPool.TplPos.x, this.mRewardBackPool.TplPos.y - (float)(num * this.mRewardBackPool.TplHeight), 0f);
+ num++;
+ XSingleton<XDebug>.singleton.AddLog("The item index: ", num.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ IXUISprite ixuisprite = gameObject.transform.Find("Item").GetComponent("XUISprite") as IXUISprite;
+ IXUISprite ixuisprite2 = gameObject.transform.Find("Item1").GetComponent("XUISprite") as IXUISprite;
+ IXUISprite ixuisprite3 = gameObject.transform.Find("Item2").GetComponent("XUISprite") as IXUISprite;
+ IXUILabel ixuilabel = gameObject.transform.Find("name").GetComponent("XUILabel") as IXUILabel;
+ IXUILabel ixuilabel2 = gameObject.transform.Find("desc").GetComponent("XUILabel") as IXUILabel;
+ IXUIButton ixuibutton = gameObject.transform.Find("Go").GetComponent("XUIButton") as IXUIButton;
+ IXUIButton ixuibutton2 = gameObject.transform.Find("Free").GetComponent("XUIButton") as IXUIButton;
+ IXUISprite ixuisprite4 = gameObject.transform.Find("Go/icon").GetComponent("XUISprite") as IXUISprite;
+ IXUISprite ixuisprite5 = gameObject.transform.Find("GoBoader").GetComponent("XUISprite") as IXUISprite;
+ ixuibutton.RegisterClickEventHandler(new ButtonClickEventHandler(this.TryFindBack));
+ ixuibutton.ID = (ulong)((long)list[i]);
+ ixuibutton2.RegisterClickEventHandler(new ButtonClickEventHandler(this.TryFindBack));
+ ixuibutton2.ID = (ulong)((long)list[i]);
+ ixuisprite5.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.WarningFatigeFull));
+ bool flag6 = this.GetFindBackCost(this.mFindBackInfo[list[i]], true) == 0 && this.GetFindBackCost(this.mFindBackInfo[list[i]], false) == 0;
+ Dictionary<int, List<int>> dictionary;
+ if (flag6)
+ {
+ ixuibutton.SetVisible(false);
+ ixuibutton2.SetVisible(true);
+ ixuibutton = ixuibutton2;
+ bool flag7 = this.mIsNormalFind;
+ if (flag7)
+ {
+ dictionary = this.mFindBackInfo[list[i]].goldItemCount;
+ }
+ else
+ {
+ dictionary = this.mFindBackInfo[list[i]].dragonCoinItemCount;
+ }
+ }
+ else
+ {
+ ixuibutton.SetVisible(true);
+ ixuibutton2.SetVisible(false);
+ bool flag8 = this.mIsNormalFind;
+ if (flag8)
+ {
+ dictionary = this.mFindBackInfo[list[i]].goldItemCount;
+ ixuisprite4.SetSprite("icon-1");
+ }
+ else
+ {
+ dictionary = this.mFindBackInfo[list[i]].dragonCoinItemCount;
+ this.mWanFindNum = 1;
+ this.mCurData = this.mFindBackInfo[list[i]];
+ bool flag9 = itemCount > 0UL && (int)itemCount * this.mBackItem2DragonCoin >= this.GetCurCost();
+ if (flag9)
+ {
+ ixuisprite4.SetSprite("icon-18");
+ }
+ else
+ {
+ ixuisprite4.SetSprite("icon-28");
+ }
+ }
+ }
+ bool flag10 = dictionary == null || dictionary.Count == 0;
+ if (flag10)
+ {
+ return;
+ }
+ IXUISprite[] array = new IXUISprite[]
+ {
+ ixuisprite,
+ ixuisprite2,
+ ixuisprite3
+ };
+ for (int j = 0; j < array.Length; j++)
+ {
+ array[j].SetVisible(false);
+ }
+ List<int> list2 = new List<int>(dictionary.Keys);
+ for (int k = 0; k < dictionary.Count; k++)
+ {
+ bool flag11 = k >= 3;
+ if (flag11)
+ {
+ break;
+ }
+ array[k].SetVisible(true);
+ XItem xitem = XBagDocument.MakeXItem(list2[k], false);
+ xitem.itemCount = dictionary[list2[k]][0];
+ XSingleton<XItemDrawerMgr>.singleton.DrawItem(array[k].gameObject, xitem);
+ IXUISprite ixuisprite6 = array[k].transform.Find("Icon").GetComponent("XUISprite") as IXUISprite;
+ ixuisprite6.ID = (ulong)((long)list2[k]);
+ ixuisprite6.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.ShowItemTip));
+ }
+ ItemBackTable.RowData rewardBackByIndex = XWelfareDocument.GetRewardBackByIndex(list[i]);
+ bool flag12 = rewardBackByIndex != null;
+ if (flag12)
+ {
+ ixuilabel.SetText(rewardBackByIndex.SystemName);
+ ixuilabel2.SetText(rewardBackByIndex.Desc);
+ }
+ ixuisprite5.SetVisible(false);
+ bool flag13 = this.mFindBackInfo[list[i]].maxfindback <= 0;
+ if (flag13)
+ {
+ ixuibutton.SetEnable(false, false);
+ }
+ else
+ {
+ bool flag14 = this.mFindBackInfo[list[i]].goldItemCount.ContainsKey(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.FATIGUE)) || this.mFindBackInfo[list[i]].dragonCoinItemCount.ContainsKey(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.FATIGUE));
+ if (flag14)
+ {
+ bool flag15 = XBagDocument.BagDoc.GetVirtualItemCount(ItemEnum.FATIGUE) >= 200UL;
+ if (flag15)
+ {
+ ixuibutton.SetEnable(false, false);
+ ixuisprite5.SetVisible(true);
+ }
+ else
+ {
+ ixuibutton.SetEnable(true, false);
+ ixuisprite5.SetVisible(false);
+ }
+ }
+ else
+ {
+ bool flag16 = this.mFindBackInfo[list[i]].goldItemCount.ContainsKey(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.DICE)) || this.mFindBackInfo[list[i]].dragonCoinItemCount.ContainsKey(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.DICE));
+ if (flag16)
+ {
+ int num2 = int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("RiskDiceMaxNum"));
+ bool flag17 = XSuperRiskDocument.Doc.LeftDiceTime >= num2;
+ if (flag17)
+ {
+ ixuibutton.SetEnable(false, false);
+ }
+ else
+ {
+ ixuibutton.SetEnable(true, false);
+ }
+ }
+ else
+ {
+ ixuibutton.SetEnable(true, false);
+ }
+ }
+ }
+ }
+ }
+ }
+ bool flag18 = XBagDocument.BagDoc.GetVirtualItemCount(ItemEnum.FATIGUE) >= 200UL && this.mHasInfo;
+ if (flag18)
+ {
+ this.mTipName.SetVisible(true);
+ }
+ else
+ {
+ this.mTipName.SetVisible(false);
+ }
+ }
+ }
+ }
+
+ public void OnFindTypeClick(IXUISprite sp)
+ {
+ bool flag = sp.ID == 1UL;
+ if (flag)
+ {
+ this.mIsNormalFind = true;
+ }
+ else
+ {
+ this.mIsNormalFind = false;
+ }
+ this.RefreshData();
+ this.mScrollView.SetPosition(0f);
+ }
+
+ public void OnCloseFindBorad(IXUISprite sp)
+ {
+ this.mPanelHint.SetVisible(false);
+ }
+
+ private int GetFindBackCost(FindBackData data, bool isdragoncoin)
+ {
+ int num = 0;
+ for (int i = 0; i < data.findbackinfo.Count; i++)
+ {
+ if (isdragoncoin)
+ {
+ num += data.findbackinfo[i].dragonCoinCost;
+ }
+ else
+ {
+ num += data.findbackinfo[i].goldCoinCost;
+ }
+ }
+ return num;
+ }
+
+ private bool HasExpFindBack(FindBackData data)
+ {
+ List<int> list = new List<int>(data.goldItemCount.Keys);
+ bool flag = list.Contains(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.EXP));
+ bool result;
+ if (flag)
+ {
+ result = true;
+ }
+ else
+ {
+ list = new List<int>(data.dragonCoinItemCount.Keys);
+ bool flag2 = list.Contains(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.EXP));
+ result = flag2;
+ }
+ return result;
+ }
+
+ private bool HasDiceBack(FindBackData data)
+ {
+ List<int> list = new List<int>(data.goldItemCount.Keys);
+ bool flag = list.Contains(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.DICE));
+ bool result;
+ if (flag)
+ {
+ result = true;
+ }
+ else
+ {
+ list = new List<int>(data.dragonCoinItemCount.Keys);
+ bool flag2 = list.Contains(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.DICE));
+ result = flag2;
+ }
+ return result;
+ }
+
+ private void InitFindBackItem()
+ {
+ this.mRewardItemPool.FakeReturnAll();
+ bool flag = this.mIsNormalFind;
+ Dictionary<int, List<int>> dictionary;
+ if (flag)
+ {
+ dictionary = this.mCurData.goldItemCount;
+ }
+ else
+ {
+ dictionary = this.mCurData.dragonCoinItemCount;
+ }
+ bool flag2 = dictionary == null || dictionary.Count == 0;
+ if (!flag2)
+ {
+ List<int> list = new List<int>(dictionary.Keys);
+ for (int i = 0; i < dictionary.Count; i++)
+ {
+ GameObject gameObject = this.mRewardItemPool.FetchGameObject(false);
+ XItem xitem = XBagDocument.MakeXItem(list[i], false);
+ ItemBackTable.RowData rewardBackByIndex = XWelfareDocument.GetRewardBackByIndex(this.mCurData.findid);
+ bool flag3 = rewardBackByIndex != null;
+ if (flag3)
+ {
+ int num = Mathf.Min(this.mCurData.findbackinfo[0].findBackCount, this.mWanFindNum);
+ int num2 = (num == this.mWanFindNum) ? 0 : (this.mWanFindNum - num);
+ xitem.itemCount = num * dictionary[list[i]][0];
+ int num3 = 1;
+ for (int j = 0; j < num2 / rewardBackByIndex.count; j++)
+ {
+ bool flag4 = j + 1 < dictionary[list[i]].Count;
+ if (flag4)
+ {
+ xitem.itemCount += dictionary[list[i]][j + 1] * rewardBackByIndex.count;
+ num3++;
+ }
+ }
+ bool flag5 = num3 < dictionary[list[i]].Count;
+ if (flag5)
+ {
+ xitem.itemCount += num2 % rewardBackByIndex.count * dictionary[list[i]][num3];
+ }
+ }
+ int num4 = (i % 2 == 0) ? 1 : -1;
+ int num5 = this.mRewardItemPool.TplWidth / 2;
+ bool flag6 = list.Count % 2 == 1;
+ if (flag6)
+ {
+ num5 = 0;
+ }
+ xitem.Description.ItemDrawer.DrawItem(gameObject, xitem, true);
+ gameObject.transform.localPosition = new Vector3(this.mRewardItemPool.TplPos.x + (float)(num4 * ((i + 1) / 2) * this.mRewardItemPool.TplWidth) + (float)num5, this.mRewardItemPool.TplPos.y, this.mRewardItemPool.TplPos.z);
+ IXUISprite ixuisprite = gameObject.GetComponent("XUISprite") as IXUISprite;
+ ixuisprite.ID = (ulong)((long)list[i]);
+ ixuisprite.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.ShowItemTip));
+ }
+ }
+ }
+
+ private bool TryFindBack(IXUIButton btn)
+ {
+ this.mFindID = (int)btn.ID;
+ this.mWanFindNum = 1;
+ this.mCurData = this.mFindBackInfo[this.mFindID];
+ this.mFindMax = this.mCurData.maxfindback;
+ this.mPanelHint.SetVisible(true);
+ this.mRewardItemPool.ReturnAll(false);
+ ulong itemCount = XBagDocument.BagDoc.GetItemCount(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.FINDBACK_ITEM));
+ bool flag = !this.mIsNormalFind && (int)itemCount * this.mBackItem2DragonCoin >= this.GetCurCost();
+ if (flag)
+ {
+ this.mIsToolFind = true;
+ }
+ else
+ {
+ this.mIsToolFind = false;
+ }
+ this.RefreshFindInfo();
+ return true;
+ }
+
+ private int GetCurCost()
+ {
+ int num = 0;
+ int num2 = this.mWanFindNum;
+ bool flag = this.mIsNormalFind;
+ if (flag)
+ {
+ for (int i = 0; i < this.mCurData.findbackinfo.Count; i++)
+ {
+ int num3 = (num2 < this.mCurData.findbackinfo[i].findBackCount) ? num2 : this.mCurData.findbackinfo[i].findBackCount;
+ bool flag2 = num2 > 0;
+ if (!flag2)
+ {
+ break;
+ }
+ num += num3 * this.mCurData.findbackinfo[i].goldCoinCost;
+ num2 -= this.mCurData.findbackinfo[i].findBackCount;
+ }
+ }
+ else
+ {
+ for (int j = 0; j < this.mCurData.findbackinfo.Count; j++)
+ {
+ int num4 = (num2 < this.mCurData.findbackinfo[j].findBackCount) ? num2 : this.mCurData.findbackinfo[j].findBackCount;
+ bool flag3 = num2 > 0;
+ if (!flag3)
+ {
+ break;
+ }
+ num += num4 * this.mCurData.findbackinfo[j].dragonCoinCost;
+ num2 -= this.mCurData.findbackinfo[j].findBackCount;
+ }
+ }
+ return num;
+ }
+
+ public int GetSingleFindBackNum()
+ {
+ bool flag = this.mIsNormalFind;
+ if (flag)
+ {
+ List<List<int>> list = new List<List<int>>(this.mCurData.goldItemCount.Values);
+ bool flag2 = list.Count > 0;
+ if (flag2)
+ {
+ return list[0][0];
+ }
+ }
+ else
+ {
+ List<List<int>> list2 = new List<List<int>>(this.mCurData.dragonCoinItemCount.Values);
+ bool flag3 = list2.Count > 0;
+ if (flag3)
+ {
+ return list2[0][0];
+ }
+ }
+ return 0;
+ }
+
+ private void RefreshFindInfo()
+ {
+ this.mFindBackNum.SetText(this.mWanFindNum.ToString());
+ this.mCostNum.SetText(this.GetCurCost().ToString());
+ bool flag = this.mIsNormalFind;
+ if (flag)
+ {
+ this.mMoneyType.SetSprite("icon-1");
+ this.mFindBackName.SetText(XSingleton<XStringTable>.singleton.GetString("WELFARE_GOLD_BACK"));
+ }
+ else
+ {
+ bool flag2 = !this.mIsToolFind;
+ if (flag2)
+ {
+ this.mMoneyType.SetSprite("icon-28");
+ }
+ else
+ {
+ this.mMoneyType.SetSprite("icon-18");
+ this.mCostNum.SetText((this.GetCurCost() / this.mBackItem2DragonCoin).ToString());
+ }
+ this.mFindBackName.SetText(XSingleton<XStringTable>.singleton.GetString("WELFARE_DRAGON_BACK"));
+ }
+ this.InitFindBackItem();
+ }
+
+ private bool SubFindCount(IXUIButton btn)
+ {
+ this.mWanFindNum--;
+ bool flag = this.mWanFindNum <= 0;
+ if (flag)
+ {
+ this.mWanFindNum = 1;
+ }
+ this.mNumberInput.SetText(this.mWanFindNum.ToString());
+ this.RefreshFindInfo();
+ return true;
+ }
+
+ private bool AddFindCount(IXUIButton btn)
+ {
+ this.mWanFindNum++;
+ bool flag = false;
+ ulong itemCount = XBagDocument.BagDoc.GetItemCount(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.FINDBACK_ITEM));
+ bool flag2 = this.mIsToolFind;
+ if (flag2)
+ {
+ bool flag3 = this.mWanFindNum <= this.mFindMax;
+ if (flag3)
+ {
+ bool flag4 = this.GetCurCost() > (int)itemCount * this.mBackItem2DragonCoin;
+ if (flag4)
+ {
+ this.mWanFindNum--;
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("WELFARE_ITEMMAX"), "fece00");
+ flag = true;
+ }
+ }
+ else
+ {
+ bool flag5 = this.mWanFindNum > this.mFindMax;
+ if (flag5)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("WELFARE_REACH_MAX"), "fece00");
+ flag = true;
+ }
+ this.mWanFindNum = ((this.mFindMax > 0) ? this.mFindMax : 1);
+ }
+ }
+ else
+ {
+ bool flag6 = this.mWanFindNum >= this.mFindMax;
+ if (flag6)
+ {
+ bool flag7 = this.mWanFindNum > this.mFindMax;
+ if (flag7)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("WELFARE_REACH_MAX"), "fece00");
+ flag = true;
+ }
+ this.mWanFindNum = ((this.mFindMax > 0) ? this.mFindMax : 1);
+ }
+ }
+ bool flag8 = XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.FATIGUE_GET) <= this.mCurData.findid && XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.FATIGUE_BUY) >= this.mCurData.findid;
+ if (flag8)
+ {
+ bool flag9 = (int)XBagDocument.BagDoc.GetVirtualItemCount(ItemEnum.FATIGUE) + (this.mWanFindNum - 1) * this.GetSingleFindBackNum() >= this.mFullFatige && this.mWanFindNum > 1;
+ if (flag9)
+ {
+ this.mWanFindNum--;
+ bool flag10 = !flag;
+ if (flag10)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("WELFARE_FATIGE_MAX"), "fece00");
+ }
+ }
+ }
+ bool flag11 = XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.DICE_BACK) == this.mCurData.findid;
+ if (flag11)
+ {
+ int num = int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("RiskDiceMaxNum"));
+ bool flag12 = XSuperRiskDocument.Doc.LeftDiceTime + this.mWanFindNum * this.GetSingleFindBackNum() > num && this.mWanFindNum > 1;
+ if (flag12)
+ {
+ this.mWanFindNum--;
+ bool flag13 = !flag;
+ if (flag13)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("WELFARE_REACH_MAX"), "fece00");
+ }
+ }
+ }
+ this.mNumberInput.SetText(this.mWanFindNum.ToString());
+ this.RefreshFindInfo();
+ return true;
+ }
+
+ private bool DoFindBack(IXUIButton btn)
+ {
+ bool flag = this.mWanFindNum == 0;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag2 = XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.FATIGUE_GET) <= this.mCurData.findid && XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.FATIGUE_BUY) >= this.mCurData.findid;
+ if (flag2)
+ {
+ int num = (int)XBagDocument.BagDoc.GetVirtualItemCount(ItemEnum.FATIGUE);
+ bool flag3 = num + this.mWanFindNum * this.GetSingleFindBackNum() > int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("MaxFatigue"));
+ if (flag3)
+ {
+ XSingleton<UiUtility>.singleton.ShowFatigueSureDlg(new ButtonClickEventHandler(this.GetFatigueSure));
+ return true;
+ }
+ bool flag4 = num + this.mWanFindNum * this.GetSingleFindBackNum() >= this.mMaxFatige;
+ if (flag4)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("WELFARE_FATIGE_FULL"), "fece00");
+ return false;
+ }
+ }
+ bool flag5 = XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.DICE_BACK) == this.mCurData.findid;
+ if (flag5)
+ {
+ int num2 = int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("RiskDiceMaxNum"));
+ bool flag6 = XSuperRiskDocument.Doc.LeftDiceTime >= num2;
+ if (flag6)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("WELFARE_REACH_MAX"), "fece00");
+ return false;
+ }
+ }
+ bool flag7 = this.mIsNormalFind;
+ if (flag7)
+ {
+ int num3 = (int)XBagDocument.BagDoc.GetVirtualItemCount(ItemEnum.GOLD);
+ bool flag8 = num3 < this.GetCurCost();
+ if (flag8)
+ {
+ int num4 = this.GetCurCost() - num3;
+ int num5 = int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("GragonCoinExchangeGold"));
+ int num6 = (num4 % num5 == 0) ? (num4 / num5) : (num4 / num5 + 1);
+ int num7 = (int)XBagDocument.BagDoc.GetVirtualItemCount(ItemEnum.DRAGON_COIN);
+ bool flag9 = num7 > num6;
+ if (flag9)
+ {
+ string text = XBagDocument.GetItemConf(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.GOLD)).ItemName[0];
+ string text2 = XBagDocument.GetItemConf(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.DRAGON_COIN)).ItemName[0];
+ int num8 = num6 * num5;
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(true, true);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetSingleButtonMode(false);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetLabelsWithSymbols(string.Format(XStringDefineProxy.GetString("WELFARE_NOT_ENOUGH"), new object[]
+ {
+ num4,
+ text,
+ num6,
+ text2,
+ num8,
+ text
+ }), XStringDefineProxy.GetString("YES"), XStringDefineProxy.GetString("NO"));
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnDoBuy), new ButtonClickEventHandler(this.OnCencelBuy));
+ }
+ else
+ {
+ DlgBase<XFpStrengthenView, XFPStrengthenBehaviour>.singleton.ShowContent(FunctionDef.JINBI);
+ }
+ return false;
+ }
+ }
+ else
+ {
+ int num9 = (int)XBagDocument.BagDoc.GetVirtualItemCount(ItemEnum.DRAGON_COIN);
+ bool flag10 = !this.mIsToolFind && num9 < this.GetCurCost();
+ if (flag10)
+ {
+ int num10 = (int)XBagDocument.BagDoc.GetVirtualItemCount(ItemEnum.DIAMOND);
+ bool flag11 = num10 > this.GetCurCost() - num9;
+ if (flag11)
+ {
+ DlgBase<XPurchaseView, XPurchaseBehaviour>.singleton.ReqQuickCommonPurchase(ItemEnum.DRAGON_COIN);
+ }
+ else
+ {
+ DlgBase<XFpStrengthenView, XFPStrengthenBehaviour>.singleton.ShowContent(FunctionDef.LONGBI);
+ }
+ return false;
+ }
+ }
+ this.mPanelHint.SetVisible(false);
+ RpcC2G_ItemFindBack rpcC2G_ItemFindBack = new RpcC2G_ItemFindBack();
+ rpcC2G_ItemFindBack.oArg.id = (ItemFindBackType)this.mCurData.findid;
+ rpcC2G_ItemFindBack.oArg.findBackCount = this.mWanFindNum;
+ rpcC2G_ItemFindBack.oArg.backType = 1 + (this.mIsNormalFind ? 1 : (this.mIsToolFind ? 2 : 0));
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_ItemFindBack);
+ result = true;
+ }
+ return result;
+ }
+
+ private bool GetFatigueSure(IXUIButton btn)
+ {
+ this.mPanelHint.SetVisible(false);
+ RpcC2G_ItemFindBack rpcC2G_ItemFindBack = new RpcC2G_ItemFindBack();
+ rpcC2G_ItemFindBack.oArg.id = (ItemFindBackType)this.mCurData.findid;
+ rpcC2G_ItemFindBack.oArg.findBackCount = this.mWanFindNum;
+ rpcC2G_ItemFindBack.oArg.backType = 1 + (this.mIsNormalFind ? 1 : (this.mIsToolFind ? 2 : 0));
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_ItemFindBack);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
+ return true;
+ }
+
+ public bool OnDoBuy(IXUIButton btn)
+ {
+ RpcC2G_ItemFindBack rpcC2G_ItemFindBack = new RpcC2G_ItemFindBack();
+ rpcC2G_ItemFindBack.oArg.id = (ItemFindBackType)this.mCurData.findid;
+ rpcC2G_ItemFindBack.oArg.findBackCount = this.mWanFindNum;
+ rpcC2G_ItemFindBack.oArg.backType = 1 + (this.mIsNormalFind ? 1 : (this.mIsToolFind ? 2 : 0));
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_ItemFindBack);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
+ this.mPanelHint.SetVisible(false);
+ return true;
+ }
+
+ public bool OnCencelBuy(IXUIButton btn)
+ {
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
+ this.mPanelHint.SetVisible(false);
+ return true;
+ }
+
+ private bool CancelFindBack(IXUIButton btn)
+ {
+ this.mPanelHint.SetVisible(false);
+ return true;
+ }
+
+ private void WarningFatigeFull(IXUISprite sp)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("WELFARE_FATIGE_ERROR"), "fece00");
+ }
+
+ private void ShowItemTip(IXUISprite sp)
+ {
+ XItem mainItem = XBagDocument.MakeXItem((int)sp.ID, false);
+ XSingleton<UiUtility>.singleton.ShowTooltipDialog(mainItem, null, sp, false, 0u);
+ }
+
+ private void InputChangeEventHandler(IXUIInput input)
+ {
+ bool flag = this.mCurData == null;
+ if (!flag)
+ {
+ bool flag2 = false;
+ int num = 1;
+ int.TryParse(input.GetText(), out num);
+ bool flag3 = num >= this.mFindMax;
+ if (flag3)
+ {
+ bool flag4 = num > this.mFindMax;
+ if (flag4)
+ {
+ flag2 = true;
+ }
+ num = ((this.mFindMax > 0) ? this.mFindMax : 1);
+ }
+ bool flag5 = XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.FATIGUE_GET) <= this.mCurData.findid && XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.FATIGUE_BUY) >= this.mCurData.findid;
+ if (flag5)
+ {
+ bool flag6 = (int)XBagDocument.BagDoc.GetVirtualItemCount(ItemEnum.FATIGUE) + (num - 1) * this.GetSingleFindBackNum() >= this.mFullFatige && num > 1 && this.GetSingleFindBackNum() > 0;
+ if (flag6)
+ {
+ num = (this.mFullFatige - (int)XBagDocument.BagDoc.GetVirtualItemCount(ItemEnum.FATIGUE)) / this.GetSingleFindBackNum();
+ }
+ }
+ bool flag7 = XFastEnumIntEqualityComparer<ItemFindBackType>.ToInt(ItemFindBackType.DICE_BACK) == this.mCurData.findid;
+ if (flag7)
+ {
+ int num2 = int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("RiskDiceMaxNum"));
+ bool flag8 = XSuperRiskDocument.Doc.LeftDiceTime + num * this.GetSingleFindBackNum() > num2 && num > 1 && this.GetSingleFindBackNum() > 0;
+ if (flag8)
+ {
+ num = (num2 - XSuperRiskDocument.Doc.LeftDiceTime) / this.GetSingleFindBackNum();
+ bool flag9 = !flag2;
+ if (flag9)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("WELFARE_REACH_MAX"), "fece00");
+ }
+ }
+ }
+ this.mWanFindNum = num;
+ input.SetText(num.ToString());
+ this.RefreshFindInfo();
+ }
+ }
+ }
+}
|