diff options
| author | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
|---|---|---|
| committer | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
| commit | 6eb915c129fc90c6f4c82ae097dd6ffad5239efc (patch) | |
| tree | 7dd2be50edf41f36b60fac84696e731c13afe617 /Client/Assets/Scripts/XMainClient/UI/ActivityTeamTowerSingleDlg.cs | |
+scripts
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/UI/ActivityTeamTowerSingleDlg.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/UI/ActivityTeamTowerSingleDlg.cs | 1289 |
1 files changed, 1289 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/UI/ActivityTeamTowerSingleDlg.cs b/Client/Assets/Scripts/XMainClient/UI/ActivityTeamTowerSingleDlg.cs new file mode 100644 index 00000000..03c53a6a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/UI/ActivityTeamTowerSingleDlg.cs @@ -0,0 +1,1289 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using UILib;
+using UnityEngine;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient.UI
+{
+ internal class ActivityTeamTowerSingleDlg : DlgBase<ActivityTeamTowerSingleDlg, ActivityTeamTowerSingleDlgBehaviour>
+ {
+ public bool SweepFinished
+ {
+ get
+ {
+ return this._sweep_finished;
+ }
+ set
+ {
+ this._sweep_finished = value;
+ }
+ }
+
+ public override string fileName
+ {
+ get
+ {
+ return "Hall/TeamTowerNewDlg";
+ }
+ }
+
+ public override int layer
+ {
+ get
+ {
+ return 1;
+ }
+ }
+
+ public override bool autoload
+ {
+ get
+ {
+ return true;
+ }
+ }
+
+ public override bool hideMainMenu
+ {
+ get
+ {
+ return true;
+ }
+ }
+
+ public override bool pushstack
+ {
+ get
+ {
+ return true;
+ }
+ }
+
+ public override bool fullscreenui
+ {
+ get
+ {
+ return true;
+ }
+ }
+
+ public override int sysid
+ {
+ get
+ {
+ return XFastEnumIntEqualityComparer<XSysDefine>.ToInt(XSysDefine.XSys_Activity_TeamTowerSingle);
+ }
+ }
+
+ private XExpeditionDocument _doc;
+
+ private uint _count_timer;
+
+ private bool _in_sweeping = false;
+
+ private float _time_left = 0f;
+
+ private bool _sweep_finished = false;
+
+ private float _sweep_time = 0f;
+
+ private int _sweep_level = 0;
+
+ private int _tower_max_floor = 100;
+
+ private uint _show_sweep_timer = 0u;
+
+ private float _effect_result = 1f;
+
+ private List<float> _random_list = new List<float>();
+
+ private List<int> _refresh_cost = new List<int>();
+
+ private List<int> _refresh_money = new List<int>();
+
+ private List<int> frames = new List<int>();
+
+ private XElapseTimer timePass = new XElapseTimer();
+
+ public ActivityTeamTowerSingleDlg.State state = ActivityTeamTowerSingleDlg.State.None;
+
+ private int _play_count = 0;
+
+ private int _acc_time = 0;
+
+ private int _all_count = 35;
+
+ private bool _is_getting_reward = false;
+
+ public enum State
+ {
+ BEGIN,
+ PLAY,
+ Idle,
+ FADE,
+ None
+ }
+
+ protected override void Init()
+ {
+ this._doc = XDocuments.GetSpecificDocument<XExpeditionDocument>(XExpeditionDocument.uuID);
+ this._doc.TeamTowerSingleView = this;
+ string value = XSingleton<XGlobalConfig>.singleton.GetValue("SweepTowerTime");
+ string[] array = value.Split(new char[]
+ {
+ '|'
+ });
+ this._sweep_time = float.Parse(array[0].Split(new char[]
+ {
+ '='
+ })[1]);
+ string value2 = XSingleton<XGlobalConfig>.singleton.GetValue("RefreshSweepRand");
+ string[] array2 = value2.Split(new char[]
+ {
+ '|'
+ });
+ this._random_list.Clear();
+ for (int i = 0; i < array2.Length; i++)
+ {
+ this._random_list.Add((float)int.Parse(array2[i].Split(new char[]
+ {
+ '='
+ })[0]) / 100f);
+ }
+ string value3 = XSingleton<XGlobalConfig>.singleton.GetValue("RefreshSweepCost");
+ string[] array3 = value3.Split(new char[]
+ {
+ '|'
+ });
+ this._refresh_cost.Clear();
+ this._refresh_money.Clear();
+ for (int j = 0; j < array3.Length; j++)
+ {
+ string[] array4 = array3[j].Split(new char[]
+ {
+ '='
+ });
+ this._refresh_cost.Add(int.Parse(array4[1]));
+ this._refresh_money.Add(int.Parse(array4[0]));
+ }
+ this.frames.Clear();
+ string value4 = XSingleton<XGlobalConfig>.singleton.GetValue("TeamTower_Ani");
+ string[] array5 = value4.Split(new char[]
+ {
+ '|'
+ });
+ for (int k = 0; k < array5.Length; k++)
+ {
+ this.frames.Add(int.Parse(array5[k]));
+ }
+ this._all_count = this.frames.Count;
+ }
+
+ public override void RegisterEvent()
+ {
+ base.RegisterEvent();
+ base.uiBehaviour.mMainClose.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnCloseDlg));
+ base.uiBehaviour.m_Help.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnHelpClicked));
+ base.uiBehaviour.mSweepBtn.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnShowSweepFrame));
+ base.uiBehaviour.mSingleDoSweep.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnQuickStartSweep));
+ base.uiBehaviour.mDoubleSweep.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnStartSweep));
+ base.uiBehaviour.mDoubleDoSweep.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnQuickStartSweep));
+ base.uiBehaviour.mBackClick.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnCloseSweep));
+ base.uiBehaviour.mCloseSweep.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnCloseSweep));
+ base.uiBehaviour.mResetBtn.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnReqResetSweep));
+ base.uiBehaviour.mRank.RegisterClickEventHandler(new ButtonClickEventHandler(this.ShowTeamTowerRank));
+ base.uiBehaviour.mGoBattle.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnEnterBattle));
+ base.uiBehaviour.mRewardRefresh.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnRefreshReward));
+ base.uiBehaviour.mRewardGet.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnGetReward));
+ base.uiBehaviour.mFirstPassBtn.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnShowFirstPassReward));
+ base.uiBehaviour.mFirstPassGetReward.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnGetFirstPassReward));
+ base.uiBehaviour.mFirstPassBackClick.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnHideFirstPassReward));
+ base.uiBehaviour.mFirstPassCheckReward.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnGetDisableReward));
+ }
+
+ public bool OnHelpClicked(IXUIButton button)
+ {
+ DlgBase<XCommonHelpTipView, XCommonHelpTipBehaviour>.singleton.ShowHelp(XSysDefine.XSys_Activity_TeamTowerSingle);
+ return true;
+ }
+
+ protected override void OnShow()
+ {
+ this.ShowTeamTowerFrame();
+ }
+
+ protected override void OnHide()
+ {
+ bool flag = this._count_timer > 0u;
+ if (flag)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._count_timer);
+ }
+ this._count_timer = 0u;
+ bool flag2 = this._show_sweep_timer > 0u;
+ if (flag2)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._show_sweep_timer);
+ }
+ this._show_sweep_timer = 0u;
+ }
+
+ private void ShowTeamTowerFrame()
+ {
+ base.uiBehaviour.mSweepFrame.SetVisible(false);
+ base.uiBehaviour.mSweepResult.SetVisible(false);
+ base.uiBehaviour.mFirstPassPanel.SetVisible(false);
+ this._sweep_level = 0;
+ this._sweep_finished = false;
+ this._is_getting_reward = false;
+ this._doc.GetSingleTowerActivityTop();
+ }
+
+ private bool OnCloseDlg(IXUIButton btn)
+ {
+ this.SetVisibleWithAnimation(false, null);
+ return true;
+ }
+
+ private bool ShowTeamTowerRank(IXUIButton btn)
+ {
+ DlgBase<XRankView, XRankBehaviour>.singleton.ShowRank(XSysDefine.XSys_Rank_TeamTower);
+ return true;
+ }
+
+ public void OnRefreshTopInfo()
+ {
+ bool flag = this._doc == null || !base.IsVisible();
+ if (!flag)
+ {
+ TeamTowerData singleTowerData = this._doc.SingleTowerData;
+ TeamTowerRewardTable.RowData[] teamTowerTable = this._doc.GetTeamTowerTable();
+ bool flag2 = singleTowerData == null;
+ if (!flag2)
+ {
+ bool flag3 = singleTowerData.sweeplefttime > 0;
+ if (flag3)
+ {
+ bool flag4 = (float)singleTowerData.sweeplefttime <= Time.time - singleTowerData.sweepreqtime;
+ if (flag4)
+ {
+ this._in_sweeping = false;
+ this._sweep_finished = true;
+ }
+ else
+ {
+ this._in_sweeping = true;
+ this._sweep_finished = false;
+ }
+ }
+ else
+ {
+ bool flag5 = singleTowerData.maxlevel == singleTowerData.sweepfloor && singleTowerData.maxlevel > 0;
+ if (flag5)
+ {
+ this._sweep_finished = true;
+ }
+ else
+ {
+ this._sweep_finished = false;
+ }
+ this._in_sweeping = false;
+ }
+ this._sweep_level = singleTowerData.sweepfloor;
+ int leftcount = this._doc.SingleTowerData.leftcount;
+ int num = singleTowerData.level + 1;
+ bool flag6 = num >= teamTowerTable.Length;
+ if (flag6)
+ {
+ num = teamTowerTable.Length;
+ }
+ base.uiBehaviour.mStage.SetText(string.Format(XSingleton<XStringTable>.singleton.GetString("TEAMTOWER_LEVEL"), num));
+ int num2 = 1;
+ int.TryParse(XSingleton<XGlobalConfig>.singleton.GetValue("TowerTeamDayCount"), out num2);
+ base.uiBehaviour.mResetNum.SetText(string.Format("{0}/{1}", leftcount, num2));
+ bool flag7 = leftcount > 0;
+ if (flag7)
+ {
+ base.uiBehaviour.mResetSprite.SetVisible(true);
+ base.uiBehaviour.mResetCount.SetText(leftcount.ToString());
+ }
+ else
+ {
+ base.uiBehaviour.mResetSprite.SetVisible(false);
+ }
+ this.OnInitMainReward();
+ this.InitTowerMap(singleTowerData.level);
+ this.OnRefreshSweepInfo();
+ this.OnInitFirstReward();
+ bool sweep_finished = this._sweep_finished;
+ if (sweep_finished)
+ {
+ this.OnShowSweepResultFrame();
+ }
+ else
+ {
+ this.OnHideSweepResultFrame();
+ }
+ }
+ }
+ }
+
+ public void OnRefreshSweepInfo()
+ {
+ TeamTowerData singleTowerData = this._doc.SingleTowerData;
+ this._time_left = (float)singleTowerData.sweeplefttime - (Time.time - singleTowerData.sweepreqtime);
+ this._in_sweeping = (this._time_left > 0f);
+ bool flag = this._time_left < 0f;
+ if (flag)
+ {
+ this._time_left = 0f;
+ }
+ bool flag2 = this._time_left > 0f;
+ if (flag2)
+ {
+ this.DoCountDown(null);
+ }
+ bool in_sweeping = this._in_sweeping;
+ if (in_sweeping)
+ {
+ this._show_sweep_timer = XSingleton<XTimerMgr>.singleton.SetTimer(0.5f, new XTimerMgr.ElapsedEventHandler(this.LateShowSweepFrame), null);
+ }
+ }
+
+ private bool HasFirstRewardRedPoint()
+ {
+ TeamTowerData singleTowerData = this._doc.SingleTowerData;
+ TeamTowerRewardTable.RowData[] teamTowerTable = this._doc.GetTeamTowerTable();
+ int num = 0;
+ bool flag = singleTowerData.firstpassreward.Count > 0;
+ if (flag)
+ {
+ num = singleTowerData.firstpassreward[singleTowerData.firstpassreward.Count - 1];
+ }
+ int num2 = 0;
+ for (int i = singleTowerData.maxlevel - 1; i >= 0; i--)
+ {
+ bool flag2 = teamTowerTable[i].FirstPassReward.Count > 0 && teamTowerTable[i].preward != 0;
+ if (flag2)
+ {
+ num2 = i + 1;
+ break;
+ }
+ }
+ return num2 > num;
+ }
+
+ private int GetRewardLevel()
+ {
+ TeamTowerData singleTowerData = this._doc.SingleTowerData;
+ TeamTowerRewardTable.RowData[] teamTowerTable = this._doc.GetTeamTowerTable();
+ int num = 0;
+ bool flag = singleTowerData.firstpassreward.Count > 0;
+ if (flag)
+ {
+ num = singleTowerData.firstpassreward[singleTowerData.firstpassreward.Count - 1];
+ }
+ for (int i = num + 1; i < singleTowerData.maxlevel; i++)
+ {
+ bool flag2 = teamTowerTable[i].FirstPassReward.Count > 0 && teamTowerTable[i].preward > 0;
+ if (flag2)
+ {
+ return i + 1;
+ }
+ }
+ return singleTowerData.firstpassreward[singleTowerData.firstpassreward.Count - 1];
+ }
+
+ private int GetNextRewardLevel()
+ {
+ TeamTowerData singleTowerData = this._doc.SingleTowerData;
+ TeamTowerRewardTable.RowData[] teamTowerTable = this._doc.GetTeamTowerTable();
+ int num = 0;
+ bool flag = singleTowerData.firstpassreward.Count > 0;
+ if (flag)
+ {
+ num = singleTowerData.firstpassreward[singleTowerData.firstpassreward.Count - 1];
+ }
+ for (int i = num + 1; i < teamTowerTable.Length; i++)
+ {
+ bool flag2 = teamTowerTable[i].FirstPassReward.Count > 0 && teamTowerTable[i].preward > 0;
+ if (flag2)
+ {
+ return i + 1;
+ }
+ }
+ return singleTowerData.firstpassreward[singleTowerData.firstpassreward.Count - 1];
+ }
+
+ private void OnInitFirstReward()
+ {
+ bool flag = this.HasFirstRewardRedPoint();
+ if (flag)
+ {
+ base.uiBehaviour.mFirstPassRedPoint.SetVisible(true);
+ base.uiBehaviour.mFirstPassLevel.SetText(string.Format(XStringDefineProxy.GetString("TEAMTOWER_LEVEL"), this.GetRewardLevel()));
+ }
+ else
+ {
+ base.uiBehaviour.mFirstPassRedPoint.SetVisible(false);
+ base.uiBehaviour.mFirstPassLevel.SetText(string.Format(XStringDefineProxy.GetString("TEAMTOWER_LEVEL"), this.GetNextRewardLevel()));
+ }
+ bool flag2 = base.uiBehaviour.mFirstPassPanel.IsVisible();
+ if (flag2)
+ {
+ this.OnShowFirstPassReward(null);
+ }
+ }
+
+ public bool OnShowFirstPassReward(IXUIButton btn)
+ {
+ base.uiBehaviour.mFirstPassPanel.SetVisible(true);
+ TeamTowerRewardTable.RowData[] teamTowerTable = this._doc.GetTeamTowerTable();
+ bool flag = this.HasFirstRewardRedPoint();
+ int num;
+ if (flag)
+ {
+ num = this.GetRewardLevel();
+ base.uiBehaviour.mFirstPassGet.gameObject.transform.localPosition = new Vector3(0f, 0f, 0f);
+ base.uiBehaviour.mFIrstPassCheck.gameObject.transform.localPosition = new Vector3(1000f, 0f, 0f);
+ base.uiBehaviour.mFirstPassCongraThrough.SetText(string.Format(XSingleton<XStringTable>.singleton.GetString("TEAMTOWER_CONGRA_THROUGH"), this.GetRewardLevel()));
+ }
+ else
+ {
+ num = this.GetNextRewardLevel();
+ base.uiBehaviour.mFirstPassGet.gameObject.transform.localPosition = new Vector3(1000f, 0f, 0f);
+ base.uiBehaviour.mFIrstPassCheck.gameObject.transform.localPosition = new Vector3(0f, 0f, 0f);
+ base.uiBehaviour.mFirstPassPlsThrough.SetText(string.Format(XSingleton<XStringTable>.singleton.GetString("TEAMTOWER_PLS_THROUGH"), this.GetNextRewardLevel()));
+ }
+ base.uiBehaviour.mFirstPassReward.ReturnAll(false);
+ SeqListRef<int> firstPassReward = teamTowerTable[num - 1].FirstPassReward;
+ for (int i = 0; i < firstPassReward.Count; i++)
+ {
+ GameObject gameObject = base.uiBehaviour.mFirstPassReward.FetchGameObject(false);
+ XItem xitem = XBagDocument.MakeXItem(firstPassReward[i, 0], false);
+ xitem.itemCount = firstPassReward[i, 1];
+ int num2 = (i % 2 == 0) ? 1 : -1;
+ int num3 = base.uiBehaviour.mFirstPassReward.TplWidth / 2;
+ bool flag2 = firstPassReward.Count % 2 == 1;
+ if (flag2)
+ {
+ num3 = 0;
+ }
+ XSingleton<XItemDrawerMgr>.singleton.DrawItem(gameObject.transform.Find("Item").gameObject, xitem);
+ gameObject.transform.localPosition = new Vector3(base.uiBehaviour.mFirstPassReward.TplPos.x + (float)(num2 * ((i + 1) / 2) * base.uiBehaviour.mFirstPassReward.TplWidth) + (float)num3, base.uiBehaviour.mFirstPassReward.TplPos.y, base.uiBehaviour.mFirstPassReward.TplPos.z);
+ }
+ return true;
+ }
+
+ private void OnHideFirstPassReward(IXUISprite sp)
+ {
+ base.uiBehaviour.mFirstPassPanel.SetVisible(false);
+ }
+
+ public bool OnGetFirstPassReward(IXUIButton btn)
+ {
+ bool is_getting_reward = this._is_getting_reward;
+ bool result;
+ if (is_getting_reward)
+ {
+ result = false;
+ }
+ else
+ {
+ this._doc.GetFirstPassReward(this.GetRewardLevel());
+ this._is_getting_reward = true;
+ result = true;
+ }
+ return result;
+ }
+
+ private bool OnGetDisableReward(IXUIButton btn)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("TEAMTOWER_CANOT_GET"), "fece00");
+ return true;
+ }
+
+ public void OnGetFirstPassRewardRes(ErrorCode error)
+ {
+ this._is_getting_reward = false;
+ bool flag = error > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(error, "fece00");
+ }
+ else
+ {
+ this._doc.GetSingleTowerActivityTop();
+ }
+ }
+
+ public void LateShowSweepFrame(object obj)
+ {
+ this.OnShowSweepFrame(null);
+ }
+
+ public bool OnShowSweepFrame(IXUIButton btn)
+ {
+ bool sweep_finished = this._sweep_finished;
+ bool result;
+ if (sweep_finished)
+ {
+ base.uiBehaviour.mSweepResult.SetVisible(true);
+ result = true;
+ }
+ else
+ {
+ bool flag = this._doc.SingleTowerData.maxlevel == 0;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("TEAMTOWER_FIRST_NOT_SWEEP"), "fece00");
+ result = false;
+ }
+ else
+ {
+ bool flag2 = this._doc.SingleTowerData.level == this._doc.SingleTowerData.maxlevel || this._sweep_finished;
+ if (flag2)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("TEAMTOWER_LAST_NOT_SWEEP"), "fece00");
+ result = false;
+ }
+ else
+ {
+ TeamTowerData singleTowerData = this._doc.SingleTowerData;
+ base.uiBehaviour.mSweepFrame.SetVisible(true);
+ base.uiBehaviour.mSweepedLevel.SetText(string.Format(XStringDefineProxy.GetString("TEAMTOWER_REACH_LEVEL"), singleTowerData.maxlevel));
+ bool in_sweeping = this._in_sweeping;
+ if (in_sweeping)
+ {
+ base.uiBehaviour.mSingleDoSweep.SetVisible(true);
+ base.uiBehaviour.mDoubleSweep.SetVisible(false);
+ base.uiBehaviour.mDoubleDoSweep.SetVisible(false);
+ base.uiBehaviour.mSingleMoneyNum.SetText("20");
+ string itemSmallIcon = XBagDocument.GetItemSmallIcon(7, 0u);
+ base.uiBehaviour.mSingleMoneySign.SetSprite(itemSmallIcon);
+ this.SetTimeLeft((int)this._time_left);
+ }
+ else
+ {
+ base.uiBehaviour.mSingleDoSweep.SetVisible(false);
+ base.uiBehaviour.mDoubleSweep.SetVisible(true);
+ base.uiBehaviour.mDoubleDoSweep.SetVisible(true);
+ base.uiBehaviour.mDoubleMoneyNum.SetText("20");
+ string itemSmallIcon2 = XBagDocument.GetItemSmallIcon(7, 0u);
+ base.uiBehaviour.mDoubleMoneySign.SetSprite(itemSmallIcon2);
+ bool flag3 = singleTowerData.maxlevel > singleTowerData.level;
+ if (flag3)
+ {
+ this.SetTimeLeft((int)this._sweep_time * (singleTowerData.maxlevel - singleTowerData.level));
+ }
+ else
+ {
+ this.SetTimeLeft((int)this._sweep_time * singleTowerData.maxlevel);
+ }
+ }
+ this.OnInitReward(base.uiBehaviour.mRewardPool, 1f);
+ result = true;
+ }
+ }
+ }
+ return result;
+ }
+
+ private void SetTimeLeft(int time)
+ {
+ int num = time / 3600;
+ int num2 = (time - num * 3600) / 60;
+ int num3 = time % 60;
+ string text = string.Format("{0:D2}:{1:D2}:{2:D2}", num, num2, num3);
+ base.uiBehaviour.mSweepEstimateTime.SetText(text);
+ }
+
+ private void OnInitReward(XUIPool pool, float rewardalpha = 1f)
+ {
+ Dictionary<int, int> dictionary = new Dictionary<int, int>();
+ TeamTowerRewardTable.RowData[] teamTowerTable = this._doc.GetTeamTowerTable();
+ TeamTowerData singleTowerData = this._doc.SingleTowerData;
+ int maxlevel = singleTowerData.maxlevel;
+ int num = (maxlevel < teamTowerTable.Length) ? maxlevel : teamTowerTable.Length;
+ for (int i = singleTowerData.level; i < num; i++)
+ {
+ TeamTowerRewardTable.RowData rowData = teamTowerTable[i];
+ for (int j = 0; j < rowData.Reward.Count; j++)
+ {
+ bool flag = dictionary.ContainsKey(rowData.Reward[j, 0]);
+ if (flag)
+ {
+ Dictionary<int, int> dictionary2 = dictionary;
+ int key = rowData.Reward[j, 0];
+ dictionary2[key] += rowData.Reward[j, 1];
+ }
+ else
+ {
+ dictionary[rowData.Reward[j, 0]] = rowData.Reward[j, 1];
+ }
+ }
+ }
+ List<int> list = new List<int>(dictionary.Keys);
+ pool.ReturnAll(false);
+ bool active = XActivityDocument.Doc.IsInnerDropTime(530u);
+ for (int k = 0; k < list.Count; k++)
+ {
+ GameObject gameObject = pool.FetchGameObject(false);
+ XItem xitem = XBagDocument.MakeXItem(list[k], false);
+ xitem.itemCount = (int)((float)dictionary[list[k]] * rewardalpha + 0.5f);
+ IXUITweenTool ixuitweenTool = gameObject.transform.Find("Item/Num").GetComponent("XUIPlayTween") as IXUITweenTool;
+ bool flag2 = ixuitweenTool != null;
+ if (flag2)
+ {
+ ixuitweenTool.ResetTweenByGroup(true, 0);
+ ixuitweenTool.PlayTween(true, -1f);
+ }
+ int num2 = (k % 2 == 0) ? 1 : -1;
+ int num3 = pool.TplWidth / 2;
+ bool flag3 = list.Count % 2 == 1;
+ if (flag3)
+ {
+ num3 = 0;
+ }
+ XSingleton<XItemDrawerMgr>.singleton.DrawItem(gameObject.transform.Find("Item").gameObject, xitem);
+ gameObject.transform.localPosition = new Vector3(pool.TplPos.x + (float)(num2 * ((k + 1) / 2) * pool.TplWidth) + (float)num3, pool.TplPos.y, pool.TplPos.z);
+ Transform transform = gameObject.transform.Find("Item/Double");
+ bool flag4 = transform != null;
+ if (flag4)
+ {
+ transform.gameObject.SetActive(active);
+ }
+ }
+ }
+
+ private void OnInitMainReward()
+ {
+ Dictionary<int, int> dictionary = new Dictionary<int, int>();
+ Dictionary<int, int> dictionary2 = new Dictionary<int, int>();
+ base.uiBehaviour.mMainRewardPool.ReturnAll(false);
+ TeamTowerRewardTable.RowData[] teamTowerTable = this._doc.GetTeamTowerTable();
+ int num = this._doc.SingleTowerData.level;
+ bool flag = num >= teamTowerTable.Length;
+ if (flag)
+ {
+ num = teamTowerTable.Length - 1;
+ }
+ TeamTowerRewardTable.RowData rowData = teamTowerTable[num];
+ bool flag2 = rowData.preward == 0 && num >= this._doc.SingleTowerData.maxlevel;
+ if (flag2)
+ {
+ for (int i = 0; i < rowData.FirstPassReward.Count; i++)
+ {
+ bool flag3 = rowData.FirstPassReward[i, 1] > 0;
+ if (flag3)
+ {
+ bool flag4 = dictionary2.ContainsKey(rowData.FirstPassReward[i, 0]);
+ if (flag4)
+ {
+ Dictionary<int, int> dictionary3 = dictionary2;
+ int key = rowData.FirstPassReward[i, 0];
+ dictionary3[key] += rowData.FirstPassReward[i, 1];
+ }
+ else
+ {
+ dictionary2[rowData.FirstPassReward[i, 0]] = rowData.FirstPassReward[i, 1];
+ }
+ }
+ }
+ }
+ for (int j = 0; j < rowData.Reward.Count; j++)
+ {
+ bool flag5 = rowData.Reward[j, 1] > 0;
+ if (flag5)
+ {
+ bool flag6 = dictionary.ContainsKey(rowData.Reward[j, 0]);
+ if (flag6)
+ {
+ Dictionary<int, int> dictionary3 = dictionary;
+ int key = rowData.Reward[j, 0];
+ dictionary3[key] += rowData.Reward[j, 1];
+ }
+ else
+ {
+ dictionary[rowData.Reward[j, 0]] = rowData.Reward[j, 1];
+ }
+ }
+ }
+ List<int> list = new List<int>(dictionary.Keys);
+ List<int> list2 = new List<int>(dictionary2.Keys);
+ int num2 = list.Count + list2.Count;
+ for (int k = 0; k < list.Count; k++)
+ {
+ GameObject gameObject = base.uiBehaviour.mMainRewardPool.FetchGameObject(false);
+ XItem xitem = XBagDocument.MakeXItem(list[k], false);
+ xitem.itemCount = dictionary[list[k]];
+ int num3 = base.uiBehaviour.mMainRewardPool.TplWidth / 2;
+ bool flag7 = num2 % 2 == 1;
+ if (flag7)
+ {
+ num3 = 0;
+ }
+ xitem.Description.ItemDrawer.DrawItem(gameObject, xitem, true);
+ gameObject.transform.localPosition = new Vector3(base.uiBehaviour.mMainRewardPool.TplPos.x + (float)(k - (num2 - 1) / 2) * 1f * (float)base.uiBehaviour.mMainRewardPool.TplWidth - (float)num3, base.uiBehaviour.mMainRewardPool.TplPos.y, base.uiBehaviour.mMainRewardPool.TplPos.z);
+ IXUISprite ixuisprite = gameObject.transform.Find("shoutong").GetComponent("XUISprite") as IXUISprite;
+ bool flag8 = ixuisprite != null;
+ if (flag8)
+ {
+ ixuisprite.SetVisible(false);
+ }
+ }
+ for (int l = 0; l < list2.Count; l++)
+ {
+ int num4 = l + list.Count;
+ GameObject gameObject2 = base.uiBehaviour.mMainRewardPool.FetchGameObject(false);
+ XItem xitem2 = XBagDocument.MakeXItem(list2[l], false);
+ xitem2.itemCount = dictionary2[list2[l]];
+ int num5 = base.uiBehaviour.mMainRewardPool.TplWidth / 2;
+ bool flag9 = (list.Count + list2.Count) % 2 == 1;
+ if (flag9)
+ {
+ num5 = 0;
+ }
+ xitem2.Description.ItemDrawer.DrawItem(gameObject2, xitem2, true);
+ gameObject2.transform.localPosition = new Vector3(base.uiBehaviour.mMainRewardPool.TplPos.x + (float)(num4 - (num2 - 1) / 2) * 1f * (float)base.uiBehaviour.mMainRewardPool.TplWidth - (float)num5, base.uiBehaviour.mMainRewardPool.TplPos.y, base.uiBehaviour.mMainRewardPool.TplPos.z);
+ IXUISprite ixuisprite2 = gameObject2.transform.Find("shoutong").GetComponent("XUISprite") as IXUISprite;
+ bool flag10 = ixuisprite2 != null;
+ if (flag10)
+ {
+ ixuisprite2.SetVisible(true);
+ }
+ }
+ double attr = XSingleton<XEntityMgr>.singleton.Player.PlayerAttributes.GetAttr(XAttributeDefine.XAttr_POWER_POINT_Total);
+ SceneTable.RowData sceneData = XSingleton<XSceneMgr>.singleton.GetSceneData((uint)rowData.SceneID);
+ double num6 = (double)sceneData.RecommendPower * 1.0;
+ bool flag11 = sceneData != null;
+ if (flag11)
+ {
+ num6 = (double)sceneData.RecommendPower * 1.0;
+ }
+ double num7 = (attr - num6 * 1.0) / num6 * 1.0;
+ bool flag12 = num7 > 0.01;
+ if (flag12)
+ {
+ base.uiBehaviour.mDemandFP.SetText(num6.ToString());
+ base.uiBehaviour.mDemandFP.SetColor(Color.green);
+ }
+ else
+ {
+ bool flag13 = num7 > -0.01;
+ if (flag13)
+ {
+ base.uiBehaviour.mDemandFP.SetText(string.Format("[e2ca9e]{0}[-]", num6));
+ }
+ else
+ {
+ base.uiBehaviour.mDemandFP.SetText(num6.ToString());
+ base.uiBehaviour.mDemandFP.SetColor(Color.red);
+ }
+ }
+ }
+
+ public bool OnCloseSweep(IXUIButton btn)
+ {
+ base.uiBehaviour.mSweepFrame.SetVisible(false);
+ return true;
+ }
+
+ public bool OnStartSweep(IXUIButton btn)
+ {
+ RpcC2G_SweepTower rpcC2G_SweepTower = new RpcC2G_SweepTower();
+ rpcC2G_SweepTower.oArg.hardLevel = this.GetHardLevel();
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_SweepTower);
+ return true;
+ }
+
+ public int GetHardLevel()
+ {
+ return this._doc.ExpeditionId % 100 / 10 + 1;
+ }
+
+ public void OnStartSweepRes(SweepTowerArg arg, int timeleft)
+ {
+ bool flag = arg.cost == null || arg.cost.itemID == 0u;
+ if (flag)
+ {
+ this._time_left = (float)timeleft;
+ this._in_sweeping = true;
+ this._sweep_finished = false;
+ this.DoCountDown(null);
+ TeamTowerData singleTowerData = this._doc.SingleTowerData;
+ singleTowerData.sweepreqtime = Time.time;
+ base.uiBehaviour.mSingleDoSweep.SetVisible(true);
+ base.uiBehaviour.mDoubleSweep.SetVisible(false);
+ base.uiBehaviour.mDoubleDoSweep.SetVisible(false);
+ }
+ else
+ {
+ this._time_left = 0f;
+ this._in_sweeping = false;
+ this._sweep_finished = true;
+ this.OnCloseSweep(null);
+ this.OnQuickStartSweepRes();
+ }
+ }
+
+ public bool OnQuickStartSweep(IXUIButton btn)
+ {
+ RpcC2G_SweepTower rpcC2G_SweepTower = new RpcC2G_SweepTower();
+ rpcC2G_SweepTower.oArg.cost = new ItemBrief();
+ rpcC2G_SweepTower.oArg.hardLevel = 1;
+ rpcC2G_SweepTower.oArg.cost.itemID = 7u;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_SweepTower);
+ return true;
+ }
+
+ public void OnQuickStartSweepRes()
+ {
+ this._sweep_finished = true;
+ this._in_sweeping = false;
+ this._time_left = 0f;
+ TeamTowerData singleTowerData = this._doc.SingleTowerData;
+ bool flag = singleTowerData.level >= this._doc.GetTeamTowerTopLevel(1);
+ if (flag)
+ {
+ this._doc.ExpeditionId = this._doc.ExpeditionId - this._doc.ExpeditionId % 10 + 1;
+ int count = this._doc.GetDayCount(TeamLevelType.TeamLevelTeamTower, null) - 1;
+ this._doc.OnRefreshDayCount(TeamLevelType.TeamLevelTeamTower, count);
+ }
+ this.OnCloseSweep(null);
+ this.OnShowSweepResultFrame();
+ this._doc.GetSingleTowerActivityTop();
+ }
+
+ private bool OnReqResetSweep(IXUIButton btn)
+ {
+ bool flag = this._doc.SingleTowerData.leftcount <= 0;
+ bool result;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(ErrorCode.ERR_TEAM_TOWER_DAYCOUNT, "fece00");
+ result = false;
+ }
+ else
+ {
+ bool flag2 = this._doc.SingleTowerData.level == 0;
+ if (flag2)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("TEAMTOWER_FIRST_NOT_RESET"), "fece00");
+ result = false;
+ }
+ else
+ {
+ bool in_sweeping = this._in_sweeping;
+ if (in_sweeping)
+ {
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(true, true);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetSingleButtonMode(true);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetLabelsWithSymbols(XStringDefineProxy.GetString("TEAMTOWER_IN_SWEEP"), XStringDefineProxy.GetString("COMMON_OK"), XStringDefineProxy.GetString("COMMON_OK"));
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnCancelReset), new ButtonClickEventHandler(this.OnCancelReset));
+ }
+ else
+ {
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(true, true);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetSingleButtonMode(false);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetLabelsWithSymbols(XStringDefineProxy.GetString("TEAMTOWER_RESET_INFO"), XStringDefineProxy.GetString("TEAMTOWER_RESET"), XStringDefineProxy.GetString("COMMON_CANCEL"));
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnResetSweep), new ButtonClickEventHandler(this.OnCancelReset));
+ }
+ result = true;
+ }
+ }
+ return result;
+ }
+
+ private bool OnCancelReset(IXUIButton btn)
+ {
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
+ return true;
+ }
+
+ public bool OnResetSweep(IXUIButton btn)
+ {
+ this._doc.ResetSingleTower();
+ return true;
+ }
+
+ public void OnResetSweepRes()
+ {
+ TeamTowerData singleTowerData = this._doc.SingleTowerData;
+ singleTowerData.sweepfloor = 1;
+ singleTowerData.sweeplefttime = 0;
+ this._in_sweeping = false;
+ this._sweep_finished = false;
+ this._doc.ExpeditionId = this._doc.ExpeditionId - this._doc.ExpeditionId % 10 + 1;
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TEAMTOWER_RESETOK"), "fece00");
+ this._doc.GetSingleTowerActivityTop();
+ }
+
+ public bool OnEnterBattle(IXUIButton btn)
+ {
+ TeamTowerRewardTable.RowData[] teamTowerTable = this._doc.GetTeamTowerTable();
+ int level = this._doc.SingleTowerData.level;
+ bool flag = level >= teamTowerTable.Length;
+ bool result;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TEAMTOWER_REACH_TOP"), "fece00");
+ result = false;
+ }
+ else
+ {
+ TeamTowerRewardTable.RowData rowData = teamTowerTable[this._doc.SingleTowerData.level];
+ PtcC2G_EnterSceneReq ptcC2G_EnterSceneReq = new PtcC2G_EnterSceneReq();
+ ptcC2G_EnterSceneReq.Data.sceneID = (uint)rowData.SceneID;
+ XSingleton<XClientNetwork>.singleton.Send(ptcC2G_EnterSceneReq);
+ result = true;
+ }
+ return result;
+ }
+
+ public void DoCountDown(object obj)
+ {
+ TeamTowerData singleTowerData = this._doc.SingleTowerData;
+ this._time_left = (float)singleTowerData.sweeplefttime - (Time.time - singleTowerData.sweepreqtime);
+ bool flag = this._count_timer > 0u;
+ if (flag)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._count_timer);
+ }
+ bool flag2 = this._time_left <= 0f;
+ if (flag2)
+ {
+ this._time_left = 0f;
+ this._in_sweeping = false;
+ this._sweep_finished = true;
+ this.SetTimeLeft(0);
+ this.OnCloseSweep(null);
+ this._doc.GetSingleTowerActivityTop();
+ }
+ else
+ {
+ this.SetTimeLeft((int)this._time_left);
+ this._count_timer = XSingleton<XTimerMgr>.singleton.SetTimer(1f, new XTimerMgr.ElapsedEventHandler(this.DoCountDown), null);
+ }
+ }
+
+ private void InitTowerMap(int curfloor = 1)
+ {
+ TeamTowerRewardTable.RowData[] teamTowerTable = this._doc.GetTeamTowerTable();
+ this._tower_max_floor = teamTowerTable.Length;
+ int num = this._doc.SingleTowerData.maxlevel;
+ num = ((num + 5 >= this._tower_max_floor) ? this._tower_max_floor : (num + 5));
+ num = ((num % 2 == 0) ? num : (num + 1));
+ int num2 = num / 2 - 1;
+ IXUILabel ixuilabel = base.uiBehaviour.transform.Find("Bg/Tower/TowerBase/Floor").GetComponent("XUILabel") as IXUILabel;
+ GameObject gameObject = base.uiBehaviour.transform.Find("Bg/Tower/TowerBase/Floor/Current/Normal/UI_hasd_gk").gameObject;
+ ixuilabel.SetText(string.Format(XSingleton<XStringTable>.singleton.GetString("TEAMTOWER_LEVEL"), 1));
+ bool flag = this._doc.SingleTowerData.level + 1 == 1;
+ if (flag)
+ {
+ gameObject.SetActive(true);
+ }
+ else
+ {
+ gameObject.SetActive(false);
+ }
+ ixuilabel = (base.uiBehaviour.transform.Find("Bg/Tower/TowerBase/Floor1").GetComponent("XUILabel") as IXUILabel);
+ ixuilabel.SetText(string.Format(XSingleton<XStringTable>.singleton.GetString("TEAMTOWER_LEVEL"), 2));
+ gameObject = base.uiBehaviour.transform.Find("Bg/Tower/TowerBase/Floor1/Current/Normal/UI_hasd_gk").gameObject;
+ bool flag2 = this._doc.SingleTowerData.level + 1 == 2;
+ if (flag2)
+ {
+ gameObject.SetActive(true);
+ }
+ else
+ {
+ gameObject.SetActive(false);
+ }
+ IXUISprite ixuisprite = base.uiBehaviour.transform.Find("Bg/Tower/TowerBase/Floor/FirstBlood").GetComponent("XUISprite") as IXUISprite;
+ ixuisprite.SetVisible(false);
+ IXUISprite ixuisprite2 = base.uiBehaviour.transform.Find("Bg/Tower/TowerBase/Floor").GetComponent("XUISprite") as IXUISprite;
+ TeamTowerRewardTable.RowData rowData = teamTowerTable[0];
+ bool flag3 = curfloor >= 1;
+ if (flag3)
+ {
+ ixuisprite2.SetEnabled(false);
+ }
+ else
+ {
+ ixuisprite2.SetEnabled(true);
+ }
+ ixuisprite2 = (base.uiBehaviour.transform.Find("Bg/Tower/TowerBase/Floor1").GetComponent("XUISprite") as IXUISprite);
+ ixuisprite = (base.uiBehaviour.transform.Find("Bg/Tower/TowerBase/Floor1/FirstBlood").GetComponent("XUISprite") as IXUISprite);
+ ixuisprite.SetVisible(false);
+ rowData = teamTowerTable[1];
+ bool flag4 = curfloor >= 2;
+ if (flag4)
+ {
+ ixuisprite2.SetEnabled(false);
+ }
+ else
+ {
+ ixuisprite2.SetEnabled(true);
+ }
+ base.uiBehaviour.mTowerPool.ReturnAll(false);
+ for (int i = 0; i < num2; i++)
+ {
+ GameObject gameObject2 = base.uiBehaviour.mTowerPool.FetchGameObject(false);
+ Vector3 localPosition;
+ localPosition = new Vector3(base.uiBehaviour.mTowerPool.TplPos.x, base.uiBehaviour.mTowerPool.TplPos.y + (float)((base.uiBehaviour.mTowerPool.TplHeight - 60) * i), base.uiBehaviour.mTowerPool.TplPos.z);
+ gameObject2.transform.localPosition = localPosition;
+ rowData = teamTowerTable[(i + 1) * 2];
+ ixuilabel = (gameObject2.transform.Find("Floor").GetComponent("XUILabel") as IXUILabel);
+ ixuilabel.SetText(string.Format(XSingleton<XStringTable>.singleton.GetString("TEAMTOWER_LEVEL"), (i + 1) * 2 + 1));
+ ixuisprite2 = (gameObject2.transform.Find("Floor").GetComponent("XUISprite") as IXUISprite);
+ ixuisprite = (gameObject2.transform.Find("Floor/FirstBlood").GetComponent("XUISprite") as IXUISprite);
+ ixuisprite.SetVisible(false);
+ gameObject = gameObject2.transform.Find("Floor/Current/Normal/UI_hasd_gk").gameObject;
+ bool flag5 = this._doc.SingleTowerData.level + 1 == (i + 1) * 2 + 1;
+ if (flag5)
+ {
+ gameObject.SetActive(true);
+ }
+ else
+ {
+ gameObject.SetActive(false);
+ }
+ bool flag6 = curfloor >= (i + 1) * 2 + 1;
+ if (flag6)
+ {
+ ixuisprite2.SetEnabled(false);
+ }
+ else
+ {
+ ixuisprite2.SetEnabled(true);
+ }
+ ixuilabel = (gameObject2.transform.Find("Floor1").GetComponent("XUILabel") as IXUILabel);
+ ixuilabel.SetText(string.Format(XSingleton<XStringTable>.singleton.GetString("TEAMTOWER_LEVEL"), (i + 1) * 2 + 2));
+ ixuisprite = (gameObject2.transform.Find("Floor1/FirstBlood").GetComponent("XUISprite") as IXUISprite);
+ ixuisprite.SetVisible(false);
+ rowData = teamTowerTable[(i + 1) * 2 + 1];
+ ixuisprite2 = (gameObject2.transform.Find("Floor1").GetComponent("XUISprite") as IXUISprite);
+ bool flag7 = curfloor >= (i + 1) * 2 + 2;
+ if (flag7)
+ {
+ ixuisprite2.SetEnabled(false);
+ }
+ else
+ {
+ ixuisprite2.SetEnabled(true);
+ }
+ gameObject = gameObject2.transform.Find("Floor1/Current/Normal/UI_hasd_gk").gameObject;
+ bool flag8 = this._doc.SingleTowerData.level + 1 == (i + 1) * 2 + 2;
+ if (flag8)
+ {
+ gameObject.SetActive(true);
+ }
+ else
+ {
+ gameObject.SetActive(false);
+ }
+ }
+ base.uiBehaviour.mScroll.NeedRecalcBounds();
+ base.uiBehaviour.mScroll.SetPosition(1f - (float)curfloor * 1f / (float)num);
+ }
+
+ private bool OnGetReward(IXUIButton btn)
+ {
+ this._doc.GetSweepSingleTowerReward();
+ return true;
+ }
+
+ public void OnGotReward()
+ {
+ base.uiBehaviour.mSweepResult.SetVisible(false);
+ this._doc.GetSingleTowerActivityTop();
+ }
+
+ public void OnShowSweepResultFrame()
+ {
+ base.uiBehaviour.mSweepResult.SetVisible(true);
+ base.uiBehaviour.mRewardFx.SetVisible(false);
+ base.uiBehaviour.mEffect.SetActive(false);
+ this.OnRefreshResult();
+ }
+
+ public void OnHideSweepResultFrame()
+ {
+ base.uiBehaviour.mSweepResult.SetVisible(false);
+ }
+
+ private bool OnRefreshReward(IXUIButton btn)
+ {
+ base.uiBehaviour.mRewardRefresh.SetEnable(false, false);
+ base.uiBehaviour.mRewardGet.SetEnable(false, false);
+ this._doc.RefreshSingleSweepReward();
+ return true;
+ }
+
+ public void OnStartPlayRefreshResultEffect(ErrorCode code, int res)
+ {
+ bool flag = code > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ base.uiBehaviour.mRewardRefresh.SetEnable(true, false);
+ base.uiBehaviour.mRewardGet.SetEnable(true, false);
+ }
+ else
+ {
+ this._effect_result = (float)res / 100f;
+ this._doc.SingleTowerData.refreshcount++;
+ bool flag2 = this._doc.SingleTowerData.refreshcount >= this._refresh_cost.Count;
+ if (flag2)
+ {
+ this._doc.SingleTowerData.refreshcount = this._refresh_cost.Count;
+ }
+ base.uiBehaviour.mRewardFx.SetVisible(true);
+ base.uiBehaviour.mEffect.SetActive(false);
+ base.uiBehaviour.mRewardFreeTime.SetText(string.Format("{0}/{1}", this._refresh_cost.Count - this._doc.SingleTowerData.refreshcount, this._refresh_cost.Count));
+ int index = (this._doc.SingleTowerData.refreshcount >= this._refresh_cost.Count) ? (this._refresh_cost.Count - 1) : this._doc.SingleTowerData.refreshcount;
+ bool flag3 = this._refresh_cost[index] == 0;
+ if (flag3)
+ {
+ base.uiBehaviour.mRewardFreeLabel.SetVisible(true);
+ base.uiBehaviour.mRewardMoneyNum.SetVisible(false);
+ }
+ else
+ {
+ base.uiBehaviour.mRewardFreeLabel.SetVisible(false);
+ base.uiBehaviour.mRewardMoneyNum.SetVisible(true);
+ base.uiBehaviour.mRewardMoneyNum.SetText(this._refresh_cost[index].ToString());
+ string itemSmallIcon = XBagDocument.GetItemSmallIcon(this._refresh_money[index], 0u);
+ base.uiBehaviour.mRewardMoneySign.SetSprite(itemSmallIcon);
+ }
+ this.state = ActivityTeamTowerSingleDlg.State.BEGIN;
+ this.timePass.LeftTime = 10f;
+ }
+ }
+
+ private int GetFrame(uint index)
+ {
+ bool flag = this.frames.Count <= 0;
+ int result;
+ if (flag)
+ {
+ result = 15;
+ }
+ else
+ {
+ bool flag2 = (long)this.frames.Count <= (long)((ulong)index);
+ if (flag2)
+ {
+ result = this.frames[this.frames.Count - 1];
+ }
+ else
+ {
+ result = this.frames[(int)index];
+ }
+ }
+ return result;
+ }
+
+ public void OnRefreshReverseCount()
+ {
+ this.OnRefreshSweepInfo();
+ }
+
+ public void RefreshAlpha()
+ {
+ int num = XSingleton<XCommon>.singleton.RandomInt(0, this._random_list.Count);
+ float num2 = this._random_list[num];
+ base.uiBehaviour.mRewardAlpha.SetText(string.Format("{0:F1}{1}", num2, XSingleton<XStringTable>.singleton.GetString("FOLD")));
+ base.uiBehaviour.mRewardAlpha.SetColor(XSingleton<UiUtility>.singleton.GetItemQualityColor(num));
+ }
+
+ private void PlayAlphaFinished()
+ {
+ base.uiBehaviour.mRewardAlpha.SetText(string.Format("{0:F1}{1}", this._effect_result, XSingleton<XStringTable>.singleton.GetString("FOLD")));
+ for (int i = 0; i < this._random_list.Count; i++)
+ {
+ bool flag = this._random_list[i] == this._effect_result;
+ if (flag)
+ {
+ base.uiBehaviour.mRewardAlpha.SetColor(XSingleton<UiUtility>.singleton.GetItemQualityColor(i));
+ }
+ }
+ base.uiBehaviour.mRewardFx.SetVisible(false);
+ this.OnInitReward(base.uiBehaviour.mRewardFramePool, this._effect_result);
+ base.uiBehaviour.mRewardRefresh.SetEnable(true, false);
+ base.uiBehaviour.mRewardGet.SetEnable(true, false);
+ base.uiBehaviour.mEffect.SetActive(true);
+ }
+
+ public void OnRefreshResult()
+ {
+ TeamTowerData singleTowerData = this._doc.SingleTowerData;
+ base.uiBehaviour.mRewardLevel.SetText(string.Format(XSingleton<XStringTable>.singleton.GetString("TEAMTOWER_REACH_LEVEL"), (singleTowerData.maxlevel == 0) ? 1 : singleTowerData.maxlevel));
+ base.uiBehaviour.mRewardAlpha.SetText(string.Format("{0:F1}{1}", 1, XSingleton<XStringTable>.singleton.GetString("FOLD")));
+ base.uiBehaviour.mRewardAlpha.SetColor(XSingleton<UiUtility>.singleton.GetItemQualityColor(0));
+ base.uiBehaviour.mRewardFreeTime.SetText(string.Format("{0}/{1}", this._refresh_cost.Count - this._doc.SingleTowerData.refreshcount, this._refresh_cost.Count));
+ int index = (this._doc.SingleTowerData.refreshcount >= this._refresh_cost.Count) ? (this._refresh_cost.Count - 1) : this._doc.SingleTowerData.refreshcount;
+ bool flag = this._refresh_cost[index] == 0;
+ if (flag)
+ {
+ base.uiBehaviour.mRewardFreeLabel.SetVisible(true);
+ base.uiBehaviour.mRewardMoneyNum.SetVisible(false);
+ }
+ else
+ {
+ base.uiBehaviour.mRewardFreeLabel.SetVisible(false);
+ base.uiBehaviour.mRewardMoneyNum.SetVisible(true);
+ base.uiBehaviour.mRewardMoneyNum.SetText(this._refresh_cost[index].ToString());
+ string itemSmallIcon = XBagDocument.GetItemSmallIcon(this._refresh_money[index], 0u);
+ base.uiBehaviour.mRewardMoneySign.SetSprite(itemSmallIcon);
+ }
+ this.OnInitReward(base.uiBehaviour.mRewardFramePool, 1f);
+ }
+
+ public override void OnUpdate()
+ {
+ bool flag = this.state == ActivityTeamTowerSingleDlg.State.BEGIN;
+ if (flag)
+ {
+ this._play_count = 0;
+ this._acc_time = 0;
+ this.timePass.LeftTime = 10f;
+ this.state = ActivityTeamTowerSingleDlg.State.PLAY;
+ }
+ else
+ {
+ bool flag2 = this.state == ActivityTeamTowerSingleDlg.State.PLAY;
+ if (flag2)
+ {
+ this.timePass.Update();
+ this._acc_time = (int)(this.timePass.PassTime * 1000f);
+ bool flag3 = this._acc_time > this.GetFrame((uint)this._play_count);
+ if (flag3)
+ {
+ this.timePass.LeftTime = 1f;
+ this._acc_time = 0;
+ this._play_count++;
+ this.RefreshAlpha();
+ bool flag4 = this._play_count >= this._all_count;
+ if (flag4)
+ {
+ this._play_count = 0;
+ this.state = ActivityTeamTowerSingleDlg.State.Idle;
+ }
+ }
+ }
+ else
+ {
+ bool flag5 = this.state == ActivityTeamTowerSingleDlg.State.Idle;
+ if (flag5)
+ {
+ this.state = ActivityTeamTowerSingleDlg.State.None;
+ this.PlayAlphaFinished();
+ }
+ }
+ }
+ }
+ }
+}
|