//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Monday, March 25, 2019
|
//--------------------------------------------------------
|
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
namespace Snxxz.UI
|
{
|
|
public class ReikiRootWin : Window
|
{
|
[SerializeField] List<PropertyBehaviour> m_BasePropertys;
|
[SerializeField] List<PropertyBehaviour> m_SpecialPropertys;
|
[SerializeField] List<ReikiRootPointBehaviour> m_ReikiRootPoints;
|
[SerializeField] RectTransform m_Container;
|
[SerializeField] NumKeyBoard m_NumKeyboard;
|
[SerializeField] UIEffect m_ResetEffect;
|
[SerializeField] Text m_FreePoint;
|
[SerializeField] Button m_Reset;
|
[SerializeField] Text m_ResetLabel;
|
[SerializeField] Button m_GetPath;
|
[SerializeField] Button m_Confirm;
|
[SerializeField] Text m_ConfirmLabel;
|
[SerializeField] Button m_Rule;
|
[SerializeField] Button m_ViewQuality;
|
|
Dictionary<int, int> currentPropertyDict = new Dictionary<int, int>();
|
Dictionary<int, int> upPropertyDict = new Dictionary<int, int>();
|
|
int openKeyboardId = 0;
|
|
bool propertyRefreshDirty = false;
|
|
const float refreshInterval = 0.5f;
|
float timer = 0f;
|
|
Clock resetPointClock = null;
|
|
public DateTime m_ResetAnimationTime = DateTime.MinValue;
|
public DateTime resetAnimationTime
|
{
|
get { return m_ResetAnimationTime; }
|
set
|
{
|
m_ResetAnimationTime = value;
|
resetPointClock = Clock.AlarmAfter(0.7f, () =>
|
{
|
m_ResetEffect.Play();
|
DisplayFreePoint();
|
});
|
}
|
}
|
|
ReikiRootModel model { get { return ModelCenter.Instance.GetModel<ReikiRootModel>(); } }
|
TreasureSkillModel treasureSkillModel { get { return ModelCenter.Instance.GetModel<TreasureSkillModel>(); } }
|
|
#region Built-in
|
protected override void BindController()
|
{
|
}
|
|
protected override void AddListeners()
|
{
|
m_Reset.AddListener(OnReset);
|
m_Confirm.AddListener(Confirm);
|
m_Rule.AddListener(OnRule);
|
m_GetPath.AddListener(GetPath);
|
m_ViewQuality.AddListener(ViewQuality);
|
|
m_NumKeyboard.onValueChange.AddListener(OnPointValChange);
|
m_NumKeyboard.onConfirm.AddListener((bool isOk) =>
|
{
|
if (isOk)
|
{
|
m_NumKeyboard.gameObject.SetActive(false);
|
}
|
});
|
}
|
|
protected override void OnPreOpen()
|
{
|
m_ResetAnimationTime = DateTime.MinValue;
|
|
model.cacheFreePoint = model.freePoint;
|
for (int i = 0; i < m_ReikiRootPoints.Count; i++)
|
{
|
if (i < model.reikiRoots.Count)
|
{
|
m_ReikiRootPoints[i].Display(this, model.reikiRoots[i]);
|
m_ReikiRootPoints[i].gameObject.SetActive(!model.displayOpenAnimation);
|
m_ReikiRootPoints[i].DisplaySelectEffect(model.selectReikiRoot == model.reikiRoots[i]);
|
}
|
}
|
|
model.selectReikiRoot = 0;
|
|
m_NumKeyboard.gameObject.SetActive(false);
|
|
model.onCacheFreePointRefresh += OnCacheFreePointRefresh;
|
PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
|
ReikiFuncOpenWin.onFlyComplete += OnFlyComplete;
|
model.onReikiRootPointRefresh += OnReikiRootPointRefresh;
|
|
Display();
|
}
|
|
protected override void OnAfterOpen()
|
{
|
if (model.displayOpenAnimation)
|
{
|
WindowCenter.Instance.Open<ReikiFuncOpenWin>();
|
model.displayOpenAnimation = false;
|
}
|
}
|
|
protected override void OnPreClose()
|
{
|
model.onCacheFreePointRefresh -= OnCacheFreePointRefresh;
|
PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
|
ReikiFuncOpenWin.onFlyComplete -= OnFlyComplete;
|
model.onReikiRootPointRefresh -= OnReikiRootPointRefresh;
|
for (int i = 0; i < m_ReikiRootPoints.Count; i++)
|
{
|
m_ReikiRootPoints[i].Dispose();
|
}
|
|
if (resetPointClock != null)
|
{
|
Clock.Stop(resetPointClock);
|
resetPointClock = null;
|
}
|
|
treasureSkillModel.newSatisfyActiveExpertDirty = false;
|
model.openFromTreasureSkill = false;
|
|
StopAllCoroutines();
|
}
|
|
protected override void OnAfterClose()
|
{
|
}
|
|
protected override void LateUpdate()
|
{
|
timer += Time.deltaTime;
|
if (timer >= refreshInterval)
|
{
|
timer = 0f;
|
if (propertyRefreshDirty)
|
{
|
DisplayProperty();
|
}
|
}
|
|
if (treasureSkillModel.newSatisfyActiveExpertDirty && !model.openFromTreasureSkill)
|
{
|
if (!WindowCenter.Instance.IsOpen<ReikiRootQualityPromoteWin>())
|
{
|
treasureSkillModel.newSatisfyActiveExpertDirty = false;
|
WindowCenter.Instance.Open<ReikiGotoSkillLevelUpWin>();
|
}
|
}
|
}
|
#endregion
|
|
void Display()
|
{
|
DisplayFreePoint();
|
DisplayProperty();
|
DisplayButtonState();
|
}
|
|
void DisplayFreePoint()
|
{
|
if ((DateTime.Now - resetAnimationTime).TotalSeconds < 0.5f)
|
{
|
return;
|
}
|
m_FreePoint.text = model.cacheFreePoint.ToString();
|
}
|
|
void DisplayProperty()
|
{
|
currentPropertyDict.Clear();
|
upPropertyDict.Clear();
|
|
foreach (var reikiRootPoint in m_ReikiRootPoints)
|
{
|
var id = reikiRootPoint.id;
|
var point = model.GetReikiRootPoint(id);
|
model.GetReikiRootProperty(id, point, ref currentPropertyDict);
|
|
var cachePoint = point + reikiRootPoint.point;
|
model.GetReikiRootProperty(id, cachePoint, ref upPropertyDict);
|
}
|
|
var baseIndex = 0;
|
var specialIndex = 0;
|
foreach (var property in currentPropertyDict.Keys)
|
{
|
var config = PlayerPropertyConfig.Get(property);
|
switch (config.type)
|
{
|
case 1:
|
if (baseIndex < m_BasePropertys.Count)
|
{
|
m_BasePropertys[baseIndex].gameObject.SetActive(true);
|
var value = UIHelper.GetPropertyValue((PropertyType)property);
|
var compareValue = currentPropertyDict[property];
|
var add = upPropertyDict.ContainsKey(property) ?
|
(upPropertyDict[property] - compareValue) : 0;
|
m_BasePropertys[baseIndex].DisplayReiki(property, value, add);
|
}
|
baseIndex++;
|
break;
|
default:
|
if (specialIndex < m_SpecialPropertys.Count)
|
{
|
m_SpecialPropertys[specialIndex].gameObject.SetActive(true);
|
var value = model.GetReikiPropertyValue(property);
|
var compareValue = currentPropertyDict[property];
|
var add = upPropertyDict.ContainsKey(property) ?
|
(upPropertyDict[property] - compareValue) : 0;
|
m_SpecialPropertys[specialIndex].DisplayReiki(property, value, add);
|
}
|
specialIndex++;
|
break;
|
}
|
}
|
for (int i = baseIndex; i < m_BasePropertys.Count; i++)
|
{
|
m_BasePropertys[i].gameObject.SetActive(false);
|
}
|
for (int i = specialIndex; i < m_SpecialPropertys.Count; i++)
|
{
|
m_SpecialPropertys[i].gameObject.SetActive(false);
|
}
|
}
|
|
void DisplayButtonState()
|
{
|
var isResetOpen = PlayerDatas.Instance.baseData.LV >= model.resetReikiLimitLevel;
|
m_Reset.SetColorful(m_ResetLabel, isResetOpen);
|
|
m_Confirm.SetInteractable(m_ConfirmLabel, model.freePoint != model.cacheFreePoint);
|
}
|
|
public void OpenKeyboard(ReikiRootPointBehaviour behaviour)
|
{
|
openKeyboardId = behaviour.id;
|
m_NumKeyboard.gameObject.SetActive(true);
|
m_NumKeyboard.max = (uint)model.cacheFreePoint + (uint)behaviour.point;
|
m_NumKeyboard.min = 0;
|
var trans = behaviour.openKeyboardBottom;
|
|
bool up = m_ReikiRootPoints.IndexOf(behaviour) == m_ReikiRootPoints.Count - 1;
|
|
var worldpos = Vector3.zero;
|
if (!up)
|
{
|
worldpos = trans.TransformPoint(new Vector3(0, -trans.rect.height / 2, 0));
|
}
|
else
|
{
|
var keyBoardRect = m_NumKeyboard.transform as RectTransform;
|
worldpos = trans.TransformPoint(new Vector3(0, trans.rect.height / 2 + keyBoardRect.rect.height, 0));
|
}
|
var localpos = m_Container.InverseTransformPoint(worldpos);
|
m_NumKeyboard.transform.localPosition = localpos;
|
}
|
|
private void OnPointValChange()
|
{
|
var behaviour = m_ReikiRootPoints.Find((x) =>
|
{
|
return x.id == openKeyboardId;
|
});
|
|
var cache = behaviour.point;
|
|
int num = int.Parse(m_NumKeyboard.Value);
|
if (model.cacheFreePoint + cache - num < 0)
|
{
|
num = model.cacheFreePoint + cache;
|
}
|
|
behaviour.point = num;
|
model.cacheFreePoint = model.cacheFreePoint - num + cache;
|
|
m_NumKeyboard.Value = num.ToString();
|
}
|
|
private void OnReset()
|
{
|
if (PlayerDatas.Instance.baseData.LV < model.resetReikiLimitLevel)
|
{
|
SysNotifyMgr.Instance.ShowTip("FuncLimit_WXLGCZ",
|
Language.Get("OpenFunc2", model.resetReikiLimitLevel));
|
return;
|
}
|
if (model.GetTotalWashPoint() <= 0)
|
{
|
SysNotifyMgr.Instance.ShowTip("NoneReikiPointCanWash");
|
return;
|
}
|
WindowCenter.Instance.Open<ReikiRootResetWin>();
|
}
|
|
private void ViewQuality()
|
{
|
WindowCenter.Instance.Open<ReikiQualityInfomationWin>();
|
}
|
|
private void OnRecommend()
|
{
|
var recommends = model.GetReikiRootRecommendPoint(model.freePoint);
|
if (recommends != null)
|
{
|
foreach (var reikiRootPoint in m_ReikiRootPoints)
|
{
|
var point = 0;
|
var list = recommends.FindAll((x) =>
|
{
|
return x.id == reikiRootPoint.id;
|
});
|
if (list != null)
|
{
|
foreach (var recommend in list)
|
{
|
point += recommend.value;
|
}
|
}
|
reikiRootPoint.point = point;
|
}
|
if (model.cacheFreePoint == 0)
|
{
|
OnCacheFreePointRefresh();
|
}
|
model.cacheFreePoint = 0;
|
}
|
}
|
|
private void Confirm()
|
{
|
if (model.freePoint != model.cacheFreePoint)
|
{
|
var length = 0;
|
for (int i = 0; i < m_ReikiRootPoints.Count; i++)
|
{
|
if (m_ReikiRootPoints[i].point > 0)
|
{
|
length++;
|
}
|
}
|
|
var ids = new byte[length];
|
var values = new ushort[length];
|
var index = 0;
|
for (int i = 0; i < m_ReikiRootPoints.Count; i++)
|
{
|
if (m_ReikiRootPoints[i].point > 0)
|
{
|
ids[index] = (byte)m_ReikiRootPoints[i].id;
|
values[index] = (ushort)m_ReikiRootPoints[i].point;
|
index++;
|
}
|
}
|
model.SendAddPoint(ids, values);
|
}
|
}
|
|
private void OnRule()
|
{
|
ModelCenter.Instance.GetModel<HowToPlayModel>().ruleId = 44;
|
WindowCenter.Instance.Open<ReikiRootRuleWin>();
|
}
|
|
private void GetPath()
|
{
|
RealmRecommandEquipGetWayWin.equipGetWays.Clear();
|
RealmRecommandEquipGetWayWin.equipGetWays.AddRange(model.reikiRootGetWays);
|
WindowCenter.Instance.Open<RealmRecommandEquipGetWayWin>();
|
}
|
|
private void OnFlyComplete()
|
{
|
StartCoroutine(Co_DisplayReikis());
|
}
|
|
IEnumerator Co_DisplayReikis()
|
{
|
for (int i = 0; i < m_ReikiRootPoints.Count; i++)
|
{
|
m_ReikiRootPoints[i].gameObject.SetActive(true);
|
yield return WaitingForSecondConst.WaitMS100;
|
}
|
var job = PlayerDatas.Instance.baseData.Job;
|
switch (job)
|
{
|
case 1:
|
NewBieCenter.Instance.StartNewBieGuide(52);
|
break;
|
case 2:
|
NewBieCenter.Instance.StartNewBieGuide(53);
|
break;
|
}
|
}
|
|
private void OnCacheFreePointRefresh()
|
{
|
DisplayFreePoint();
|
DisplayProperty();
|
DisplayButtonState();
|
}
|
|
private void PlayerDataRefreshEvent(PlayerDataType dataType)
|
{
|
if (dataType == PlayerDataType.FreePoint)
|
{
|
model.RefreshReikiRootPoint();
|
if (model.cacheFreePoint == model.freePoint)
|
{
|
OnCacheFreePointRefresh();
|
}
|
model.cacheFreePoint = model.freePoint;
|
|
DisplayButtonState();
|
}
|
else if (dataType == PlayerDataType.LV)
|
{
|
DisplayButtonState();
|
}
|
else
|
{
|
propertyRefreshDirty = true;
|
}
|
}
|
|
private void OnReikiRootPointRefresh()
|
{
|
propertyRefreshDirty = true;
|
}
|
}
|
|
}
|
|
|
|
|
