From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../XMainClient/UI/XWelfareRewardBackHandler.cs | 1134 ++++++++++++++++++++ 1 file changed, 1134 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/UI/XWelfareRewardBackHandler.cs (limited to 'Client/Assets/Scripts/XMainClient/UI/XWelfareRewardBackHandler.cs') 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.singleton.m_uiTool); + + private XUIPool mRewardItemPool = new XUIPool(XSingleton.singleton.m_uiTool); + + private Dictionary mFindBackInfo = new Dictionary(); + + 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.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.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.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.uuID); + } + List 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(this.compare)); + for (int j = 0; j < findBackInfo.Count; j++) + { + int num = XFastEnumIntEqualityComparer.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(); + } + this.mFindBackInfo[num].goldItemCount[itemID].Add((int)findBackInfo[j].goldCoinFindBackItems[k].itemCount); + } + List>> list = new List>>(this.mFindBackInfo[num].goldItemCount); + list.Sort((KeyValuePair> s1, KeyValuePair> 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(); + } + 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(); + } + this.mFindBackInfo[num].dragonCoinItemCount[itemID2].Add((int)findBackInfo[j].dragonCoinFindBackItems[n].itemCount); + } + } + list = new List>>(this.mFindBackInfo[num].dragonCoinItemCount); + list.Sort((KeyValuePair> s1, KeyValuePair> 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 list = new List(this.mFindBackInfo.Keys); + int i = 0; + while (i < this.mFindBackInfo.Count) + { + bool flag = XFastEnumIntEqualityComparer.ToInt(ItemFindBackType.FATIGUE_GET) <= list[i] && XFastEnumIntEqualityComparer.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.ToInt(ItemFindBackType.DICE_BACK); + if (flag3) + { + int num = int.Parse(XSingleton.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.singleton.XPlayerData == null; + if (!flag2) + { + XSingleton.singleton.AddLog("Findback info num: ", this.mFindBackInfo.Count.ToString(), null, null, null, null, XDebugColor.XDebug_None); + List list = new List(this.mFindBackInfo.Keys); + int num = 0; + uint level = XSingleton.singleton.XPlayerData.Level; + XLevelSealDocument specificDocument = XDocuments.GetSpecificDocument(XLevelSealDocument.uuID); + ulong itemCount = XBagDocument.BagDoc.GetItemCount(XFastEnumIntEqualityComparer.ToInt(ItemEnum.FINDBACK_ITEM)); + bool flag3 = list.Count > 1; + if (flag3) + { + list.Sort(new Comparison(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.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> 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 list2 = new List(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.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.ToInt(ItemEnum.FATIGUE)) || this.mFindBackInfo[list[i]].dragonCoinItemCount.ContainsKey(XFastEnumIntEqualityComparer.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.ToInt(ItemEnum.DICE)) || this.mFindBackInfo[list[i]].dragonCoinItemCount.ContainsKey(XFastEnumIntEqualityComparer.ToInt(ItemEnum.DICE)); + if (flag16) + { + int num2 = int.Parse(XSingleton.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 list = new List(data.goldItemCount.Keys); + bool flag = list.Contains(XFastEnumIntEqualityComparer.ToInt(ItemEnum.EXP)); + bool result; + if (flag) + { + result = true; + } + else + { + list = new List(data.dragonCoinItemCount.Keys); + bool flag2 = list.Contains(XFastEnumIntEqualityComparer.ToInt(ItemEnum.EXP)); + result = flag2; + } + return result; + } + + private bool HasDiceBack(FindBackData data) + { + List list = new List(data.goldItemCount.Keys); + bool flag = list.Contains(XFastEnumIntEqualityComparer.ToInt(ItemEnum.DICE)); + bool result; + if (flag) + { + result = true; + } + else + { + list = new List(data.dragonCoinItemCount.Keys); + bool flag2 = list.Contains(XFastEnumIntEqualityComparer.ToInt(ItemEnum.DICE)); + result = flag2; + } + return result; + } + + private void InitFindBackItem() + { + this.mRewardItemPool.FakeReturnAll(); + bool flag = this.mIsNormalFind; + Dictionary> dictionary; + if (flag) + { + dictionary = this.mCurData.goldItemCount; + } + else + { + dictionary = this.mCurData.dragonCoinItemCount; + } + bool flag2 = dictionary == null || dictionary.Count == 0; + if (!flag2) + { + List list = new List(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.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 = new List>(this.mCurData.goldItemCount.Values); + bool flag2 = list.Count > 0; + if (flag2) + { + return list[0][0]; + } + } + else + { + List> list2 = new List>(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.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.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.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.singleton.ShowSystemTip(XSingleton.singleton.GetString("WELFARE_ITEMMAX"), "fece00"); + flag = true; + } + } + else + { + bool flag5 = this.mWanFindNum > this.mFindMax; + if (flag5) + { + XSingleton.singleton.ShowSystemTip(XSingleton.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.singleton.ShowSystemTip(XSingleton.singleton.GetString("WELFARE_REACH_MAX"), "fece00"); + flag = true; + } + this.mWanFindNum = ((this.mFindMax > 0) ? this.mFindMax : 1); + } + } + bool flag8 = XFastEnumIntEqualityComparer.ToInt(ItemFindBackType.FATIGUE_GET) <= this.mCurData.findid && XFastEnumIntEqualityComparer.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.singleton.ShowSystemTip(XSingleton.singleton.GetString("WELFARE_FATIGE_MAX"), "fece00"); + } + } + } + bool flag11 = XFastEnumIntEqualityComparer.ToInt(ItemFindBackType.DICE_BACK) == this.mCurData.findid; + if (flag11) + { + int num = int.Parse(XSingleton.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.singleton.ShowSystemTip(XSingleton.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.ToInt(ItemFindBackType.FATIGUE_GET) <= this.mCurData.findid && XFastEnumIntEqualityComparer.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.singleton.GetValue("MaxFatigue")); + if (flag3) + { + XSingleton.singleton.ShowFatigueSureDlg(new ButtonClickEventHandler(this.GetFatigueSure)); + return true; + } + bool flag4 = num + this.mWanFindNum * this.GetSingleFindBackNum() >= this.mMaxFatige; + if (flag4) + { + XSingleton.singleton.ShowSystemTip(XSingleton.singleton.GetString("WELFARE_FATIGE_FULL"), "fece00"); + return false; + } + } + bool flag5 = XFastEnumIntEqualityComparer.ToInt(ItemFindBackType.DICE_BACK) == this.mCurData.findid; + if (flag5) + { + int num2 = int.Parse(XSingleton.singleton.GetValue("RiskDiceMaxNum")); + bool flag6 = XSuperRiskDocument.Doc.LeftDiceTime >= num2; + if (flag6) + { + XSingleton.singleton.ShowSystemTip(XSingleton.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.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.ToInt(ItemEnum.GOLD)).ItemName[0]; + string text2 = XBagDocument.GetItemConf(XFastEnumIntEqualityComparer.ToInt(ItemEnum.DRAGON_COIN)).ItemName[0]; + int num8 = num6 * num5; + DlgBase.singleton.SetVisible(true, true); + DlgBase.singleton.SetSingleButtonMode(false); + DlgBase.singleton.SetLabelsWithSymbols(string.Format(XStringDefineProxy.GetString("WELFARE_NOT_ENOUGH"), new object[] + { + num4, + text, + num6, + text2, + num8, + text + }), XStringDefineProxy.GetString("YES"), XStringDefineProxy.GetString("NO")); + DlgBase.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnDoBuy), new ButtonClickEventHandler(this.OnCencelBuy)); + } + else + { + DlgBase.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.singleton.ReqQuickCommonPurchase(ItemEnum.DRAGON_COIN); + } + else + { + DlgBase.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.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.singleton.Send(rpcC2G_ItemFindBack); + DlgBase.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.singleton.Send(rpcC2G_ItemFindBack); + DlgBase.singleton.SetVisible(false, true); + this.mPanelHint.SetVisible(false); + return true; + } + + public bool OnCencelBuy(IXUIButton btn) + { + DlgBase.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.singleton.ShowSystemTip(XSingleton.singleton.GetString("WELFARE_FATIGE_ERROR"), "fece00"); + } + + private void ShowItemTip(IXUISprite sp) + { + XItem mainItem = XBagDocument.MakeXItem((int)sp.ID, false); + XSingleton.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.ToInt(ItemFindBackType.FATIGUE_GET) <= this.mCurData.findid && XFastEnumIntEqualityComparer.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.ToInt(ItemFindBackType.DICE_BACK) == this.mCurData.findid; + if (flag7) + { + int num2 = int.Parse(XSingleton.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.singleton.ShowSystemTip(XSingleton.singleton.GetString("WELFARE_REACH_MAX"), "fece00"); + } + } + } + this.mWanFindNum = num; + input.SetText(num.ToString()); + this.RefreshFindInfo(); + } + } + } +} -- cgit v1.1-26-g67d0