using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Linq;
|
|
using UnityEngine;
|
namespace Snxxz.UI
|
{
|
[XLua.Hotfix]
|
[XLua.LuaCallCSharp]
|
public class JadeDynastyGemModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
|
{
|
Dictionary<int, GemEquipData> equipGemDict = new Dictionary<int, GemEquipData>();
|
Dictionary<int, Dictionary<int, bool>> gemHoleRedpoints = new Dictionary<int, Dictionary<int, bool>>();
|
public readonly List<int> equipPlaces = new List<int>()
|
{ 121,122,123,124,125,126,127,128,129,130,131,132};
|
public int[] gemOpenLevels { get; private set; }
|
|
int m_SelectEquipPlace;
|
public int selectEquipPlace
|
{
|
get { return m_SelectEquipPlace; }
|
set
|
{
|
if (m_SelectEquipPlace != value)
|
{
|
m_SelectEquipPlace = value;
|
if (selectEquipPlaceRefresh != null)
|
{
|
selectEquipPlaceRefresh();
|
}
|
}
|
}
|
}
|
|
public int inlayHole = -1;
|
|
public readonly Redpoint redpoint = new Redpoint(117, REDPOINTID);
|
|
public Dictionary<int, Redpoint> redpointList = new Dictionary<int, Redpoint>(12);
|
public List<Redpoint> gemHoleReds = new List<Redpoint>(4);
|
public List<Redpoint> gemComposeReds = new List<Redpoint>(4);
|
|
|
public const int REDPOINTID = 11703;
|
public const int FUNCTIONID = 169;
|
public const int GEMTYPE = 140;
|
|
public event Action selectEquipPlaceRefresh;
|
public event Action equipGemRefresh;
|
|
GemModel gemModel { get { return ModelCenter.Instance.GetModel<GemModel>(); } }
|
|
PlayerPackModel playerPack { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }
|
|
public override void Init()
|
{
|
ParseConfig();
|
InitRedPoint();
|
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
|
playerPack.RefreshItemCountAct += RefreshItemCountAct;
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
equipGemDict.Clear();
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
UpdateRedpoint();
|
}
|
|
public override void UnInit()
|
{
|
FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
|
playerPack.RefreshItemCountAct -= RefreshItemCountAct;
|
}
|
|
void ParseConfig()
|
{
|
var config = FuncConfigConfig.Get("GemOpen");
|
gemOpenLevels = ConfigParse.GetMultipleStr<int>(config.Numerical2);
|
}
|
|
public void InitRedPoint()
|
{
|
for (int i = 0; i < equipPlaces.Count; i++)
|
{
|
Redpoint redpoint = new Redpoint(REDPOINTID, REDPOINTID * 100 + equipPlaces[i] - 121);
|
redpointList.Add(equipPlaces[i], redpoint);
|
redpoint.state = RedPointState.None;
|
Dictionary<int, bool> dict = new Dictionary<int, bool>();
|
for (int k = 0; k < 4; k++)
|
{
|
dict.Add(k, false);
|
}
|
gemHoleRedpoints.Add(equipPlaces[i], dict);
|
}
|
for (int i = 0; i < 4; i++)
|
{
|
Redpoint redpoint = new Redpoint(REDPOINTID, REDPOINTID * 100 + 20 + i);
|
gemHoleReds.Add(redpoint);
|
redpoint.state = RedPointState.None;
|
Redpoint composeRedpoint = new Redpoint(REDPOINTID, REDPOINTID * 100 + 30 + i);
|
gemComposeReds.Add(composeRedpoint);
|
composeRedpoint.state = RedPointState.None;
|
}
|
}
|
|
private void OnFuncStateChangeEvent(int id)
|
{
|
if (FUNCTIONID == id)
|
{
|
UpdateRedpoint();
|
}
|
}
|
|
private void RefreshItemCountAct(PackType packType, int arg2, int arg3)
|
{
|
if (packType != PackType.JadeDynastyItem
|
&& packType != PackType.JadeDynastyEquip)
|
{
|
return;
|
}
|
UpdateRedpoint();
|
}
|
|
public int GetGemType(int pos)
|
{
|
foreach (var type in gemModel.equipGemTypeDict.Keys)
|
{
|
var list = gemModel.equipGemTypeDict[type];
|
foreach (var equipPlace in list)
|
{
|
if (equipPlace == pos)
|
{
|
return type;
|
}
|
}
|
}
|
return 0;
|
}
|
|
public bool GetHoleRedpoint(int equipPlace, int _index)
|
{
|
if (gemHoleRedpoints.ContainsKey(equipPlace))
|
{
|
return gemHoleRedpoints[equipPlace][_index];
|
}
|
return false;
|
}
|
|
public bool CheckEquipHole(int _pos, int _hole, int _itemId)
|
{
|
GemEquipData equipData;
|
if (TryGetEquipGems(_pos, out equipData))
|
{
|
return _itemId > equipData.items[_hole];
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
public bool TryGetEquipGems(int pos,out GemEquipData equipData)
|
{
|
return equipGemDict.TryGetValue(pos, out equipData);
|
}
|
|
public bool IsHightestLevelGem(int _id)
|
{
|
var _itemCfg = ItemConfig.Get(_id);
|
if (_itemCfg == null)
|
{
|
return true;
|
}
|
var type = _itemCfg.EffectValueA1;
|
if (_itemCfg.EffectValueB1 >= gemModel.gemHighestLevelDict[type])
|
{
|
return true;
|
}
|
return false;
|
}
|
|
public void OnReceivePackage(HA3BC_tagMCStoneInfo package)
|
{
|
for (int i = 0; i < package.EquipCount; i++)
|
{
|
var data = package.InfoList[i];
|
if (data.EquipPlace < (int)RoleEquipType.JadeDynasty_Cloak
|
|| data.EquipPlace > (int)RoleEquipType.JadeDynasty_Sword4)
|
{
|
continue;
|
}
|
var gemEquipData = new GemEquipData()
|
{
|
binds = new int[4] { 0, 0, 0, 0 },
|
items = new uint[4] { 0, 0, 0, 0 },
|
};
|
for (int k = 0; k < data.StoneInfo.Length; k++)
|
{
|
gemEquipData.items[k] = data.StoneInfo[k];
|
gemEquipData.binds[k] = data.StoneBind[k];
|
}
|
equipGemDict[data.EquipPlace] = gemEquipData;
|
}
|
if (equipGemRefresh != null)
|
{
|
equipGemRefresh();
|
}
|
UpdateRedpoint();
|
}
|
|
public RedPointState GetRedpointState(int _pos)
|
{
|
return redpointList[_pos].state;
|
}
|
|
private void UpdateRedpoint()
|
{
|
var _keys = gemHoleRedpoints.Keys.ToList();
|
for (int i = 0; i < _keys.Count; i++)
|
{
|
var _dict = gemHoleRedpoints[_keys[i]];
|
var _poses = _dict.Keys.ToList();
|
for (int k = 0; k < _poses.Count; k++)
|
{
|
_dict[_poses[k]] = false;
|
}
|
}
|
foreach (var key in redpointList.Keys)
|
{
|
redpointList[key].state = RedPointState.None;
|
}
|
for (int i = 0; i < gemHoleReds.Count; i++)
|
{
|
gemHoleReds[i].state = RedPointState.None;
|
gemComposeReds[i].state = RedPointState.None;
|
}
|
if (!FuncOpen.Instance.IsFuncOpen(FUNCTIONID))
|
{
|
return;
|
}
|
foreach (var equipPlace in equipPlaces)
|
{
|
ItemModel item = playerPack.GetItemModelByIndex(PackType.JadeDynastyEquip, equipPlace);
|
redpointList[equipPlace].state = RedPointState.None;
|
if (item == null)
|
{
|
continue;
|
}
|
ItemConfig itemCfg = ItemConfig.Get((int)item.itemId);
|
List<ItemModel> list = IsBagHaveGem(GetGemType(equipPlace));
|
if (list == null || list.Count == 0)
|
{
|
continue;
|
}
|
GemEquipData equipData;
|
bool existGem = TryGetEquipGems(equipPlace, out equipData);
|
for (int j = 0; j < 4; j++)
|
{
|
if (j == 3)
|
{
|
if (PlayerDatas.Instance.baseData.VIPLv < gemModel.gemVipHoleLv || itemCfg.LV < gemOpenLevels[0])
|
{
|
continue;
|
}
|
}
|
else
|
{
|
if (itemCfg.LV < gemOpenLevels[j])
|
{
|
continue;
|
}
|
}
|
|
if ((existGem && equipData.items[j] != 0) && list.Count > 0)
|
{
|
if (IsSatisfyGemCompose(equipPlace, j, (int)equipData.items[j]))
|
{
|
redpointList[equipPlace].state = RedPointState.Simple;
|
continue;
|
}
|
}
|
}
|
}
|
for (int i = 3; i <= 5; i++)
|
{
|
var list = IsBagHaveGem(i);
|
if (list == null || list.Count == 0)
|
{
|
continue;
|
}
|
list.Sort((ItemModel x, ItemModel y) =>
|
{
|
return -x.itemId.CompareTo(y.itemId);
|
});
|
int _pos = 0; int _hole = 0;
|
for (int k = 0; k < list.Count; k++)
|
{
|
if (GetMinLevelGem(i, list[k].itemId, out _pos, out _hole))
|
{
|
redpointList[_pos].state = RedPointState.Simple;
|
gemHoleRedpoints[_pos][_hole] = true;
|
break;
|
}
|
}
|
}
|
UpdateHoleRedpoint(selectEquipPlace);
|
}
|
|
public void UpdateHoleRedpoint(int _index)
|
{
|
if (!gemHoleRedpoints.ContainsKey(_index))
|
{
|
return;
|
}
|
GemEquipData equipData;
|
var existGem = TryGetEquipGems(_index, out equipData);
|
for (int i = 0; i < 4; i++)
|
{
|
bool _compose = false;
|
if (existGem && equipData.items[i] != 0
|
&& IsSatisfyGemCompose(_index, i, (int)equipData.items[i]))
|
{
|
_compose = true;
|
gemComposeReds[i].state = RedPointState.Simple;
|
}
|
gemHoleReds[i].state = gemHoleRedpoints[_index][i] || _compose ? RedPointState.Simple : RedPointState.None;
|
}
|
}
|
|
public bool GetMinLevelGem(int _type, int _itemId, out int _pos, out int _hole)
|
{
|
_pos = 0; _hole = 0;
|
int _minItemId = 0;
|
foreach (var equipPlace in equipPlaces)
|
{
|
var equip = playerPack.GetItemModelByIndex(PackType.JadeDynastyEquip, equipPlace);
|
if (equip == null)
|
{
|
continue;
|
}
|
if (GetGemType(equipPlace) != _type)
|
{
|
continue;
|
}
|
var itemConfig = ItemConfig.Get((int)equip.itemId);
|
GemEquipData equipData;
|
var existGem = TryGetEquipGems(equipPlace, out equipData);
|
for (int j = 0; j < 4; j++)
|
{
|
if (j == 3)
|
{
|
if (PlayerDatas.Instance.baseData.VIPLv < gemModel.gemVipHoleLv || itemConfig.LV < gemOpenLevels[0])
|
{
|
continue;
|
}
|
}
|
else
|
{
|
if (itemConfig.LV < gemOpenLevels[j])
|
{
|
continue;
|
}
|
}
|
|
if ((!existGem || equipData.items[j] == 0))
|
{
|
_pos = equipPlace; _hole = j;
|
return true;
|
}
|
else
|
{
|
if (equipData.items[j] >= _itemId)
|
{
|
continue;
|
}
|
if (_minItemId == 0 || _minItemId > equipData.items[j])
|
{
|
_minItemId = (int)equipData.items[j];
|
_pos = equipPlace; _hole = j;
|
}
|
}
|
}
|
}
|
if (_minItemId != 0 && !IsHightestLevelGem(_minItemId))
|
{
|
return true;
|
}
|
return false;
|
}
|
|
private Dictionary<int, int> m_GemLevelCountDict = new Dictionary<int, int>();
|
public bool IsSatisfyGemCompose(int _place, int _index, int _item)
|
{
|
if (IsHightestLevelGem(_item))
|
{
|
return false;
|
}
|
var _itemCfg = ItemConfig.Get(_item);
|
var _type = GetGemType(_place);
|
if (GemCountByLevel(_type, _itemCfg.EffectValueB1) < 2)
|
{
|
return false;
|
}
|
m_GemLevelCountDict.Clear();
|
for (int i = _itemCfg.EffectValueB1; i <= gemModel.gemHighestLevelDict[_type]; i++)
|
{
|
m_GemLevelCountDict.Add(i, GemCountByLevel(_type, i));
|
}
|
foreach (var equipPlace in equipPlaces)
|
{
|
if (GetGemType(equipPlace) != _type)
|
{
|
continue;
|
}
|
ItemModel _equip = playerPack.GetItemModelByIndex(PackType.JadeDynastyEquip, equipPlace);
|
if (_equip == null)
|
{
|
continue;
|
}
|
var itemCfg = ItemConfig.Get(_equip.itemId);
|
GemEquipData equipData;
|
var existGem=TryGetEquipGems(equipPlace, out equipData);
|
for (int j = 0; j < 4; j++)
|
{
|
if (j == 3)
|
{
|
if (PlayerDatas.Instance.baseData.VIPLv < gemModel.gemVipHoleLv || itemCfg.LV < gemOpenLevels[0])
|
{
|
continue;
|
}
|
}
|
else
|
{
|
if (itemCfg.LV < gemOpenLevels[j])
|
{
|
continue;
|
}
|
}
|
if (!existGem || equipData.items[j] == 0)
|
{
|
GemReduce(m_GemLevelCountDict, 0);
|
continue;
|
}
|
else
|
{
|
var _gem = equipData.items[j];
|
var _level = ItemConfig.Get((int)_gem).EffectValueB1;
|
GemReduce(m_GemLevelCountDict, _level);
|
}
|
}
|
}
|
if (m_GemLevelCountDict[_itemCfg.EffectValueB1] >= 2)
|
{
|
return true;
|
}
|
return false;
|
}
|
|
private void GemReduce(Dictionary<int, int> _dict, int _level)
|
{
|
var _list = _dict.Keys.ToList();
|
for (int i = _list.Count - 1; i >= 0; i--)
|
{
|
if (_level < _list[i] && _dict[_list[i]] > 0)
|
{
|
_dict[_list[i]]--;
|
break;
|
}
|
}
|
}
|
|
public int GemCountByLevel(int _type, int _level, bool _bind = false, int _isBind = 0)
|
{
|
var _count = 0;
|
SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.JadeDynastyItem);
|
List<ItemModel> _list = null;
|
singlePack.GetItemCountByType(GEMTYPE, out _list);
|
for (int i = 0; i < _list.Count; i++)
|
{
|
ItemModel _itemModel = _list[i];
|
ItemConfig _itemCfg = ItemConfig.Get(_itemModel.itemId);
|
if (_itemCfg.EffectValueA1 == _type && _itemCfg.EffectValueB1 == _level)
|
{
|
if (_bind)
|
{
|
if (_itemModel.itemInfo.IsBind == _isBind)
|
{
|
_count += _itemModel.itemInfo.ItemCount;
|
}
|
}
|
else
|
{
|
_count += _itemModel.itemInfo.ItemCount;
|
}
|
}
|
}
|
return _count;
|
}
|
|
public List<ItemModel> IsBagHaveGem(int type)
|
{
|
List<ItemModel> list = null;
|
SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.JadeDynastyItem);
|
singlePack.GetItemCountByType(GEMTYPE, out list);
|
if (list != null && list.Count > 0)
|
{
|
for (int i = 0; i < list.Count; i++)
|
{
|
ItemModel item = list[i];
|
ItemConfig cfg = ItemConfig.Get((int)item.itemId);
|
if (cfg.EffectValueA1 != type)
|
{
|
list.RemoveAt(i);
|
i--;
|
}
|
}
|
}
|
return list;
|
}
|
|
public struct GemEquipData
|
{
|
public uint[] items;
|
public int[] binds;
|
}
|
}
|
}
|
|
