using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
|
using LitJson;
|
|
namespace Snxxz.UI
|
{
|
public enum SuitType
|
{
|
None = 0, //没有套装
|
LowSuit = 1, //普通套装
|
HighSuit = 2, //强化套装
|
}
|
|
[XLua.LuaCallCSharp]
|
public class PlayerSuitModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk
|
{
|
public List<int> suitPartlist { get; private set; }
|
private Dictionary<int, Dictionary<int, int>> suitMaxLvDict = new Dictionary<int, Dictionary<int, int>>();
|
private Dictionary<int, List<int>> suitConditionsDict = new Dictionary<int, List<int>>();
|
private Dictionary<int, List<int>> suitGroupDict = new Dictionary<int, List<int>>();
|
|
PlayerPackModel _playerPack;
|
PlayerPackModel playerPack
|
{
|
get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PlayerPackModel>()); }
|
}
|
|
public override void Init()
|
{
|
FuncConfigConfig conditionConfig = FuncConfigConfig.Get("EquipSuitColorStar");
|
JsonData conditionJson = JsonMapper.ToObject(conditionConfig.Numerical1);
|
suitConditionsDict.Clear();
|
foreach (var suitType in conditionJson.Keys)
|
{
|
List<int> conditonlist = new List<int>();
|
suitConditionsDict.Add(int.Parse(suitType), conditonlist);
|
if (conditionJson[suitType].IsArray)
|
{
|
for (int i = 0; i < conditionJson[suitType].Count; i++)
|
{
|
int con = int.Parse(conditionJson[suitType][i].ToString());
|
conditonlist.Add(con);
|
}
|
}
|
}
|
FuncConfigConfig funcDisPlayModel = FuncConfigConfig.Get("StrengthenDisplay");
|
int[] suitOrder = ConfigParse.GetMultipleStr<int>(funcDisPlayModel.Numerical1);
|
suitPartlist = new List<int>();
|
for (int i = 0; i < suitOrder.Length; i++)
|
{
|
if ((RoleEquipType)suitOrder[i] != RoleEquipType.Weapon && (RoleEquipType)suitOrder[i] != RoleEquipType.Weapon2)
|
{
|
suitPartlist.Add(suitOrder[i]);
|
}
|
}
|
|
FuncConfigConfig suitGroupConfig = FuncConfigConfig.Get("EquipSuitType");
|
JsonData groupJson = JsonMapper.ToObject(suitGroupConfig.Numerical1);
|
suitGroupDict.Clear();
|
foreach (var groupType in groupJson.Keys)
|
{
|
List<int> partlist = new List<int>();
|
suitGroupDict.Add(int.Parse(groupType), partlist);
|
if (groupJson[groupType].IsArray)
|
{
|
for (int i = 0; i < groupJson[groupType].Count; i++)
|
{
|
partlist.Add(int.Parse(groupJson[groupType][i].ToString()));
|
}
|
}
|
}
|
|
FuncConfigConfig maxLvConfig = FuncConfigConfig.Get("EquipSuitMaxLv");
|
JsonData maxjsonData = JsonMapper.ToObject(maxLvConfig.Numerical1);
|
suitMaxLvDict.Clear();
|
foreach (var part in maxjsonData.Keys)
|
{
|
Dictionary<int, int> suitTypeDict = new Dictionary<int, int>();
|
suitMaxLvDict.Add(int.Parse(part), suitTypeDict);
|
foreach (var type in maxjsonData[part].Keys)
|
{
|
int maxLv = int.Parse(maxjsonData[part][type].ToString());
|
suitTypeDict.Add(int.Parse(type), maxLv);
|
}
|
}
|
|
SetSuitCellRedPointlist();
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
suitModelDict.Clear();
|
FuncOpen.Instance.OnFuncStateChangeEvent -= RefreshFuncOpenState;
|
playerPack.RefreshItemCountAct -= RefreshMat;
|
}
|
|
public void OnAfterPlayerDataInitialize()
|
{
|
playerPack.RefreshItemCountAct += RefreshMat;
|
FuncOpen.Instance.OnFuncStateChangeEvent += RefreshFuncOpenState;
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
GetEquipOrderlist(EquipSuitTips.E_SuitType);
|
int equipPlace = 0;
|
CheckRedPointCondition(out equipPlace);
|
CheckTypeBtnRedPointCondition();
|
}
|
|
#region 处理跳转数据
|
public void SetJumpModel(int suitType)
|
{
|
EquipSuitTips.E_SuitType = (SuitType)suitType;
|
}
|
#endregion
|
|
private void RefreshFuncOpenState(int funcId)
|
{
|
if (funcId != (int)FuncOpenEnum.Suit)
|
return;
|
int equipPlace = 0;
|
CheckRedPointCondition(out equipPlace);
|
CheckTypeBtnRedPointCondition();
|
}
|
|
private void RefreshMat(PackType type, int index, int id)
|
{
|
if (type != PackType.Item)
|
return;
|
|
int equipPlace = 0;
|
CheckRedPointCondition(out equipPlace);
|
CheckTypeBtnRedPointCondition();
|
}
|
|
public override void UnInit()
|
{
|
|
}
|
|
/// <summary>
|
/// 获取排序后的装备位顺序
|
/// </summary>
|
Dictionary<int, ItemModel> equipDict;
|
public List<int> GetEquipOrderlist(SuitType type)
|
{
|
List<int> orderlist = new List<int>();
|
SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.Equip);
|
if (singlePack == null)
|
{
|
orderlist.AddRange(suitPartlist);
|
return orderlist;
|
}
|
|
equipDict = singlePack.GetAllItems();
|
for(int i = 0; i < suitPartlist.Count; i++)
|
{
|
if(equipDict.ContainsKey(suitPartlist[i]))
|
{
|
ItemModel itemModel = equipDict[suitPartlist[i]];
|
if(IsMakerSuit(type, itemModel.config.ItemColor,itemModel.config.StarLevel))
|
{
|
orderlist.Add(suitPartlist[i]);
|
}
|
}
|
}
|
|
for (int i = 0; i < suitPartlist.Count; i++)
|
{
|
if (equipDict.ContainsKey(suitPartlist[i]))
|
{
|
ItemModel itemModel = equipDict[suitPartlist[i]];
|
if (!IsMakerSuit(type, itemModel.config.ItemColor, itemModel.config.StarLevel))
|
{
|
orderlist.Add(suitPartlist[i]);
|
}
|
}
|
}
|
|
for (int i = 0; i < suitPartlist.Count; i++)
|
{
|
if (!equipDict.ContainsKey(suitPartlist[i]))
|
{
|
orderlist.Add(suitPartlist[i]);
|
}
|
}
|
|
return orderlist;
|
}
|
|
#region 接收服务端数据
|
public Dictionary<int, Dictionary<int, int>> suitModelDict = new Dictionary<int, Dictionary<int, int>>();
|
public event Action RefreshSuitModelAct;
|
public void GetServerSuitModel(HA309_tagMCEquipPartSuiteLVInfo info)
|
{
|
for (int i = 0; i < info.Count; i++)
|
{
|
int equipPlace = info.InfoList[i].EquipIndex;
|
string suitLvInfo = info.InfoList[i].SuiteLVInfo;
|
JsonData suitTypeJson = JsonMapper.ToObject(suitLvInfo);
|
if (!suitModelDict.ContainsKey(equipPlace))
|
{
|
Dictionary<int, int> suitTypeDict = new Dictionary<int, int>();
|
suitModelDict.Add(equipPlace, suitTypeDict);
|
foreach (var type in suitTypeJson.Keys)
|
{
|
suitTypeDict.Add(int.Parse(type), int.Parse(suitTypeJson[type].ToString()));
|
}
|
}
|
else
|
{
|
suitModelDict[equipPlace].Clear();
|
|
foreach (var type in suitTypeJson.Keys)
|
{
|
if (!suitModelDict[equipPlace].ContainsKey(int.Parse(type)))
|
{
|
suitModelDict[equipPlace].Add(int.Parse(type), int.Parse(suitTypeJson[type].ToString()));
|
}
|
else
|
{
|
suitModelDict[equipPlace][int.Parse(type)] = int.Parse(suitTypeJson[type].ToString());
|
}
|
}
|
}
|
}
|
|
if (RefreshSuitModelAct != null)
|
{
|
RefreshSuitModelAct();
|
}
|
|
int place = 0;
|
CheckRedPointCondition(out place);
|
}
|
|
#endregion
|
|
#region 发送请求
|
public void SendMakeSuit(int suitType, int equipPlace)
|
{
|
CA317_tagCMSuitCompose suitMaker = new CA317_tagCMSuitCompose();
|
suitMaker.SuiteType = (byte)suitType;
|
suitMaker.EquipPlace = (byte)equipPlace;
|
GameNetSystem.Instance.SendInfo(suitMaker);
|
}
|
|
public void SendSplitSuit(int equipPlace, SuitType suitType)
|
{
|
CA308_tagCMSuiteDecompose decompose = new CA308_tagCMSuiteDecompose();
|
decompose.EquipPlace = (byte)equipPlace;
|
switch (suitType)
|
{
|
case SuitType.None:
|
case SuitType.LowSuit:
|
decompose.SuiteType = (byte)SuitType.None;
|
break;
|
case SuitType.HighSuit:
|
decompose.SuiteType = (byte)SuitType.HighSuit;
|
break;
|
}
|
GameNetSystem.Instance.SendInfo(decompose);
|
}
|
#endregion
|
|
#region 处理套装预览数据
|
public Dictionary<string, ActivateSuitData> activateAttrDict { get; private set; }
|
public void GetActivateSuitModel()
|
{
|
Dictionary<string, EquipSuitAttrConfig.EquipSuitAttrData> suitAttrDict = EquipSuitAttrConfig.GetSuitAttrDict();
|
activateAttrDict = new Dictionary<string, ActivateSuitData>();
|
foreach (var suitID in suitAttrDict.Keys)
|
{
|
var attrData = suitAttrDict[suitID];
|
EquipSuitAttrConfig attrConfig = attrData.attrConfig;
|
List<int> equipPlacelist = null;
|
int suitCnt = GetSameSuitCnt((SuitType)attrConfig.suiteType, GetEquipPlaceByGroupType(attrConfig.groupType)[0], attrConfig.suiteLV, out equipPlacelist, attrConfig.job);
|
if (suitCnt >= attrConfig.count1)
|
{
|
if (!activateAttrDict.ContainsKey(suitID))
|
{
|
ActivateSuitData suitData = new ActivateSuitData(suitCnt,attrData, equipPlacelist);
|
activateAttrDict.Add(suitID, suitData);
|
}
|
}
|
}
|
}
|
|
public ActivateSuitData GetSingleSuitAttr(string suitID)
|
{
|
ActivateSuitData suitData = default(ActivateSuitData);
|
activateAttrDict.TryGetValue(suitID, out suitData);
|
return suitData;
|
}
|
|
/// <summary>
|
/// 获取所有激活套装的属性加成
|
/// </summary>
|
Dictionary<int, int> activateSuitAttrDict = new Dictionary<int, int>();
|
public Dictionary<int,int> GetActiveSuitAttr()
|
{
|
activateSuitAttrDict.Clear();
|
GetActivateSuitModel();
|
foreach(var key in activateAttrDict.Keys)
|
{
|
ActivateSuitData suitData = activateAttrDict[key];
|
int[] attrIds = null;
|
int[] attrValues = null;
|
if (suitData.suitCnt >= suitData.attrData.attrConfig.count1)
|
{
|
attrIds = suitData.attrData.attr1Ids;
|
attrValues = suitData.attrData.attr1Values;
|
SetActiveSuitAttr(attrIds,attrValues);
|
}
|
|
if(suitData.suitCnt >= suitData.attrData.attrConfig.count2)
|
{
|
attrIds = suitData.attrData.attr2Ids;
|
attrValues = suitData.attrData.attr2Values;
|
SetActiveSuitAttr(attrIds, attrValues);
|
}
|
|
if (suitData.suitCnt >= suitData.attrData.attrConfig.count3)
|
{
|
attrIds = suitData.attrData.attr3Ids;
|
attrValues = suitData.attrData.attr3Values;
|
SetActiveSuitAttr(attrIds, attrValues);
|
}
|
}
|
return activateSuitAttrDict;
|
}
|
|
public void SetActiveSuitAttr(int[] attrIds,int[] attrValues)
|
{
|
for (int i = 0; i < attrIds.Length; i++)
|
{
|
if (!activateSuitAttrDict.ContainsKey(attrIds[i]))
|
{
|
activateSuitAttrDict.Add(attrIds[i], attrValues[i]);
|
}
|
else
|
{
|
activateSuitAttrDict[attrIds[i]] += attrValues[i];
|
}
|
}
|
}
|
#endregion
|
|
public bool IsReachMax(int equipPlace, int suitType, int suitLv)
|
{
|
bool isReach = false;
|
if (suitMaxLvDict.ContainsKey(equipPlace))
|
{
|
if (suitMaxLvDict[equipPlace].ContainsKey(suitType))
|
{
|
int maxLv = suitMaxLvDict[equipPlace][suitType];
|
if (suitLv >= maxLv)
|
{
|
isReach = true;
|
}
|
}
|
}
|
return isReach;
|
}
|
|
/// <summary>
|
/// 判断当前装备是否需要升阶才可以进行锻造
|
/// </summary>
|
/// <returns></returns>
|
public bool IsNeedUpgradEquipLv(int equipPlace,int suitType)
|
{
|
ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.Equip,equipPlace);
|
if (itemModel == null) return false;
|
|
int suitLv = GetServerSuitLv(equipPlace, suitType);
|
if(suitLv >= itemModel.config.LV)
|
{
|
if(!IsReachMax(equipPlace,suitType,suitLv))
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool IsFirstEquipMaker()
|
{
|
for(int i = 0; i < suitPartlist.Count; i++)
|
{
|
if(GetServerSuitLv(suitPartlist[i],(int)SuitType.LowSuit) > 0)
|
{
|
return false;
|
}
|
}
|
return true;
|
}
|
|
public List<int> GetNeedConditions(int suitType)
|
{
|
List<int> list = null;
|
suitConditionsDict.TryGetValue(suitType, out list);
|
return list;
|
}
|
|
public int GetServerSuitLv(int equipPlace, int suitType)
|
{
|
int suitLv = 0;
|
if (suitModelDict.ContainsKey(equipPlace))
|
{
|
if (suitModelDict[equipPlace].ContainsKey(suitType))
|
{
|
suitLv = suitModelDict[equipPlace][suitType];
|
}
|
}
|
return suitLv;
|
}
|
|
public Dictionary<int, int> GetServerSuitModelByPlace(int equipPlace)
|
{
|
Dictionary<int, int> dictionary = null;
|
suitModelDict.TryGetValue(equipPlace, out dictionary);
|
return dictionary;
|
}
|
|
public Dictionary<SuitType, int> GetServerSuitCntByPlace(int equipPlace)
|
{
|
Dictionary<SuitType, int> dictionary = null;
|
if (suitModelDict.ContainsKey(equipPlace))
|
{
|
dictionary = new Dictionary<SuitType, int>();
|
|
foreach (var type in suitModelDict[equipPlace].Keys)
|
{
|
SuitType suitType = (SuitType)type;
|
int suitLv = suitModelDict[equipPlace][type];
|
List<int> placelist;
|
int suitCnt = GetSameSuitCnt(suitType, equipPlace, suitLv, out placelist);
|
dictionary.Add(suitType, suitCnt);
|
}
|
}
|
return dictionary;
|
}
|
|
public bool IsMakerSuit(SuitType suitType, int itemColor, int starLv)
|
{
|
bool isMaker = false;
|
if (suitConditionsDict.ContainsKey((int)suitType))
|
{
|
List<int> list = suitConditionsDict[(int)suitType];
|
if (itemColor >= list[0] && starLv >= list[1])
|
{
|
isMaker = true;
|
}
|
}
|
return isMaker;
|
}
|
|
public int GetSameSuitCnt(SuitType suitType, int equipPlace, int suitLv, out List<int> equipPlacelist, int job = 0)
|
{
|
equipPlacelist = new List<int>();
|
int sumNumber = 0;
|
SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.Equip);
|
if (singlePack == null || suitLv <= 0)
|
return sumNumber;
|
|
if (PlayerDatas.Instance.baseData.Job != job && job != 0)
|
return sumNumber;
|
|
Dictionary<int, ItemModel> equipDict = singlePack.GetAllItems();
|
foreach (ItemModel model in equipDict.Values)
|
{
|
if (GetGroupType(model.itemPlace) == GetGroupType(equipPlace))
|
{
|
int serverSuitLv = GetServerSuitLv(model.itemPlace, (int)suitType);
|
|
if (serverSuitLv != 0)
|
{
|
if (IsMakerSuit(suitType, model.config.ItemColor, model.config.StarLevel))
|
{
|
if (model.config.LV < serverSuitLv)
|
{
|
serverSuitLv = model.config.LV;
|
}
|
}
|
else
|
{
|
serverSuitLv = 0;
|
}
|
|
if (serverSuitLv == suitLv)
|
{
|
sumNumber++;
|
equipPlacelist.Add(model.itemPlace);
|
}
|
}
|
}
|
}
|
return sumNumber;
|
}
|
|
public int GetSameSuitCntByType(SuitType suitType)
|
{
|
int sumCnt = 0;
|
SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.Equip);
|
if (singlePack == null)
|
return sumCnt;
|
|
Dictionary<int, ItemModel> equipDict = singlePack.GetAllItems();
|
foreach (ItemModel model in equipDict.Values)
|
{
|
Dictionary<int, int> suitTypeDic = GetServerSuitModelByPlace(model.itemPlace);
|
if (suitTypeDic != null)
|
{
|
if (suitTypeDic.ContainsKey((int)suitType))
|
{
|
if (suitTypeDic[(int)suitType] > 0)
|
{
|
sumCnt++;
|
}
|
}
|
}
|
}
|
return sumCnt;
|
}
|
|
public int GetGroupType(int equipPlace)
|
{
|
foreach (var groupType in suitGroupDict.Keys)
|
{
|
if (suitGroupDict[groupType].Contains(equipPlace))
|
{
|
return groupType;
|
}
|
}
|
|
return 0;
|
}
|
|
public List<int> GetEquipPlaceByGroupType(int groupType)
|
{
|
if (suitGroupDict.ContainsKey(groupType))
|
{
|
return suitGroupDict[groupType];
|
}
|
|
return null;
|
}
|
|
public int GetEquipJob(int itemId)
|
{
|
ItemConfig itemConfig = ItemConfig.Get(itemId);
|
return (int)Math.Floor((double)itemConfig.JobLimit / 100);
|
}
|
|
public bool IsUpgradSuitLv(int equipPlace, int suitType, int suitlv)
|
{
|
ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.Equip, equipPlace);
|
if (itemModel == null)
|
{
|
return false;
|
}
|
else
|
{
|
bool isUpgrad = true;
|
bool isMaker = IsMakerSuit((SuitType)suitType, itemModel.config.ItemColor, itemModel.config.StarLevel);
|
if (isMaker)
|
{
|
if (!IsReachMax(equipPlace, suitType, suitlv))
|
{
|
if (suitlv >= itemModel.config.LV)
|
{
|
isUpgrad = false;
|
}
|
if (suitType == (int)SuitType.HighSuit)
|
{
|
int lowSuitLv = GetServerSuitLv(equipPlace, (int)SuitType.LowSuit);
|
if (suitlv >= lowSuitLv)
|
{
|
isUpgrad = false;
|
}
|
}
|
}
|
else
|
{
|
isUpgrad = false;
|
}
|
}
|
else
|
{
|
isUpgrad = false;
|
}
|
return isUpgrad;
|
}
|
}
|
|
public bool IsPerfectGetSuitLv(int itemId, int equipPlace)
|
{
|
ItemConfig itemConfig = ItemConfig.Get(itemId);
|
if (itemConfig == null)
|
return false;
|
|
bool isPerfect = true;
|
if (IsMakerSuit(SuitType.LowSuit, itemConfig.ItemColor, itemConfig.StarLevel))
|
{
|
int suitLv = GetServerSuitLv(equipPlace, (int)SuitType.LowSuit);
|
if (suitLv > 0)
|
{
|
if (itemConfig.LV < suitLv)
|
{
|
isPerfect = false;
|
}
|
}
|
else
|
{
|
isPerfect = false;
|
}
|
}
|
else if (IsMakerSuit(SuitType.HighSuit, itemConfig.ItemColor, itemConfig.StarLevel))
|
{
|
int suitLv = GetServerSuitLv(equipPlace, (int)SuitType.HighSuit);
|
if (suitLv > 0)
|
{
|
if (itemConfig.LV < suitLv)
|
{
|
isPerfect = false;
|
}
|
}
|
else
|
{
|
isPerfect = false;
|
}
|
}
|
else
|
{
|
isPerfect = false;
|
}
|
|
return isPerfect;
|
|
}
|
|
public Dictionary<SuitType, ReplaceSuit> SetReplaceSuitModel(int itemId, int equipPlace)
|
{
|
ItemConfig itemConfig = ItemConfig.Get(itemId);
|
Dictionary<SuitType, ReplaceSuit> replaceDict = new Dictionary<SuitType, ReplaceSuit>();
|
if (itemConfig == null)
|
return replaceDict;
|
|
ItemModel putOnModel = playerPack.GetItemModelByIndex(PackType.Equip, equipPlace);
|
|
ReplaceSuit replaceLowSuit = new ReplaceSuit();
|
replaceLowSuit.isNoEffect = false;
|
replaceLowSuit.isPerfect = false;
|
replaceLowSuit.effectLv = 0;
|
|
ReplaceSuit replaceHighSuit = new ReplaceSuit();
|
replaceHighSuit.isNoEffect = false;
|
replaceHighSuit.isPerfect = false;
|
replaceHighSuit.effectLv = 0;
|
int suitLv = GetServerSuitLv(equipPlace, (int)SuitType.LowSuit);
|
int realSuitLv = 0;
|
if(putOnModel != null)
|
{
|
if(IsMakerSuit(SuitType.LowSuit, putOnModel.config.ItemColor, putOnModel.config.StarLevel))
|
{
|
if(putOnModel.config.LV < suitLv)
|
{
|
realSuitLv = putOnModel.config.LV;
|
}
|
else
|
{
|
realSuitLv = suitLv;
|
}
|
}
|
}
|
if (!IsMakerSuit(SuitType.LowSuit, itemConfig.ItemColor, itemConfig.StarLevel))
|
{
|
if (realSuitLv > 0)
|
{
|
replaceLowSuit.isNoEffect = true;
|
}
|
}
|
else
|
{
|
if (realSuitLv > 0)
|
{
|
if (itemConfig.LV < realSuitLv)
|
{
|
|
replaceLowSuit.effectLv = itemConfig.LV;
|
}
|
else
|
{
|
replaceLowSuit.isPerfect = true;
|
}
|
}
|
}
|
|
suitLv = GetServerSuitLv(equipPlace, (int)SuitType.HighSuit);
|
realSuitLv = 0;
|
if (putOnModel != null)
|
{
|
if (IsMakerSuit(SuitType.HighSuit, putOnModel.config.ItemColor, putOnModel.config.StarLevel))
|
{
|
if (putOnModel.config.LV < suitLv)
|
{
|
realSuitLv = putOnModel.config.LV;
|
}
|
else
|
{
|
realSuitLv = suitLv;
|
}
|
}
|
}
|
if (!IsMakerSuit(SuitType.HighSuit, itemConfig.ItemColor, itemConfig.StarLevel))
|
{
|
if (realSuitLv > 0)
|
{
|
replaceHighSuit.isNoEffect = true;
|
}
|
}
|
else
|
{
|
if (realSuitLv > 0)
|
{
|
if (itemConfig.LV < realSuitLv)
|
{
|
replaceHighSuit.effectLv = itemConfig.LV;
|
}
|
else
|
{
|
replaceHighSuit.isPerfect = true;
|
}
|
}
|
}
|
|
|
replaceDict.Add(SuitType.LowSuit, replaceLowSuit);
|
replaceDict.Add(SuitType.HighSuit, replaceHighSuit);
|
return replaceDict;
|
}
|
|
#region 红点逻辑处理
|
public const int SUITTYPEBTNREDPOINT_KEY = 106041000;
|
public Redpoint typeBtnRedPoint = new Redpoint(MainRedDot.RedPoint_SuitFuncKey, SUITTYPEBTNREDPOINT_KEY);
|
public Dictionary<int, Redpoint> suitCellRedPointDict { get; private set; }
|
SuitType redSuitType = SuitType.None;
|
|
public void SetSuitCellRedPointlist()
|
{
|
if (suitPartlist == null)
|
return;
|
|
suitCellRedPointDict = new Dictionary<int, Redpoint>();
|
int i = 0;
|
for (i = 0; i < suitPartlist.Count; i++)
|
{
|
int id = MainRedDot.RedPoint_SuitFuncKey * 1000 + i;
|
Redpoint suitRedPoint = new Redpoint(MainRedDot.RedPoint_SuitFuncKey, id);
|
suitCellRedPointDict.Add(suitPartlist[i], suitRedPoint);
|
}
|
}
|
|
public void CheckRedPointCondition(out int equipPlace)
|
{
|
equipPlace = 0;
|
for (int i = 0; i < suitPartlist.Count; i++)
|
{
|
if (suitCellRedPointDict.ContainsKey(suitPartlist[i]))
|
{
|
suitCellRedPointDict[suitPartlist[i]].state = RedPointState.None;
|
}
|
}
|
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Suit))
|
return;
|
|
redSuitType = EquipSuitTips.E_SuitType;
|
List<int> orderPlacelist = GetEquipOrderlist(redSuitType);
|
orderPlacelist.Sort(CompareSuitLV);
|
|
for (int i = 0; i < orderPlacelist.Count; i++)
|
{
|
if (IsShowRedPoint(orderPlacelist[i], redSuitType))
|
{
|
suitCellRedPointDict[orderPlacelist[i]].state = RedPointState.Simple;
|
equipPlace = orderPlacelist[i];
|
return;
|
}
|
}
|
if (IsReachSuitActive(redSuitType, orderPlacelist, out equipPlace))
|
{
|
suitCellRedPointDict[equipPlace].state = RedPointState.Simple;
|
return;
|
}
|
}
|
|
public void CheckTypeBtnRedPointCondition()
|
{
|
typeBtnRedPoint.state = RedPointState.None;
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Suit))
|
return;
|
|
redSuitType = SuitType.None;
|
switch (EquipSuitTips.E_SuitType)
|
{
|
case SuitType.LowSuit:
|
redSuitType = SuitType.HighSuit;
|
break;
|
case SuitType.HighSuit:
|
redSuitType = SuitType.LowSuit;
|
break;
|
}
|
|
List<int> orderPlacelist = GetEquipOrderlist(redSuitType);
|
orderPlacelist.Sort(CompareSuitLV);
|
|
for (int i = 0; i < orderPlacelist.Count; i++)
|
{
|
if (IsShowRedPoint(orderPlacelist[i], redSuitType))
|
{
|
typeBtnRedPoint.state = RedPointState.Simple;
|
return;
|
}
|
|
}
|
int equipPlace = 0;
|
if (IsReachSuitActive(redSuitType, orderPlacelist, out equipPlace))
|
{
|
typeBtnRedPoint.state = RedPointState.Simple;
|
return;
|
}
|
}
|
|
public int CompareSuitLV(int startPlace, int endPlace)
|
{
|
int startSuitLv = GetServerSuitLv(startPlace, (int)redSuitType);
|
int endSuitLv = GetServerSuitLv(endPlace, (int)redSuitType);
|
if (startSuitLv.CompareTo(endSuitLv) != 0)
|
return startSuitLv.CompareTo(endSuitLv);
|
int startIndex = suitPartlist.IndexOf(startPlace);
|
int endIndex = suitPartlist.IndexOf(endPlace);
|
if (startIndex.CompareTo(endIndex) != 0)
|
return startIndex.CompareTo(endIndex);
|
|
return 0;
|
}
|
|
private bool IsShowRedPoint(int equipPlace, SuitType suitType)
|
{
|
int groupType = GetGroupType(equipPlace);
|
ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.Equip, equipPlace);
|
if (groupType == 0 || itemModel == null)
|
return false;
|
|
bool isShow = false;
|
int suitLv = GetServerSuitLv(equipPlace, (int)suitType);
|
|
EquipSuitCompoundConfig matConfig = EquipSuitCompoundConfig.GetMakerEquipSuitMatModel((int)suitType,
|
equipPlace, suitLv + 1, GetEquipJob(itemModel.itemId));
|
|
var suitAttrData = EquipSuitAttrConfig.GetSuitAttrData(groupType
|
, (int)suitType, 1, GetEquipJob(itemModel.itemId));
|
EquipSuitAttrConfig attrConfig = suitAttrData == null ? null : suitAttrData.attrConfig;
|
|
bool isUpgrad = IsUpgradSuitLv(equipPlace,(int)suitType,suitLv);
|
if (isUpgrad)
|
{
|
bool isMatEnough = true;
|
if (matConfig != null)
|
{
|
int[] matIds = matConfig.CostItemID;
|
int[] matCnts = matConfig.CostItemCnt;
|
for (int i = 0; i < matIds.Length; i++)
|
{
|
int haveCnt = playerPack.GetItemCountByID(PackType.Item, matIds[i]);
|
if (haveCnt < matCnts[i])
|
{
|
isMatEnough = false;
|
break;
|
}
|
}
|
}
|
else
|
{
|
isMatEnough = false;
|
}
|
|
if (isMatEnough)
|
{
|
List<int> placelist = null;
|
int nowSuitCnt = GetSameSuitCnt(suitType, equipPlace, suitLv, out placelist);
|
int willSuitCnt = GetSameSuitCnt(suitType, equipPlace, suitLv + 1, out placelist) + 1;
|
DebugEx.Log("装备位置：" + equipPlace);
|
if (IsAdaptRules(groupType, nowSuitCnt, willSuitCnt, attrConfig))
|
{
|
isShow = true;
|
}
|
}
|
}
|
|
return isShow;
|
}
|
|
private bool IsAdaptRules(int groupType, int nowSuitCnt, int willSuitCnt, EquipSuitAttrConfig attrConfig)
|
{
|
if (attrConfig == null)
|
return false;
|
|
bool isAdapt = true;
|
if (willSuitCnt != attrConfig.count1 && willSuitCnt != attrConfig.count2 && willSuitCnt != attrConfig.count3)
|
{
|
isAdapt = false;
|
}
|
//DesignDebug.Log("groupType:" + groupType + "NowSuitCnt:" + nowSuitCnt + "willSuitCnt:" + willSuitCnt);
|
//if (nowSuitCnt == attrConfig.count1 || nowSuitCnt == attrConfig.count2 || nowSuitCnt == attrConfig.count3)
|
//{
|
// if (willSuitCnt != attrConfig.count1 && willSuitCnt != attrConfig.count2 && willSuitCnt != attrConfig.count3)
|
// {
|
// isAdapt = false;
|
// }
|
//}
|
return isAdapt;
|
}
|
|
public bool IsReachSuitActive(SuitType suitType, List<int> partlist, out int equipPlace)
|
{
|
equipPlace = 0;
|
if (partlist == null)
|
return false;
|
|
Dictionary<int, Dictionary<int, int>> needMatCntDict = new Dictionary<int, Dictionary<int, int>>(); //群组 id 数量
|
Dictionary<int, int> minActiveSuitCntDic = new Dictionary<int, int>();
|
Dictionary<int, List<int>> upgradEquipPlaceDict = new Dictionary<int, List<int>>();
|
for (int i = 0; i < partlist.Count; i++)
|
{
|
int groupType = GetGroupType(partlist[i]);
|
int suitLv = GetServerSuitLv(partlist[i], (int)suitType);
|
ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.Equip, partlist[i]);
|
if (itemModel != null)
|
{
|
bool isUpgrad = IsUpgradSuitLv(partlist[i], (int)suitType, suitLv);
|
EquipSuitCompoundConfig matConfig = EquipSuitCompoundConfig.GetMakerEquipSuitMatModel((int)suitType,
|
partlist[i], suitLv + 1, GetEquipJob(itemModel.itemId));
|
|
if (isUpgrad)
|
{
|
if (matConfig != null)
|
{
|
if (!needMatCntDict.ContainsKey(groupType))
|
{
|
Dictionary<int, int> matCntDict = new Dictionary<int, int>();
|
needMatCntDict.Add(groupType, matCntDict);
|
//minActiveSuitCntDic.Add(groupType, 1);
|
List<int> equipPlacelist = new List<int>();
|
upgradEquipPlaceDict.Add(groupType, equipPlacelist);
|
}
|
|
int[] matIds = matConfig.CostItemID;
|
int[] matCnts = matConfig.CostItemCnt;
|
for (int j = 0; j < matIds.Length; j++)
|
{
|
if (!needMatCntDict[groupType].ContainsKey(matIds[j]))
|
{
|
needMatCntDict[groupType].Add(matIds[j], matCnts[j]);
|
}
|
else
|
{
|
needMatCntDict[groupType][matIds[j]] += matCnts[j];
|
}
|
}
|
|
bool isReach = true;
|
foreach(var id in needMatCntDict[groupType].Keys)
|
{
|
int haveCnt = playerPack.GetItemCountByID(PackType.Item, id);
|
if (haveCnt < needMatCntDict[groupType][id])
|
{
|
isReach = false;
|
break;
|
}
|
}
|
if(isReach)
|
{
|
upgradEquipPlaceDict[groupType].Add(partlist[i]);
|
}
|
}
|
}
|
}
|
}
|
|
foreach(var type in upgradEquipPlaceDict.Keys)
|
{
|
if(upgradEquipPlaceDict[type].Count > 0)
|
{
|
ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.Equip, upgradEquipPlaceDict[type][0]);
|
var suitAttrData = EquipSuitAttrConfig.GetSuitAttrData(type
|
, (int)suitType, 1, GetEquipJob(itemModel.itemId));
|
EquipSuitAttrConfig attrConfig = suitAttrData == null ? null : suitAttrData.attrConfig;
|
if(attrConfig != null)
|
{
|
if (upgradEquipPlaceDict[type].Count >= attrConfig.count1)
|
{
|
equipPlace = upgradEquipPlaceDict[type][0];
|
return true;
|
}
|
}
|
}
|
}
|
return false;
|
}
|
#endregion
|
|
#region 成就前往数据
|
public SuitType jumpToSuitType { get; private set;}
|
public int jumpToGroupType { get; private set; } //1.防具 2.仙器
|
public int jumpToEquipPlace { get; private set; }
|
/// <summary>
|
/// 设置成就前往数据
|
/// </summary>
|
/// <param name="suitType"></param>
|
/// <param name="groupType"></param>
|
public void SetJumpToModel(SuitType suitType,int groupType)
|
{
|
jumpToSuitType = suitType;
|
jumpToGroupType = groupType;
|
//jumpToEquipPlace = GetMakerEquipPlace();
|
}
|
|
public void ClearJumpModel()
|
{
|
jumpToSuitType = SuitType.None;
|
jumpToGroupType = 0;
|
jumpToEquipPlace = 0;
|
}
|
#endregion
|
|
public int GetMakerEquipPlace()
|
{
|
SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.Equip);
|
if (singlePack == null) return 0;
|
|
Dictionary<int, ItemModel> dic = singlePack.GetAllItems();
|
List<int> placelist = new List<int>();
|
placelist.AddRange(suitPartlist);
|
placelist.Sort(CompareBySuitLv);
|
for(int i = 0; i <placelist.Count; i++)
|
{
|
int group = GetGroupType(placelist[i]);
|
if(dic.ContainsKey(placelist[i]) && group == jumpToGroupType)
|
{
|
int suitLv = GetServerSuitLv(placelist[i], (int)jumpToSuitType);
|
bool isMatEnough = IsEnoughSuitMat((int)jumpToSuitType,placelist[i], suitLv, dic[placelist[i]].itemId);
|
bool isMaker = IsMakerSuit(jumpToSuitType, dic[placelist[i]].config.ItemColor, dic[placelist[i]].config.StarLevel);
|
if(isMaker && dic[placelist[i]].config.LV > suitLv && isMatEnough)
|
{
|
return placelist[i];
|
}
|
}
|
}
|
|
return 0;
|
}
|
|
public bool IsEnoughSuitMat(int suitTye,int equipPlace,int suitLv,int itemId)
|
{
|
EquipSuitCompoundConfig matConfig = EquipSuitCompoundConfig.GetMakerEquipSuitMatModel((int)suitTye,
|
equipPlace, suitLv + 1, GetEquipJob(itemId));
|
|
bool isMatEnough = true;
|
if (matConfig != null)
|
{
|
int[] matIds = matConfig.CostItemID;
|
int[] matCnts = matConfig.CostItemCnt;
|
for (int i = 0; i < matIds.Length; i++)
|
{
|
int haveCnt = playerPack.GetItemCountByID(PackType.Item, matIds[i]);
|
if (haveCnt < matCnts[i])
|
{
|
isMatEnough = false;
|
break;
|
}
|
}
|
}
|
else
|
{
|
isMatEnough = false;
|
}
|
|
return isMatEnough;
|
}
|
|
public int CompareBySuitLv(int starPlace,int endPlace)
|
{
|
int suitLv1 = GetServerSuitLv(starPlace,(int)jumpToSuitType);
|
int suitLv2 = GetServerSuitLv(endPlace,(int)jumpToSuitType);
|
if (suitLv1.CompareTo(suitLv2) != 0) return suitLv1.CompareTo(suitLv2);
|
|
int starIndex = suitPartlist.IndexOf(starPlace);
|
int endIndex = suitPartlist.IndexOf(endPlace);
|
if (starIndex.CompareTo(endIndex) != 0) return starIndex.CompareTo(endIndex);
|
|
return 0;
|
}
|
|
}
|
|
public struct ActivateSuitData
|
{
|
public int suitCnt;
|
public EquipSuitAttrConfig.EquipSuitAttrData attrData;
|
public List<int> equipPlacelist;
|
public ActivateSuitData(int cnt, EquipSuitAttrConfig.EquipSuitAttrData data, List<int> list)
|
{
|
suitCnt = cnt;
|
attrData = data;
|
equipPlacelist = list;
|
}
|
}
|
|
public struct ReplaceSuit
|
{
|
public bool isNoEffect;
|
public bool isPerfect;
|
public int effectLv;
|
}
|
}
|
