using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Linq;
|
using UnityEngine;
|
namespace vnxbqy.UI
|
{
|
|
|
public class EquipGemModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
|
{
|
Dictionary<int, int[]> m_EquipGems = new Dictionary<int, int[]>();
|
Dictionary<int, List<int>> m_EquipGemTypes = new Dictionary<int, List<int>>();
|
Dictionary<int, GemHoleCondition> m_GemHoleConditions = new Dictionary<int, GemHoleCondition>();
|
Dictionary<int, GemType> m_GemTypes = new Dictionary<int, GemType>();
|
Dictionary<int, EquipGemRedpoint> m_EquipGemRedpoints = new Dictionary<int, EquipGemRedpoint>();
|
Dictionary<int, Redpoint> m_EquipSetRedpoints = new Dictionary<int, Redpoint>();
|
|
List<int> m_EquipPlaces = new List<int>();
|
|
readonly List<int> m_GemHoleItemIds = new List<int> { 0, 0, 0, 0 };
|
public List<EquipSetSelect> EquipSetList = new List<EquipSetSelect>();
|
public readonly Redpoint redpoint = new Redpoint(106, 10602);
|
int m_SelectHoleIndex = 0;
|
public int SelectHoleIndex
|
{
|
get { return m_SelectHoleIndex; }
|
set
|
{
|
m_SelectHoleIndex = value;
|
if (selectHoleRefresh != null)
|
{
|
selectHoleRefresh();
|
}
|
}
|
}
|
|
public const int EQUIPGEM_HOLE_COUNT = 4;
|
public static int REDPOINTBASE = 106020000;
|
|
int m_SelectLevel = 0;
|
public int selectLevel
|
{
|
get { return m_SelectLevel; }
|
set
|
{
|
if (m_SelectLevel != value)
|
{
|
m_SelectLevel = value;
|
if (selectLevelRefresh != null)
|
{
|
selectLevelRefresh();
|
}
|
}
|
}
|
}
|
|
int m_SelectEquipPlace = 0;
|
public int selectEquipPlace
|
{
|
get { return m_SelectEquipPlace; }
|
set
|
{
|
if (m_SelectEquipPlace != value)
|
{
|
m_SelectEquipPlace = value;
|
if (selectEquipRefresh != null)
|
{
|
selectEquipRefresh();
|
}
|
}
|
}
|
}
|
|
public Int2 jumpEquipPosition { get; set; }
|
|
public event Action selectLevelRefresh;
|
public event Action selectEquipRefresh;
|
public event Action<int, int> equipGemRefresh;
|
public event Action<int, int, int> equipGemLevelUp;
|
public event Action selectHoleRefresh;
|
|
EquipModel equipModel
|
{
|
get { return ModelCenter.Instance.GetModel<EquipModel>(); }
|
}
|
|
EquipStarModel equipStarModel { get { return ModelCenter.Instance.GetModel<EquipStarModel>(); } }
|
PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
|
ComposeWinModel composeModel { get { return ModelCenter.Instance.GetModel<ComposeWinModel>(); } }
|
|
public bool serverInited { get; private set; }
|
|
public override void Init()
|
{
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
|
packModel.refreshItemCountEvent += RefreshItemCountEvent;
|
PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;
|
equipModel.OnSelectFuncSetEvent += OnSelect;
|
ParseConfig();
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
serverInited = false;
|
m_EquipGems.Clear();
|
|
foreach (var instance in EquipSetList)
|
{
|
GameObject.Destroy(instance.gameObject);
|
}
|
EquipSetList.Clear();
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
serverInited = true;
|
}
|
|
public override void UnInit()
|
{
|
FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
|
packModel.refreshItemCountEvent -= RefreshItemCountEvent;
|
PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;
|
equipModel.OnSelectFuncSetEvent -= OnSelect;
|
}
|
|
private void OnSelect(int equipLevel)
|
{
|
if (selectLevel == equipLevel)
|
{
|
return;
|
}
|
else
|
{
|
selectLevel = equipLevel;
|
}
|
}
|
|
void ParseConfig()
|
{
|
var gemTypeConfig = FuncConfigConfig.Get("GemTypeCount");
|
var gemTypeCount = int.Parse(gemTypeConfig.Numerical1);
|
|
var gemCostConfig = FuncConfigConfig.Get("GemUpCostFormula");
|
var shopDict = ConfigParse.GetDic<int, int>(gemCostConfig.Numerical1);
|
var composeCount = int.Parse(gemCostConfig.Numerical2);
|
|
Dictionary<int, Item> composeItems = new Dictionary<int, Item>();
|
var composeItemJson = LitJson.JsonMapper.ToObject(gemCostConfig.Numerical3);
|
foreach (var levelKey in composeItemJson.Keys)
|
{
|
var itemArray = LitJson.JsonMapper.ToObject<int[]>(composeItemJson[levelKey].ToJson());
|
composeItems.Add(int.Parse(levelKey), new Item()
|
{
|
id = itemArray[0],
|
count = itemArray[1],
|
});
|
}
|
|
for (int i = 1; i <= gemTypeCount; i++)
|
{
|
int[] getWays = null;
|
string description = string.Empty;
|
var gemConfig = FuncConfigConfig.Get("GemType" + i);
|
if (gemConfig != null)
|
{
|
var equips = ConfigParse.GetMultipleStr<int>(gemConfig.Numerical1);
|
for (int k = 0; k < equips.Length; k++)
|
{
|
List<int> gemTypes = null;
|
if (!m_EquipGemTypes.TryGetValue(equips[k], out gemTypes))
|
{
|
gemTypes = new List<int>();
|
m_EquipGemTypes.Add(equips[k], gemTypes);
|
}
|
gemTypes.Add(i);
|
}
|
|
if (!string.IsNullOrEmpty(gemConfig.Numerical3))
|
{
|
getWays = ConfigParse.GetMultipleStr<int>(gemConfig.Numerical3);
|
}
|
|
description = gemConfig.Numerical2;
|
}
|
|
var level = 1;
|
var maxLevel = level;
|
var itemType = 0;
|
var itemConfig = ItemConfig.GetGemDataByLevelAndType(level, i);
|
if (itemConfig != null)
|
{
|
itemType = itemConfig.Type;
|
}
|
while (itemConfig != null && itemConfig.EffectValueA1 == i)
|
{
|
maxLevel = level;
|
level++;
|
itemConfig = ItemConfig.Get(itemConfig.EffectValueC1);
|
}
|
|
m_GemTypes.Add(i, new GemType()
|
{
|
maxLevel = maxLevel,
|
getWays = getWays,
|
description = description,
|
itemType = itemType,
|
shopItemId = shopDict.ContainsKey(i) ? shopDict[i] : 0,
|
composeCount = composeCount,
|
composeItems = composeItems,
|
filterParams = new SinglePack.FilterParams()
|
{
|
itemTypes = new List<int>() { itemType },
|
}
|
});
|
}
|
|
m_EquipPlaces.AddRange(m_EquipGemTypes.Keys);
|
m_EquipPlaces.Sort();
|
|
var commonHoleConfig = FuncConfigConfig.Get("GemOpen");
|
var vipHoleConfig = FuncConfigConfig.Get("GemOpenVip");
|
var commonOpens = ConfigParse.GetMultipleStr<int>(commonHoleConfig.Numerical1);
|
for (int i = 0; i < commonOpens.Length; i++)
|
{
|
m_GemHoleConditions.Add(i, new GemHoleCondition()
|
{
|
equipStar = commonOpens[i],
|
vipLevel = 0,
|
});
|
}
|
m_GemHoleConditions.Add(3, new GemHoleCondition()
|
{
|
equipStar = commonOpens[0],
|
vipLevel = int.Parse(vipHoleConfig.Numerical1),
|
});
|
|
var configs = EquipControlConfig.GetValues();
|
var totalEquipLevels = new List<int>();
|
foreach (var item in configs)
|
{
|
var level = item.level;
|
if (!totalEquipLevels.Contains(level))
|
{
|
totalEquipLevels.Add(level);
|
}
|
}
|
|
foreach (var level in totalEquipLevels)
|
{
|
var equipSetRedpointBase = REDPOINTBASE++;
|
m_EquipSetRedpoints[level] = new Redpoint(redpoint.id, equipSetRedpointBase);
|
foreach (var place in m_EquipPlaces)
|
{
|
var packIndex = EquipPlaceMapConfig.GetServerPlace(level, place);
|
if (!m_EquipGemRedpoints.ContainsKey(packIndex))
|
{
|
EquipGemRedpoint _redpoint = new EquipGemRedpoint(equipSetRedpointBase);
|
m_EquipGemRedpoints.Add(packIndex, _redpoint);
|
}
|
}
|
}
|
}
|
|
|
|
public bool TryGetGemHoleCondition(int hole, out GemHoleCondition condition)
|
{
|
return m_GemHoleConditions.TryGetValue(hole, out condition);
|
}
|
|
public bool TryGetEquipGems(int packIndex, out int[] gems)
|
{
|
return m_EquipGems.TryGetValue(packIndex, out gems);
|
}
|
|
public bool TryGetEquipGems(int level, int place, out int[] gems)
|
{
|
var packIndex = EquipPlaceMapConfig.GetServerPlace(level, place);
|
return TryGetEquipGems(packIndex, out gems);
|
}
|
|
//获取某阶的装备宝石总等级
|
public int GetGemLevelByEquipLevel(int level, int placeCount = 12)
|
{
|
int findCount = 0;
|
for (int i = 1; i <= placeCount; i++)
|
{
|
int[] gems;
|
if (TryGetEquipGems(level, i, out gems))
|
{
|
foreach (var equipGem in gems)
|
{
|
if (equipGem == 0)
|
{
|
continue;
|
}
|
findCount += GetGemLevel(equipGem);
|
}
|
}
|
}
|
|
return findCount;
|
}
|
|
public bool TryGetEquipGem(int level, int place, int hole, out int equipGem)
|
{
|
equipGem = 0;
|
int[] equipGems;
|
if (TryGetEquipGems(level, place, out equipGems))
|
{
|
if (hole < equipGems.Length)
|
{
|
equipGem = equipGems[hole];
|
return equipGem != 0;
|
}
|
}
|
return false;
|
}
|
|
public bool TryGetGemTypes(int place, out List<int> types)
|
{
|
return m_EquipGemTypes.TryGetValue(place, out types);
|
}
|
|
public bool TryGetGemType(int type, out GemType gemType)
|
{
|
return m_GemTypes.TryGetValue(type, out gemType);
|
}
|
|
public bool TryGetRedpoint(int level, int place, out EquipGemRedpoint _redpoint)
|
{
|
var packIndex = EquipPlaceMapConfig.GetServerPlace(level, place);
|
return m_EquipGemRedpoints.TryGetValue(packIndex, out _redpoint);
|
}
|
|
public bool TryGetRedpoint(int level, out Redpoint _redpoint)
|
{
|
return m_EquipSetRedpoints.TryGetValue(level, out _redpoint);
|
}
|
|
public Int2 TryGotoUseGem(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
if (config == null)
|
{
|
return Int2.zero;
|
}
|
GemType gemType;
|
if (!TryGetGemType(config.EffectValueA1, out gemType))
|
{
|
return Int2.zero;
|
}
|
Int2 equipPosition = Int2.zero;
|
foreach (var level in cacheEquipSets)
|
{
|
foreach (var place in m_EquipPlaces)
|
{
|
var gemTypes = m_EquipGemTypes[place];
|
if (!gemTypes.Contains(config.EffectValueA1))
|
{
|
continue;
|
}
|
for (int i = 0; i < EQUIPGEM_HOLE_COUNT; i++)
|
{
|
if (!IsEquipGemHoleOpen(level, place, i))
|
{
|
continue;
|
}
|
if (equipPosition.Equals(Int2.zero))
|
{
|
equipPosition.x = level;
|
equipPosition.y = place;
|
}
|
var equipGem = 0;
|
if (TryGetEquipGem(level, place, i, out equipGem))
|
{
|
var compareConfig = ItemConfig.Get(equipGem);
|
if(config.EffectValueB1 > compareConfig.EffectValueB1)
|
{
|
return new Int2(level, place);
|
}
|
}
|
else
|
{
|
return new Int2(level, place);
|
}
|
}
|
}
|
}
|
return equipPosition;
|
}
|
|
public bool IsEquipGemHoleOpen(int level, int place, int hole)
|
{
|
var equipPosition = new Int2(level, place);
|
var equipGuid = equipModel.GetEquip(equipPosition);
|
if (string.IsNullOrEmpty(equipGuid))
|
{
|
return false;
|
}
|
var equip = packModel.GetItemByGuid(equipGuid);
|
GemHoleCondition condition;
|
if (TryGetGemHoleCondition(hole, out condition))
|
{
|
var starLimit = 0;
|
if (GeneralDefine.equipStarLimit.ContainsKey(equip.config.ItemColor))
|
{
|
var itemLevelStars = GeneralDefine.equipStarLimit[equip.config.ItemColor];
|
if (itemLevelStars.ContainsKey(equip.config.LV))
|
{
|
starLimit = itemLevelStars[equip.config.LV];
|
}
|
}
|
var star = Mathf.Min(starLimit, equipStarModel.GetStarLevel(equipPosition));
|
if (star < condition.equipStar)
|
{
|
return false;
|
}
|
var vipLevel = PlayerDatas.Instance.baseData.VIPLv;
|
if (vipLevel < condition.vipLevel)
|
{
|
return false;
|
}
|
}
|
return true;
|
}
|
|
public bool IsGemHoleOpen(int hole, int starLevel)
|
{
|
GemHoleCondition condition;
|
if (TryGetGemHoleCondition(hole, out condition))
|
{
|
if (starLevel < condition.equipStar)
|
{
|
return false;
|
}
|
}
|
return true;
|
}
|
|
//宝石合成需要总材料信息
|
public Dictionary<int, List<int>> GetComposeNeedGemList(int makeSrcID, int itemID)
|
{
|
//{合成需要的物品ID：[背包中数量，需要数量]}
|
Dictionary<int, List<int>> needGemDict = new Dictionary<int, List<int>>();
|
if (makeSrcID == 0)
|
{
|
return needGemDict;
|
}
|
int makeID = makeSrcID;
|
int makeCnt = 1; //默认扣除已镶嵌的宝石
|
// 此处逻辑只考虑了每次合成只有一种新合成物，比如不会出现3级宝石 需要两种不同的2级宝石合成
|
while (makeCnt > 0)
|
{
|
var composeConfig = composeModel.ComposeDataDictByMakeID[makeID];
|
int nextMakeCnt = 0;
|
int nextMakeID = 0;
|
for (int i = 0; i < composeConfig.itemID.Length; i++)
|
{
|
int needCnt = composeConfig.itemCount[i] * makeCnt;
|
int needItemID = composeConfig.itemID[i];
|
if (needItemID == itemID)
|
{
|
needCnt--;
|
if (needCnt == 0)
|
continue;
|
}
|
|
//非合成物处理
|
if (!composeModel.ComposeDataDictByMakeID.ContainsKey(needItemID))
|
{
|
if (needGemDict.ContainsKey(needItemID))
|
{
|
needGemDict[needItemID][1] = needGemDict[needItemID][1] + needCnt;
|
}
|
else
|
{
|
needGemDict[needItemID] = new List<int>() {
|
packModel.GetItemCountByID(PackType.Item, needItemID),
|
needCnt
|
};
|
}
|
}
|
else
|
{
|
var hasCnt = packModel.GetItemCountByID(PackType.Item, needItemID);
|
if (hasCnt > 0)
|
{
|
needGemDict[needItemID] = new List<int>() {hasCnt, Math.Min(hasCnt, needCnt) };
|
needCnt = Math.Max(needCnt - hasCnt, 0);
|
}
|
nextMakeCnt = nextMakeCnt + needCnt;
|
nextMakeID = needItemID;
|
}
|
}
|
|
makeID = nextMakeID;
|
makeCnt = nextMakeCnt;
|
}
|
return needGemDict;
|
}
|
|
public bool IsEquipGemHoleOpen(int packIndex, int hole)
|
{
|
var config = EquipPlaceMapConfig.Get(packIndex);
|
if (config != null)
|
{
|
return IsEquipGemHoleOpen(config.LV, config.EquipPlace, hole);
|
}
|
return false;
|
}
|
|
public bool IsEquipGemMaxLevel(int id)
|
{
|
var itemConfig = ItemConfig.Get(id);
|
if (itemConfig == null)
|
{
|
return true;
|
}
|
var gemType = itemConfig.EffectValueA1;
|
if (m_GemTypes.ContainsKey(gemType))
|
{
|
return itemConfig.EffectValueB1 >= m_GemTypes[gemType].maxLevel;
|
}
|
return true;
|
}
|
|
public bool IsBetterGem(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
if (config == null)
|
{
|
return false;
|
}
|
foreach (var level in cacheEquipSets)
|
{
|
foreach (var place in m_EquipPlaces)
|
{
|
var gemTypes = m_EquipGemTypes[place];
|
if (!gemTypes.Contains(config.EffectValueA1))
|
{
|
continue;
|
}
|
for (int i = 0; i < EQUIPGEM_HOLE_COUNT; i++)
|
{
|
if (!IsEquipGemHoleOpen(level, place, i))
|
{
|
continue;
|
}
|
var equipGem = 0;
|
if (TryGetEquipGem(level, place, i, out equipGem))
|
{
|
var compareConfig = ItemConfig.Get(equipGem);
|
return config.EffectValueB1 > compareConfig.EffectValueB1;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
}
|
}
|
return false;
|
}
|
|
public ICollection<int> GetMosaicEquipPlaces()
|
{
|
return m_EquipPlaces;
|
}
|
|
public int GetUnlockEquipSlotCount(int level)
|
{
|
var equipSet = equipModel.GetEquipSet(level);
|
if (equipSet == null || !equipSet.unLocked)
|
{
|
return 0;
|
}
|
var count = 0;
|
var places = GetMosaicEquipPlaces();
|
foreach (var place in places)
|
{
|
if (equipSet.IsSlotUnLocked(place))
|
{
|
count++;
|
}
|
}
|
return count;
|
}
|
|
public List<string> GetSatisfyEquipGemGuids(int place)
|
{
|
if (!m_EquipGemTypes.ContainsKey(place))
|
{
|
return null;
|
}
|
List<string> items = new List<string>();
|
var types = m_EquipGemTypes[place];
|
foreach (var type in types)
|
{
|
var gemType = m_GemTypes[type];
|
var itemModels = packModel.GetItems(PackType.Item, gemType.filterParams);
|
if (itemModels != null)
|
{
|
foreach (var itemModel in itemModels)
|
{
|
if (itemModel.config.EffectValueA1 == type)
|
{
|
items.Add(itemModel.guid);
|
}
|
}
|
}
|
}
|
return items;
|
}
|
|
public ItemConfig GetNextLevelConfig(int id)
|
{
|
if (IsEquipGemMaxLevel(id))
|
{
|
return null;
|
}
|
var config = ItemConfig.Get(id);
|
if (config == null)
|
{
|
return null;
|
}
|
return ItemConfig.GetGemDataByLevelAndType(config.EffectValueB1 + 1, config.EffectValueA1);
|
}
|
|
public int GetGemLevelUpCost(int type, int level)
|
{
|
var cost = 0;
|
GemType gemType;
|
if (TryGetGemType(type, out gemType))
|
{
|
cost += GetGemComposeCost(type, level);
|
for (int i = 1; i < level; i++)
|
{
|
if (gemType.composeItems.ContainsKey(i + 1))
|
{
|
var item = gemType.composeItems[i + 1];
|
var shopConfig = StoreConfig.GetStoreCfg(item.id, 1);
|
if (shopConfig != null)
|
{
|
cost += shopConfig.MoneyNumber * item.count * (1 << (level - 1 - i));
|
}
|
}
|
}
|
if (gemType.composeItems.ContainsKey(level + 1))
|
{
|
var item = gemType.composeItems[level + 1];
|
var shopConfig = StoreConfig.GetStoreCfg(item.id, 1);
|
if (shopConfig != null)
|
{
|
cost += shopConfig.MoneyNumber * item.count;
|
}
|
}
|
}
|
return cost;
|
}
|
|
public int GetGemComposeCost(int type, int level)
|
{
|
var cost = 0;
|
GemType gemType;
|
if (TryGetGemType(type, out gemType))
|
{
|
if (level > 1)
|
{
|
cost += gemType.composeCount * GetGemComposeCost(type, level - 1);
|
}
|
else
|
{
|
var singlePrice = 0;
|
if (gemType.shopItemId != 0)
|
{
|
var shopConfig = StoreConfig.GetStoreCfg(gemType.shopItemId, 1);
|
if (shopConfig != null)
|
{
|
singlePrice = shopConfig.MoneyNumber;
|
}
|
}
|
cost = singlePrice;
|
}
|
}
|
return cost;
|
}
|
|
public int GetGemCount(int type, int level)
|
{
|
GemType gemType;
|
TryGetGemType(type, out gemType);
|
var count = 0;
|
var items = packModel.GetItems(PackType.Item, gemType.filterParams);
|
if (items == null)
|
{
|
return 0;
|
}
|
for (int i = 0; i < items.Count; i++)
|
{
|
var item = items[i];
|
var config = ItemConfig.Get(item.itemId);
|
if (config.EffectValueA1 == type && config.EffectValueB1 == level)
|
{
|
count += item.count;
|
}
|
}
|
return count;
|
}
|
|
public int GetBetterGemCount(int type, int level)
|
{
|
GemType gemType;
|
TryGetGemType(type, out gemType);
|
var count = 0;
|
var items = packModel.GetItems(PackType.Item, gemType.filterParams);
|
if (items == null)
|
{
|
return 0;
|
}
|
for (int i = 0; i < items.Count; i++)
|
{
|
var item = items[i];
|
var config = ItemConfig.Get(item.itemId);
|
if (config.EffectValueA1 == type && config.EffectValueB1 > level)
|
{
|
count += item.count;
|
}
|
}
|
return count;
|
}
|
|
public int GetSameLevelGemCount(int type, int level)
|
{
|
GemType gemType;
|
TryGetGemType(type, out gemType);
|
var count = 0;
|
var items = packModel.GetItems(PackType.Item, gemType.filterParams);
|
if (items == null)
|
{
|
return 0;
|
}
|
for (int i = 0; i < items.Count; i++)
|
{
|
var item = items[i];
|
var config = ItemConfig.Get(item.itemId);
|
if (config.EffectValueA1 == type && config.EffectValueB1 == level)
|
{
|
count += item.count;
|
}
|
}
|
return count;
|
}
|
|
public int GetSameTypeEmptyUnlockHole(List<int> equipSets, int type)
|
{
|
var count = 0;
|
foreach (var level in equipSets)
|
{
|
foreach (var place in m_EquipPlaces)
|
{
|
if (!m_EquipGemTypes[place].Contains(type))
|
{
|
continue;
|
}
|
for (int i = 0; i < EQUIPGEM_HOLE_COUNT; i++)
|
{
|
if (!IsEquipGemHoleOpen(level, place, i))
|
{
|
continue;
|
}
|
int equipGem;
|
if (!TryGetEquipGem(level, place, i, out equipGem))
|
{
|
count++;
|
}
|
}
|
}
|
}
|
return count;
|
}
|
|
public int GetAllGemsLevel()
|
{
|
var level = 0;
|
foreach (var key in m_EquipGems.Keys)
|
{
|
var equipGems = m_EquipGems[key];
|
foreach (var equipGem in equipGems)
|
{
|
if (equipGem == 0)
|
{
|
continue;
|
}
|
level += GetGemLevel(equipGem);
|
}
|
}
|
return level;
|
}
|
|
public int GetEmptyGemHoleCount(int level, int place)
|
{
|
var count = 0;
|
for (int i = 0; i < EQUIPGEM_HOLE_COUNT; i++)
|
{
|
var itemId = 0;
|
if (IsEquipGemHoleOpen(level, place, i)
|
&& !TryGetEquipGem(level, place, i, out itemId))
|
{
|
count++;
|
}
|
}
|
return count;
|
}
|
|
public int GetGemLevel(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
return config == null ? 0 : config.EffectValueB1;
|
}
|
|
public int Compare(string lhs, string rhs)
|
{
|
var lhsItem = packModel.GetItemByGuid(lhs);
|
var rhsItem = packModel.GetItemByGuid(rhs);
|
if (lhsItem == null || rhsItem == null)
|
{
|
return 0;
|
}
|
var lhsConfig = ItemConfig.Get(lhsItem.itemId);
|
var rhsConfig = ItemConfig.Get(rhsItem.itemId);
|
if (lhsConfig.EffectValueB1 != rhsConfig.EffectValueB1)
|
{
|
return -lhsConfig.EffectValueB1.CompareTo(rhsConfig.EffectValueB1);
|
}
|
return lhsItem.itemId.CompareTo(rhsItem.itemId);
|
}
|
|
public void ReceivePackage(HA3BC_tagMCStoneInfo package)
|
{
|
for (int i = 0; i < package.EquipCount; i++)
|
{
|
var data = package.InfoList[i];
|
var config = EquipPlaceMapConfig.Get(data.EquipPlace);
|
if (config == null)
|
{
|
continue;
|
}
|
|
for (int k = 0; k < m_GemHoleItemIds.Count; k++)
|
{
|
int equipGem;
|
TryGetEquipGem(config.LV, config.EquipPlace, k, out equipGem);
|
m_GemHoleItemIds[k] = equipGem;
|
}
|
|
int[] gems = null;
|
if (!m_EquipGems.TryGetValue(data.EquipPlace, out gems))
|
{
|
gems = new int[EQUIPGEM_HOLE_COUNT];
|
m_EquipGems.Add(data.EquipPlace, gems);
|
}
|
for (int k = 0; k < data.MaxStoneCount; k++)
|
{
|
gems[k] = (int)data.StoneInfo[k];
|
if (data.StoneInfo[k] > m_GemHoleItemIds[k])
|
{
|
if (serverInited && equipGemLevelUp != null)
|
{
|
equipGemLevelUp(config.LV, config.EquipPlace, k);
|
}
|
}
|
}
|
if (equipGemRefresh != null)
|
{
|
equipGemRefresh(config.LV, config.EquipPlace);
|
}
|
}
|
RefreshRedpoint();
|
}
|
|
public void SendGemLevelUp(int level, int place, int hole, int levelUpType)
|
{
|
CA306_tagCMEquipStoneUpgrade levelUp = new CA306_tagCMEquipStoneUpgrade();
|
levelUp.EquipIndex = (byte)EquipPlaceMapConfig.GetServerPlace(level, place);
|
if (hole == 3)
|
{
|
levelUp.HoleIndex = 10;
|
}
|
else
|
{
|
levelUp.HoleIndex = (byte)hole;
|
}
|
levelUp.UpWay = (byte)levelUpType;
|
GameNetSystem.Instance.SendInfo(levelUp);
|
}
|
|
List<int> m_CacheEquipSets;
|
List<int> cacheEquipSets
|
{
|
get
|
{
|
if (m_CacheEquipSets == null)
|
{
|
m_CacheEquipSets = equipModel.GetAllEquipSets();
|
}
|
return m_CacheEquipSets;
|
}
|
}
|
|
void RefreshRedpoint()
|
{
|
//宝石镶嵌功能和强化一起开放，避免红点问题
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Strength))
|
{
|
return;
|
}
|
|
List<int> places = new List<int>(m_EquipPlaces);
|
|
#region 检查空的孔位
|
places.Sort((int x, int y) =>
|
{
|
List<int> x_types;
|
List<int> y_types;
|
if (TryGetGemTypes(x, out x_types)
|
&& TryGetGemTypes(y, out y_types))
|
{
|
if (x_types[0] != y_types[0])
|
{
|
return -x_types[0].CompareTo(y_types[0]);
|
}
|
}
|
return x.CompareTo(y);
|
});
|
|
foreach (var level in cacheEquipSets)
|
{
|
foreach (var place in places)
|
{
|
for (int i = 0; i < EQUIPGEM_HOLE_COUNT; i++)
|
{
|
int equipGem;
|
if (!TryGetEquipGem(level, place, i, out equipGem))
|
{
|
if (SatisfyInlayBetterGem(level, place, i))
|
{
|
SetRedpoint(new Int2(level, place), i, 1);
|
return;
|
}
|
}
|
}
|
}
|
}
|
#endregion
|
|
#region 检查所有孔位
|
foreach (var level in cacheEquipSets)
|
{
|
foreach (var place in places)
|
{
|
for (int i = 0; i < EQUIPGEM_HOLE_COUNT; i++)
|
{
|
if (SatisfyInlayBetterGem(level, place, i))
|
{
|
SetRedpoint(new Int2(level, place), i, 1);
|
return;
|
}
|
}
|
}
|
}
|
#endregion
|
|
#region 检查非空孔位
|
int cacheLevel = 0;
|
Int2 position = Int2.zero;
|
int hole = 0;
|
int type = 0;
|
foreach (var level in cacheEquipSets)
|
{
|
foreach (var place in places)
|
{
|
for (int i = 0; i < EQUIPGEM_HOLE_COUNT; i++)
|
{
|
int equipGem;
|
if (TryGetEquipGem(level, place, i, out equipGem))
|
{
|
if (SatisfyComposeGem(level, place, i))
|
{
|
if (cacheLevel == 0 || cacheLevel > GetGemLevel(equipGem))
|
{
|
cacheLevel = GetGemLevel(equipGem);
|
position.x = level;
|
position.y = place;
|
hole = i;
|
type = 2;
|
}
|
}
|
}
|
}
|
}
|
}
|
#endregion
|
|
SetRedpoint(position, hole, type);
|
}
|
|
void SetRedpoint(Int2 position, int hole, int type)
|
{
|
foreach (var level in cacheEquipSets)
|
{
|
foreach (var place in m_EquipPlaces)
|
{
|
var packIndex = EquipPlaceMapConfig.GetServerPlace(level, place);
|
EquipGemRedpoint equipGemRedpoint;
|
TryGetRedpoint(level, place, out equipGemRedpoint);
|
for (int i = 0; i < EQUIPGEM_HOLE_COUNT; i++)
|
{
|
var inlayAble = position.x == level && position.y == place && hole == i && type == 1;
|
var composeAble = position.x == level && position.y == place && hole == i && type == 2;
|
equipGemRedpoint.SetInlayRedpoint(i, inlayAble);
|
equipGemRedpoint.SetComposeRedpoint(i, composeAble);
|
}
|
}
|
}
|
}
|
|
//只处理空孔的红点，更好的不处理
|
public bool SatisfyInlayBetterGem(int level, int place, int hole)
|
{
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Gem))
|
{
|
return false;
|
}
|
if (!IsEquipGemHoleOpen(level, place, hole))
|
{
|
return false;
|
}
|
int equipGem;
|
TryGetEquipGem(level, place, hole, out equipGem);
|
var equipGemLevel = 0;
|
if (equipGem != 0)
|
{
|
// var config = ItemConfig.Get(equipGem);
|
// equipGemLevel = config.EffectValueB1;
|
//只处理未镶嵌，不比较更好
|
return false;
|
}
|
List<int> gemTypes = m_EquipGemTypes[place];
|
foreach (var type in gemTypes)
|
{
|
var count = GetBetterGemCount(type, equipGemLevel);
|
if (count > 0)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool SatisfyComposeGem(int level, int place, int hole)
|
{
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Gem))
|
{
|
return false;
|
}
|
if (!IsEquipGemHoleOpen(level, place, hole))
|
{
|
return false;
|
}
|
int equipGem;
|
TryGetEquipGem(level, place, hole, out equipGem);
|
if (equipGem == 0)
|
{
|
return false;
|
}
|
if (IsEquipGemMaxLevel(equipGem))
|
{
|
return false;
|
}
|
var config = ItemConfig.Get(equipGem);
|
var type = config.EffectValueA1;
|
var emptyHoleCount = GetSameTypeEmptyUnlockHole(cacheEquipSets, type);
|
var sameLevelCount = GetSameLevelGemCount(type, config.EffectValueB1);
|
sameLevelCount -= emptyHoleCount;
|
GemType gemType;
|
TryGetGemType(type, out gemType);
|
if (sameLevelCount < gemType.composeCount - 1)
|
{
|
return false;
|
}
|
if (gemType.composeItems.ContainsKey(config.EffectValueB1 + 1))
|
{
|
var item = gemType.composeItems[config.EffectValueB1 + 1];
|
var count = packModel.GetItemCountByID(PackType.Item, item.id);
|
if (count < item.count)
|
{
|
return false;
|
}
|
}
|
return true;
|
}
|
|
private void OnFuncStateChangeEvent(int id)
|
{
|
if ((int)FuncOpenEnum.Gem == id)
|
{
|
RefreshRedpoint();
|
}
|
}
|
|
private void RefreshItemCountEvent(PackType packType, int arg2, int itemId)
|
{
|
if (packType == PackType.Equip)
|
{
|
RefreshRedpoint();
|
}
|
if (packType == PackType.Item)
|
{
|
var config = ItemConfig.Get(itemId);
|
if (m_GemTypes.ContainsKey(config.EffectValueA1)
|
&& m_GemTypes[config.EffectValueA1].itemType == config.Type)
|
{
|
RefreshRedpoint();
|
}
|
}
|
}
|
|
private void PlayerDataRefreshInfoEvent(PlayerDataType refreshType)
|
{
|
if (refreshType == PlayerDataType.VIPLv)
|
{
|
RefreshRedpoint();
|
}
|
}
|
}
|
|
public struct GemHoleCondition
|
{
|
public int equipStar;
|
public int vipLevel;
|
}
|
|
public struct GemType
|
{
|
public int maxLevel;
|
public int[] getWays;
|
public string description;
|
public int itemType;
|
public int shopItemId;
|
public int composeCount;
|
public Dictionary<int, Item> composeItems;
|
public SinglePack.FilterParams filterParams;
|
}
|
|
public class EquipGemRedpoint
|
{
|
public readonly Redpoint repoint;
|
readonly List<Redpoint> holeRedpooints;
|
readonly List<Redpoint> holeInlayRedpoints;
|
readonly List<Redpoint> holeComposeRedpoints;
|
|
public EquipGemRedpoint(int baseId)
|
{
|
repoint = new Redpoint(baseId, EquipGemModel.REDPOINTBASE++);
|
holeRedpooints = new List<Redpoint>(EquipGemModel.EQUIPGEM_HOLE_COUNT);
|
holeInlayRedpoints = new List<Redpoint>(EquipGemModel.EQUIPGEM_HOLE_COUNT);
|
holeComposeRedpoints = new List<Redpoint>(EquipGemModel.EQUIPGEM_HOLE_COUNT);
|
for (int i = 0; i < EquipGemModel.EQUIPGEM_HOLE_COUNT; i++)
|
{
|
holeRedpooints.Add(new Redpoint(repoint.id, EquipGemModel.REDPOINTBASE++));
|
holeInlayRedpoints.Add(new Redpoint(holeRedpooints[i].id, EquipGemModel.REDPOINTBASE++));
|
holeComposeRedpoints.Add(new Redpoint(holeRedpooints[i].id, EquipGemModel.REDPOINTBASE++));
|
}
|
}
|
|
public void SetInlayRedpoint(int hole, bool inlayable)
|
{
|
if (hole < holeInlayRedpoints.Count)
|
{
|
holeInlayRedpoints[hole].state = inlayable ? RedPointState.Simple : RedPointState.None;
|
}
|
}
|
|
public void SetComposeRedpoint(int hole, bool composeAble)
|
{
|
if (hole < holeComposeRedpoints.Count)
|
{
|
holeComposeRedpoints[hole].state = composeAble ? RedPointState.Simple : RedPointState.None;
|
}
|
}
|
|
public Redpoint GetInlayRedpoint(int hole)
|
{
|
if (hole < holeInlayRedpoints.Count)
|
{
|
return holeInlayRedpoints[hole];
|
}
|
return null;
|
}
|
|
public Redpoint GetComposeRedpoint(int hole)
|
{
|
if (hole < holeComposeRedpoints.Count)
|
{
|
return holeComposeRedpoints[hole];
|
}
|
return null;
|
}
|
|
public Redpoint GetHoleRedpoint(int hole)
|
{
|
if (hole < holeRedpooints.Count)
|
{
|
return holeRedpooints[hole];
|
}
|
return null;
|
}
|
}
|
|
public enum GemEquipType
|
{
|
MultiEquip,
|
}
|
}
|
|
