using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Text.RegularExpressions;
|
using UnityEngine;
|
|
namespace Snxxz.UI
|
{
|
public class PetBackpack//宠物背包
|
{
|
public int PetClass;//宠物阶级
|
public int PetStatus;//宠物当前状态 1为出战 0未出战
|
public int ItemPlace;//宠物位置索引
|
public int[] PetSkill;//宠物当前学习的技能
|
public int petExp; //宠物当前经验
|
}
|
|
public enum PetEnum
|
{
|
PetDan = 0,//灵宠丹
|
PetDebris = 1,//灵宠碎片
|
PetStone = 2,//灵宠魂石
|
}
|
|
public class PetModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
|
{
|
public Dictionary<int, int> _TagPetItem = new Dictionary<int, int>();//关于灵兽魂石
|
public Dictionary<int, PetBackpack> _DicPetBack = new Dictionary<int, PetBackpack>();//宠物背包列表
|
public Dictionary<int, int> _PetSkillAcquire = new Dictionary<int, int>();//灵宠已获得的技能（同类技能只存最高等级）1.技能TypeID，2.技能ID
|
public delegate void Delegate_HB701(HB701_tagMCPetLV info);
|
public delegate void Delegate_Ha339(HA339_tagMCAttrFruitEatCntList info);
|
public static event Delegate_Ha339 Event_Ha339;//灵兽魂石
|
public delegate void Delegate_H0704();
|
public static event Delegate_H0704 Event_H0704Add;//灵宠添加(进阶)
|
public static Action<int> Event_H0704Update;//灵宠刷新
|
public delegate void SpiritPetPlay(int _toPlay = 0);//宠物是否出战
|
public static event SpiritPetPlay Event_SpiritPetPlay;
|
public int PetNow = 0;//用来保存出战的灵宠
|
public bool Wait = true;//(使用灵宠丹)等待回包
|
public Dictionary<int, Redpoint> DeblockingRedPoint = new Dictionary<int, Redpoint>();//解锁按钮红点（灵宠红点子级）
|
public Dictionary<int, Redpoint> PetRedpoint = new Dictionary<int, Redpoint>();//灵宠列表
|
public Dictionary<int, Redpoint> CultivateRedPoint = new Dictionary<int, Redpoint>();//灵宠培养按钮红点
|
private List<PetInfoConfig> Sortpet = new List<PetInfoConfig>();//用于红点排序
|
|
public int MinAtkNunber = 0;//灵宠最小攻击力
|
public int MaxAtkNunber = 0;//灵宠最大攻击力
|
|
public int PetStoneItemId = 0;//用来记录坐骑魂石的ID
|
|
public bool isServerPrepare { get; private set; }
|
private int PetDanExp = 0;//灵宠丹经验
|
public List<int> ListEffectSkill = new List<int>();
|
PackModel _playerPack;
|
PackModel playerPack
|
{
|
get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PackModel>()); }
|
}
|
|
public Dictionary<int, string> petLvNameDict { get; private set; }
|
public int curPetId { get; set; }
|
public int petUpgradeToolId { get; set; }
|
public int autoActivePetId { get; private set; }
|
public bool hasSendAutoActive { get; private set; }
|
|
public event Action PlayerLoginOkData;
|
private Dictionary<int, int> DicDefaultPet = new Dictionary<int, int>();
|
List<PetInfoConfig> allPetConfigs = new List<PetInfoConfig>();
|
|
Dictionary<SkillEffectGroup, int> integrationSkills = new Dictionary<SkillEffectGroup, int>();
|
Dictionary<SkillEffectGroup, List<int>> integrationPetSkills = new Dictionary<SkillEffectGroup, List<int>>();
|
Dictionary<int, SkillEffectGroup> petSkillEffectValues = new Dictionary<int, SkillEffectGroup>();
|
Dictionary<int, int> petSkills = new Dictionary<int, int>();
|
|
public override void Init()
|
{
|
ToAddSorting();
|
playerPack.refreshItemCountEvent += OnItemRefreshEvent;
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChange;
|
PetAttributeWin.IsRedPointCultivate += IsRedPointCultivate;
|
PetNumberPreservation();
|
|
petLvNameDict = new Dictionary<int, string>();
|
FuncConfigConfig petLvName = FuncConfigConfig.Get("PetQuality");
|
int[] petLvArray = ConfigParse.GetMultipleStr<int>(petLvName.Numerical1);
|
string[] petLvNameArray = ConfigParse.GetMultipleStr(petLvName.Numerical2);
|
for (int i = 0; i < petLvArray.Length; i++)
|
{
|
if (!petLvNameDict.ContainsKey(petLvArray[i]))
|
{
|
petLvNameDict.Add(petLvArray[i], petLvNameArray[i]);
|
}
|
}
|
|
petUpgradeToolId = int.Parse(FuncConfigConfig.Get("PetUpItem").Numerical1);
|
string str = FuncConfigConfig.Get("PetSkillEffect").Numerical1;
|
int[] listeffect = ConfigParse.GetMultipleStr<int>(str);
|
ListEffectSkill.Clear();
|
for (int i = 0; i < listeffect.Length; i++)
|
{
|
ListEffectSkill.Add(listeffect[i]);
|
}
|
string PetRedDotstr = FuncConfigConfig.Get("MountPetRedDot").Numerical2;
|
DicDefaultPet = ConfigParse.GetDic<int, int>(PetRedDotstr);
|
PetDanExp = int.Parse(FuncConfigConfig.Get("PetUpItem").Numerical2);
|
|
var funcConfig = FuncConfigConfig.Get("PetHorseSkillIntegration");
|
var intArray = ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1);
|
for (int i = 0; i < intArray.Length; i++)
|
{
|
var skillConfig = SkillConfig.Get(intArray[i]);
|
if (skillConfig != null)
|
{
|
var effectValue = SkillConfig.GetSkillEffectValue(skillConfig);
|
integrationSkills.Add(effectValue, intArray[i]);
|
}
|
}
|
|
funcConfig = FuncConfigConfig.Get("AutoActivePetHorse");
|
autoActivePetId = int.Parse(funcConfig.Numerical1);
|
|
var configs = PetInfoConfig.GetValues();
|
foreach (var config in configs)
|
{
|
for (int i = 0; i < config.SkillID.Length; i++)
|
{
|
var skillConfig = SkillConfig.Get(config.SkillID[i]);
|
var effectValue = SkillConfig.GetSkillEffectValue(skillConfig);
|
|
if (integrationSkills.ContainsKey(effectValue))
|
{
|
List<int> skills = null;
|
if (!integrationPetSkills.TryGetValue(effectValue, out skills))
|
{
|
skills = new List<int>();
|
integrationPetSkills.Add(effectValue, skills);
|
}
|
skills.Add(config.SkillID[i]);
|
}
|
|
petSkills.Add(config.SkillID[i], config.ID);
|
petSkillEffectValues.Add(config.SkillID[i], effectValue);
|
}
|
}
|
}
|
|
public override void UnInit()
|
{
|
playerPack.refreshItemCountEvent -= OnItemRefreshEvent;
|
FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChange;
|
PetAttributeWin.IsRedPointCultivate -= IsRedPointCultivate;
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
Wait = true;
|
isServerPrepare = false;
|
hasSendAutoActive = false;
|
_TagPetItem.Clear();
|
_DicPetBack.Clear();
|
PetNow = 0;
|
MinAtkNunber = 0;
|
MaxAtkNunber = 0;
|
curPetId = 0;
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
GlobalTimeEvent.Instance.secondEvent -= secondEvent;
|
GlobalTimeEvent.Instance.secondEvent += secondEvent;
|
SinglePack singPack = playerPack.GetSinglePack(PackType.PetPack);
|
if (singPack == null) return;
|
foreach (var index in singPack.GetAllItems().Keys)
|
{
|
OnItemRefreshEvent(singPack.type, index, singPack.GetAllItems()[index].itemId);
|
}
|
isServerPrepare = true;
|
if (PlayerLoginOkData != null)
|
{
|
PlayerLoginOkData();
|
}
|
}
|
|
private DateTime dateTimeA;
|
private void secondEvent()
|
{
|
if (!Wait)
|
{
|
TimeSpan timeS = DateTime.Now - dateTimeA;
|
if (timeS.Seconds >= 2f)
|
{
|
Wait = true;
|
}
|
}
|
else
|
{
|
dateTimeA = DateTime.Now;
|
}
|
}
|
|
#region 发送服务端请求
|
public void SendPetSwitchQuest(int petIndex)
|
{
|
C1603_tagCPetStateChange tag_Cpet = new C1603_tagCPetStateChange();
|
tag_Cpet.PetID = (uint)petIndex;
|
tag_Cpet.State = 1;
|
GameNetSystem.Instance.SendInfo(tag_Cpet);
|
}
|
|
public void SendBreakPetLockQuest(int petId)
|
{
|
CA702_tagCMActivatePet CMPet = new CA702_tagCMActivatePet();
|
CMPet.PetNPCID = (uint)petId;
|
GameNetSystem.Instance.SendInfo(CMPet);
|
if (ItemOperateUtility.Instance.useItemModel != null)
|
{
|
ItemOperateUtility.Instance.useItemModel = null;
|
}
|
}
|
|
public void SendPetTrainQuest(int petIndex, int number)
|
{
|
CA704_tagCMPetClassUP _tagCA704 = new CA704_tagCMPetClassUP();
|
_tagCA704.PetItemIndex = (byte)petIndex;
|
_tagCA704.UseItemCnt = (ushort)number;
|
GameNetSystem.Instance.SendInfo(_tagCA704);
|
}
|
#endregion
|
|
|
private void OnItemRefreshEvent(PackType type, int index, int id)
|
{
|
PetH0704(playerPack.GetItemByIndex(type, index));
|
if (type == PackType.Item)
|
{
|
if (_TagPetItem.ContainsKey(id))
|
{
|
PetStoneRed();
|
}
|
PetActivateRedPoint();
|
GetCultivateRedPoint();
|
|
var config = PetInfoConfig.Get(autoActivePetId);
|
if (config != null && id == config.UnLockNeedItemID)
|
{
|
TryAutoActivePet();
|
}
|
}
|
}
|
|
private void OnFuncStateChange(int funcId)
|
{
|
if (funcId == (int)FuncOpenEnum.Pet)
|
{
|
PetStoneRed();
|
PetActivateRedPoint();
|
GetCultivateRedPoint();
|
|
TryAutoActivePet();
|
}
|
}
|
|
private void TryAutoActivePet()
|
{
|
if (isServerPrepare && FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Pet)
|
&& !_DicPetBack.ContainsKey(autoActivePetId) && !hasSendAutoActive)
|
{
|
var petConfig = PetInfoConfig.Get(autoActivePetId);
|
if (petConfig != null)
|
{
|
var itemCount = playerPack.GetItemCountByID(PackType.Item, petConfig.UnLockNeedItemID);
|
if (itemCount >= petConfig.UnLockNeedItemCnt)
|
{
|
hasSendAutoActive = true;
|
SendBreakPetLockQuest(autoActivePetId);
|
}
|
}
|
}
|
}
|
|
private const int Redpoint_key1 = 1050201;
|
private Redpoint redPointStre1 = new Redpoint(MainRedDot.RedPoint_PetKey2, Redpoint_key1);
|
private void PetStoneRed()//灵宠魂石红点
|
{
|
redPointStre1.state = RedPointState.None;
|
if (!FuncOpen.Instance.IsFuncOpen(6))
|
{
|
return;
|
}
|
int type = 0;
|
foreach (var key in _TagPetItem.Keys)
|
{
|
if (_TagPetItem[key] >= AttrFruitConfig.Get(key).basicUseLimit)
|
{
|
continue;
|
}
|
type += playerPack.GetItemCountByID(PackType.Item, key);
|
|
}
|
if (type > 0)
|
{
|
redPointStre1.state = RedPointState.Simple;
|
return;
|
}
|
}
|
private void PetNumberPreservation()//用来对灵宠个数进行保存
|
{
|
if (PetRedpoint.Count != 0)
|
{
|
return;
|
}
|
int type = 0;
|
if (allPetConfigs.Count <= 0)
|
{
|
allPetConfigs = PetInfoConfig.GetValues();
|
}
|
// var allPetConfigs = PetInfoConfig.GetValues();
|
foreach (var config in allPetConfigs)
|
{
|
if (!DeblockingRedPoint.ContainsKey(config.ID))
|
{
|
type += 1;
|
int petID = config.ID;
|
int RedPoint_Mountkey = MainRedDot.RedPoint_PetKey2 * 10 + type;
|
Redpoint redPointMountStare = new Redpoint(MainRedDot.RedPoint_PetKey2, RedPoint_Mountkey);
|
PetRedpoint.Add(petID, redPointMountStare);//列表
|
|
int RedPoint_Mountkey1 = RedPoint_Mountkey * 10 + type;
|
Redpoint redPointMountStare1 = new Redpoint(RedPoint_Mountkey, RedPoint_Mountkey1);
|
DeblockingRedPoint.Add(petID, redPointMountStare1);//解锁按钮
|
int RedPoint_Mountkey2 = RedPoint_Mountkey1 * 10 + type;
|
Redpoint redPointMountStare2 = new Redpoint(RedPoint_Mountkey, RedPoint_Mountkey2);
|
CultivateRedPoint.Add(petID, redPointMountStare2);
|
}
|
}
|
}
|
|
private void PetActivateRedPoint()//灵宠激活红点
|
{
|
foreach (var key in PetRedpoint.Keys)
|
{
|
DeblockingRedPoint[key].state = RedPointState.None;
|
}
|
if (!FuncOpen.Instance.IsFuncOpen(6))
|
{
|
return;
|
}
|
// var configs = PetInfoConfig.GetValues();
|
if (allPetConfigs.Count <= 0)
|
{
|
allPetConfigs = PetInfoConfig.GetValues();
|
}
|
foreach (var config in allPetConfigs)
|
{
|
int unlockItemID = config.UnLockNeedItemID;
|
int itemCount = playerPack.GetItemCountByID(PackType.Item, unlockItemID);
|
int unlockItemCnt = config.UnLockNeedItemCnt;
|
if (itemCount >= unlockItemCnt && !_DicPetBack.ContainsKey(config.ID) && FuncOpen.Instance.IsFuncOpen(6))
|
{
|
DeblockingRedPoint[config.ID].state = RedPointState.Simple;
|
}
|
}
|
}
|
private void IsRedPointCultivate()
|
{
|
GetCultivateRedPoint();
|
}
|
private void ToAddSorting()
|
{
|
Sortpet.Clear();
|
if (allPetConfigs.Count <= 0)
|
{
|
allPetConfigs = PetInfoConfig.GetValues();
|
}
|
Sortpet = allPetConfigs;
|
Sortpet.Sort(Compare);
|
}
|
int Compare(PetInfoConfig x, PetInfoConfig y)//数组排列
|
{
|
if (x.Sort.CompareTo(y.Sort) != 0)
|
{
|
return x.Sort.CompareTo(y.Sort);
|
}
|
return 1;
|
}
|
public void GetCultivateRedPoint()//灵宠培养红点
|
{
|
foreach (var key in CultivateRedPoint.Keys)
|
{
|
CultivateRedPoint[key].state = RedPointState.None;
|
}
|
if (!FuncOpen.Instance.IsFuncOpen(6))
|
{
|
return;
|
}
|
if (_DicPetBack.Count <= 0)
|
{
|
return;
|
}
|
int GetPetId = 0;
|
int petLv = 100;
|
int itemCount = playerPack.GetItemCountByID(PackType.Item, 4151);
|
List<int> ListInt = new List<int>();
|
for (int i = 0; i < Sortpet.Count; i++)
|
{
|
int petID = Sortpet[i].ID;
|
int MaxLv = PetInfoConfig.Get(petID).MaxRank;
|
if (_DicPetBack.ContainsKey(petID) && _DicPetBack[petID].PetClass < MaxLv)
|
{
|
int _NeedExp = PetClassCostConfig.GetPetIdAndRank(petID, _DicPetBack[petID].PetClass).UpNeedExp;
|
int NeedExp = _NeedExp - _DicPetBack[petID].petExp;
|
int NeedNumber = Mathf.CeilToInt((float)NeedExp / PetDanExp);
|
if (itemCount >= NeedNumber)
|
{
|
ListInt.Add(petID);
|
}
|
}
|
}
|
|
foreach (var key in _DicPetBack.Keys)//因为有成就任务限制所有 第一只坐骑红点逻辑特殊写
|
{
|
if (DicDefaultPet.ContainsKey(key) && DicDefaultPet[key] > _DicPetBack[key].PetClass
|
&& itemCount > 0 && CultivateRedPoint.ContainsKey(key))
|
{
|
CultivateRedPoint[key].state = RedPointState.Simple;
|
return;
|
}
|
}
|
List<int> IntListSkill = new List<int>();
|
for (int i = 0; i < ListInt.Count; i++)//选择出升级灵宠等级最低且有技能未解锁的且经验最接近
|
{
|
if (_DicPetBack.ContainsKey(ListInt[i]))
|
{
|
var PetConfig = PetInfoConfig.Get(ListInt[i]);
|
if (PetConfig == null)
|
{
|
return;
|
}
|
int[] SkillUnLockInt = PetConfig.SkillUnLock;
|
int SkillLvMax = SkillUnLockInt[(SkillUnLockInt.Length - 1)];
|
if (_DicPetBack[(ListInt[i])].PetClass < SkillLvMax)
|
{
|
IntListSkill.Add((ListInt[i]));
|
}
|
}
|
}
|
int SkillPetId = GetRedPointPetID(IntListSkill);
|
if (SkillPetId != 0 && CultivateRedPoint.ContainsKey(SkillPetId))
|
{
|
CultivateRedPoint[SkillPetId].state = RedPointState.Simple;
|
return;
|
}
|
|
|
for (int i = 0; i < ListInt.Count; i++)//选择出等级最低的灵宠
|
{
|
if (_DicPetBack.ContainsKey(ListInt[i]))
|
{
|
if (_DicPetBack[(ListInt[i])].PetClass < petLv)
|
{
|
petLv = _DicPetBack[(ListInt[i])].PetClass;
|
GetPetId = (ListInt[i]);
|
}
|
}
|
}
|
if (GetPetId != 0 && CultivateRedPoint.ContainsKey(GetPetId))
|
{
|
CultivateRedPoint[GetPetId].state = RedPointState.Simple;
|
return;
|
}
|
}
|
|
|
private int GetRedPointPetID(List<int> PetList)
|
{
|
int GetSkillMinLv = 999;
|
for (int i = 0; i < PetList.Count; i++)
|
{
|
int SkillminLv = GetSkillLvDis(PetList[i]);
|
if (SkillminLv < GetSkillMinLv && SkillminLv != 0)
|
{
|
GetSkillMinLv = SkillminLv;
|
}
|
}
|
|
int petId = 0;
|
int ExpNumber = 999999999;
|
for (int i = 0; i < PetList.Count; i++)
|
{
|
int SkillLv = GetSkillLvDis(PetList[i]);
|
if (SkillLv > GetSkillMinLv || SkillLv == 0)
|
{
|
continue;
|
}
|
var Pet1 = PetClassCostConfig.GetPetIdAndRank(PetList[i], SkillLv);
|
var Pet2 = PetClassCostConfig.GetPetIdAndRank(PetList[i], _DicPetBack[(PetList[i])].PetClass);
|
int Exp = Pet1.NeedExpTotal - Pet2.NeedExpTotal - _DicPetBack[(PetList[i])].petExp;
|
if (Exp < ExpNumber)
|
{
|
ExpNumber = Exp;
|
petId = PetList[i];
|
}
|
}
|
return petId;
|
}
|
private int GetSkillLvDis(int PetId)//获取离升级最近的技能等级
|
{
|
int SkillLv = 0;
|
var petInfo = PetInfoConfig.Get(PetId);
|
if (petInfo == null)
|
{
|
return 0;
|
}
|
int[] ListPetSkillUnLock = petInfo.SkillUnLock;
|
for (int i = 0; i < ListPetSkillUnLock.Length; i++)
|
{
|
if (_DicPetBack.ContainsKey(PetId) && ListPetSkillUnLock[i] > _DicPetBack[PetId].PetClass)
|
{
|
SkillLv = ListPetSkillUnLock[i];
|
return SkillLv;
|
}
|
}
|
return SkillLv;
|
}
|
public int GetMinPetExp()
|
{
|
foreach (var key in CultivateRedPoint.Keys)//当存在培养红点时，选中当有红点的那只
|
{
|
if (CultivateRedPoint[key].state == RedPointState.Simple)
|
{
|
return key;
|
}
|
}
|
|
List<int> IntListSkill = new List<int>();
|
foreach (var key in _DicPetBack.Keys)
|
{
|
var petConfig = PetInfoConfig.Get(key);
|
if (_DicPetBack[key].PetClass < petConfig.MaxRank)
|
{
|
IntListSkill.Add(key);
|
}
|
}
|
int SkillPetId = GetRedPointPetID(IntListSkill);
|
if (SkillPetId != 0)
|
{
|
return SkillPetId;
|
}
|
int GetPetId = 0;
|
int GetPetLv = 999;
|
|
foreach (var key in _DicPetBack.Keys)//无红点时跳转选中等级最低的
|
{
|
var config = PetInfoConfig.Get(key);
|
if (_DicPetBack[key].PetClass < GetPetLv && _DicPetBack[key].PetClass < config.MaxRank)
|
{
|
GetPetId = key;
|
GetPetLv = _DicPetBack[key].PetClass;
|
}
|
}
|
return GetPetId;
|
}
|
private int GetPetSkillMaxLv(int PetID)
|
{
|
int maxskillLV = 0;
|
int[] curPetUnlocks;
|
PetInfoConfig petInfo = PetInfoConfig.Get(PetID);
|
if (petInfo != null)
|
{
|
curPetUnlocks = petInfo.SkillUnLock;
|
maxskillLV = curPetUnlocks[(curPetUnlocks.Length) - 1];
|
}
|
return maxskillLV;
|
}
|
public void PetA339(HA339_tagMCAttrFruitEatCntList info)
|
{
|
for (int i = 0; i < info.count; i++)
|
{
|
var configItem = ItemConfig.Get((int)info.EatCntList[i].ItemID);
|
if (configItem == null)
|
{
|
continue;
|
}
|
if (_TagPetItem.ContainsKey((int)info.EatCntList[i].ItemID))
|
{
|
_TagPetItem[(int)info.EatCntList[i].ItemID] = (int)info.EatCntList[i].EatCnt;
|
if (Event_Ha339 != null)
|
Event_Ha339(info);
|
}
|
else
|
{
|
if (configItem.Type == 28)
|
{
|
_TagPetItem.Add((int)info.EatCntList[i].ItemID, (int)info.EatCntList[i].EatCnt);
|
|
}
|
}
|
}
|
PetStoneRed();
|
}
|
|
private void AddPetSkill(int[] intlist)
|
{
|
for (int i = 0; i < intlist.Length; i++)
|
{
|
var skillPet = SkillConfig.Get(intlist[i]);
|
if (_PetSkillAcquire.ContainsKey(skillPet.SkillTypeID))
|
{
|
int skilllv = SkillConfig.Get(_PetSkillAcquire[skillPet.SkillTypeID]).SkillLV;
|
if (skillPet.SkillLV > skilllv)
|
{
|
_PetSkillAcquire[skillPet.SkillTypeID] = skillPet.SkillID;
|
}
|
}
|
else
|
{
|
_PetSkillAcquire.Add(skillPet.SkillTypeID, skillPet.SkillID);
|
}
|
}
|
}
|
|
public void PetH0704(ItemModel info)//宠物背包列表
|
{
|
if (info == null)
|
return;
|
|
if (info.packType == PackType.PetPack)
|
{
|
var isChangePetNow = false;
|
|
Dictionary<int, int[]> _dic = Analysis(info.itemInfo.userData);
|
if (GetUseDataModel(200, _dic) != null)
|
{
|
int petId = _dic[200][0];
|
int petLv = 0;
|
int petState = 0;
|
int[] petSkill = null;
|
int petIndex = info.gridIndex;
|
int petExp = 0;
|
if (GetUseDataModel(201, _dic) != null)
|
{
|
petSkill = _dic[201];//宠物当前学习的技能
|
}
|
|
if (GetUseDataModel(202, _dic) != null)
|
{
|
petLv = _dic[202][0] + 1;//宠物阶级
|
}
|
|
if (GetUseDataModel(204, _dic) != null)
|
{
|
petState = _dic[204][0];//宠物当前状态;
|
}
|
|
if (GetUseDataModel(208, _dic) != null)
|
{
|
petExp = _dic[208][0]; //宠物经验
|
}
|
|
if (!_DicPetBack.ContainsKey(petId))
|
{
|
|
PetBackpack _petBack = new PetBackpack();
|
_petBack.PetClass = petLv;
|
_petBack.petExp = petExp; //宠物经验
|
_petBack.PetStatus = petState;//宠物当前状态
|
if (_petBack.PetStatus == 1)
|
{
|
if (petId != PetNow)
|
{
|
isChangePetNow = true;
|
}
|
PetNow = petId;
|
}
|
|
if (petSkill != null)
|
{
|
_petBack.PetSkill = petSkill;//宠物当前学习的技能
|
AddPetSkill(_petBack.PetSkill);
|
}
|
else
|
{
|
_petBack.PetSkill = null;
|
}
|
_petBack.ItemPlace = petIndex;//宠物位置索引
|
_DicPetBack.Add(petId, _petBack);
|
if (Event_H0704Add != null && isServerPrepare)
|
{
|
Event_H0704Add();
|
}
|
|
}
|
else
|
{
|
_DicPetBack[petId].PetClass = petLv;
|
_DicPetBack[petId].PetStatus = petState;
|
_DicPetBack[petId].petExp = petExp; //宠物经验
|
if (petSkill != null)
|
{
|
_DicPetBack[petId].PetSkill = petSkill;//宠物当前学习的技能
|
AddPetSkill(_DicPetBack[petId].PetSkill);
|
}
|
else
|
{
|
_DicPetBack[petId].PetSkill = null;
|
}
|
|
_DicPetBack[petId].ItemPlace = petIndex;
|
if (Event_H0704Update != null && isServerPrepare)
|
{
|
Event_H0704Update(petId);
|
}
|
if (_DicPetBack[petId].PetStatus == 1)
|
{
|
if (petId != PetNow)
|
{
|
isChangePetNow = true;
|
}
|
PetNow = petId;
|
if (Event_SpiritPetPlay != null && isServerPrepare)
|
{
|
Event_SpiritPetPlay(petState);
|
|
}
|
}
|
}
|
}
|
|
if (isServerPrepare && isChangePetNow && PetNow != 0)
|
{
|
ScrollTip.ShowTip(Language.Get("Z1811"));//外观切换成功
|
}
|
}
|
PetStoneRed();
|
PetActivateRedPoint();
|
GetCultivateRedPoint();
|
GetPetMinAndMaxAttack();
|
}
|
|
public int[] GetUseDataModel(int key, Dictionary<int, int[]> useDataDict)
|
{
|
int[] list = null;
|
if (useDataDict != null)
|
{
|
useDataDict.TryGetValue(key, out list);
|
}
|
return list;
|
}
|
|
private void GetPetMinAndMaxAttack()
|
{
|
if (_DicPetBack.Count <= 0)
|
{
|
return;
|
}
|
MinAtkNunber = 0;
|
MaxAtkNunber = 0;
|
foreach (var key in _DicPetBack.Keys)
|
{
|
PetClassCostConfig _tagPetClass = PetClassCostConfig.GetPetIdAndRank(key, _DicPetBack[key].PetClass);
|
MinAtkNunber += _tagPetClass.AtkAdd;
|
MaxAtkNunber += _tagPetClass.AtkAdd;
|
}
|
}
|
|
public static Regex userData = new Regex(@"'([0-9]+)':\[(.*?)\]", RegexOptions.Singleline);
|
|
public Dictionary<int, int[]> Analysis(string val)//正则表达式的字符串分割
|
{
|
if (!userData.IsMatch(val))
|
{
|
return null;
|
}
|
else
|
{
|
Dictionary<int, int[]> dics = new Dictionary<int, int[]>();
|
foreach (Match match in userData.Matches(val))
|
{
|
int id = int.Parse(match.Groups[1].Value);
|
string str = match.Groups[2].Value;
|
string[] vals = str.Split(',');
|
int[] intarray = new int[vals.Length];
|
for (int i = 0; i < vals.Length; i++)
|
{
|
int intval = int.Parse(vals[i].Replace('\'', ' '));
|
intarray[i] = intval;
|
}
|
if (!dics.ContainsKey(id))
|
{
|
dics.Add(id, intarray);
|
}
|
}
|
return dics;
|
}
|
}
|
|
public bool IsHint(PetEnum petEnum, int id = 0)//True提示，False不提示
|
{
|
bool iSHint = false;
|
switch (petEnum)
|
{
|
case PetEnum.PetDan:
|
foreach (var key in _DicPetBack.Keys)
|
{
|
PetInfoConfig petConfig = PetInfoConfig.Get(key);
|
if (petConfig.MaxRank > _DicPetBack[key].PetClass)
|
{
|
iSHint = true;
|
}
|
}
|
return iSHint;
|
case PetEnum.PetDebris:
|
if (allPetConfigs.Count <= 0)
|
{
|
allPetConfigs = PetInfoConfig.GetValues();
|
}
|
foreach (var value in allPetConfigs)
|
{
|
if (value.UnLockNeedItemID == id)
|
{
|
if (!_DicPetBack.ContainsKey(value.ID))
|
{
|
iSHint = true;
|
}
|
}
|
}
|
return iSHint;
|
case PetEnum.PetStone:
|
int _maxuse = AttrFruitConfig.Get(id).basicUseLimit;
|
if (_TagPetItem.ContainsKey(id))
|
{
|
if (_maxuse > _TagPetItem[id])
|
{
|
iSHint = true;
|
}
|
}
|
return iSHint;
|
default:
|
return true;
|
}
|
}
|
|
public int IsPetPanelRedPointState()//用于判断当前灵宠页签是否有红点亮起
|
{
|
int Type = 0;
|
foreach (var value in DeblockingRedPoint.Values)
|
{
|
if (value.state == RedPointState.Simple)
|
{
|
Type = 2;
|
return Type;
|
}
|
}
|
if (MainRedDot.Instance.redPonintPetFunc2.state == RedPointState.Simple)
|
{
|
Type = 1;
|
return Type;
|
}
|
return Type;
|
|
}
|
|
#region 预览宠物碎片属性
|
Dictionary<int, int> petAttrDict = new Dictionary<int, int>();
|
public Dictionary<int, int> GetPetAttrAddDict(int petCode)
|
{
|
PetInfoConfig infoConfig = PetInfoConfig.Get(petCode);
|
petAttrDict.Clear();
|
if (infoConfig == null) return petAttrDict;
|
|
int maxRank = infoConfig.MaxRank;
|
PetClassCostConfig cost = PetClassCostConfig.GetPetIdAndRank(petCode, maxRank);
|
int allAtkAdd = 0;
|
if (cost != null)
|
{
|
allAtkAdd = cost.AtkAdd;
|
}
|
petAttrDict.Add(7, allAtkAdd);
|
return petAttrDict;
|
}
|
#endregion
|
|
#region 技能整合
|
public ICollection<int> GetPetTotalSkills()
|
{
|
return petSkills.Keys;
|
}
|
|
public SkillEffectGroup GetSkillEffectGroup(int skillId)
|
{
|
if (petSkillEffectValues.ContainsKey(skillId))
|
{
|
return petSkillEffectValues[skillId];
|
}
|
return default(SkillEffectGroup);
|
}
|
|
public bool TryGetIntegrationSkill(SkillEffectGroup effect, out int skillId)
|
{
|
return integrationSkills.TryGetValue(effect, out skillId);
|
}
|
|
public bool TryGetPetSkills(SkillEffectGroup effect, out List<int> skills)
|
{
|
return integrationPetSkills.TryGetValue(effect, out skills);
|
}
|
|
public bool TryGetPetId(int skillId, out int petId)
|
{
|
return petSkills.TryGetValue(skillId, out petId);
|
}
|
|
public bool IsSkillUnlock(int skillId)
|
{
|
var config = SkillConfig.Get(skillId);
|
if (config == null)
|
{
|
return false;
|
}
|
var effect = SkillConfig.GetSkillEffectValue(config);
|
|
if (integrationPetSkills.ContainsKey(effect)
|
&& !integrationPetSkills[effect].Contains(skillId))
|
{
|
var skills = integrationPetSkills[effect];
|
foreach (var id in skills)
|
{
|
if (IsSkillUnlock(id))
|
{
|
return true;
|
}
|
}
|
}
|
else
|
{
|
if (petSkills.ContainsKey(skillId))
|
{
|
var petId = petSkills[skillId];
|
if (!_DicPetBack.ContainsKey(petId))
|
{
|
return false;
|
}
|
var petInfo = _DicPetBack[petId];
|
if (petInfo.PetClass >= GetSkillUnlockLevel(skillId))
|
{
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
public int GetSkillUnlockLevel(int skillId)
|
{
|
var petId = 0;
|
if (TryGetPetId(skillId, out petId))
|
{
|
var petConfig = PetInfoConfig.Get(petId);
|
var index = 0;
|
for (int i = 0; i < petConfig.SkillID.Length; i++)
|
{
|
if (petConfig.SkillID[i] == skillId)
|
{
|
index = i;
|
}
|
}
|
if (index < petConfig.SkillUnLock.Length)
|
{
|
return petConfig.SkillUnLock[index];
|
}
|
}
|
return 0;
|
}
|
#endregion
|
}
|
}
|
