//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Tuesday, October 23, 2018
|
//--------------------------------------------------------
|
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
namespace Snxxz.UI
|
{
|
|
public class RolePointWin : Window
|
{
|
[SerializeField] Button m_Close;
|
[SerializeField] Button m_Suggest;
|
[SerializeField] Button m_Confirm;
|
[SerializeField] Text m_Point;
|
[SerializeField] RectTransform m_ContainerRight;
|
[SerializeField] List<PropertyValue> m_PropertyValues;
|
[SerializeField] List<AddPointBehaviour> m_AddPoints;
|
[SerializeField] NumKeyBoard m_NumkeyBoard;
|
|
RolePointModel model { get { return ModelCenter.Instance.GetModel<RolePointModel>(); } }
|
|
bool isSpeedUp = false;
|
int presentAddPoint = 0;
|
int surplusPoint = 0;
|
Dictionary<int, int> allocatPoints = new Dictionary<int, int>();
|
|
static WaitForSeconds waitSpeedUp = new WaitForSeconds(0.5f);
|
static WaitForSeconds waitSpeedFaster = new WaitForSeconds(0.05f);
|
static WaitForSeconds waitSpeedSlow = new WaitForSeconds(0.2f);
|
|
const int WAITCNT = 1;
|
|
|
protected override void BindController()
|
{
|
|
}
|
|
protected override void AddListeners()
|
{
|
m_Close.onClick.AddListener(CloseClick);
|
m_Confirm.onClick.AddListener(Confirm);
|
m_Suggest.onClick.AddListener(Suggest);
|
m_NumkeyBoard.onValueChange.AddListener(OnPointValChange);
|
m_NumkeyBoard.onConfirm.AddListener((bool isOk) =>
|
{
|
if (isOk)
|
{
|
m_NumkeyBoard.gameObject.SetActive(false);
|
}
|
});
|
for (int i = 0; i < m_AddPoints.Count; i++)
|
{
|
m_AddPoints[i].onPreview = OnPreview;
|
m_AddPoints[i].onSub = OnSub;
|
m_AddPoints[i].onAdd = OnAdd;
|
}
|
}
|
|
protected override void OnPreOpen()
|
{
|
PlayerDatas.Instance.PlayerDataRefreshInfoEvent += OnPlayerInfoRefresh;
|
m_NumkeyBoard.gameObject.SetActive(false);
|
Dictionary<int, string> dict = null;
|
if (model.TryGetPointFormula(PlayerDatas.Instance.baseData.Job, out dict))
|
{
|
int i = 0;
|
foreach (var _type in dict.Keys)
|
{
|
m_PropertyValues[i].property = _type;
|
i++;
|
}
|
}
|
OnRefreshProprety();
|
isSpeedUp = false;
|
}
|
|
protected override void OnAfterOpen()
|
{
|
HandleAchievement();
|
}
|
|
protected override void OnPreClose()
|
{
|
PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= OnPlayerInfoRefresh;
|
isSpeedUp = false;
|
StopAllCoroutines();
|
}
|
|
protected override void OnAfterClose()
|
{
|
if (!WindowJumpMgr.Instance.IsJumpState
|
&& !WindowCenter.Instance.IsOpen<RolePanel>()
|
&& !WindowCenter.Instance.IsOpen<MainInterfaceWin>())
|
{
|
WindowCenter.Instance.Open<MainInterfaceWin>();
|
}
|
}
|
|
void OnRefreshProprety()
|
{
|
if (model.propertys != null)
|
{
|
for (int i = 0; i < model.propertys.Length; i++)
|
{
|
var proprety = model.propertys[i];
|
var behaviour = m_AddPoints.Find((x) =>
|
{
|
return x.property == proprety;
|
});
|
var config = PlayerPropertyConfig.Get(proprety);
|
behaviour.propertyName.text = config.Name;
|
behaviour.propertyValue.text = UIHelper.GetPropertyMapPlayerData((AttrEnum)proprety).ToString();
|
allocatPoints[proprety] = 0;
|
behaviour.propertyPreview.text = allocatPoints[proprety].ToString();
|
}
|
}
|
|
surplusPoint = (int)PlayerDatas.Instance.baseData.FreePoint;
|
m_Point.text = surplusPoint.ToString();
|
|
OnRefreshAdd();
|
}
|
|
private void OnRefreshAdd()
|
{
|
Equation.Instance.Clear();
|
foreach (var key in allocatPoints.Keys)
|
{
|
var config = PlayerPropertyConfig.Get(key);
|
Equation.Instance.AddKeyValue(config.Parameter, allocatPoints[key]);
|
}
|
Dictionary<int, string> dict = null;
|
if (model.TryGetPointFormula(PlayerDatas.Instance.baseData.Job, out dict))
|
{
|
foreach (var property in dict.Keys)
|
{
|
float value = Equation.Instance.Eval<float>(dict[property]);
|
GetProperty(property).RefreshAdd(value);
|
}
|
}
|
}
|
|
private PropertyValue GetProperty(int property)
|
{
|
return m_PropertyValues.Find((x) =>
|
{
|
return x.property == property;
|
});
|
}
|
|
private void HandleAchievement()
|
{
|
if (AchievementGoto.achievementType == AchievementGoto.RolePoint)
|
{
|
var _effect = AchievementGuideEffectPool.Require(1);
|
_effect.transform.SetParentEx(m_Suggest.transform, Vector3.zero, Vector3.zero, Vector3.one);
|
AchievementGoto.achievementType = 0;
|
}
|
}
|
|
private void Confirm()
|
{
|
foreach (int key in allocatPoints.Keys)
|
{
|
if (allocatPoints[key] > 0)
|
{
|
model.SendAddPoint(key, allocatPoints[key]);
|
}
|
}
|
}
|
|
private void Suggest()
|
{
|
int points = (int)PlayerDatas.Instance.baseData.FreePoint;
|
int totalpoints = points;
|
int pt = 0;
|
|
Dictionary<int, float> suggestDict = null;
|
model.TryGetPointSuggest(PlayerDatas.Instance.baseData.Job, out suggestDict);
|
Dictionary<int, int> initDict = null;
|
model.TryGetPointInit(PlayerDatas.Instance.baseData.Job, out initDict);
|
|
if (suggestDict == null || initDict == null)
|
{
|
return;
|
}
|
|
foreach (var property in suggestDict.Keys)
|
{
|
totalpoints += ((int)UIHelper.GetPropertyMapPlayerData((AttrEnum)property) - initDict[property]);
|
}
|
|
allocatPoints.Clear();
|
foreach (var property in initDict.Keys)
|
{
|
allocatPoints.Add(property, 0);
|
var behaviour = m_AddPoints.Find((x) =>
|
{
|
return x.property == property;
|
});
|
behaviour.propertyPreview.text = allocatPoints[property].ToString();
|
}
|
|
foreach (var property in suggestDict.Keys)
|
{
|
int expectpt = Mathf.RoundToInt(suggestDict[property] * totalpoints);
|
int presentpt = expectpt - ((int)UIHelper.GetPropertyMapPlayerData((AttrEnum)property) - initDict[property]);
|
if (presentpt > 0)
|
{
|
if (pt + presentpt > points)
|
{
|
presentpt = points - pt;
|
}
|
pt += presentpt;
|
allocatPoints[property] = presentpt;
|
}
|
var behaviour = m_AddPoints.Find((x) =>
|
{
|
return x.property == property;
|
});
|
behaviour.propertyPreview.text = allocatPoints[property].ToString();
|
}
|
|
surplusPoint = points - pt;
|
m_Point.text = surplusPoint.ToString();
|
OnRefreshAdd();
|
}
|
|
private void OnPlayerInfoRefresh(PlayerDataRefresh refreshType)
|
{
|
switch (refreshType)
|
{
|
case PlayerDataRefresh.FreePoint:
|
{
|
OnRefreshProprety();
|
}
|
break;
|
case PlayerDataRefresh.STR:
|
case PlayerDataRefresh.PNE:
|
case PlayerDataRefresh.PHY:
|
case PlayerDataRefresh.CON:
|
{
|
OnRefreshProprety();
|
}
|
break;
|
case PlayerDataRefresh.MAXATK:
|
case PlayerDataRefresh.MINATK:
|
case PlayerDataRefresh.MaxHP:
|
case PlayerDataRefresh.DEF:
|
case PlayerDataRefresh.HIT:
|
case PlayerDataRefresh.AtkInterval:
|
case PlayerDataRefresh.BattleValEx1:
|
{
|
foreach (var property in m_PropertyValues)
|
{
|
property.RefreshValue();
|
}
|
}
|
break;
|
}
|
}
|
|
private void OnPointValChange()
|
{
|
var key = presentAddPoint;
|
surplusPoint += allocatPoints[key];
|
int num = int.Parse(m_NumkeyBoard.Value);
|
if (surplusPoint - num < 0)
|
{
|
num = surplusPoint;
|
}
|
allocatPoints[key] = num;
|
surplusPoint -= num;
|
OnUpdatePoint(key);
|
m_NumkeyBoard.Value = num.ToString();
|
}
|
|
private void OnUpdatePoint(int key)
|
{
|
var behaviour = m_AddPoints.Find((x) =>
|
{
|
return x.property == key;
|
});
|
behaviour.propertyPreview.text = allocatPoints[key].ToString();
|
m_Point.text = surplusPoint.ToString();
|
OnRefreshAdd();
|
}
|
|
private void OnAdd(int property, bool down)
|
{
|
if (!down)
|
{
|
isSpeedUp = false;
|
StopAllCoroutines();
|
return;
|
}
|
isSpeedUp = true;
|
if (allocatPoints.ContainsKey(property))
|
{
|
if (surplusPoint < 1)
|
{
|
return;
|
}
|
allocatPoints[property]++;
|
surplusPoint--;
|
OnUpdatePoint(property);
|
}
|
StartCoroutine(Co_OnSpeedUp(true, property));
|
}
|
|
private void OnSub(int property, bool down)
|
{
|
if (!down)
|
{
|
isSpeedUp = false;
|
StopAllCoroutines();
|
return;
|
}
|
isSpeedUp = true;
|
if (allocatPoints.ContainsKey(property))
|
{
|
if (allocatPoints[property] < 1)
|
{
|
return;
|
}
|
allocatPoints[property]--;
|
surplusPoint++;
|
OnUpdatePoint(property);
|
}
|
StartCoroutine(Co_OnSpeedUp(false, property));
|
}
|
|
IEnumerator Co_OnSpeedUp(bool up, int property)
|
{
|
yield return waitSpeedUp;
|
int upCnt = 0;
|
while (isSpeedUp)
|
{
|
if (allocatPoints.ContainsKey(property))
|
{
|
if (up)
|
{
|
if (surplusPoint < 1)
|
{
|
yield break;
|
}
|
allocatPoints[property]++;
|
surplusPoint--;
|
OnUpdatePoint(property);
|
}
|
else
|
{
|
if (allocatPoints[property] < 1)
|
{
|
yield break;
|
}
|
allocatPoints[property]--;
|
surplusPoint++;
|
OnUpdatePoint(property);
|
}
|
}
|
if (upCnt < WAITCNT)
|
{
|
yield return waitSpeedSlow;
|
}
|
else
|
{
|
yield return waitSpeedFaster;
|
}
|
upCnt++;
|
}
|
}
|
|
private void OnPreview(int property)
|
{
|
presentAddPoint = property;
|
m_NumkeyBoard.gameObject.SetActive(true);
|
m_NumkeyBoard.max = (uint)surplusPoint + (uint)allocatPoints[property];
|
m_NumkeyBoard.min = 0;
|
var behaviour = m_AddPoints.Find((x) =>
|
{
|
return x.property == property;
|
});
|
RectTransform parent = behaviour.pointBottom;
|
var worldpos = parent.TransformPoint(new Vector3(0, -parent.rect.height / 2, 0));
|
var localpos = m_ContainerRight.InverseTransformPoint(worldpos);
|
m_NumkeyBoard.transform.localPosition = localpos;
|
}
|
|
[Serializable]
|
public class PropertyValue
|
{
|
private int m_Property;
|
public int property
|
{
|
get
|
{
|
return m_Property;
|
}
|
set
|
{
|
m_Property = value;
|
Refresh();
|
}
|
}
|
|
[SerializeField] Text m_PropertyName;
|
[SerializeField] Text m_PropertyValue;
|
[SerializeField] Text m_PropertyAdd;
|
|
public void Refresh()
|
{
|
var config = PlayerPropertyConfig.Get(property);
|
if (config != null)
|
{
|
m_PropertyName.text = config.Name;
|
RefreshValue();
|
RefreshAdd(0);
|
}
|
}
|
|
public void RefreshValue()
|
{
|
var config = PlayerPropertyConfig.Get(property);
|
if ((AttrEnum)property == AttrEnum.ATK)
|
{
|
m_PropertyValue.text = StringUtility.Contact(UIHelper.ReplaceLargeNum((ulong)PlayerDatas.Instance.extersion.MINATK),
|
"-", UIHelper.ReplaceLargeNum((ulong)PlayerDatas.Instance.extersion.MAXATK));
|
}
|
else
|
{
|
m_PropertyValue.text = UIHelper.ReplaceLargeNum((ulong)UIHelper.GetPropertyMapPlayerData((AttrEnum)property));
|
}
|
}
|
|
public void RefreshAdd(float _value)
|
{
|
m_PropertyAdd.gameObject.SetActive(_value != 0);
|
if (_value > 0)
|
{
|
m_PropertyAdd.text = StringUtility.Contact("+", _value);
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
