using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using UnityEngine.UI;
|
|
public class HeroFatesManager : GameSystemManager<HeroFatesManager>
|
{
|
public readonly int rowCountMax = 5;
|
public readonly int attrRowCountMax = 3;
|
public override void Init()
|
{
|
DTC0102_tagCDBPlayer.beforePlayerDataInitializeEventOnRelogin += OnBeforePlayerDataInitializeEventOnRelogin;
|
DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent += OnPlayerLoginOk;
|
HeroUIManager.Instance.OnHeroCollectEvent += OnHeroCollectEvent;
|
HeroManager.Instance.onHeroChangeEvent += OnHeroChangeEvent;
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
|
}
|
|
public override void Release()
|
{
|
DTC0102_tagCDBPlayer.beforePlayerDataInitializeEventOnRelogin -= OnBeforePlayerDataInitializeEventOnRelogin;
|
DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent -= OnPlayerLoginOk;
|
HeroUIManager.Instance.OnHeroCollectEvent -= OnHeroCollectEvent;
|
HeroManager.Instance.onHeroChangeEvent -= OnHeroChangeEvent;
|
FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
|
}
|
|
private void OnFuncStateChangeEvent(int obj)
|
{
|
if (obj == (int)FuncOpenEnum.Hero || obj == (int)FuncOpenEnum.HeroFatesUpgrade)
|
{
|
UpdateRedpoint();
|
}
|
}
|
|
private void OnBeforePlayerDataInitializeEventOnRelogin()
|
{
|
heroFatesInfos.Clear();
|
}
|
|
private void OnPlayerLoginOk()
|
{
|
UpdateRedpoint();
|
RefreshAttr();
|
}
|
|
private void OnHeroCollectEvent()
|
{
|
UpdateRedpoint();
|
}
|
|
private void OnHeroChangeEvent(HeroInfo info)
|
{
|
UpdateRedpoint();
|
}
|
|
List<int> allFatesHeroID = new List<int>();
|
|
public List<int> GetAllFatesHeroID()
|
{
|
if (allFatesHeroID.IsNullOrEmpty())
|
{
|
foreach (var info in HeroFatesConfig.GetValues())
|
{
|
if (info.HeroIDList.IsNullOrEmpty())
|
{
|
continue;
|
}
|
foreach (var HeroID in info.HeroIDList)
|
{
|
if (!allFatesHeroID.Contains(HeroID))
|
{
|
allFatesHeroID.Add(HeroID);
|
}
|
}
|
}
|
}
|
return allFatesHeroID;
|
}
|
|
Redpoint redpoint = new Redpoint(MainRedDot.MainHerosRedpoint, MainRedDot.HeroFatesRepoint);
|
public void UpdateRedpoint()
|
{
|
redpoint.state = RedPointState.None;
|
//武将没开不刷红点
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Hero))
|
return;
|
bool hasShowRedDotFates = HasShowRedDotFates(out int firstIndex);
|
if (hasShowRedDotFates)
|
{
|
redpoint.state = RedPointState.Simple;
|
}
|
}
|
|
//<宿缘ID，宿缘信息>
|
public Dictionary<int, HeroFates> heroFatesInfos = new Dictionary<int, HeroFates>();
|
|
public bool TryGetHeroFates(int fatesID, out HeroFates info)
|
{
|
return heroFatesInfos.TryGetValue(fatesID, out info);
|
}
|
|
public event Action OnUpdateHeroFatesInfoEvent;
|
public event Action OnUpgradeHeroFatesEvent;
|
public void OnUpdateHeroFatesInfo(HB131_tagSCHeroFatesInfo vNetData)
|
{
|
if (vNetData == null || vNetData.FatesList.IsNullOrEmpty())
|
{
|
return;
|
}
|
bool isUpgrade = false;
|
|
foreach (var vInfo in vNetData.FatesList)
|
{
|
if (!heroFatesInfos.ContainsKey(vInfo.FatesID))
|
{
|
heroFatesInfos[vInfo.FatesID] = new HeroFates();
|
}
|
|
heroFatesInfos[vInfo.FatesID].FatesID = vInfo.FatesID;
|
heroFatesInfos[vInfo.FatesID].State = vInfo.State;
|
|
if (heroFatesInfos[vInfo.FatesID].FatesLV != vInfo.FatesLV)
|
{
|
isUpgrade = true;
|
}
|
heroFatesInfos[vInfo.FatesID].FatesLV = vInfo.FatesLV;
|
}
|
RefreshAttr();
|
UpdateRedpoint();
|
OnUpdateHeroFatesInfoEvent?.Invoke();
|
if (isUpgrade)
|
{
|
OnUpgradeHeroFatesEvent?.Invoke();
|
}
|
}
|
|
public ushort[] GetItemIndexList(List<HeroInfo> heroInfos)
|
{
|
return heroInfos.Select(heroInfo => (ushort)heroInfo.itemHero.gridIndex).ToArray();
|
}
|
|
public void SendHeroFates(int fatesID, int opType, ushort[] itemIndexList = null)
|
{
|
CB241_tagCSHeroFates pack = new CB241_tagCSHeroFates();
|
pack.FatesID = (byte)fatesID; // 宿缘ID
|
pack.OPType = (byte)opType; // 0-激活领奖；1-升级
|
|
// 升级时消耗的材料卡在武将背包索引列表，升级时才发
|
bool isNullOrEmpty = itemIndexList.IsNullOrEmpty();
|
pack.ItemIndexList = isNullOrEmpty ? null : itemIndexList;
|
pack.IndexCnt = isNullOrEmpty ? (byte)0 : (byte)itemIndexList.Length;
|
|
GameNetSystem.Instance.SendInfo(pack);
|
}
|
|
public HeroFatesState GetHeroFatesState(int fatesID)
|
{
|
//没有封包
|
if (!TryGetHeroFates(fatesID, out HeroFates info))
|
{
|
return IsHeroIDListAllActive(fatesID) ? HeroFatesState.Activatable : HeroFatesState.Locked;
|
}
|
|
// 封包宿缘状态：0-未激活；1-已激活已领奖
|
if (info.State == 0)
|
{
|
//武将ID组合列表中的武将的图鉴有没解锁的?- 未解锁
|
return IsHeroIDListAllActive(fatesID) ? HeroFatesState.Activatable : HeroFatesState.Locked;
|
}
|
else if (info.State == 1)
|
{
|
// 宿缘升级功能没开时视为不可升级
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.HeroFatesUpgrade))
|
{
|
return HeroFatesState.ActiveNotUpgradable;
|
}
|
|
if (IsHeroFatesStarMax(fatesID))
|
{
|
return HeroFatesState.MaxLevel;
|
}
|
return IsHeroFatesCanUp(fatesID, out int fromFatesLv, out int toFatesLv) ? HeroFatesState.ActiveUpgradable : HeroFatesState.ActiveNotUpgradable;
|
}
|
return HeroFatesState.Locked;
|
}
|
|
public bool IsHeroFatesCanUp(int fatesID, out int fromFatesLv, out int toFatesLv)
|
{
|
fromFatesLv = 0;
|
toFatesLv = 0;
|
|
if (!TryGetHeroFatesConfig(fatesID, out HeroFatesConfig config))
|
{
|
return false;
|
}
|
|
if (!TryGetHeroFates(fatesID, out HeroFates info))
|
{
|
return false;
|
}
|
|
fromFatesLv = info.FatesLV;
|
toFatesLv = info.FatesLV + 1;
|
|
int fatesQuality = config.FatesQuality;
|
if (!HeroFatesQualityLVConfig.TryGetHeroFatesQualityLVConfig(fatesQuality, toFatesLv, out HeroFatesQualityLVConfig heroFatesQualityLVConfig))
|
{
|
return false;
|
}
|
|
// 武将总星级是否满足升级需求
|
int needStarCnt = heroFatesQualityLVConfig.NeedStarTotal;
|
int hasStarCnt = GetFatesNowStarCnt(fatesID);
|
if (hasStarCnt < needStarCnt)
|
{
|
return false;
|
}
|
// 消耗武将数量是否满足需求
|
List<HeroInfo> consumableHeroInfos = GetConsumableHeroInfoList(heroFatesQualityLVConfig.NeedQuality);
|
int hasHeroCnt = consumableHeroInfos == null ? 0 : consumableHeroInfos.Count;
|
int needHeroCnt = heroFatesQualityLVConfig.NeedHeroCnt;
|
if (hasHeroCnt < needHeroCnt)
|
{
|
return false;
|
}
|
return true;
|
}
|
|
|
// 获得背包中的所有指定品质的可消耗武将 宿缘品质就是武将品质
|
public List<HeroInfo> GetConsumableHeroInfoList(int fatesQuality)
|
{
|
List<HeroInfo> result = new List<HeroInfo>();
|
List<HeroInfo> allHeroesInBag = HeroManager.Instance.GetHeroList();
|
foreach (var item in allHeroesInBag)
|
{
|
if (item == null)
|
continue;
|
//不是所需品质
|
if (item.Quality != fatesQuality)
|
continue;
|
// 激活中的武将
|
if (item.isActive)
|
continue;
|
// 在任何阵容中上阵
|
bool isInAnyTeam = item.IsInAnyTeam();
|
if (isInAnyTeam)
|
continue;
|
// 锁定中
|
if (item.isLock)
|
continue;
|
// 升级过
|
if (item.heroLevel > 1)
|
continue;
|
// 生星过
|
if (item.heroStar > 0)
|
continue;
|
// 觉醒过
|
if (item.awakeLevel > 0)
|
continue;
|
result.Add(item);
|
}
|
result.Sort((a, b) => a.heroId.CompareTo(b.heroId));
|
return result;
|
}
|
|
// 当前宿缘的当前最高总星级是否已满级
|
public bool IsHeroFatesStarMax(int fatesID)
|
{
|
if (!TryGetHeroFates(fatesID, out HeroFates info))
|
return false;
|
if (!TryGetMaxFatesLVConfigByFatesID(fatesID, out HeroFatesQualityLVConfig heroFatesQualityLVConfig))
|
return false;
|
int maxLv = heroFatesQualityLVConfig.FatesLV;
|
int nowLv = info.FatesLV;
|
return nowLv >= maxLv;
|
}
|
|
// 武将ID组合列表中的武将的图鉴都解锁了？
|
public bool IsHeroIDListAllActive(int fatesID)
|
{
|
if (!TryGetHeroFatesConfig(fatesID, out HeroFatesConfig config) || config.HeroIDList.IsNullOrEmpty())
|
return false;
|
int activeHeroCnt = GetFateNeedHeroHasCnt(fatesID);
|
return config.HeroIDList.Length <= activeHeroCnt;
|
}
|
|
public int GetFateNeedHeroHasCnt(int fatesID)
|
{
|
int res = 0;
|
if (!TryGetHeroFatesConfig(fatesID, out HeroFatesConfig config) || config.HeroIDList.IsNullOrEmpty())
|
return 0;
|
foreach (var heroID in config.HeroIDList)
|
{
|
if (!TryGetHeroConfig(heroID, out HeroConfig heroConfig))
|
continue;
|
// heroBookState: 0未获得、1可激活、2常规、3突破升级、4星升级、5已满级
|
int heroBookState = HeroUIManager.Instance.GetHeroBookState(heroID, heroConfig.Quality);
|
if (heroBookState > 0)
|
res += 1;
|
}
|
return res;
|
}
|
|
public bool TryGetNowMaxStarHeroDict(out Dictionary<int, HeroInfo> nowMaxStarHeroDict)
|
{
|
nowMaxStarHeroDict = new Dictionary<int, HeroInfo>();
|
List<HeroInfo> allHeroesInBag = HeroManager.Instance.GetHeroList();
|
if (allHeroesInBag.IsNullOrEmpty())
|
return false;
|
foreach (var item in allHeroesInBag)
|
{
|
if (item == null)
|
continue;
|
if (!nowMaxStarHeroDict.TryGetValue(item.heroId, out HeroInfo heroInfo))
|
{
|
nowMaxStarHeroDict[item.heroId] = item;
|
}
|
else
|
{
|
if (item.heroStar > heroInfo.heroStar)
|
nowMaxStarHeroDict[item.heroId] = item;
|
}
|
}
|
return true;
|
}
|
|
public Dictionary<int, HeroInfo> GetFatesNowStarHeroInfoDict(int fatesID)
|
{
|
if (!IsHeroIDListAllActive(fatesID))
|
return null;
|
if (!TryGetHeroFatesConfig(fatesID, out HeroFatesConfig config) || config.HeroIDList.IsNullOrEmpty())
|
return null;
|
if (!TryGetNowMaxStarHeroDict(out Dictionary<int, HeroInfo> nowMaxStarHeroDict) || nowMaxStarHeroDict.IsNullOrEmpty())
|
return null;
|
Dictionary<int, HeroInfo> heroInfoDict = new Dictionary<int, HeroInfo>();
|
foreach (var heroID in config.HeroIDList)
|
{
|
if (nowMaxStarHeroDict.ContainsKey(heroID))
|
{
|
heroInfoDict[heroID] = nowMaxStarHeroDict[heroID];
|
}
|
}
|
return heroInfoDict;
|
}
|
|
// 获取当前宿缘的当前最高总星级
|
public int GetFatesNowStarCnt(int fatesID)
|
{
|
Dictionary<int, HeroInfo> dict = GetFatesNowStarHeroInfoDict(fatesID);
|
if (dict.IsNullOrEmpty())
|
return 0;
|
// 遍历宿缘配置中所需的武将ID，从maxStarsInBag中获取最高星级并累加
|
int res = 0;
|
foreach (var item in dict.Values)
|
{
|
res += item.heroStar;
|
}
|
return res;
|
}
|
|
|
public void DisplayStars(List<Image> starImgList, int starCnt)
|
{
|
for (int i = 0; i < starImgList.Count; i++)
|
{
|
//不显示星级
|
if (starCnt == -1)
|
{
|
starImgList[i].SetActive(false);
|
}
|
else if (starCnt == 0 && i == 0)
|
{
|
// 无星级 特殊处理
|
starImgList[i].SetActive(true);
|
starImgList[i].SetSprite("herostar" + starCnt);
|
}
|
else if ((starCnt - 1) % starImgList.Count >= i)
|
{
|
starImgList[i].SetActive(true);
|
starImgList[i].SetSprite("herostar" + (((starCnt - 1) / starImgList.Count) + 1) * starImgList.Count);
|
}
|
else
|
{
|
starImgList[i].SetActive(false);
|
}
|
}
|
}
|
|
public bool IsShowRedDot(int fatesID)
|
{
|
HeroFatesState state = GetHeroFatesState(fatesID);
|
return state == HeroFatesState.Activatable || state == HeroFatesState.ActiveUpgradable;
|
}
|
|
public bool HasShowRedDotFates(out int firstIndex)
|
{
|
firstIndex = 0;
|
List<int> list = GetFatesIDList();
|
if (list.IsNullOrEmpty())
|
return false;
|
for (int i = 0; i < list.Count; i++)
|
{
|
int fatesID = list[i];
|
if (IsShowRedDot(fatesID))
|
{
|
firstIndex = i;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
|
public List<HeroInfo> GetPutPreviewHeroList(int fatesID)
|
{
|
if (!TryGetHeroFatesConfig(fatesID, out HeroFatesConfig config))
|
{
|
return null;
|
}
|
|
int fatesQuality = config.FatesQuality;
|
if (!TryGetNowLVAndNextLVConfig(fatesID, out int nowLv, out HeroFatesQualityLVConfig nowLVConfig, out HeroFatesQualityLVConfig nextLVConfig))
|
{
|
return null;
|
}
|
|
int needHeroCnt = nextLVConfig.NeedHeroCnt;
|
List<HeroInfo> consumableHeroInfoList = GetConsumableHeroInfoList(nextLVConfig.NeedQuality);
|
if (consumableHeroInfoList.IsNullOrEmpty())
|
{
|
return null;
|
}
|
List<HeroInfo> putPreviewHeroList = new List<HeroInfo>();
|
int count = Math.Min(needHeroCnt, consumableHeroInfoList.Count);
|
for (int i = 0; i < count; i++)
|
{
|
putPreviewHeroList.Add(consumableHeroInfoList[i]);
|
}
|
|
return putPreviewHeroList;
|
}
|
|
#region 玩家选中内容
|
public int chooseHeroFatesId = 0;
|
public HeroInfo chooseHeroInfo = null;
|
|
// 给玩家操作选中的列表
|
public List<HeroInfo> chooseCostHeroInfos = new List<HeroInfo>();
|
// 玩家实际选中的列表
|
public List<HeroInfo> realCostHeroInfos = new List<HeroInfo>();
|
public event Action OnRealChooseChangeEvent;
|
public event Action OnChooseChangeEvent;
|
|
public void InitChooseList()
|
{
|
chooseCostHeroInfos.Clear();
|
foreach (var heroInfo in realCostHeroInfos)
|
{
|
chooseCostHeroInfos.Add(heroInfo);
|
}
|
chooseHeroInfo = null;
|
}
|
|
public void ChooseAdd(HeroInfo heroInfo)
|
{
|
if (chooseCostHeroInfos.Contains(heroInfo))
|
{
|
chooseCostHeroInfos.Remove(heroInfo);
|
chooseHeroInfo = null;
|
}
|
else
|
{
|
chooseCostHeroInfos.Add(heroInfo);
|
chooseHeroInfo = heroInfo;
|
}
|
OnChooseChangeEvent?.Invoke();
|
}
|
|
public void ClearAllList()
|
{
|
chooseCostHeroInfos.Clear();
|
realCostHeroInfos.Clear();
|
chooseHeroInfo = null;
|
OnRealChooseChangeEvent?.Invoke();
|
}
|
|
public void PutList()
|
{
|
realCostHeroInfos.Clear();
|
foreach (var heroInfo in chooseCostHeroInfos)
|
{
|
realCostHeroInfos.Add(heroInfo);
|
}
|
OnRealChooseChangeEvent?.Invoke();
|
}
|
|
public void FastAddList(List<HeroInfo> heroInfos)
|
{
|
if (heroInfos.IsNullOrEmpty())
|
return;
|
chooseCostHeroInfos.Clear();
|
realCostHeroInfos.Clear();
|
foreach (var heroInfo in heroInfos)
|
{
|
chooseCostHeroInfos.Add(heroInfo);
|
realCostHeroInfos.Add(heroInfo);
|
}
|
OnRealChooseChangeEvent?.Invoke();
|
}
|
|
#endregion
|
|
|
#region 属性计算
|
public Dictionary<int, long> attrDic = new Dictionary<int, long>();
|
|
public Dictionary<int, long> GetTotalAttr()
|
{
|
return attrDic;
|
}
|
|
public long GetAttrValue(int attrID)
|
{
|
attrDic.TryGetValue(attrID, out long value);
|
return value;
|
}
|
|
public int GetAttrPer(int attrID)
|
{
|
if (PlayerPropertyConfig.baseAttr2perDict.ContainsKey(attrID))
|
{
|
var pertype = PlayerPropertyConfig.baseAttr2perDict[attrID];
|
attrDic.TryGetValue(pertype, out long value);
|
return (int)(value);
|
}
|
return 0;
|
}
|
|
public void RefreshAttr()
|
{
|
attrDic.Clear();
|
List<int> allIds = HeroFatesConfig.GetKeys();
|
foreach (var fatesID in allIds)
|
{
|
HeroFatesState state = GetHeroFatesState(fatesID);
|
if (!TryGetAttrIDListAndLVAttrValueList(fatesID, out int[] attrIDList, out int[] lvAttrValueList))
|
continue;
|
for (int i = 0; i < attrIDList.Length; i++)
|
{
|
if (!attrDic.ContainsKey(attrIDList[i]))
|
{
|
attrDic[attrIDList[i]] = 0;
|
}
|
if (state == HeroFatesState.Locked || state == HeroFatesState.Activatable)
|
continue;
|
int value = GetNowAttrValue(fatesID, i);
|
attrDic[attrIDList[i]] += value;
|
}
|
}
|
}
|
|
//最终属性 = 等级 * 每级属性值
|
public int GetNowAttrValue(int fatesID, int attrIndex)
|
{
|
if (!TryGetAttrIDListAndLVAttrValueList(fatesID, out int[] attrIDList, out int[] lvAttrValueList))
|
return 0;
|
if (attrIndex < 0 || attrIndex > attrIDList.Length)
|
return 0;
|
if (!TryGetHeroFates(fatesID, out HeroFates info))
|
return 0;
|
int lv = info.FatesLV;
|
return lv * lvAttrValueList[attrIndex];
|
}
|
|
//下一级属性 = (等级 + 1) * 每级属性值
|
public int GetNextAttrValue(int fatesID, int attrIndex)
|
{
|
if (!TryGetAttrIDListAndLVAttrValueList(fatesID, out int[] attrIDList, out int[] lvAttrValueList))
|
return 0;
|
if (attrIndex < 0 || attrIndex > attrIDList.Length)
|
return 0;
|
if (!TryGetHeroFates(fatesID, out HeroFates info))
|
return 0;
|
int lv = info.FatesLV + 1;
|
return lv * lvAttrValueList[attrIndex];
|
}
|
|
|
#endregion
|
|
#region 读表
|
// 0级时，不返回nowLVConfig，只返回nowLVConfig
|
public bool TryGetNowLVAndNextLVConfig(int fatesID, out int nowLv, out HeroFatesQualityLVConfig nowLVConfig, out HeroFatesQualityLVConfig nextLVConfig)
|
{
|
nowLv = 0;
|
nowLVConfig = null;
|
nextLVConfig = null;
|
if (!TryGetHeroFates(fatesID, out HeroFates info))
|
return false;
|
if (!TryGetHeroFatesConfig(fatesID, out HeroFatesConfig config))
|
return false;
|
int quality = config.FatesQuality;
|
nowLv = info.FatesLV;
|
if (nowLv != 0)
|
{
|
if (!HeroFatesQualityLVConfig.TryGetHeroFatesQualityLVConfig(quality, nowLv, out nowLVConfig))
|
return false;
|
}
|
int nextLv = nowLv + 1;
|
return HeroFatesQualityLVConfig.TryGetHeroFatesQualityLVConfig(quality, nextLv, out nextLVConfig);
|
}
|
|
public bool TryGetMaxFatesLVConfigByFatesID(int fatesID, out HeroFatesQualityLVConfig heroFatesQualityLVConfig)
|
{
|
heroFatesQualityLVConfig = null;
|
if (!TryGetHeroFatesConfig(fatesID, out HeroFatesConfig config))
|
return false;
|
int fatesQuality = config.FatesQuality;
|
if (!HeroFatesQualityLVConfig.TryGetDictByFatesQuality(fatesQuality, out Dictionary<int, int> dict) || dict.IsNullOrEmpty())
|
return false;
|
int maxFatesLV = dict.Keys.Max();
|
if (!HeroFatesQualityLVConfig.TryGetHeroFatesQualityLVConfig(fatesQuality, maxFatesLV, out heroFatesQualityLVConfig))
|
return false;
|
return true;
|
}
|
|
public bool TryGetHeroFatesConfig(int fatesID, out HeroFatesConfig config)
|
{
|
config = null;
|
if (!HeroFatesConfig.HasKey(fatesID))
|
return false;
|
config = HeroFatesConfig.Get(fatesID);
|
return true;
|
}
|
|
public bool TryGetAttrIDListAndLVAttrValueList(int fatesID, out int[] attrIDList, out int[] lvAttrValueList)
|
{
|
attrIDList = null;
|
lvAttrValueList = null;
|
if (!TryGetHeroFatesConfig(fatesID, out HeroFatesConfig config))
|
return false;
|
attrIDList = config.AttrIDList;
|
lvAttrValueList = config.LVAttrValueList;
|
if (attrIDList.IsNullOrEmpty() || lvAttrValueList.IsNullOrEmpty())
|
return false;
|
return attrIDList.Length == lvAttrValueList.Length;
|
}
|
public bool TryGetHeroConfig(int heroID, out HeroConfig config)
|
{
|
config = null;
|
if (!HeroConfig.HasKey(heroID))
|
return false;
|
config = HeroConfig.Get(heroID);
|
return true;
|
}
|
public bool TryGetHeroAndSkinConfigByHeroID(int heroID, out HeroConfig heroConfig, out HeroSkinConfig heroSkinConfig)
|
{
|
heroConfig = null;
|
heroSkinConfig = null;
|
if (!HeroConfig.HasKey(heroID))
|
return false;
|
heroConfig = HeroConfig.Get(heroID);
|
int[] skinIDList = heroConfig.SkinIDList;
|
if (skinIDList.IsNullOrEmpty())
|
return false;
|
int skinID = skinIDList[0];
|
if (!HeroSkinConfig.HasKey(skinID))
|
return false;
|
heroSkinConfig = HeroSkinConfig.Get(skinID);
|
return true;
|
}
|
|
List<int> fatesIDList = null;
|
public List<int> GetFatesIDList()
|
{
|
if (fatesIDList.IsNullOrEmpty())
|
{
|
fatesIDList = HeroFatesConfig.GetKeys();
|
// 按品质降序排序，相同品质按ID降序排序
|
fatesIDList.Sort((id1, id2) =>
|
{
|
if (!TryGetHeroFatesConfig(id1, out HeroFatesConfig config1) ||
|
!TryGetHeroFatesConfig(id2, out HeroFatesConfig config2))
|
{
|
return id1.CompareTo(id2); // 如果获取配置失败，按ID排序
|
}
|
|
// 先比较品质
|
int qualityCompare = config2.BGQuality.CompareTo(config1.BGQuality);
|
if (qualityCompare != 0)
|
{
|
return qualityCompare; // 品质不同，按品质排序
|
}
|
|
// 品质相同，按ID排序
|
return id1.CompareTo(id2);
|
});
|
}
|
return fatesIDList;
|
}
|
|
|
public string GetCellBgByFatesQuality(int fatesQuality)
|
{
|
return StringUtility.Concat("HeroFatesQualityBG", fatesQuality.ToString());
|
}
|
|
public string GetHeroFatesNameBGByFatesQuality(int fatesQuality)
|
{
|
return StringUtility.Concat("HeroFatesNameBG", fatesQuality.ToString());
|
}
|
#endregion
|
}
|
public enum HeroFatesState
|
{
|
Locked, // 未激活
|
Activatable, // 可激活 (未激活但材料足够)
|
ActiveNotUpgradable,// 已激活但不可升级 (材料不足或配置不支持)
|
ActiveUpgradable, // 已激活且可升级 (材料足够升级下一档)
|
MaxLevel, // 已升到满级
|
}
|
public class HeroFates
|
{
|
public int FatesID; // 宿缘ID
|
public int State; // 宿缘状态：0-未激活；1-已激活已领奖
|
public int FatesLV; // 宿缘等级，激活时为0级，升级后有升级属性
|
}
|
