using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
|
using UnityEngine;
|
using UnityEngine.UI;
|
namespace vnxbqy.UI
|
{
|
|
public class GatherSoulItem
|
{
|
public int soulID;
|
public int soulLevel;
|
public int soulCount;
|
|
public GatherSoulItem(int id, int lv, int count)
|
{
|
soulID = id;
|
soulLevel = lv;
|
soulCount = count;
|
}
|
}
|
|
public class GatheringSoulModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
|
{
|
public const int soulDustItemID = 37001; //魂尘物品ID
|
public const int xbItemID = 37000; //寻宝所需材料
|
public const int xbType = 4; //寻宝类型
|
public int selectSoulID = 0;
|
|
public float selectSoulTime = 0;
|
public int m_SelectEmptyHole; //选择的孔 从1开始
|
public int selectEmptyHole
|
{
|
get { return m_SelectEmptyHole; }
|
set
|
{
|
m_SelectEmptyHole = value;
|
selectSoulTime = Time.time;
|
if (m_SelectEmptyHole != 0)
|
OnSelectEmptyHoleChange?.Invoke();
|
}
|
}
|
public bool isOpenXBWin = false; //寻宝界面是否开启
|
public event Action OnSelectEmptyHoleChange; //触发格子重新排序
|
|
|
Dictionary<int, int> holeSoulDict = new Dictionary<int, int>(); //聚魂孔编号（1开始），聚魂ID
|
public event Action OnGatherSoulHoleRefresh;
|
|
Dictionary<int, GatherSoulItem> soulInfoDict = new Dictionary<int, GatherSoulItem>(); //拥有的聚魂信息 聚魂ID，等级；数量通过A206获取
|
List<int> soulPack = new List<int>(); //聚魂ID假背包列表，排除已出战的聚魂, 只用于界面显示，判断等需求用soulInfoDict
|
public event Action<bool> UpdateSoulInfos; //bool true表示聚魂种类不变，false表示有获得新的聚魂种类
|
|
public const int GATHERSOUL_REDPOINT_BASE = 10104;
|
public const int GATHERSOUL_REDPOINT_XB = 10107; //猎魂寻宝
|
|
Redpoint redpointpa = new Redpoint(MainRedDot.GatherSourRedpointEnter);
|
Redpoint redpoint = new Redpoint(MainRedDot.GatherSourRedpointEnter, GATHERSOUL_REDPOINT_BASE);
|
Redpoint redpointUp = new Redpoint(GATHERSOUL_REDPOINT_BASE, GATHERSOUL_REDPOINT_BASE * 10 + 9); //背包中可升级不需要公共材料
|
|
Redpoint redpointXB = new Redpoint(MainRedDot.GatherSourRedpointEnter, GATHERSOUL_REDPOINT_XB);
|
|
List<Redpoint> holeRepoints = new List<Redpoint>() {
|
new Redpoint(GATHERSOUL_REDPOINT_BASE, GATHERSOUL_REDPOINT_BASE * 10 + 0),
|
new Redpoint(GATHERSOUL_REDPOINT_BASE, GATHERSOUL_REDPOINT_BASE * 10 + 1),
|
new Redpoint(GATHERSOUL_REDPOINT_BASE, GATHERSOUL_REDPOINT_BASE * 10 + 2),
|
new Redpoint(GATHERSOUL_REDPOINT_BASE, GATHERSOUL_REDPOINT_BASE * 10 + 3),
|
new Redpoint(GATHERSOUL_REDPOINT_BASE, GATHERSOUL_REDPOINT_BASE * 10 + 4),
|
new Redpoint(GATHERSOUL_REDPOINT_BASE, GATHERSOUL_REDPOINT_BASE * 10 + 5),
|
};
|
|
VirtualPackModel virtualPackModel { get { return ModelCenter.Instance.GetModel<VirtualPackModel>(); } }
|
PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
|
|
public int[] baseAttrArray = new int[] { 7, 8, 6 };//攻防血
|
int totalSoulLV;
|
Dictionary<int, long> allAttrDict = new Dictionary<int, long>();
|
public List<int> attrIDList = new List<int>(); //排除攻防血的属性，排序显示
|
|
public int resetMoneyType;
|
public int resetMoney;
|
|
public override void Init()
|
{
|
PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;
|
virtualPackModel.OnNoPackItemCountRefresh += VirtualPackModel_OnNoPackItemCountRefresh;
|
packModel.refreshItemCountEvent += OnRefreshItemCountEvent;
|
var arr = GeneralDefine.GetIntArray("GatherTheSoulHole", 2);
|
resetMoneyType = arr[0];
|
resetMoney = arr[1];
|
}
|
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
holeSoulDict.Clear();
|
soulInfoDict.Clear();
|
m_SelectEmptyHole = 0;
|
totalSoulLV = 0;
|
allAttrDict.Clear();
|
soulPack.Clear();
|
attrIDList.Clear();
|
selectSoulTime = 0;
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
UpdateRedpoint();
|
UpdateRedpointXB();
|
}
|
|
public override void UnInit()
|
{
|
PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;
|
virtualPackModel.OnNoPackItemCountRefresh -= VirtualPackModel_OnNoPackItemCountRefresh;
|
packModel.refreshItemCountEvent -= OnRefreshItemCountEvent;
|
}
|
|
|
|
private void PlayerDataRefreshInfoEvent(PlayerDataType refreshType)
|
{
|
if (refreshType == PlayerDataType.default35)
|
{
|
UpdateRedpoint();
|
}
|
}
|
|
|
//孔红点：可升级，可出战；非出战的聚魂只要有一个可升级就只设置总标签红点，聚魂自身没有红点ID但有红点图片显示
|
void UpdateRedpoint()
|
{
|
for (int i = 0; i < holeRepoints.Count; i++)
|
{
|
holeRepoints[i].state = RedPointState.None;
|
}
|
redpointUp.state = RedPointState.None;
|
|
var keys = soulInfoDict.Keys.ToList();
|
for (int i = 0; i < holeRepoints.Count; i++)
|
{
|
int holeIndex = i + 1;
|
int soulID = GetHoleSoulID(holeIndex);
|
if (soulID == 0)
|
{
|
for (int j = 0; j < keys.Count; j++)
|
{
|
int soul = keys[j];
|
|
var config = GatherTheSoulConfig.Get(soul);
|
if (config.HoleNum == holeIndex)
|
{
|
var soulItem = soulInfoDict[soul];
|
if (soulItem.soulLevel > 0)
|
{
|
holeRepoints[i].state = RedPointState.Simple;
|
return;
|
}
|
|
if (CanLevelUp(soul))
|
{
|
holeRepoints[i].state = RedPointState.Simple;
|
return;
|
}
|
}
|
}
|
}
|
else if (CanLevelUp(soulID))
|
{
|
holeRepoints[i].state = RedPointState.Simple;
|
return;
|
}
|
|
}
|
|
//背包中可升级不需要公共材料, 有一个可升级就显示红点
|
for (int j = 0; j < keys.Count; j++)
|
{
|
if (OnlyPieceCanLevelUp(keys[j]))
|
{
|
redpointUp.state = RedPointState.Simple;
|
return;
|
}
|
}
|
}
|
|
bool OnlyPieceCanLevelUp(int soulID)
|
{
|
int lv = GetSoulLevel(soulID);
|
var nextConfig = GatherTheSoulLVConfig.GetSoulLVConfig(soulID, lv + 1);
|
if (nextConfig == null)
|
return false;
|
|
if (nextConfig.NeedSoulValue > 0)
|
{
|
return false;
|
}
|
|
if (nextConfig.NeedPiece > 0 && GetSoulItemCount(soulID) < nextConfig.NeedPiece)
|
{
|
return false;
|
}
|
|
return true;
|
}
|
|
|
void UpdateRedpointXB()
|
{
|
redpointXB.state = RedPointState.None;
|
if (packModel.GetItemCountByID(PackType.Item, xbItemID) > 0)
|
{
|
redpointXB.state = RedPointState.Simple;
|
}
|
}
|
|
//是否可以升级聚魂，includeSoulValue代表需要判断魂尘材料，false则不能升级
|
bool CanLevelUp(int soulID)
|
{
|
int lv = GetSoulLevel(soulID);
|
var nextConfig = GatherTheSoulLVConfig.GetSoulLVConfig(soulID, lv + 1);
|
if (nextConfig == null)
|
return false;
|
|
if (nextConfig.NeedSoulValue > 0 && UIHelper.GetMoneyCnt(44) < (ulong)nextConfig.NeedSoulValue)
|
{
|
return false;
|
}
|
|
if (nextConfig.NeedPiece > 0 && GetSoulItemCount(soulID) < nextConfig.NeedPiece)
|
{
|
return false;
|
}
|
|
return true;
|
}
|
|
|
public void OnReceiveServerPack(HA361_tagMCGatherTheSoulHoleInfo package)
|
{
|
holeSoulDict.Clear();
|
for (int i = 0; i < package.Count; i++)
|
{
|
int soulID = (int)package.HoleSoulList[i];
|
GatherTheSoulConfig config = GatherTheSoulConfig.Get(soulID);
|
if (config == null)
|
continue;
|
holeSoulDict[config.HoleNum] = soulID;
|
}
|
|
SortGatherSoulPack();
|
OnGatherSoulHoleRefresh?.Invoke();
|
UpdateRedpoint();
|
}
|
|
//0代表未镶嵌，其他数字对应表中的聚魂ID品质
|
public void SetHoleBackGround(Image _image, int soulColor)
|
{
|
if (_image == null)
|
{
|
return;
|
}
|
_image.SetSprite(string.Format("GatherSoulHoleColor_{0}", soulColor));
|
}
|
|
|
public void UpdateSoulInfo(HA360_tagMCGatherTheSoulInfo vNetData)
|
{
|
int beforeCnt = soulInfoDict.Count;
|
for (int i = 0; i < vNetData.SoulList.Length; i++)
|
{
|
int soulID = (int)vNetData.SoulList[i].SoulID;
|
int lv = vNetData.SoulList[i].LV;
|
if (soulInfoDict.ContainsKey(soulID))
|
{
|
soulInfoDict[soulID].soulLevel = lv;
|
}
|
else
|
{
|
soulInfoDict[soulID] = new GatherSoulItem(soulID, lv, 0);
|
}
|
}
|
RefreshAllSoulAttr();
|
RefreshGatherSoulTotalLV();
|
UpdateSoulInfos?.Invoke(beforeCnt == soulInfoDict.Count);
|
UpdateRedpoint();
|
}
|
|
//获取聚魂孔已出战的魂ID，没有为0
|
public int GetHoleSoulID(int hole)
|
{
|
if (!holeSoulDict.ContainsKey(hole))
|
return 0;
|
return holeSoulDict[hole];
|
}
|
|
//获得某个聚魂ID的的等级
|
public int GetSoulLevel(int soulID)
|
{
|
if (!soulInfoDict.ContainsKey(soulID))
|
return 0;
|
return soulInfoDict[soulID].soulLevel;
|
}
|
|
//获取某个聚魂ID的当前物品数量
|
public int GetSoulItemCount(int soulID)
|
{
|
if (soulID == 0) return 0;
|
int itemID = GatherTheSoulConfig.Get(soulID).PieceItemID;
|
return virtualPackModel.GetNoPackItemCount(itemID);
|
}
|
|
//获取聚魂总等级
|
public int GetGatherSoulTotalLV()
|
{
|
return totalSoulLV;
|
}
|
|
public void RefreshGatherSoulTotalLV()
|
{
|
totalSoulLV = 0;
|
foreach (var item in soulInfoDict)
|
{
|
totalSoulLV += item.Value.soulLevel;
|
}
|
}
|
|
|
|
|
//所有聚魂的总属性
|
public Dictionary<int, long> GetAllSoulAttr()
|
{
|
return allAttrDict;
|
}
|
|
public void RefreshAllSoulAttr()
|
{
|
allAttrDict.Clear();
|
foreach (var item in soulInfoDict)
|
{
|
var config = GatherTheSoulLVConfig.GetSoulLVConfig(item.Key, item.Value.soulLevel);
|
if (config == null)
|
continue;
|
for (int i = 0; i < config.LVAttrType.Length; i++)
|
{
|
int attrType = config.LVAttrType[i];
|
long attrValue = config.LVAttrValue[i];
|
if (allAttrDict.ContainsKey(attrType))
|
{
|
allAttrDict[attrType] += attrValue;
|
}
|
else
|
{
|
allAttrDict[attrType] = attrValue;
|
}
|
}
|
}
|
|
attrIDList = allAttrDict.Keys.ToList();
|
foreach (var id in baseAttrArray)
|
{
|
if (attrIDList.Contains(id))
|
{
|
attrIDList.Remove(id);
|
}
|
}
|
if (!attrIDList.IsNullOrEmpty())
|
attrIDList.Sort((a, b) => {
|
PlayerPropertyConfig aConfig = PlayerPropertyConfig.Get(a);
|
PlayerPropertyConfig bConfig = PlayerPropertyConfig.Get(b);
|
if (aConfig.showSequence != bConfig.showSequence)
|
return aConfig.showSequence.CompareTo(bConfig.showSequence);
|
return a.CompareTo(b);
|
});
|
}
|
|
private void VirtualPackModel_OnNoPackItemCountRefresh()
|
{
|
int beforeCnt = soulInfoDict.Count;
|
var dict = virtualPackModel.GetAllNoPackItem();
|
foreach (var item in dict)
|
{
|
int soulID = GatherTheSoulConfig.GetSoulIDByItemID(item.Key);
|
if (soulID == 0)
|
continue;
|
|
if (soulInfoDict.ContainsKey(soulID))
|
{
|
soulInfoDict[soulID].soulCount = item.Value;
|
}
|
else
|
{
|
soulInfoDict[soulID] = new GatherSoulItem(soulID, 0, item.Value);
|
}
|
}
|
if (WindowCenter.Instance.IsOpen<GatherSoulWin>())
|
{
|
SortGatherSoulPack();
|
UpdateSoulInfos?.Invoke(beforeCnt == soulInfoDict.Count);
|
}
|
|
UpdateRedpoint();
|
}
|
|
|
//聚魂假背包列表排序，排除已出战的聚魂；第一次打开界面排序，点击聚魂孔后重新排序
|
//排序 选中的类型在前面 - 红点 - 孔顺序 - 品质高 - id顺序；已出战的不显示在队列中
|
public void SortGatherSoulPack()
|
{
|
soulPack.Clear();
|
soulPack = soulInfoDict.Keys.ToList();
|
|
foreach (var item in holeSoulDict)
|
{
|
if (soulPack.Contains(item.Value))
|
soulPack.Remove(item.Value);
|
}
|
|
|
soulPack.Sort((a, b) =>
|
{
|
var aConfig = GatherTheSoulConfig.Get(a);
|
var bConfig = GatherTheSoulConfig.Get(b);
|
bool isASelectHoleIndex = aConfig.HoleNum == m_SelectEmptyHole;
|
bool isBSelectHoleIndex = bConfig.HoleNum == m_SelectEmptyHole;
|
if (isASelectHoleIndex != isBSelectHoleIndex)
|
return isBSelectHoleIndex.CompareTo(isASelectHoleIndex);
|
|
bool canlvupA = OnlyPieceCanLevelUp(a);
|
bool canlvupB = OnlyPieceCanLevelUp(b);
|
|
if (canlvupA != canlvupB)
|
return canlvupB.CompareTo(canlvupA);
|
|
|
int aHole = aConfig.HoleNum;
|
int bHole = bConfig.HoleNum;
|
if (aHole != bHole)
|
return aHole.CompareTo(bHole);
|
|
int aQuality = aConfig.SoulColor;
|
int bQuality = bConfig.SoulColor;
|
if (aQuality != bQuality)
|
return bQuality.CompareTo(aQuality);
|
|
return a.CompareTo(b);
|
});
|
}
|
|
public List<int> GetGatherSoulPack()
|
{
|
return soulPack;
|
}
|
|
public void SendGatherTheSoulOP(int soulID, int opType)
|
{
|
CB225_tagCMGatherTheSoulOP package = new CB225_tagCMGatherTheSoulOP();
|
package.SoulID = (uint)soulID;
|
package.OpType = (byte)opType;
|
GameNetSystem.Instance.SendInfo(package);
|
}
|
|
//获取下一个技能激活的聚魂所需等级和达到技能等级, 0代表满级
|
public Int2 GetNextSkillLV(int soulID)
|
{
|
var config = GatherTheSoulConfig.Get(soulID);
|
int lv = GetSoulLevel(soulID);
|
int[] skillAttr = config.SoulSkillLVList; //技能激活所需的聚魂等级，索引代表技能等级从1开始
|
int nextSkillLV = 0;
|
int nextSoulLV = 0;
|
for (int i = 0; i < skillAttr.Length; i++)
|
{
|
if (lv < skillAttr[i])
|
{
|
nextSkillLV = i + 1;
|
nextSoulLV = skillAttr[i];
|
break;
|
}
|
}
|
|
return new Int2(nextSkillLV, nextSoulLV);
|
}
|
|
void OnRefreshItemCountEvent(PackType packType, int index, int itemID)
|
{
|
if (packType == PackType.Item && itemID == xbItemID)
|
{
|
UpdateRedpointXB();
|
}
|
}
|
}
|
}
|
|
