//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Saturday, October 14, 2017
|
//--------------------------------------------------------
|
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
using System.Linq;
|
|
namespace Snxxz.UI {
|
|
public class RealmPracticeWin : Window
|
{
|
private ScrollerController _practiceTypeCtrl;
|
private ScrollerController _taskTypeCtrl;
|
private Text _curPracticePointText;
|
private Text _nextRealmPointText;
|
private RealmConfig _tagRealmModel;
|
RealmPracticeModel practiceModel { get { return ModelCenter.Instance.GetModel<RealmPracticeModel>(); } }
|
Dictionary<int, Dictionary<int, List<RealmPracticeConfig>>> realmPraDict;
|
private int selectFirstType = 0;
|
private int selectSecondType = 0;
|
private bool isOpen = true;
|
#region Built-in
|
protected override void BindController()
|
{
|
_practiceTypeCtrl = transform.Find("PracticeTypeCtrl").GetComponent<ScrollerController>();
|
_taskTypeCtrl = transform.Find("TaskTypeCtrl").GetComponent<ScrollerController>();
|
_curPracticePointText = transform.Find("NowNumImg/PointValue").GetComponent<Text>();
|
_nextRealmPointText = transform.Find("NowNumImg/PointValue/TipsText").GetComponent<Text>();
|
_taskTypeCtrl.lockType = EnhanceLockType.KeepVertical;
|
|
}
|
|
protected override void AddListeners()
|
{
|
|
}
|
|
protected override void OnPreOpen()
|
{
|
isOpen = true;
|
_practiceTypeCtrl.OnRefreshCell += RefreshPracticeTypeCell;
|
_taskTypeCtrl.OnRefreshCell += RefreshTaskTypeCell;
|
practiceModel.AchieveModel.achievementAwardableEvent += RefreshIsReach;
|
practiceModel.AchieveModel.achievementCompletedEvent += RefreshComplete;
|
PlayerDatas.Instance.PlayerDataRefreshInfoEvent += RefreshRealmPoint;
|
realmPraDict = practiceModel.GetAllOpenRealmPra();
|
if(realmPraDict.Count > 0)
|
{
|
selectFirstType = realmPraDict.Keys.ToList()[0];
|
}
|
if (AchievementGoto.guideAchievementId != 0)
|
{
|
SuccessConfig config = SuccessConfig.Get(AchievementGoto.guideAchievementId);
|
if (config.Type == 114)
|
{
|
bool isAchieveReach = false;
|
foreach(var first in practiceModel.realmFirstTypeDict.Keys)
|
{
|
if(practiceModel.realmFirstTypeDict[first].state == RedPointState.Simple)
|
{
|
isAchieveReach = true;
|
selectFirstType = first;
|
}
|
|
foreach(var second in practiceModel.realmSecondTypeDict[first].Keys)
|
{
|
if(practiceModel.realmSecondTypeDict[first][second].state == RedPointState.Simple)
|
{
|
selectSecondType = second;
|
break;
|
}
|
}
|
|
if(isAchieveReach)
|
{
|
break;
|
}
|
}
|
|
if(!isAchieveReach)
|
{
|
ServerTipDetails.DisplayNormalTip(Language.Get("RealmWin_Practice_1"));
|
}
|
AchievementGoto.guideAchievementId = 0;
|
}
|
}
|
|
InitUI();
|
}
|
|
protected override void OnAfterOpen()
|
{
|
_taskTypeCtrl.vertical = true;
|
_practiceTypeCtrl.mScrollRect.verticalNormalizedPosition = 1;
|
_taskTypeCtrl.mScrollRect.verticalNormalizedPosition = 1;
|
}
|
|
protected override void OnPreClose()
|
{
|
}
|
|
protected override void OnAfterClose()
|
{
|
_practiceTypeCtrl.OnRefreshCell -= RefreshPracticeTypeCell;
|
PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= RefreshRealmPoint;
|
_taskTypeCtrl.OnRefreshCell -= RefreshTaskTypeCell;
|
practiceModel.AchieveModel.achievementCompletedEvent -= RefreshComplete;
|
practiceModel.AchieveModel.achievementAwardableEvent -= RefreshIsReach;
|
}
|
#endregion
|
|
public void InitUI()
|
{
|
OnClickFirstTypeCell(selectFirstType);
|
RefreshUI();
|
isOpen = false;
|
}
|
|
|
private void RefreshComplete(int id)
|
{
|
SuccessConfig successConfig = SuccessConfig.Get(id);
|
RealmPracticeConfig practiceConfig = RealmPracticeConfig.Get(successConfig.RealmPracticeID);
|
|
if (practiceConfig != null && PracticeModellist != null)
|
{
|
if(PracticeModellist.Contains(practiceConfig))
|
{
|
PracticeModellist = practiceModel.GetRealmPracticelist(selectFirstType,selectSecondType);
|
_practiceTypeCtrl.m_Scorller.RefreshActiveCellViews();
|
_taskTypeCtrl.m_Scorller.RefreshActiveCellViews();
|
}
|
}
|
}
|
|
private void RefreshIsReach(int id)
|
{
|
SuccessConfig successConfig = SuccessConfig.Get(id);
|
RealmPracticeConfig practiceConfig = RealmPracticeConfig.Get(successConfig.RealmPracticeID);
|
|
if (practiceConfig != null && PracticeModellist != null)
|
{
|
if (PracticeModellist.Contains(practiceConfig))
|
{
|
PracticeModellist = practiceModel.GetRealmPracticelist(selectFirstType, selectSecondType);
|
_practiceTypeCtrl.m_Scorller.RefreshActiveCellViews();
|
_taskTypeCtrl.m_Scorller.RefreshActiveCellViews();
|
}
|
}
|
}
|
|
private void RefreshRealmPoint(PlayerDataRefresh type)
|
{
|
if (type != PlayerDataRefresh.RealmPoint) return;
|
|
RefreshUI();
|
}
|
|
public void RefreshUI()
|
{
|
_curPracticePointText.text = UIHelper.ReplaceLargeNum(PlayerDatas.Instance.extersion.realmPoint);
|
_tagRealmModel = RealmConfig.Get(PlayerDatas.Instance.baseData.realmLevel);
|
if (_tagRealmModel != null)
|
{
|
_nextRealmPointText.text = Language.Get("RealmPractice101").Replace("{0}",UIHelper.ReplaceLargeNum(_tagRealmModel.NeedPoint));
|
}
|
}
|
|
private void CreatePracticeTypeCell()
|
{
|
_practiceTypeCtrl.Refresh();
|
foreach (var first in realmPraDict.Keys)
|
{
|
_practiceTypeCtrl.AddCell(ScrollerDataType.Header, first);
|
if (selectFirstType == first && !isDoubleClick)
|
{
|
foreach (var second in realmPraDict[first].Keys)
|
{
|
if (second != 0)
|
{
|
_practiceTypeCtrl.AddCell(ScrollerDataType.Normal, second);
|
}
|
}
|
}
|
}
|
_practiceTypeCtrl.Restart();
|
DebugEx.Log("Cell数量" + _practiceTypeCtrl.GetNumberOfCells(_practiceTypeCtrl.m_Scorller));
|
if (_practiceTypeCtrl.GetNumberOfCells(_practiceTypeCtrl.m_Scorller) < _practiceTypeCtrl.maxCellCnt)
|
{
|
_practiceTypeCtrl.mScrollRect.vertical = false;
|
}
|
else
|
{
|
_practiceTypeCtrl.mScrollRect.vertical = true;
|
}
|
}
|
|
private void RefreshPracticeTypeCell(ScrollerDataType type, CellView cell)
|
{
|
switch (type)
|
{
|
case ScrollerDataType.Header:
|
PracticeTypeCell firstType = cell.GetComponent<PracticeTypeCell>();
|
firstType.Init(cell.index,selectFirstType,isDoubleClick);
|
firstType.cellBtn.RemoveAllListeners();
|
firstType.cellBtn.AddListener(() => { OnClickFirstTypeCell(cell.index); });
|
break;
|
case ScrollerDataType.Normal:
|
SecondPraTypeCell secondType = cell.GetComponent<SecondPraTypeCell>();
|
secondType.Init(selectFirstType,cell.index,selectSecondType);
|
secondType.cellBtn.RemoveAllListeners();
|
secondType.cellBtn.AddListener(() => { OnClickSecondTypeCell(cell.index); });
|
break;
|
}
|
}
|
|
private bool isDoubleClick = false;
|
private void OnClickFirstTypeCell(int firstType)
|
{
|
if (!isOpen)
|
{
|
if (selectFirstType == firstType)
|
{
|
if(!isDoubleClick)
|
{
|
isDoubleClick = true;
|
}
|
else
|
{
|
isDoubleClick = false;
|
}
|
CreatePracticeTypeCell();
|
if (!realmPraDict[firstType].ContainsKey(selectSecondType))
|
{
|
selectSecondType = realmPraDict[firstType].Keys.ToList()[0];
|
}
|
CreateTaskTypeCell();
|
return;
|
}
|
|
}
|
isDoubleClick = false;
|
selectFirstType = firstType;
|
selectSecondType = realmPraDict[firstType].Keys.ToList()[0];
|
CreatePracticeTypeCell();
|
CreateTaskTypeCell();
|
}
|
|
private void OnClickSecondTypeCell(int secondType)
|
{
|
selectSecondType = secondType;
|
_practiceTypeCtrl.m_Scorller.RefreshActiveCellViews();
|
CreateTaskTypeCell();
|
}
|
|
private List<RealmPracticeConfig> PracticeModellist;
|
private void CreateTaskTypeCell()
|
{
|
_taskTypeCtrl.Refresh();
|
PracticeModellist = practiceModel.GetRealmPracticelist(selectFirstType,selectSecondType);
|
for (int i = 0; i < PracticeModellist.Count; i++)
|
{
|
_taskTypeCtrl.AddCell(ScrollerDataType.Header, i);
|
|
}
|
_taskTypeCtrl.Restart();
|
if (PracticeModellist.Count < _taskTypeCtrl.maxCellCnt)
|
_taskTypeCtrl.mScrollRect.vertical = false;
|
|
}
|
|
private void RefreshTaskTypeCell(ScrollerDataType type, CellView cell)
|
{
|
TaskTypeCell taskTypeCell = cell.GetComponent<TaskTypeCell>();
|
taskTypeCell.InitModel(PracticeModellist[cell.index]);
|
}
|
|
private void OnClickReceiveReward(int id)
|
{
|
|
practiceModel.AchieveModel.GetAchievementReward(id);
|
}
|
}
|
|
}
|
