using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
using TableConfig;
|
using System;
|
using System.Text;
|
using System.Linq;
|
|
namespace Snxxz.UI
|
{
|
public class RuneModel : Model, IBeforePlayerDataInitialize,IPlayerLoginOk
|
{
|
RuneComposeModel m_RuneComposeModel;
|
RuneComposeModel runeComposeModel {
|
get {
|
return m_RuneComposeModel ?? (m_RuneComposeModel = ModelCenter.Instance.GetModel<RuneComposeModel>());
|
}
|
}
|
|
public override void Init()
|
{
|
ParseConfig();
|
for (int i = 0; i < RUNE_HOLE_COUNT; i++)
|
{
|
Redpoint redpoint = new Redpoint(10801, 1080101 + i);
|
runeHoleRedpoints.Add(redpoint);
|
redpoint.state = RedPointState.None;
|
}
|
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
|
PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerDataRefreshInfoEvent;
|
}
|
|
private void OnFuncStateChangeEvent(int func)
|
{
|
if (func == (int)FuncOpenEnum.Rune)
|
{
|
UpdateRedpoint();
|
UpdateBreakRedpoint();
|
}
|
}
|
|
public override void UnInit()
|
{
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
ClearRuneData();
|
serverInited = false;
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
serverInited = true;
|
}
|
|
#region 配置
|
public const int RUNE_TYPE = 30;
|
public const int RUNE_CREAMTYPE = 31;
|
public const int RUNE_HOLE_COUNT = 9;
|
public Dictionary<int, Dictionary<int, float>> runeAttrDic = new Dictionary<int, Dictionary<int, float>>();
|
public Dictionary<int, float> runeAttrAdditionDic = new Dictionary<int, float>();
|
public Dictionary<int, float> runeExpDic = new Dictionary<int, float>();
|
public Dictionary<int, float> runeEliteAdditonDic = new Dictionary<int, float>();
|
Dictionary<int, int> runeQualityMaxLevel;
|
public int[] runeUnlockArray { get; private set; }
|
public float runeExpAddition { get; private set; }
|
public string runeExpFormula { get; private set; }
|
public int runePackMaxNum { get; private set; }
|
public Dictionary<int, int> doublePropRuneInlayDict { get; private set; }
|
public Dictionary<int,SpecialRuneHoleCondition> specialHoles = new Dictionary<int, SpecialRuneHoleCondition>();
|
int[] specialRedLevels = null;
|
private void ParseConfig()
|
{
|
|
System.Threading.ThreadPool.QueueUserWorkItem(
|
(object aaa) =>
|
{
|
foreach (var key in FuncConfigConfig.m_RuneAttrCfgs.Keys)
|
{
|
runeAttrDic.Add(key, ConfigParse.GetDic<int, float>(FuncConfigConfig.m_RuneAttrCfgs[key].Numerical2));
|
runeAttrAdditionDic.Add(key, float.Parse(FuncConfigConfig.m_RuneAttrCfgs[key].Numerical3));
|
}
|
runeExpDic = ConfigParse.GetDic<int, float>(FuncConfigConfig.GetRuneNeedExpFormula().Numerical2);
|
runeExpAddition = float.Parse(FuncConfigConfig.GetRuneNeedExpFormula().Numerical3);
|
runeEliteAdditonDic = ConfigParse.GetDic<int, float>(FuncConfigConfig.GetRuneNeedExpFormula().Numerical4);
|
runeExpFormula = FuncConfigConfig.GetRuneNeedExpFormula().Numerical1;
|
FuncConfigConfig config = Config.Instance.Get<FuncConfigConfig>("RuneUnlock");
|
if (config != null)
|
{
|
runeUnlockArray = ConfigParse.GetMultipleStr<int>(config.Numerical1);
|
var costDict = ConfigParse.GetDic<int, int>(config.Numerical2);
|
var levelDict = ConfigParse.GetDic<int, int>(config.Numerical3);
|
foreach (var _hole in costDict.Keys)
|
{
|
specialHoles.Add(_hole, new SpecialRuneHoleCondition()
|
{
|
cost = costDict[_hole],
|
level = levelDict.ContainsKey(_hole) ? levelDict[_hole] : 0,
|
});
|
}
|
}
|
config = Config.Instance.Get<FuncConfigConfig>("RunePackageNum");
|
runePackMaxNum = int.Parse(config.Numerical1);
|
|
config = Config.Instance.Get<FuncConfigConfig>("RuneMaxLV");
|
runeQualityMaxLevel = ConfigParse.GetDic<int, int>(config.Numerical1);
|
|
var maxlevel = runeQualityMaxLevel != null ? runeQualityMaxLevel.Values.Last() : 0;
|
|
for (int i = 1; i < maxlevel; i++)
|
{
|
Equation.Instance.Clear();
|
Equation.Instance.AddKeyValue(replaceValStr, i + 1);
|
var _result = Equation.Instance.Eval<float>(runeExpFormula);
|
runeExpResultDict.Add(i + 1, _result);
|
}
|
doublePropertyRunes = new List<int>();
|
var _cfgs = Config.Instance.GetAllValues<RuneComposeConfig>();
|
foreach (var _cfg in _cfgs)
|
{
|
doublePropertyRunes.Add(_cfg.TagItemID);
|
}
|
|
config = Config.Instance.Get<FuncConfigConfig>("RuneDoubleInlayCnt");
|
doublePropRuneInlayDict = ConfigParse.GetDic<int, int>(config.Numerical1);
|
|
config = Config.Instance.Get<FuncConfigConfig>("RuneSpecialRedLevel");
|
specialRedLevels = ConfigParse.GetMultipleStr<int>(config.Numerical1);
|
}
|
);
|
|
}
|
|
private static StringBuilder _textBuilder = new StringBuilder();
|
static readonly string replaceValStr = "level";
|
|
bool serverInited = false;
|
|
private void PlayerDataRefreshInfoEvent(PlayerDataRefresh refreshType)
|
{
|
if (refreshType == PlayerDataRefresh.LV)
|
{
|
UpdateSpecialHoleRedpoint();
|
}
|
}
|
|
public int GetRuneMaxLevel(int _itemColor)
|
{
|
if (runeQualityMaxLevel != null && runeQualityMaxLevel.ContainsKey(_itemColor))
|
{
|
return runeQualityMaxLevel[_itemColor];
|
}
|
if (runeQualityMaxLevel != null)
|
{
|
return runeQualityMaxLevel.Values.Last();
|
}
|
return 0;
|
}
|
|
public int GetRuneMaxLevelByItem(int _itemId)
|
{
|
var config = Config.Instance.Get<ItemConfig>(_itemId);
|
return config == null ? 0 : GetRuneMaxLevel(config.ItemColor);
|
}
|
|
public string GetRuneAttrStr(int id, int level)
|
{
|
_textBuilder.Length = 0;
|
RuneConfig _tagRuneModel = Config.Instance.Get<RuneConfig>(id);
|
int[] runeTypes = _tagRuneModel.AttrType;
|
int i = 0;
|
for (i = 0; i < runeTypes.Length; i++)
|
{
|
PlayerPropertyConfig playerPro = Config.Instance.Get<PlayerPropertyConfig>(runeTypes[i]);
|
string _str = StringUtility.Contact(playerPro.Name, " ", "+",
|
UIHelper.ReplacePercentage(GetRuneAttrVal(id, level, runeTypes[i]), playerPro.ISPercentage),
|
playerPro.ISPercentage == 1 ? "%" : string.Empty, i == runeTypes.Length - 1 ? string.Empty : "\n");
|
_textBuilder.Append(_str);
|
}
|
return _textBuilder.ToString();
|
}
|
public Dictionary<int, Dictionary<int, float>> runeAttrResultDict = new Dictionary<int, Dictionary<int, float>>();
|
public int GetRuneAttrVal(int id, int level, int type)
|
{
|
ItemConfig _tagChinModel = Config.Instance.Get<ItemConfig>(id);
|
RuneConfig _tagRuneModel = Config.Instance.Get<RuneConfig>(id);
|
float runeValue = 0;
|
if (_tagChinModel != null && _tagRuneModel != null)
|
{
|
float params1 = 0;
|
Dictionary<int, float> _dict = null;
|
if (runeAttrResultDict.TryGetValue(type, out _dict))
|
{
|
if (_dict.ContainsKey(level))
|
{
|
params1 = _dict[level];
|
}
|
}
|
else
|
{
|
_dict = new Dictionary<int, float>();
|
runeAttrResultDict.Add(type, _dict);
|
}
|
if (params1 == 0)
|
{
|
Equation.Instance.Clear();
|
Equation.Instance.AddKeyValue(replaceValStr, level);
|
FuncConfigConfig funcRune = FuncConfigConfig.GetRuneAttrFormula(type);
|
params1 = Equation.Instance.Eval<float>(funcRune.Numerical1);
|
_dict.Add(level, params1);
|
}
|
int[] runeTypes = _tagRuneModel.AttrType;
|
float params2 = runeAttrDic[type][_tagChinModel.ItemColor];
|
if (runeTypes.Length > 1)
|
{
|
float coe = runeAttrAdditionDic[type];
|
coe = coe == 0 ? 1 : coe;
|
runeValue = params1 * params2 * coe;
|
}
|
else
|
{
|
runeValue = params1 * params2;
|
}
|
}
|
return Mathf.RoundToInt(runeValue);
|
}
|
private Dictionary<int, float> runeExpResultDict = new Dictionary<int, float>();
|
public List<int> doublePropertyRunes { get; private set; }
|
public int GetRuneNeedExp(int id, int level)
|
{
|
float _levelUpExp = 0;
|
ItemConfig _tagChinModel = Config.Instance.Get<ItemConfig>(id);
|
if (level < GetRuneMaxLevel(_tagChinModel.ItemColor))
|
{
|
float _result = 0;
|
if (runeExpResultDict.ContainsKey(level + 1))
|
{
|
_result = runeExpResultDict[level + 1];
|
}
|
else
|
{
|
Equation.Instance.Clear();
|
Equation.Instance.AddKeyValue(replaceValStr, level + 1);
|
_result = Equation.Instance.Eval<float>(runeExpFormula);
|
runeExpResultDict.Add(level + 1, _result);
|
}
|
RuneConfig cfg = Config.Instance.Get<RuneConfig>(id);
|
if (cfg.AttrType.Length > 1)
|
{
|
_levelUpExp = _result * runeExpDic[_tagChinModel.ItemColor] * runeExpAddition;
|
}
|
else
|
{
|
_levelUpExp = _result * runeExpDic[_tagChinModel.ItemColor];
|
}
|
}
|
return Mathf.RoundToInt(_levelUpExp);
|
}
|
|
public float GetRuneSoulBreakExp(RuneData _rune)
|
{
|
ItemConfig _itemCfg = Config.Instance.Get<ItemConfig>(_rune.id);
|
var _treasureSoul = ModelCenter.Instance.GetModel<TreasureSoulModel>();
|
var _upper = (float)_treasureSoul.GetTreasureSoulValue((int)TreasurePrivilege.RuneBreakExpAdd) / 10000;
|
if (_itemCfg.Type == RUNE_CREAMTYPE)
|
{
|
return _itemCfg.EffectValueA1 * _upper;
|
}
|
else
|
{
|
return runeEliteAdditonDic[_itemCfg.ItemColor] * _upper;
|
}
|
}
|
|
public float GetRuneBreakExp(RuneData _rune, bool _compose = false)
|
{
|
float _exp = 0;
|
ItemConfig _itemCfg = Config.Instance.Get<ItemConfig>(_rune.id);
|
var _treasureSoul = ModelCenter.Instance.GetModel<TreasureSoulModel>();
|
var _upper = (float)_treasureSoul.GetTreasureSoulValue((int)TreasurePrivilege.RuneBreakExpAdd) / 10000;
|
if (_itemCfg.Type == RUNE_CREAMTYPE)
|
{
|
return _itemCfg.EffectValueA1 + _itemCfg.EffectValueA1 * _upper;
|
}
|
for (int i = 1; i <= _rune.lv; i++)
|
{
|
if (i == 1 && !_compose)
|
{
|
_exp += runeEliteAdditonDic[_itemCfg.ItemColor] + runeEliteAdditonDic[_itemCfg.ItemColor] * _upper;
|
}
|
else
|
{
|
_exp += GetRuneNeedExp(_rune.id, i - 1);
|
}
|
}
|
return _exp;
|
}
|
|
public int GetRuneLevelByExp(int id, float _exp)
|
{
|
float _totalExp = 0;
|
var maxlevel = runeQualityMaxLevel != null ? runeQualityMaxLevel.Values.Last() : 0;
|
for (int i = 1; i < maxlevel; i++)
|
{
|
_totalExp += GetRuneNeedExp(id, i);
|
if (_totalExp > _exp)
|
{
|
return i;
|
}
|
}
|
return maxlevel;
|
}
|
#endregion
|
public const int RUNE_REDPOINT_INTERVAL = 100;
|
private Redpoint runeRedpoint = new Redpoint(1, 108);
|
private Redpoint m_RuneMosaicRedpoint = new Redpoint(108, 10801);
|
public Redpoint runeLevelUpRedpoint = new Redpoint(1080120);
|
public Redpoint runeReplaceRedpoint = new Redpoint(1080130);
|
private List<Redpoint> runeHoleRedpoints = new List<Redpoint>();
|
public Redpoint runeMosaicRedpoint { get { return m_RuneMosaicRedpoint; } }
|
public Redpoint specialRuneRemindRedpoint = new Redpoint(10801, 1080140);
|
public Redpoint GetRedpoint(int _hole)
|
{
|
return runeHoleRedpoints[_hole];
|
}
|
|
void UpdateSpecialHoleRedpoint()
|
{
|
specialRuneRemindRedpoint.state = RedPointState.None;
|
if (DayRemind.Instance.GetDayRemind(DayRemind.RUNE_SPECIAL_HOLE))
|
{
|
return;
|
}
|
foreach (var hole in specialHoles.Keys)
|
{
|
if (IsRuneHoleOpen(hole))
|
{
|
continue;
|
}
|
if (PlayerDatas.Instance.baseData.LV >= specialHoles[hole].level
|
&& PlayerDatas.Instance.baseData.LV >= specialRedLevels[0]
|
&& PlayerDatas.Instance.baseData.LV < specialRedLevels[1])
|
{
|
specialRuneRemindRedpoint.state = RedPointState.Simple;
|
break;
|
}
|
}
|
}
|
|
public void SetDayRemind()
|
{
|
if (specialRuneRemindRedpoint.state == RedPointState.Simple)
|
{
|
DayRemind.Instance.SetDayRemind(DayRemind.RUNE_SPECIAL_HOLE, true);
|
UpdateSpecialHoleRedpoint();
|
}
|
}
|
|
|
/// <summary>
|
/// 新版符印红点
|
///1.有可操作的时候仅按优先级显示1个红点
|
///2.优先级：可镶嵌>可替换>可升级
|
///3.同时有可镶嵌，可替换，可升级的符印孔时，默认只显示1个红点在镶嵌孔上
|
///4.镶嵌：同时存在2个或以上的孔可镶嵌时，优先显示在孔位低的孔上，当孔上镶嵌了符印后，红点在下一个可镶嵌孔位置上显示，直至没有新符印可镶嵌，才继续判断更好品质符印的替换逻辑
|
///5.替换：同上，有可替换更好品质的符印时，显示红点，同时多个时，从孔位低的开始显示，直到没有可替换的孔，再判断符印可升级的逻辑
|
///6.升级：仅一个符印满足升级条件时，红点在该孔上；同时存在多个符印孔可升级时，红点显示在符印等级最低的孔上；符印等级相同时，红点显示在消耗少的孔上；升级需要的精华相同时，按孔位低的优先显示红点
|
///7.右下角操作按钮：可镶嵌时镶嵌按钮红点显示；替换和升级同时满足时，仅替换按钮显示红点；无镶嵌和替换时，升级按钮红点显示
|
///8.选中有红点的符印孔时，符印孔上的红点隐藏不显示
|
/// </summary>
|
List<int> runelevelUpSorts = new List<int>();
|
public void UpdateRedpoint()
|
{
|
for (int i = 0; i < runeHoleRedpoints.Count; i++)
|
{
|
runeHoleRedpoints[i].state = RedPointState.None;
|
}
|
runeLevelUpRedpoint.state = RedPointState.None;
|
runeReplaceRedpoint.state = RedPointState.None;
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Rune))
|
{
|
return;
|
}
|
var _holeCount = runeHoleRedpoints.Count;
|
for (int i = 0; i < _holeCount; i++)
|
{
|
var _data = GetHoleRune(i);
|
if (_data == null && CanMosaicRune(i))
|
{
|
runeHoleRedpoints[i].state = RedPointState.Simple;
|
if (sltRuneHole == i)
|
{
|
runeReplaceRedpoint.state = RedPointState.Simple;
|
}
|
return;
|
}
|
}
|
for (int i = 0; i < _holeCount; i++)
|
{
|
var _data = GetHoleRune(i);
|
if (_data != null && CanEquipBetterRune(i))
|
{
|
runeHoleRedpoints[i].state = RedPointState.Simple;
|
if (sltRuneHole == i)
|
{
|
runeReplaceRedpoint.state = RedPointState.Simple;
|
}
|
return;
|
}
|
}
|
runelevelUpSorts.Clear();
|
for (int i = 0; i < _holeCount; i++)
|
{
|
var _data = GetHoleRune(i);
|
if (_data != null && RuneSplinters >= GetRuneNeedExp(_data.id, _data.lv)
|
&& _data.lv < GetRuneMaxLevelByItem(_data.id))
|
{
|
runelevelUpSorts.Add(i);
|
}
|
}
|
if (runelevelUpSorts.Count > 0)
|
{
|
runelevelUpSorts.Sort(CompareLevelUp);
|
runeHoleRedpoints[runelevelUpSorts[0]].state = RedPointState.Simple;
|
if (sltRuneHole == runelevelUpSorts[0])
|
{
|
runeLevelUpRedpoint.state = RedPointState.Simple;
|
}
|
}
|
}
|
|
int CompareLevelUp(int x, int y)
|
{
|
var _data_x = GetHoleRune(x);
|
var _data_y = GetHoleRune(y);
|
if (_data_x.lv != _data_y.lv)
|
{
|
return _data_x.lv.CompareTo(_data_y.lv);
|
}
|
var _cost_x = GetRuneNeedExp(_data_x.id, _data_x.lv);
|
var _cost_y = GetRuneNeedExp(_data_y.id, _data_y.lv);
|
if (_cost_x != _cost_y)
|
{
|
return _cost_x.CompareTo(_cost_y);
|
}
|
return x.CompareTo(y);
|
}
|
|
private Redpoint m_ResolveRedpoint = new Redpoint(108, 10802);
|
public void UpdateBreakRedpoint()
|
{
|
m_ResolveRedpoint.state = RedPointState.None;
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Rune))
|
{
|
return;
|
}
|
|
m_ResolveRedpoint.state = runePackData.Count >= runePackMaxNum && !IsEmptyHole() ? RedPointState.Simple : RedPointState.None;
|
}
|
|
public bool CanLevelUpRune(int _hole)
|
{
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Rune))
|
{
|
return false;
|
}
|
RuneData runeData = GetHoleRune(_hole);
|
if (runeData != null)
|
{
|
if (RuneSplinters > GetRuneNeedExp(runeData.id, runeData.lv)
|
&& runeData.lv < GetRuneMaxLevelByItem(runeData.id))
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool CanLevelUpRune(out int _hole)
|
{
|
_hole = 0;
|
for (int i = 0; i < RUNE_HOLE_COUNT; i++)
|
{
|
if (CanLevelUpRune(i))
|
{
|
_hole = i;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool CanMosaicRune(int _hole)
|
{
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Rune))
|
{
|
return false;
|
}
|
RuneData runeData = GetHoleRune(_hole);
|
if (runeData == null && IsRuneHoleOpen(_hole))
|
{
|
foreach (var rune in runePackData.Values)
|
{
|
ItemConfig _itemCfg = Config.Instance.Get<ItemConfig>(rune.id);
|
if (_itemCfg.Type == RUNE_CREAMTYPE)
|
{
|
continue;
|
}
|
if (!IsSameInHoleRune(_itemCfg.ID, _hole))
|
{
|
if (runeComposeModel.m_RuneBothPropertys.Contains(rune.id)
|
&& GetDoublePropLimitCount() <= GetCurrentDoublePropCount())
|
{
|
return false;
|
}
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
public int GetDoublePropLimitCount()
|
{
|
var _count = 0;
|
foreach (var _key in doublePropRuneInlayDict.Keys)
|
{
|
if (RuneTowerOpenLV >= _key)
|
{
|
_count = doublePropRuneInlayDict[_key];
|
}
|
else
|
{
|
break;
|
}
|
}
|
return _count;
|
}
|
|
public int GetCurrentDoublePropCount()
|
{
|
var _count = 0;
|
foreach (var _rune in runeHoleData.Values)
|
{
|
if (runeComposeModel.m_RuneBothPropertys.Contains(_rune.id))
|
{
|
_count += 1;
|
}
|
}
|
return _count;
|
}
|
|
public int SurplusRunePackCnt {
|
get {
|
return runePackMaxNum - runePackData.Count;
|
}
|
}
|
private Dictionary<int, RuneData> runePackData = new Dictionary<int, RuneData>();
|
private Dictionary<int, RuneData> runeHoleData = new Dictionary<int, RuneData>();
|
private uint runeTowerOpenLv = 0;
|
public uint RuneTowerOpenLV {
|
get { return runeTowerOpenLv; }
|
}
|
public event Action OnRefreshRuneHole;
|
public event Action OnRefreshRunePack;
|
public event Action OnRefreshRuneExp;
|
public event Action OnRefreshRuneChip;
|
public event Action OnRefreshRuneTowerLv;
|
private uint holeState = 0;
|
public int sltRuneHole = -1;
|
private int runeSplinters = 0;
|
public int RuneSplinters {
|
get {
|
return runeSplinters;
|
}
|
}
|
private int runeChip = 0;
|
public int RuneChip {
|
get {
|
return runeChip;
|
}
|
}
|
public void SetRuneChip(int val)
|
{
|
runeChip = val;
|
if (OnRefreshRuneChip != null)
|
OnRefreshRuneChip();
|
}
|
public void SetRuneSplinters(int val)
|
{
|
runeSplinters = val;
|
if (OnRefreshRuneExp != null)
|
{
|
OnRefreshRuneExp();
|
}
|
UpdateRedpoint();
|
}
|
public void OnRunePackRefresh(HA204_tagMCVPackRefresh vNetData)
|
{
|
for (ushort i = 0; i < vNetData.Count; i++)
|
{
|
HA204_tagMCVPackRefresh.tagMCVPackItem item = vNetData.VPacklItemList[i];
|
string runeData = item.ItemData.ToString();
|
int dlt = 10 - runeData.Length;
|
_textBuilder.Length = 0;
|
_textBuilder.Append('0', dlt);
|
runeData = runeData.Insert(0, _textBuilder.ToString());
|
int id = int.Parse(runeData.Substring(5, 5));
|
int lv = int.Parse(runeData.Substring(2, 3)) + 1;
|
int sourceType = int.Parse(runeData.Substring(1, 1));
|
int packType = vNetData.PackType;
|
int index = item.ItemPlace;
|
RuneData data = null;
|
runePackData.TryGetValue(index, out data);
|
if (data == null)
|
{
|
data = new RuneData(index, id, lv, packType, sourceType, 0);
|
runePackData.Add(index, data);
|
}
|
else
|
{
|
data.SetRuneData(index, id, lv, packType, sourceType, 0);
|
}
|
}
|
if (OnRefreshRunePack != null)
|
{
|
OnRefreshRunePack();
|
}
|
UpdateRedpoint();
|
UpdateBreakRedpoint();
|
}
|
public void OnRunePackClear(HA205_tagMCVPackClear vNetData)
|
{
|
for (ushort i = 0; i < vNetData.Count; i++)
|
{
|
int index = vNetData.ItemPlaceList[i];
|
if (runePackData.ContainsKey(index))
|
{
|
runePackData.Remove(index);
|
}
|
}
|
if (OnRefreshRunePack != null)
|
{
|
OnRefreshRunePack();
|
}
|
UpdateRedpoint();
|
UpdateBreakRedpoint();
|
}
|
|
public event Action<int> openNewHoleEvent;
|
public void OnRuneHoleRefresh(HA31F_tagMCRuneInfo vNetData)
|
{
|
uint oldHoleState = holeState;
|
holeState = vNetData.RuneHoleOpenState;
|
for (byte i = 0; i < vNetData.Count; i++)
|
{
|
RuneData data = null;
|
runeHoleData.TryGetValue(i, out data);
|
if (IsRuneHoleOpen(i) && vNetData.RuneDataList[i] != 0)
|
{
|
_textBuilder.Length = 0;
|
string runeData = vNetData.RuneDataList[i].ToString();
|
int dlt = 10 - runeData.Length;
|
_textBuilder.Length = 0;
|
_textBuilder.Append('0', dlt);
|
runeData = runeData.Insert(0, _textBuilder.ToString());
|
int id = int.Parse(runeData.Substring(5, 5));
|
if (id == 0)
|
{
|
continue;
|
}
|
int lv = int.Parse(runeData.Substring(2, 3)) + 1;
|
int sourceType = int.Parse(runeData.Substring(1, 1));
|
int placetype = 1;
|
if (data == null)
|
{
|
data = new RuneData(i, id, lv, (int)PackType.rptInterimPack, sourceType, placetype);
|
runeHoleData.Add(i, data);
|
}
|
else
|
{
|
data.SetRuneData(i, id, lv, (int)PackType.rptInterimPack, sourceType, placetype);
|
}
|
}
|
else
|
{
|
if (data != null)
|
{
|
data = null;
|
runeHoleData.Remove(i);
|
}
|
}
|
}
|
for (int i = 0; i < RUNE_HOLE_COUNT; i++)
|
{
|
if (!serverInited)
|
{
|
break;
|
}
|
int k = 1 << i;
|
var oldOpen = (oldHoleState & k) == k;
|
if (!oldOpen && IsRuneHoleOpen(i))
|
{
|
if (openNewHoleEvent != null)
|
{
|
openNewHoleEvent(i);
|
}
|
}
|
}
|
if (OnRefreshRuneHole != null)
|
{
|
OnRefreshRuneHole();
|
}
|
UpdateRedpoint();
|
UpdateBreakRedpoint();
|
UpdateSpecialHoleRedpoint();
|
}
|
|
public void UnlockSpecialHole(int hole)
|
{
|
if (IsSpeicalHole(hole))
|
{
|
if (IsRuneHoleOpen(hole))
|
{
|
return;
|
}
|
int error = 0;
|
if (!TestUnlockSpeicalHole(hole, out error))
|
{
|
ProcessUnlockError(error, specialHoles[hole]);
|
return;
|
}
|
CA513_tagCMUnlockRuneHole pak = new CA513_tagCMUnlockRuneHole();
|
pak.HoleIndex = (byte)hole;
|
GameNetSystem.Instance.SendInfo(pak);
|
}
|
}
|
|
public bool TestUnlockSpeicalHole(int hole, out int error)
|
{
|
error = 0;
|
SpecialRuneHoleCondition speicalHole;
|
if (specialHoles.TryGetValue(hole, out speicalHole))
|
{
|
if (PlayerDatas.Instance.baseData.LV < speicalHole.level)
|
{
|
error = 1;
|
return false;
|
}
|
if (PlayerDatas.Instance.baseData.Gold < speicalHole.cost)
|
{
|
error = 2;
|
return false;
|
}
|
return true;
|
}
|
return false;
|
}
|
|
public void ProcessUnlockError(int error, SpecialRuneHoleCondition specialHole)
|
{
|
switch (error)
|
{
|
case 1:
|
SysNotifyMgr.Instance.ShowTip("RuneSpecialHoleLevelError", specialHole.level);
|
break;
|
case 2:
|
WindowCenter.Instance.Open<RechargeTipWin>();
|
break;
|
}
|
}
|
|
public bool ResolveFusionStone(int sourceType)
|
{
|
if (sourceType == 0 || sourceType == 2)
|
{
|
return true;
|
}
|
return false;
|
}
|
|
public bool IsSpeicalHole(int hole)
|
{
|
return specialHoles.ContainsKey(hole);
|
}
|
|
public bool IsRuneHoleOpen(int hole)
|
{
|
if (holeState < 1)
|
{
|
return false;
|
}
|
int k = 1 << hole;
|
if ((holeState & k) == k)
|
{
|
return true;
|
}
|
return false;
|
}
|
public RuneData GetHoleRune(int hole)
|
{
|
RuneData data = null;
|
runeHoleData.TryGetValue(hole, out data);
|
return data;
|
}
|
public Dictionary<int, RuneData> GetAllRuneData()
|
{
|
return runeHoleData;
|
}
|
public int GetHoleRuneCnt()
|
{
|
return runeHoleData.Count;
|
}
|
|
public bool IsEmptyHole()
|
{
|
for (int i = 0; i < RUNE_HOLE_COUNT; i++)
|
{
|
if (IsRuneHoleOpen(i) && !runeHoleData.ContainsKey(i))
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public Dictionary<int, RuneData> GetPackRune()
|
{
|
return runePackData;
|
}
|
|
public int RuneCount {
|
get {
|
var _count = 0;
|
foreach (var _rune in runePackData.Values)
|
{
|
if (!_rune.IsRuneCream)
|
{
|
_count++;
|
}
|
}
|
return _count;
|
}
|
}
|
|
public int GetRuneCountById(int _itemId)
|
{
|
var count = 0;
|
foreach (var _rune in runePackData.Values)
|
{
|
if (_rune.id == _itemId)
|
{
|
count += 1;
|
}
|
}
|
return count;
|
}
|
|
/// <summary>
|
///得到所有的解锁符印Id
|
/// </summary>
|
/// <returns></returns>
|
public Dictionary<int, List<int>> GetAllUnlockRuneIdlist()
|
{
|
List<RuneConfig> runes = Config.Instance.GetAllValues<RuneConfig>();
|
if (runes == null) return null;
|
|
Dictionary<int, List<int>> unlockDict = new Dictionary<int, List<int>>();
|
for (int i = 0; i < runes.Count; i++)
|
{
|
int offset = (int)RuneTowerOpenLV - runes[i].TowerID;
|
if (offset >= 0 && runes[i].AttrType.Length < 2)
|
{
|
if (!unlockDict.ContainsKey(runes[i].TowerID))
|
{
|
List<int> unlocklist = new List<int>();
|
unlocklist.Add(runes[i].ID);
|
unlockDict.Add(runes[i].TowerID, unlocklist);
|
}
|
else
|
{
|
unlockDict[runes[i].TowerID].Add(runes[i].ID);
|
}
|
}
|
}
|
return unlockDict;
|
}
|
|
public bool CanEquipRune(int _color, out int _hole)
|
{
|
_hole = 0;
|
foreach (var _rune in runePackData.Values)
|
{
|
var _itemCfg = Config.Instance.Get<ItemConfig>(_rune.id);
|
if (_itemCfg.Type == RUNE_CREAMTYPE)
|
{
|
continue;
|
}
|
else
|
{
|
if (_itemCfg.ItemColor >= _color)
|
{
|
if (CanEquipHoleRune(_itemCfg.ID, _itemCfg.ItemColor, out _hole))
|
{
|
return true;
|
}
|
}
|
}
|
}
|
return false;
|
}
|
|
public bool CanEquipBetterRune(int _hole)
|
{
|
var _runeHole = GetHoleRune(_hole);
|
if (_runeHole == null)
|
{
|
return false;
|
}
|
var _runeCfg = Config.Instance.Get<RuneConfig>(_runeHole.id);
|
var _itemCfg = Config.Instance.Get<ItemConfig>(_runeHole.id);
|
var _propertyType = _runeCfg.AttrType[0];
|
if (_runeCfg == null)
|
{
|
return false;
|
}
|
foreach (var _rune in runePackData.Values)
|
{
|
if (_rune.IsRuneCream)
|
{
|
continue;
|
}
|
var _runeBetterCfg = Config.Instance.Get<RuneConfig>(_rune.id);
|
if (_runeBetterCfg == null)
|
{
|
continue;
|
}
|
bool _same = false;
|
for (int i = 0; i < _runeBetterCfg.AttrType.Length; i++)
|
{
|
if (_runeBetterCfg.AttrType[i] == _propertyType)
|
{
|
_same = true;
|
break;
|
}
|
}
|
if (!_same)
|
{
|
continue;
|
}
|
var _itemBetterCfg = Config.Instance.Get<ItemConfig>(_rune.id);
|
if (_itemBetterCfg.ItemColor > _itemCfg.ItemColor
|
|| (_itemBetterCfg.ItemColor == _itemCfg.ItemColor && _runeCfg.AttrType.Length == 1 && _runeBetterCfg.AttrType.Length == 2))
|
{
|
if (runeComposeModel.m_RuneBothPropertys.Contains(_rune.id)
|
&& GetDoublePropLimitCount() <= GetCurrentDoublePropCount()
|
&& !runeComposeModel.m_RuneBothPropertys.Contains(_runeHole.id))
|
{
|
return false;
|
}
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool IsBetterRune(RuneData _data, int _hole)
|
{
|
var _runeHole = GetHoleRune(_hole);
|
if (_runeHole == null)
|
{
|
return false;
|
}
|
var _runeCfg = Config.Instance.Get<RuneConfig>(_runeHole.id);
|
var _itemCfg = Config.Instance.Get<ItemConfig>(_runeHole.id);
|
var _propertyType = _runeCfg.AttrType[0];
|
if (_runeCfg == null)
|
{
|
return false;
|
}
|
if (_data.IsRuneCream)
|
{
|
return false;
|
}
|
var _runeBetterCfg = Config.Instance.Get<RuneConfig>(_data.id);
|
bool _same = false;
|
for (int i = 0; i < _runeBetterCfg.AttrType.Length; i++)
|
{
|
if (_runeBetterCfg.AttrType[i] == _propertyType)
|
{
|
_same = true;
|
break;
|
}
|
}
|
if (!_same)
|
{
|
return false;
|
}
|
var _itemBetterCfg = Config.Instance.Get<ItemConfig>(_data.id);
|
if (_itemBetterCfg.ItemColor > _itemCfg.ItemColor
|
|| (_itemBetterCfg.ItemColor == _itemCfg.ItemColor && _runeCfg.AttrType.Length == 1 && _runeBetterCfg.AttrType.Length == 2))
|
{
|
if (runeComposeModel.m_RuneBothPropertys.Contains(_data.id)
|
&& GetDoublePropLimitCount() <= GetCurrentDoublePropCount()
|
&& !runeComposeModel.m_RuneBothPropertys.Contains(_runeHole.id))
|
{
|
return false;
|
}
|
return true;
|
}
|
return false;
|
}
|
|
public bool CanEquipHoleRune(int id, int _color, out int _hole)
|
{
|
_hole = 0;
|
for (int i = 0; i < RUNE_HOLE_COUNT; i++)
|
{
|
if (!IsRuneHoleOpen(i))
|
{
|
return false;
|
}
|
var _rune = GetHoleRune(i);
|
if (runeComposeModel.m_RuneBothPropertys.Contains(id))
|
{
|
if (GetDoublePropLimitCount() <= GetCurrentDoublePropCount())
|
{
|
return false;
|
}
|
}
|
if (_rune == null)
|
{
|
if (IsSameInHoleRune(id, i))
|
{
|
continue;
|
}
|
_hole = i;
|
return true;
|
}
|
else
|
{
|
var _itemCfg = Config.Instance.Get<ItemConfig>(_rune.id);
|
if (_itemCfg.ItemColor < _color && !IsSameInHoleRune(id, i))
|
{
|
_hole = i;
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
public RuneData GetPackRune(int index)
|
{
|
RuneData data = null;
|
runePackData.TryGetValue(index, out data);
|
return data;
|
}
|
public List<RuneData> runePackList { get; set; }
|
public void OnRuneTowerRefresh(HA3BA_tagMCTrialTowerInfo vNetData)
|
{
|
if (runeTowerOpenLv != vNetData.PassLV)
|
{
|
runeTowerOpenLv = vNetData.PassLV;
|
if (OnRefreshRuneTowerLv != null)
|
{
|
OnRefreshRuneTowerLv();
|
}
|
}
|
UpdateRedpoint();
|
}
|
|
public bool IsSameInHoleRune(int id, int hole)
|
{
|
var _runeConfig = Config.Instance.Get<RuneConfig>(id);
|
for (int i = 0; i < _runeConfig.AttrType.Length; i++)
|
{
|
if (IsSameRune(_runeConfig.AttrType[i], hole))
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool IsSameRune(int type, int hole)
|
{
|
foreach (int key in runeHoleData.Keys)
|
{
|
if (key == hole)
|
{
|
continue;
|
}
|
RuneConfig _runeCfg = Config.Instance.Get<RuneConfig>(runeHoleData[key].id);
|
for (int i = 0; i < _runeCfg.AttrType.Length; i++)
|
{
|
if (type == _runeCfg.AttrType[i])
|
{
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
public int GetOpenTowerCnt(bool includeSpecial = false)
|
{
|
int Cnt = 0;
|
for (int i = 0; i < RUNE_HOLE_COUNT; i++)
|
{
|
if (IsSpeicalHole(i) && !includeSpecial)
|
{
|
continue;
|
}
|
if (IsRuneHoleOpen(i))
|
{
|
Cnt++;
|
}
|
else
|
{
|
break;
|
}
|
}
|
return Cnt;
|
}
|
|
public void ClearRuneData()
|
{
|
runePackData.Clear();
|
runeHoleData.Clear();
|
}
|
|
public event Action JumpToComposeEvent;
|
public void JumpToRuneCompose()
|
{
|
if (WindowCenter.Instance.CheckOpen<RunePanel>())
|
{
|
if (JumpToComposeEvent != null)
|
{
|
JumpToComposeEvent();
|
}
|
}
|
}
|
|
#region 符印合成
|
public int GetMaxLevelRuneCnt(int _id, out RuneData _runeData)
|
{
|
int _Cnt = 0;
|
_runeData = null;
|
foreach (var _rune in runePackData.Values)
|
{
|
if (_rune.id == _id)
|
{
|
if (_runeData == null || _rune.lv >= _runeData.lv)
|
{
|
_runeData = _rune;
|
}
|
_Cnt++;
|
}
|
}
|
foreach (var _rune in runeHoleData.Values)
|
{
|
if (_rune.id == _id)
|
{
|
if (_runeData == null || _rune.lv >= _runeData.lv)
|
{
|
_runeData = _rune;
|
}
|
_Cnt++;
|
break;
|
}
|
}
|
return _Cnt;
|
}
|
#endregion
|
#region 符印分解
|
public List<RuneData> runeBreakList { get; set; }
|
private Dictionary<int, bool> m_RuneBreakEnableDict = new Dictionary<int, bool>();
|
public Dictionary<int, bool> runeBreakEnableDict {
|
get {
|
return m_RuneBreakEnableDict;
|
}
|
}
|
private List<Transform> m_RuneBreakRects = new List<Transform>();
|
public List<Transform> runeBreakRects {
|
get {
|
return m_RuneBreakRects;
|
}
|
}
|
public event Action OnRefreshBreakRune;
|
public void UpdateBreakRune()
|
{
|
if (OnRefreshBreakRune != null)
|
{
|
OnRefreshBreakRune();
|
}
|
}
|
#endregion
|
}
|
|
public struct SpecialRuneHoleCondition
|
{
|
public int level;
|
public int cost;
|
}
|
|
public enum RuneSource
|
{
|
Normal,
|
Compose,
|
}
|
|
public class RuneData
|
{
|
/// <summary>
|
/// 符印对应位置索引，若在孔上则对应孔id,若在背包，则对应背包位置索引
|
/// </summary>
|
private int m_Index = -1;
|
public int index { get { return m_Index; } }
|
/// <summary>
|
/// 符印对应物品id
|
/// </summary>
|
private int m_Id = -1;
|
public int id { get { return m_Id; } }
|
/// <summary>
|
/// 符印对应强化等级
|
/// </summary>
|
private int m_Level = 0;
|
public int lv { get { return m_Level; } }
|
/// <summary>
|
/// 预留字段
|
/// </summary>
|
private int m_Lock = -1;
|
public int locked { get { return m_Lock; } }
|
/// <summary>
|
/// 背包类型，符印背包255
|
/// </summary>
|
private int m_PackType = -1;
|
public int packtype { get { return m_PackType; } }
|
/// <summary>
|
/// 符印放置位置，默认为符印背包
|
/// </summary>
|
private int m_PlaceType = 0;
|
public int placetype { get { return m_PlaceType; } }
|
|
public int m_SourceType = 0;
|
public int sourceType { get { return m_SourceType; } }//来源（老号0,默认1，合成2）
|
|
public bool IsRuneCream { get; private set; }
|
|
public RuneData(int index, int id, int level, int packtype, int sourcetype, int placetype = 0)
|
{
|
m_Index = index;
|
m_Id = id;
|
m_Level = level;
|
m_PackType = packtype;
|
m_PlaceType = placetype;
|
m_SourceType = sourcetype;
|
var config = Config.Instance.Get<ItemConfig>(id);
|
if (config != null)
|
{
|
IsRuneCream = config.Type == RuneModel.RUNE_CREAMTYPE;
|
}
|
}
|
|
public void SetRuneData(int index, int id, int level, int packtype, int sourcetype, int placetype = 0)
|
{
|
m_Index = index;
|
m_Id = id;
|
m_Level = level;
|
m_PackType = packtype;
|
m_PlaceType = placetype;
|
m_SourceType = sourcetype;
|
var config = Config.Instance.Get<ItemConfig>(id);
|
if (config != null)
|
{
|
IsRuneCream = config.Type == RuneModel.RUNE_CREAMTYPE;
|
}
|
}
|
}
|
}
|
|
