using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Text.RegularExpressions;
|
using UnityEngine;
|
namespace vnxbqy.UI
|
{
|
|
public class ReikiRootModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
|
{
|
Dictionary<int, int> m_ReikiRootPoints = new Dictionary<int, int>();
|
Dictionary<int, int> m_ReikiRootFreePoints = new Dictionary<int, int>();
|
Dictionary<int, List<int>> m_RecommendReikiRoots = new Dictionary<int, List<int>>();
|
Dictionary<int, int> m_ReikiQualityMapColors;
|
Dictionary<int, int> m_CacheReikiRootPoints = new Dictionary<int, int>();
|
Dictionary<int, Dictionary<int, List<ReikiQualityProperty>>> m_PromotePropertyValues = new Dictionary<int, Dictionary<int, List<ReikiQualityProperty>>>();
|
Dictionary<int, int> m_ReikiPropertyValues = new Dictionary<int, int>();
|
Dictionary<int, Dictionary<int, List<ReikiPointProperty>>> m_ReikiPointPropertys = new Dictionary<int, Dictionary<int, List<ReikiPointProperty>>>();
|
Dictionary<int, List<int>> m_PreLimitReikiRoots = new Dictionary<int, List<int>>();
|
Dictionary<int, List<int>> m_AfterLimitReikiRoots = new Dictionary<int, List<int>>();
|
|
public Dictionary<int, int> lastReikiRootPoints = new Dictionary<int, int>();
|
public Dictionary<int, int> afterReikiRootPoints = new Dictionary<int, int>();
|
|
public List<int> reikiRoots = new List<int>();
|
|
public Dictionary<int, List<int>> qualityPropertySorts = new Dictionary<int, List<int>>();
|
|
public int freePoint
|
{
|
get
|
{
|
return (int)PlayerDatas.Instance.baseData.FreePoint;
|
}
|
}
|
|
int lastFreePoint = 0;
|
|
int m_CacheFreePoint = 0;
|
public int cacheFreePoint
|
{
|
get { return m_CacheFreePoint; }
|
set
|
{
|
if (m_CacheFreePoint != value)
|
{
|
m_CacheFreePoint = value;
|
if (onCacheFreePointRefresh != null)
|
{
|
onCacheFreePointRefresh();
|
}
|
}
|
}
|
}
|
|
public int maxQuality { get; private set; }
|
|
private Int3 redpointRequirePoint;
|
|
public int freeResetLevel { get; private set; }
|
|
public int[] resetCostItemIds { get; private set; }
|
|
public int[] reikiRootGetWays { get; private set; }
|
|
public bool isServerPrepare { get; private set; }
|
|
public bool displayOpenAnimation
|
{
|
get
|
{
|
return LocalSave.GetBool("ReikiRootOpenAnimation");
|
}
|
set
|
{
|
LocalSave.SetBool("ReikiRootOpenAnimation", value);
|
}
|
}
|
|
public bool resetReikiRootRecord { get; set; }
|
public bool resetReikiRemind { get; set; }
|
public int resetReikiLimitLevel { get; private set; }
|
|
public int selectReikiRoot { get; set; }
|
|
public bool openFromTreasureSkill { get; set; }
|
|
public bool reikiPointPromoteSymbol { get; set; }
|
|
public int effectLimitLevel { get; private set; }
|
|
public int reikiPointAutoAddLevel { get; private set; }
|
public int levelUpAddPoint { get; private set; }
|
public int afterReikiRootLimitLevel { get; private set; }
|
|
public TitleAddPoint titleAddPoint { get; private set; }
|
|
public TreasureAddPoint treasureAddPoint { get; private set; }
|
|
public readonly Redpoint redpoint = new Redpoint(101, 10103);
|
|
public event Action onCacheFreePointRefresh;
|
public event Action onReikiRootPointRefresh;
|
public event Action<int> onReikiRootPointReset;
|
public event Action onReikiRootEffectRefresh;
|
|
TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }
|
TreasureSkillModel treasureSkillModel { get { return ModelCenter.Instance.GetModel<TreasureSkillModel>(); } }
|
|
public override void Init()
|
{
|
ParseConfig();
|
|
PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
|
StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
|
WindowCenter.Instance.windowAfterCloseEvent += WindowAfterCloseEvent;
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
m_ReikiRootPoints.Clear();
|
m_ReikiRootFreePoints.Clear();
|
isServerPrepare = false;
|
resetReikiRootRecord = false;
|
reikiPointPromoteSymbol = false;
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
RefreshReikiRootPoint();
|
lastFreePoint = freePoint;
|
isServerPrepare = true;
|
}
|
|
public override void UnInit()
|
{
|
PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
|
FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
|
StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;
|
WindowCenter.Instance.windowAfterCloseEvent -= WindowAfterCloseEvent;
|
}
|
|
void ParseConfig()
|
{
|
var funcConfig = FuncConfigConfig.Get("RecommendPoint");
|
var json = LitJson.JsonMapper.ToObject(funcConfig.Numerical1);
|
foreach (var jobKey in json.Keys)
|
{
|
var job = int.Parse(jobKey);
|
m_RecommendReikiRoots.Add(job, new List<int>(LitJson.JsonMapper.ToObject<int[]>(json[jobKey].ToJson())));
|
}
|
|
m_ReikiQualityMapColors = ConfigParse.GetDic<int, int>(funcConfig.Numerical2);
|
Int3.TryParse(funcConfig.Numerical3, out redpointRequirePoint);
|
|
reikiRootGetWays = ConfigParse.GetMultipleStr<int>(funcConfig.Numerical4);
|
|
effectLimitLevel = int.Parse(funcConfig.Numerical5);
|
|
funcConfig = FuncConfigConfig.Get("LVUPAddPoint");
|
|
var match = Regex.Match(funcConfig.Numerical1, @"\(([0-9]+)\,[0-9]+\):([0-9]+)");
|
if (match != null)
|
{
|
reikiPointAutoAddLevel = int.Parse(match.Groups[1].Value);
|
levelUpAddPoint = int.Parse(match.Groups[2].Value);
|
}
|
|
freeResetLevel = int.Parse(funcConfig.Numerical4);
|
resetCostItemIds = LitJson.JsonMapper.ToObject<int[]>(funcConfig.Numerical5);
|
|
funcConfig = FuncConfigConfig.Get("LimitAddPoint");
|
json = LitJson.JsonMapper.ToObject(funcConfig.Numerical1);
|
foreach (var jobKey in json.Keys)
|
{
|
var job = int.Parse(jobKey);
|
m_PreLimitReikiRoots.Add(job, new List<int>(LitJson.JsonMapper.ToObject<int[]>(json[jobKey].ToJson())));
|
}
|
resetReikiLimitLevel = int.Parse(funcConfig.Numerical2);
|
|
json = LitJson.JsonMapper.ToObject(funcConfig.Numerical3);
|
foreach (var jobKey in json.Keys)
|
{
|
var job = int.Parse(jobKey);
|
m_AfterLimitReikiRoots.Add(job, new List<int>(LitJson.JsonMapper.ToObject<int[]>(json[jobKey].ToJson())));
|
}
|
afterReikiRootLimitLevel = int.Parse(funcConfig.Numerical4);
|
|
funcConfig = FuncConfigConfig.Get("TitleAddPoint");
|
titleAddPoint = new TitleAddPoint()
|
{
|
titleId = int.Parse(funcConfig.Numerical1),
|
point = int.Parse(funcConfig.Numerical2),
|
};
|
|
funcConfig = FuncConfigConfig.Get("FabaoAddPoint");
|
treasureAddPoint = new TreasureAddPoint()
|
{
|
treasureId = int.Parse(funcConfig.Numerical1),
|
point = int.Parse(funcConfig.Numerical2),
|
};
|
|
var config = ReikiRootConfig.GetValues()[0];
|
maxQuality = config.qualityArea.Length;
|
|
reikiRoots.Add((int)PropertyType.Mater);
|
reikiRoots.Add((int)PropertyType.Wood);
|
reikiRoots.Add((int)PropertyType.Water);
|
reikiRoots.Add((int)PropertyType.Fire);
|
reikiRoots.Add((int)PropertyType.Earth);
|
|
var configs = ReikiRootConfig.GetValues();
|
foreach (var _config in configs)
|
{
|
m_PromotePropertyValues.Add(_config.id, new Dictionary<int, List<ReikiQualityProperty>>());
|
var _json = LitJson.JsonMapper.ToObject(_config.promoteProperty);
|
foreach (var _jobKey in _json.Keys)
|
{
|
var job = int.Parse(_jobKey);
|
m_PromotePropertyValues[_config.id].Add(job, new List<ReikiQualityProperty>());
|
if (!qualityPropertySorts.ContainsKey(job))
|
{
|
qualityPropertySorts.Add(job, new List<int>());
|
}
|
foreach (var _propertyKey in _json[_jobKey].Keys)
|
{
|
var _property = int.Parse(_propertyKey);
|
m_PromotePropertyValues[_config.id][job].Add(new ReikiQualityProperty()
|
{
|
property = _property,
|
propertyValues = LitJson.JsonMapper.ToObject<int[]>(_json[_jobKey][_propertyKey].ToJson())
|
}
|
);
|
|
|
if (!qualityPropertySorts[job].Contains(_property))
|
{
|
qualityPropertySorts[job].Add(_property);
|
}
|
}
|
}
|
_json = LitJson.JsonMapper.ToObject(_config.propertyPerPoint);
|
m_ReikiPointPropertys.Add(_config.id, new Dictionary<int, List<ReikiPointProperty>>());
|
foreach (var jobKey in _json.Keys)
|
{
|
var job = int.Parse(jobKey);
|
m_ReikiPointPropertys[_config.id].Add(job, new List<ReikiPointProperty>());
|
var array = LitJson.JsonMapper.ToObject<int[][]>(_json[jobKey].ToJson());
|
for (int i = 0; i < array.Length; i++)
|
{
|
m_ReikiPointPropertys[_config.id][job].Add(new ReikiPointProperty()
|
{
|
point = array[i][0],
|
property = array[i][1],
|
value = array[i][2],
|
});
|
}
|
}
|
}
|
|
foreach (var propertys in qualityPropertySorts.Values)
|
{
|
propertys.Sort((x, y) =>
|
{
|
var lhs_atk = x == (int)PropertyType.ATK;
|
var rhs_atk = y == (int)PropertyType.ATK;
|
if (lhs_atk != rhs_atk)
|
{
|
return -lhs_atk.CompareTo(rhs_atk);
|
}
|
return x.CompareTo(y);
|
});
|
}
|
}
|
|
private void OnStageLoadFinish()
|
{
|
if (!(StageLoad.Instance.currentStage is DungeonStage))
|
{
|
resetReikiRemind = false;
|
}
|
}
|
|
private void OnFuncStateChangeEvent(int id)
|
{
|
if (id == (int)FuncOpenEnum.ReikiRoot)
|
{
|
RefreshRedpoint();
|
if (isServerPrepare && FuncOpen.Instance.IsFuncOpen(id))
|
{
|
displayOpenAnimation = true;
|
}
|
}
|
}
|
|
private void WindowAfterCloseEvent(Window window)
|
{
|
if (window is TreasureNewGotWin)
|
{
|
if (treasureModel.newGotTreasureId == treasureAddPoint.treasureId)
|
{
|
SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureAddPointRemind());
|
}
|
}
|
}
|
|
IEnumerator Co_OpenTreasureAddPointRemind()
|
{
|
yield return WaitingForSecondConst.WaitMS500;
|
if (!NewBieCenter.Instance.inGuiding)
|
{
|
var reikiPoint = 0;
|
if (PlayerDatas.Instance.baseData.LV >= reikiPointAutoAddLevel)
|
{
|
var levels = PlayerDatas.Instance.baseData.LV - reikiPointAutoAddLevel + 1;
|
reikiPoint = levels * treasureAddPoint.point;
|
}
|
var treasureConfig = TreasureConfig.Get(treasureAddPoint.treasureId);
|
ConfirmCancel.ShowRealmPopConfirm(Language.Get("Mail101"),
|
Language.Get("ReikiRootAddPointRemind_1", treasureConfig.Name, reikiPoint),
|
Language.Get("GotoAddPoint"), () =>
|
{
|
WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.RolePoint);
|
});
|
}
|
}
|
|
public int GetReikiRootQuality(int id, int point)
|
{
|
var config = ReikiRootConfig.Get(id);
|
if (config == null)
|
{
|
return 0;
|
}
|
var quality = 0;
|
for (int i = 0; i < config.qualityArea.Length; i++)
|
{
|
if (point >= config.qualityArea[i])
|
{
|
quality = i + 1;
|
}
|
else
|
{
|
break;
|
}
|
}
|
return quality;
|
}
|
|
public int GetMaxReikiRootQuality(int id)
|
{
|
var config = ReikiRootConfig.Get(id);
|
if (config == null)
|
{
|
return 0;
|
}
|
return config.qualityArea.Length;
|
}
|
|
public int GetReikiRootQuality(int id)
|
{
|
return GetReikiRootQuality(id, GetReikiRootPoint(id));
|
}
|
|
public int GetReikiRootPoint(int id)
|
{
|
return m_ReikiRootPoints.ContainsKey(id) ? m_ReikiRootPoints[id] : 0;
|
}
|
|
public int GetReikiRootFreePoint(int id)
|
{
|
return m_ReikiRootFreePoints.ContainsKey(id) ? m_ReikiRootFreePoints[id] : 0;
|
}
|
|
int GetReikiRootCachePoint(int id)
|
{
|
return m_CacheReikiRootPoints.ContainsKey(id) ? m_CacheReikiRootPoints[id] : 0;
|
}
|
|
public int GetTotalWashPoint()
|
{
|
var totalPoint = 0;
|
foreach (var point in m_ReikiRootFreePoints.Values)
|
{
|
totalPoint += point;
|
}
|
return totalPoint;
|
}
|
|
public int GetReikiRootTotalPoint()
|
{
|
var point = 0;
|
foreach (var _point in m_ReikiRootPoints.Values)
|
{
|
point += _point;
|
}
|
return point;
|
}
|
|
public int GetReikiRootTotalPointWithFree()
|
{
|
return GetReikiRootTotalPoint() + freePoint;
|
}
|
|
public List<ReikiRootRecommend> GetReikiRootRecommendPoint(int point)
|
{
|
if (point == 0)
|
{
|
return null;
|
}
|
|
m_CacheReikiRootPoints.Clear();
|
foreach (var id in m_ReikiRootPoints.Keys)
|
{
|
m_CacheReikiRootPoints[id] = m_ReikiRootPoints[id];
|
}
|
|
var recommends = new List<ReikiRootRecommend>();
|
var job = PlayerDatas.Instance.baseData.Job;
|
|
if (m_RecommendReikiRoots.ContainsKey(job))
|
{
|
var reikis = m_RecommendReikiRoots[job];
|
var surplusPoint = point;
|
while (surplusPoint > 0)
|
{
|
reikis.Sort((int x, int y) =>
|
{
|
var x_point = GetReikiRootCachePoint(x);
|
var y_point = GetReikiRootCachePoint(y);
|
if (x_point != y_point)
|
{
|
return x_point.CompareTo(y_point);
|
}
|
return x.CompareTo(y);
|
});
|
|
var minpoint = GetReikiRootCachePoint(reikis[0]);
|
var samepointIds = reikis.FindAll((x) =>
|
{
|
return GetReikiRootCachePoint(x) == minpoint;
|
});
|
|
var recommendPoint = 0;
|
|
if (samepointIds.Count != reikis.Count)
|
{
|
var secondpointId = reikis.Find((x) =>
|
{
|
return GetReikiRootCachePoint(x) > minpoint;
|
});
|
var secondpoint = GetReikiRootCachePoint(secondpointId);
|
recommendPoint = Mathf.Min((secondpoint - minpoint) * samepointIds.Count, surplusPoint) / samepointIds.Count;
|
}
|
else
|
{
|
recommendPoint = surplusPoint / samepointIds.Count;
|
}
|
|
if (recommendPoint > 0)
|
{
|
foreach (var id in samepointIds)
|
{
|
recommends.Add(new ReikiRootRecommend()
|
{
|
id = id,
|
value = recommendPoint,
|
});
|
surplusPoint -= recommendPoint;
|
m_CacheReikiRootPoints[id] += recommendPoint;
|
}
|
}
|
else
|
{
|
var id = samepointIds[0];
|
recommends.Add(new ReikiRootRecommend()
|
{
|
id = id,
|
value = 1,
|
});
|
surplusPoint -= 1;
|
m_CacheReikiRootPoints[id] += 1;
|
}
|
}
|
}
|
|
return recommends;
|
}
|
|
int GetCacheQualityRequrePoint(int id,int quality)
|
{
|
var requirePoint = 0;
|
var currebtQuality = GetReikiRootQuality(id, GetReikiRootCachePoint(id));
|
if (currebtQuality < quality)
|
{
|
var point = GetReikiRootCachePoint(id);
|
requirePoint = GetQualityPoint(id, quality) - point;
|
}
|
return requirePoint;
|
}
|
|
public int GetQualityPoint(int id, int quality)
|
{
|
var config = ReikiRootConfig.Get(id);
|
for (int i = 0; i < config.qualityArea.Length; i++)
|
{
|
if (quality == i + 1)
|
{
|
return config.qualityArea[i];
|
}
|
}
|
return 0;
|
}
|
|
public void GetReikiRootProperty(int id, int point, ref Dictionary<int, int> propertyDict)
|
{
|
var config = ReikiRootConfig.Get(id);
|
|
var job = PlayerDatas.Instance.baseData.Job;
|
var reikiPointPropertys = m_ReikiPointPropertys[id][job];
|
for (int i = 0; i < reikiPointPropertys.Count; i++)
|
{
|
var reikiPointProperty = reikiPointPropertys[i];
|
if (!propertyDict.ContainsKey(reikiPointProperty.property))
|
{
|
propertyDict.Add(reikiPointProperty.property, 0);
|
}
|
var step = point / reikiPointProperty.point;
|
propertyDict[reikiPointProperty.property] += step * reikiPointProperty.value;
|
}
|
|
var qualityPropertys = m_PromotePropertyValues[id][job];
|
for (int i = 0; i < qualityPropertys.Count; i++)
|
{
|
var propertyId = qualityPropertys[i].property;
|
if (!propertyDict.ContainsKey(propertyId))
|
{
|
propertyDict.Add(propertyId, 0);
|
}
|
var quality = GetReikiRootQuality(id, point);
|
propertyDict[propertyId] += GetQualityProperty(quality, qualityPropertys[i].propertyValues);
|
}
|
}
|
|
public int GetReikiPropertyValue(int id)
|
{
|
if (m_ReikiPropertyValues.ContainsKey(id))
|
{
|
return m_ReikiPropertyValues[id];
|
}
|
return 0;
|
}
|
|
public List<ReikiQualityProperty> GetReikiQualityProperties(int id)
|
{
|
var job = PlayerDatas.Instance.baseData.Job;
|
return m_PromotePropertyValues[id][job];
|
}
|
|
public int GetQualityProperty(int quality, int[] values)
|
{
|
var value = 0;
|
for (int i = 0; i < values.Length; i++)
|
{
|
if (quality > i)
|
{
|
value = values[i];
|
}
|
else
|
{
|
break;
|
}
|
}
|
return value;
|
}
|
|
public static string GetQualityLabel(int quality)
|
{
|
return Language.Get(StringUtility.Contact("ReikiRootQuality_", quality));
|
}
|
|
public int GetQualityColor(int quality)
|
{
|
return m_ReikiQualityMapColors.ContainsKey(quality) ? m_ReikiQualityMapColors[quality] : 1;
|
}
|
|
public int GetUnLimitTimeResetItem()
|
{
|
var itemId = resetCostItemIds[0];
|
for (int i = 0; i < resetCostItemIds.Length; i++)
|
{
|
var config = ItemConfig.Get(resetCostItemIds[i]);
|
if (config.ExpireTime == 0)
|
{
|
return resetCostItemIds[i];
|
}
|
}
|
return itemId;
|
}
|
|
public bool IsQualityProperty(int id, int property)
|
{
|
var propertys = GetReikiQualityProperties(id);
|
foreach (var item in propertys)
|
{
|
if (item.property == property)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool IsPreReikiRoot(int id)
|
{
|
if (PlayerDatas.Instance.baseData.LV >= resetReikiLimitLevel)
|
{
|
return true;
|
}
|
var job = PlayerDatas.Instance.baseData.Job;
|
if (m_PreLimitReikiRoots.ContainsKey(job))
|
{
|
return m_PreLimitReikiRoots[job].Contains(id);
|
}
|
return false;
|
}
|
|
public bool IsAfterReikiRoot(int id)
|
{
|
if (PlayerDatas.Instance.baseData.LV >= afterReikiRootLimitLevel)
|
{
|
return true;
|
}
|
var job = PlayerDatas.Instance.baseData.Job;
|
if (m_AfterLimitReikiRoots.ContainsKey(job))
|
{
|
return m_AfterLimitReikiRoots[job].Contains(id);
|
}
|
return false;
|
}
|
|
public bool IsSatisfyReikiRootCondition(int id, out int condition)
|
{
|
condition = 0;
|
if (!IsAfterReikiRoot(id))
|
{
|
condition = 2;
|
return false;
|
}
|
if (!IsPreReikiRoot(id))
|
{
|
condition = 1;
|
return false;
|
}
|
return true;
|
}
|
|
public void ReceivePackage(HB107_tagMCRolePointInfo package)
|
{
|
var isReikiQualityChange = false;
|
|
foreach (var id in reikiRoots)
|
{
|
lastReikiRootPoints[id] = GetReikiRootPoint(id);
|
afterReikiRootPoints[id] = GetReikiRootPoint(id);
|
}
|
|
for (int i = 0; i < package.PointAttrIDCount; i++)
|
{
|
var id = package.PointAttrIDList[i];
|
|
var lastFreePoint = m_ReikiRootFreePoints.ContainsKey(id) ? m_ReikiRootFreePoints[id] : 0;
|
|
var point = (int)package.PointValueList[i];
|
m_ReikiRootFreePoints[id] = point;
|
|
afterReikiRootPoints[id] = m_ReikiRootPoints[id] - lastFreePoint + point;
|
|
if (GetReikiRootQuality(id, lastReikiRootPoints[id]) <
|
GetReikiRootQuality(id, afterReikiRootPoints[id]))
|
{
|
isReikiQualityChange = true;
|
}
|
|
if (isServerPrepare && lastFreePoint > 0 && point == 0)
|
{
|
if (onReikiRootPointReset != null)
|
{
|
onReikiRootPointReset(id);
|
}
|
}
|
}
|
|
if (isServerPrepare && isReikiQualityChange)
|
{
|
if (!WindowCenter.Instance.IsOpen<ReikiRootQualityPromoteWin>())
|
{
|
if (WindowCenter.Instance.IsOpen<ReikiRootWin>())
|
{
|
WindowCenter.Instance.Open<ReikiRootQualityPromoteWin>();
|
}
|
}
|
}
|
}
|
|
public void SendAddPoint(byte[] points, uint[] pointValues)
|
{
|
var pak = new CB206_tagCMAddPoint();
|
pak.PointAttrIDList = points;
|
pak.PointValueList = pointValues;
|
pak.PointAttrIDCount = (byte)points.Length;
|
GameNetSystem.Instance.SendInfo(pak);
|
}
|
|
private void PlayerDataRefreshEvent(PlayerDataType dataType)
|
{
|
switch (dataType)
|
{
|
case PlayerDataType.CDBPlayerRefresh_Mater:
|
case PlayerDataType.CDBPlayerRefresh_Wood:
|
case PlayerDataType.CDBPlayerRefresh_Water:
|
case PlayerDataType.CDBPlayerRefresh_Fire:
|
case PlayerDataType.CDBPlayerRefresh_Earth:
|
RefreshReikiRootPoint();
|
break;
|
case PlayerDataType.FreePoint:
|
RefreshRedpoint();
|
|
if (freePoint > lastFreePoint && isServerPrepare
|
&& WindowCenter.Instance.IsOpen<AlchemyNormalUseDrugWin>()
|
&& reikiPointPromoteSymbol)
|
{
|
ReikiRootPointPromoteWin.point = new Int2(lastFreePoint, freePoint);
|
WindowCenter.Instance.Open<ReikiRootPointPromoteWin>();
|
}
|
lastFreePoint = freePoint;
|
reikiPointPromoteSymbol = false;
|
break;
|
case PlayerDataType.LV:
|
RefreshRedpoint();
|
break;
|
}
|
}
|
|
public void RefreshReikiRootPoint()
|
{
|
m_ReikiPropertyValues.Clear();
|
foreach (var id in reikiRoots)
|
{
|
m_ReikiRootPoints[id] = (int)UIHelper.GetPropertyValue((PropertyType)id);
|
GetReikiRootProperty(id, m_ReikiRootPoints[id], ref m_ReikiPropertyValues);
|
}
|
|
if (onReikiRootPointRefresh != null)
|
{
|
onReikiRootPointRefresh();
|
}
|
}
|
|
void RefreshRedpoint()
|
{
|
var existFreePoint = false;
|
if (FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.ReikiRoot))
|
{
|
if (PlayerDatas.Instance.baseData.LV < redpointRequirePoint.x)
|
{
|
existFreePoint = freePoint >= redpointRequirePoint.y;
|
}
|
else
|
{
|
existFreePoint = freePoint >= redpointRequirePoint.z;
|
}
|
}
|
redpoint.state = existFreePoint ? RedPointState.Simple : RedPointState.None;
|
}
|
}
|
|
public struct ReikiPointProperty
|
{
|
public int point;
|
public int property;
|
public int value;
|
}
|
|
public struct ReikiQualityProperty
|
{
|
public int property;
|
public int[] propertyValues;
|
}
|
|
public struct ReikiRootRecommend
|
{
|
public int id;
|
public int value;
|
}
|
|
public struct TitleAddPoint
|
{
|
public int titleId;
|
public int point;
|
}
|
|
public struct TreasureAddPoint
|
{
|
public int treasureId;
|
public int point;
|
}
|
|
}
|
|
|
