using Snxxz.UI;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
|
using LitJson;
|
using UnityEngine;
|
|
namespace Snxxz.UI
|
{
|
[XLua.LuaCallCSharp]
|
public class ItemTipsModel : Model, IBeforePlayerDataInitialize
|
{
|
|
FuncConfigConfig exhaustedFunc;
|
public Dictionary<int, List<string>> guardDesDict { get; private set; }
|
|
public Dictionary<int, PetInfoConfig> unlockPetDict { get; private set; }
|
public Dictionary<int, HorseConfig> unlockMountDict { get; private set; }
|
|
private Dictionary<int, Dictionary<int, int>> petSkillDict = new Dictionary<int, Dictionary<int, int>>(); // 编号 解锁阶级 技能
|
private Dictionary<int, Dictionary<int, List<int>>> mountSkillDict = new Dictionary<int, Dictionary<int, List<int>>>(); // 编号 解锁阶级 技能
|
|
Dictionary<int, string> petAndMountQualityDict = new Dictionary<int, string>();
|
string expValueFormula = "";
|
Dictionary<int, string> exhaustedAttrFormula { get; set; }
|
Dictionary<int, int> exhaustedMaxLvDict { get; set; }
|
|
public int[] gemOpenLvs { get; private set; }
|
public int[] jadeDynastyGemOpenLvs { get; private set; }
|
public int gemOpenVipLv { get; private set; }
|
public int[] gemType1s { get; private set; }
|
public int[] gemType2s { get; private set; }
|
|
public int[] equipMidHeights { get; private set; }
|
public int[] wingsMidHeights { get; private set; }
|
|
public int[] jumpAndUseTypes { get; private set; }
|
|
public int equipSuitStar { get; private set; }
|
|
public int[] ItemRenewalIds { get; private set; }
|
public int[] tryPutOnEquipIds { get; private set; }
|
|
public int[] randomRuneIds { get; private set; }
|
public int[] PeerlessEquipIds { get; private set; } //绝世装备列表
|
|
PackModel playerPack { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
|
StoreModel m_storeModel { get { return ModelCenter.Instance.GetModel<StoreModel>(); } }
|
FashionDressModel fashionDress { get { return ModelCenter.Instance.GetModel<FashionDressModel>(); } }
|
DogzModel dogzModel { get { return ModelCenter.Instance.GetModel<DogzModel>(); } }
|
|
public override void Init()
|
{
|
m_storeModel.RefreshTCBPlayerDataEvent += RefreshOfflinePluginTime;
|
|
exhaustedFunc = FuncConfigConfig.Get("OutOfPrintValue");
|
exhaustedAttrFormula = new Dictionary<int, string>();
|
JsonData exhaustedJsonData = JsonMapper.ToObject(exhaustedFunc.Numerical2);
|
foreach (var key in exhaustedJsonData.Keys)
|
{
|
int attrId = int.Parse(key);
|
exhaustedAttrFormula.Add(attrId, exhaustedJsonData[key].ToString());
|
}
|
|
FuncConfigConfig OutOfPrintValueDes = FuncConfigConfig.Get("OutOfPrintValueDes");
|
exhaustedMaxLvDict = ConfigParse.GetDic<int, int>(OutOfPrintValueDes.Numerical1);
|
|
FuncConfigConfig suitlimitModel = FuncConfigConfig.Get("EquipSuitLimit");
|
equipSuitStar = int.Parse(suitlimitModel.Numerical2);
|
|
FuncConfigConfig bagUseItem = FuncConfigConfig.Get("BagUseItem");
|
jumpAndUseTypes = ConfigParse.GetMultipleStr<int>(bagUseItem.Numerical1);
|
|
FuncConfigConfig renewalFunc = FuncConfigConfig.Get("ItemRepayButton");
|
ItemRenewalIds = ConfigParse.GetMultipleStr<int>(renewalFunc.Numerical1);
|
tryPutOnEquipIds = ConfigParse.GetMultipleStr<int>(renewalFunc.Numerical2);
|
|
FuncConfigConfig EquipOutWordID = FuncConfigConfig.Get("EquipOutWordID");
|
PeerlessEquipIds = ConfigParse.GetMultipleStr<int>(EquipOutWordID.Numerical1);
|
|
guardDesDict = new Dictionary<int, List<string>>();
|
FuncConfigConfig guardDesFunc = FuncConfigConfig.Get("GuardianTips");
|
JsonData guardDesData = JsonMapper.ToObject(guardDesFunc.Numerical1);
|
foreach (var key in guardDesData.Keys)
|
{
|
List<string> list = new List<string>();
|
for (int i = 0; i < guardDesData[key].Count; i++)
|
{
|
list.Add(guardDesData[key][i].ToString());
|
}
|
guardDesDict.Add(int.Parse(key), list);
|
}
|
|
gemOpenLvs = null;
|
gemOpenVipLv = 0;
|
jadeDynastyGemOpenLvs = null;
|
FuncConfigConfig gemOpenModel = FuncConfigConfig.Get("GemOpen");
|
FuncConfigConfig gemOpenVipModel = FuncConfigConfig.Get("GemOpenVip");
|
gemOpenLvs = ConfigParse.GetMultipleStr<int>(gemOpenModel.Numerical1);
|
gemOpenVipLv = int.Parse(gemOpenVipModel.Numerical1);
|
jadeDynastyGemOpenLvs = ConfigParse.GetMultipleStr<int>(gemOpenModel.Numerical2);
|
|
FuncConfigConfig gemtype1 = FuncConfigConfig.Get("GemType1");
|
gemType1s = ConfigParse.GetMultipleStr<int>(gemtype1.Numerical1);
|
FuncConfigConfig gemtype2 = FuncConfigConfig.Get("GemType2");
|
gemType2s = ConfigParse.GetMultipleStr<int>(gemtype2.Numerical1);
|
|
FuncConfigConfig equipMidFunc = FuncConfigConfig.Get("EquipPartLength");
|
equipMidHeights = ConfigParse.GetMultipleStr<int>(equipMidFunc.Numerical1);
|
FuncConfigConfig wingsMidFunc = FuncConfigConfig.Get("WingsPartLength");
|
wingsMidHeights = ConfigParse.GetMultipleStr<int>(wingsMidFunc.Numerical1);
|
|
FuncConfigConfig expFormula = FuncConfigConfig.Get("ExpValueDes");
|
expValueFormula = expFormula.Numerical1;
|
|
#region 灵宠坐骑解锁
|
unlockPetDict = new Dictionary<int, PetInfoConfig>();
|
petSkillDict.Clear();
|
List<PetInfoConfig> petInfolist = PetInfoConfig.GetValues();
|
for (int i = 0; i < petInfolist.Count; i++)
|
{
|
if (!unlockPetDict.ContainsKey(petInfolist[i].UnLockNeedItemID))
|
{
|
unlockPetDict.Add(petInfolist[i].UnLockNeedItemID, petInfolist[i]);
|
}
|
Dictionary<int, int> skillDict = new Dictionary<int, int>();
|
petSkillDict.Add(petInfolist[i].ID, skillDict);
|
int[] skillIds = petInfolist[i].SkillID;
|
int[] skillUnlocks = petInfolist[i].SkillUnLock;
|
if (skillIds != null)
|
{
|
for (int j = 0; j < skillIds.Length; j++)
|
{
|
skillDict.Add(skillUnlocks[j], skillIds[j]);
|
}
|
}
|
}
|
unlockMountDict = new Dictionary<int, HorseConfig>();
|
mountSkillDict.Clear();
|
List<HorseConfig> horselist = HorseConfig.GetValues();
|
for (int i = 0; i < horselist.Count; i++)
|
{
|
if (!unlockMountDict.ContainsKey(horselist[i].UnlockItemID))
|
{
|
unlockMountDict.Add(horselist[i].UnlockItemID, horselist[i]);
|
}
|
Dictionary<int, List<int>> skillDict = new Dictionary<int, List<int>>();
|
mountSkillDict.Add(horselist[i].HorseID, skillDict);
|
List<HorseUpConfig> mountlist = HorseUpConfig.GetMountlistById(horselist[i].HorseID);
|
if (mountlist != null)
|
{
|
for (int j = 0; j < mountlist.Count; j++)
|
{
|
int[] skills = mountlist[j].SkillID;
|
List<int> skilllist = new List<int>();
|
if (skills != null)
|
{
|
for (int k = 0; k < skills.Length; k++)
|
{
|
if (skills[k] != 0)
|
{
|
skilllist.Add(skills[k]);
|
skillDict.Add(mountlist[j].LV, skilllist);
|
}
|
}
|
}
|
}
|
}
|
}
|
#endregion
|
|
FuncConfigConfig randomRuneConfig = FuncConfigConfig.Get("RandomRuneIDList");
|
randomRuneIds = ConfigParse.GetMultipleStr<int>(randomRuneConfig.Numerical1);
|
|
FuncConfigConfig petQuality = FuncConfigConfig.Get("PetQuality");
|
int[] qualitys = ConfigParse.GetMultipleStr<int>(petQuality.Numerical1);
|
string[] qualityNames = ConfigParse.GetMultipleStr(petQuality.Numerical2);
|
if (qualitys != null && qualityNames != null
|
&& qualitys.Length == qualityNames.Length)
|
{
|
for (int i = 0; i < qualitys.Length; i++)
|
{
|
petAndMountQualityDict.Add(qualitys[i], qualityNames[i]);
|
}
|
}
|
|
ParseFuncConfig();
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
|
}
|
|
public override void UnInit()
|
{
|
|
}
|
|
#region 解析本地数据
|
public Dictionary<string, List<int>> atkSpeedColorDict { get; private set; }
|
private void ParseFuncConfig()
|
{
|
atkSpeedColorDict = new Dictionary<string, List<int>>();
|
var equipYPAtkSpeedColor = FuncConfigConfig.Get("EquipYPAtkSpeedColor");
|
JsonData atkSpeedData = JsonMapper.ToObject(equipYPAtkSpeedColor.Numerical1);
|
foreach (var color in atkSpeedData.Keys)
|
{
|
List<int> list = new List<int>();
|
atkSpeedColorDict.Add(color, list);
|
if (atkSpeedData[color].IsArray)
|
{
|
for (int i = 0; i < atkSpeedData[color].Count; i++)
|
{
|
int range = 0;
|
int.TryParse(atkSpeedData[color][i].ToString(), out range);
|
list.Add(range);
|
}
|
}
|
}
|
}
|
|
public bool TryGetAtkSpeedColor(int atkSpeed, out string color)
|
{
|
color = string.Empty;
|
foreach (var key in atkSpeedColorDict.Keys)
|
{
|
var rangelist = atkSpeedColorDict[key];
|
if (rangelist.Count > 1)
|
{
|
if (atkSpeed >= rangelist[0] && atkSpeed <= rangelist[1])
|
{
|
color = key;
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
#endregion
|
|
/// <summary>
|
/// 刷新脱机外挂时间
|
/// </summary>
|
/// <param name="refresh"></param>
|
private void RefreshOfflinePluginTime(PlayerDataType refresh)
|
{
|
if (refresh != PlayerDataType.HappyPoint) return;
|
|
HangUpSetModel.Instance.SetOfflinePluginTime(m_storeModel.GetTCBPlayerData(refresh));
|
}
|
|
public ItemAttrData curAttrData { get; private set; }
|
public ItemAttrData compareAttrData { get; private set; }
|
|
/// <summary>
|
///从背包类型中得到物品展示
|
/// </summary>
|
public void SetItemTipsModel(PackType type, string guid, bool isShowUINow = true, bool isCompare = false, ItemTipChildType childType = ItemTipChildType.Normal)
|
{
|
curAttrData = null;
|
compareAttrData = null;
|
curTips = null;
|
compareTips = null;
|
ItemModel itemModel = playerPack.GetItemByGuid(guid);
|
if (itemModel != null)
|
{
|
curAttrData = new ItemAttrData(itemModel.itemId, false, (ulong)itemModel.count
|
, itemModel.gridIndex, isCompare
|
, type, guid, ConfigParse.Analysis(itemModel.itemInfo.userData), childType);
|
|
if (isCompare)
|
{
|
switch (type)
|
{
|
case PackType.DogzItem:
|
SetCompareAttrData(PackType.DogzEquip, itemModel.config.EquipPlace);
|
break;
|
default:
|
SetCompareAttrData(PackType.Equip, itemModel.config.EquipPlace);
|
break;
|
}
|
}
|
}
|
|
if (isShowUINow)
|
{
|
ShowTip();
|
}
|
}
|
|
/// <summary>
|
/// 预览物品信息
|
/// </summary>
|
/// <param name="itemAttrData"></param>
|
public void SetItemTipsModel(ItemAttrData itemAttrData, bool isShowUINow = true)
|
{
|
compareAttrData = null;
|
curTips = null;
|
compareTips = null;
|
curAttrData = itemAttrData;
|
if (itemAttrData == null) return;
|
|
if (itemAttrData.isCompare)
|
{
|
switch (itemAttrData.packType)
|
{
|
case PackType.DogzItem:
|
SetCompareAttrData(PackType.DogzEquip, itemAttrData.itemConfig.EquipPlace);
|
break;
|
default:
|
SetCompareAttrData(PackType.Equip, itemAttrData.itemConfig.EquipPlace);
|
break;
|
}
|
}
|
|
if (isShowUINow)
|
{
|
ShowTip();
|
}
|
}
|
|
public void SetCurrentAttrData(ItemModel itemModel, bool isCompare)
|
{
|
curAttrData = new ItemAttrData(itemModel.itemId, false, (ulong)itemModel.count
|
, itemModel.gridIndex, isCompare
|
, itemModel.packType, itemModel.guid, ConfigParse.Analysis(itemModel.itemInfo.userData), ItemTipChildType.Normal);
|
}
|
|
|
public void SetCompareAttrData(ItemModel itemModel)
|
{
|
compareAttrData = new ItemAttrData(itemModel.itemId, false, (ulong)itemModel.count
|
, itemModel.gridIndex, true
|
, itemModel.packType, itemModel.guid, ConfigParse.Analysis(itemModel.itemInfo.userData));
|
}
|
|
private void SetCompareAttrData(PackType type, int equipPlace)
|
{
|
compareAttrData = null;
|
ItemModel itemModel = null;
|
switch (type)
|
{
|
case PackType.Equip:
|
itemModel = playerPack.GetItemByIndex(type, equipPlace);
|
break;
|
case PackType.DogzEquip:
|
var dogzModel = ModelCenter.Instance.GetModel<DogzModel>();
|
dogzModel.TryGetDogzEquip(dogzModel.presentSelectDogz, equipPlace, out itemModel);
|
break;
|
}
|
|
if (itemModel == null) return;
|
|
compareAttrData = new ItemAttrData(itemModel.itemId, false, (ulong)itemModel.count
|
, itemModel.gridIndex, true
|
, type, itemModel.guid, ConfigParse.Analysis(itemModel.itemInfo.userData));
|
}
|
|
public void ShowTip()
|
{
|
if (curAttrData == null) return;
|
|
#if UNITY_EDITOR
|
Debug.LogFormat("你查看的物品是：guid->{0}", string.IsNullOrEmpty(curAttrData.guid) ? "" : curAttrData.guid);
|
Debug.LogFormat("你查看的物品是：itemId->{0}", curAttrData.itemId);
|
Debug.LogFormat("你查看的物品是：name->{0}", curAttrData.itemConfig.ItemName);
|
#endif
|
switch (curAttrData.winType)
|
{
|
case ItemWinType.itemWin:
|
if (curAttrData.isPreview)
|
{
|
EquipTipUtility.Show(TipType.Normal, curAttrData.itemId);
|
}
|
else
|
{
|
EquipTipUtility.Show(curAttrData.guid);
|
}
|
break;
|
case ItemWinType.boxWin:
|
WindowCenter.Instance.Open<BoxInfoWin>();
|
break;
|
case ItemWinType.equipWin:
|
if (ItemLogicUtility.Instance.IsEquip(curAttrData.itemId))
|
{
|
if (curAttrData.isPreview)
|
{
|
EquipTipUtility.Show(TipType.Normal, curAttrData.itemId);
|
}
|
else
|
{
|
EquipTipUtility.Show(curAttrData.guid);
|
}
|
}
|
else
|
{
|
WindowCenter.Instance.Open<EquipWin>();
|
}
|
break;
|
case ItemWinType.wingsWin:
|
WindowCenter.Instance.Open<WingsWin>();
|
break;
|
case ItemWinType.guardWin:
|
WindowCenter.Instance.Open<GuardianWin>();
|
break;
|
case ItemWinType.buyItemWin:
|
WindowCenter.Instance.Open<BuyItemInfoWin>();
|
break;
|
case ItemWinType.buyBoxWin:
|
WindowCenter.Instance.Open<BuyBoxInfoWin>();
|
break;
|
case ItemWinType.petMatWin:
|
if (curAttrData.isPreview)
|
{
|
EquipTipUtility.Show(TipType.Normal, curAttrData.itemId);
|
}
|
else
|
{
|
EquipTipUtility.Show(curAttrData.guid);
|
}
|
break;
|
case ItemWinType.buyPetMatWin:
|
WindowCenter.Instance.Open<BuyPetMatInfoWin>();
|
break;
|
case ItemWinType.gatherSoul:
|
WindowCenter.Instance.Open<GatherSoulTipWin>();
|
break;
|
case ItemWinType.kingTreasure:
|
var kingTreasureShow = ModelCenter.Instance.GetModel<KingTreasureShowModel>();
|
kingTreasureShow.SetInitData(curAttrData.itemId);
|
break;
|
}
|
}
|
|
private StringBuilder attrSB = new StringBuilder();
|
private PlayerPropertyConfig playerProModel;
|
|
#region 设置装备基础信息
|
/// <summary>
|
/// 得到弹框标题
|
/// </summary>
|
/// <returns></returns>
|
public string GetItemTipsTitle(ItemAttrData attrData)
|
{
|
string equipName = "";
|
if (attrData == null) return equipName;
|
|
if (attrData.StrengthLV > 0)
|
{
|
equipName = StringUtility.Contact(equipName, attrData.itemConfig.ItemName, "+", attrData.StrengthLV);
|
}
|
else
|
{
|
equipName = StringUtility.Contact(equipName, attrData.itemConfig.ItemName);
|
}
|
return equipName;
|
}
|
|
/// <summary>
|
/// 得到装备的职业
|
/// </summary>
|
/// <param name="attrData"></param>
|
/// <returns></returns
|
string jobName = "";
|
public string GetEquipJobName(ItemAttrData attrData)
|
{
|
jobName = "";
|
if (attrData == null) return jobName;
|
|
string playerJob = StringUtility.Contact(PlayerDatas.Instance.baseData.Job, "0", 1);
|
if (!attrData.isHavePutLimit)
|
{
|
SetJobName(attrData, int.Parse(playerJob), attrData.itemConfig.JobLimit);
|
}
|
else
|
{
|
SetJobName(attrData, int.Parse(playerJob), attrData.itemConfig.JobLimit);
|
}
|
|
return jobName;
|
}
|
|
private void SetJobName(ItemAttrData attrData, int playerJob, int equipJob)
|
{
|
if (attrData.itemConfig.JobLimit != 0)
|
{
|
var config = JobNameConfig.Get(attrData.itemConfig.JobLimit);
|
jobName = UIHelper.AppendColor(playerJob >= equipJob ? TextColType.White : TextColType.Red, config.name);
|
}
|
else
|
{
|
jobName = UIHelper.AppendColor(TextColType.White, Language.Get("StoreWin110"));
|
}
|
}
|
|
#endregion
|
|
#region 设置弹框按钮
|
|
/// <summary>
|
/// 设置背包的弹框按钮
|
/// </summary>
|
/// <param name="attrData"></param>
|
public void SetBagTipsBtn(ItemAttrData attrData)
|
{
|
var horseModel = ModelCenter.Instance.GetModel<MountModel>();
|
var petmodel = ModelCenter.Instance.GetModel<PetModel>();
|
bool isOverdue = ItemLogicUtility.Instance.IsOverdue(attrData.guid);
|
HorseConfig horseConfig = null;
|
PetInfoConfig petInfo = null;
|
switch (attrData.itemConfig.Type)
|
{
|
case 26:
|
petInfo = unlockPetDict[attrData.itemId];
|
if (petmodel._DicPetBack.ContainsKey(petInfo.ID))
|
{
|
if (attrData.itemConfig.CanSell == 1)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.sell, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.SellItem(attrData); });
|
}
|
}
|
break;
|
case 41:
|
horseConfig = unlockMountDict[attrData.itemId];
|
if (horseModel._DicHorse.ContainsKey(horseConfig.HorseID))
|
{
|
if (attrData.itemConfig.CanSell == 1)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.sell, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.SellItem(attrData); });
|
}
|
}
|
break;
|
case 124:
|
horseConfig = unlockMountDict[attrData.itemConfig.EffectValueA1];
|
if (horseModel._DicHorse.ContainsKey(horseConfig.HorseID))
|
{
|
if (attrData.itemConfig.CanSell == 1)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.sell, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.SellItem(attrData); });
|
}
|
}
|
break;
|
case 125:
|
petInfo = unlockPetDict[attrData.itemConfig.EffectValueA1];
|
if (petmodel._DicPetBack.ContainsKey(petInfo.ID))
|
{
|
if (attrData.itemConfig.CanSell == 1)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.sell, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.SellItem(attrData); });
|
}
|
}
|
break;
|
default:
|
if (attrData.itemConfig.CanSell == 1)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.sell, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.SellItem(attrData); });
|
}
|
break;
|
}
|
|
List<int> dismantleReturnlist = attrData.GetUseDataModel((int)ItemUseDataKey.itemDecompound);
|
if (dismantleReturnlist != null && dismantleReturnlist.Count > 0)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.dismantle, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.DismantleItem(attrData); });
|
}
|
|
if (!isOverdue)
|
{
|
if (attrData.itemConfig.JumpComposeCondi != null && attrData.itemConfig.JumpComposeCondi.Length > 0)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.compose, (ItemWinBtnType, ItemAttrData) =>
|
{
|
int jumpId = 0;
|
bool isUnlock = ModelCenter.Instance.GetModel<ComposeWinModel>().CheckComposeItemById(attrData.itemId, out jumpId);
|
if (isUnlock)
|
{
|
ItemOperateUtility.Instance.GotoComposeItem(jumpId);
|
}
|
});
|
}
|
|
if (attrData.itemConfig.Type == 25 && attrData.itemConfig.Effect1 == 225)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.inlay, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.GotoInlayItem(attrData.guid); });
|
}
|
|
if ((ItemType)attrData.itemConfig.Type == ItemType.WingsMat)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.refine, (ItemWinBtnType, ItemAttrData) =>
|
{
|
// BoxGetItemModel.Instance.SetModel(attrData.guid);
|
WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.StrengthFunc3);
|
});
|
|
}
|
}
|
|
if (attrData.count > 1)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.split, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.OnClickSplitBtn(attrData.guid); });
|
}
|
|
if (!isOverdue)
|
{
|
switch (attrData.winType)
|
{
|
case ItemWinType.equipWin:
|
case ItemWinType.wingsWin:
|
case ItemWinType.guardWin:
|
attrData.SetTipsFuncBtn(ItemOperateType.putOn, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.PutOnItem(attrData.guid); });
|
break;
|
}
|
|
if (attrData.itemConfig.UseTag == 1)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.makeUse, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.GotoUseItem(attrData.guid); });
|
}
|
}
|
|
for (int i = 0; i < ItemRenewalIds.Length; i++)
|
{
|
if (ItemRenewalIds[i] == attrData.itemId)
|
{
|
if (isOverdue)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.renewal, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.RenewalItem(attrData.guid); });
|
}
|
}
|
}
|
|
for (int i = 0; i < tryPutOnEquipIds.Length; i++)
|
{
|
if (tryPutOnEquipIds[i] == attrData.itemId)
|
{
|
if (PlayerDatas.Instance.baseData.coinPointTotal <= 0)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.renewal, (ItemWinBtnType, ItemAttrData) => { WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.FirstRecharge); });
|
}
|
}
|
}
|
|
if (!string.IsNullOrEmpty(attrData.guid))
|
{
|
var item = playerPack.GetItemByGuid(attrData.guid);
|
if (item.isAuction)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.putAway, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.PutAway(attrData.guid); });
|
}
|
}
|
}
|
|
public void SetDogzItemBtn(ItemAttrData attrData)
|
{
|
if (attrData == null) return;
|
|
if (attrData.itemConfig.CanSell == 1)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.sell, (ItemWinBtnType, ItemAttrData) => { ItemOperateUtility.Instance.SellItem(attrData); });
|
}
|
|
switch (attrData.winType)
|
{
|
case ItemWinType.equipWin:
|
attrData.SetTipsFuncBtn(ItemOperateType.putOn, (ItemWinBtnType, ItemAttrData) =>
|
{
|
if (dogzModel.CheckIsPutOn(attrData.itemId))
|
{
|
List<int> indexlist = new List<int>();
|
indexlist.Add(attrData.index);
|
dogzModel.SendPutOnEquip(indexlist);
|
}
|
|
});
|
break;
|
}
|
}
|
|
public void SetDogzEquipBtn(ItemAttrData attrData)
|
{
|
if (attrData == null) return;
|
|
attrData.SetTipsFuncBtn(ItemOperateType.putOff, (ItemWinBtnType, ItemAttrData) =>
|
{
|
dogzModel.CheckPutOff(dogzModel.GetDogzEquipPlaceByIndex(attrData.index));
|
});
|
|
if (dogzModel.TryGetAssistDogzState(dogzModel.presentSelectDogz))
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.strength, (ItemWinBtnType, ItemAttrData) =>
|
{
|
dogzModel.OpenDogzFuncEvent(1, attrData.index);
|
});
|
}
|
|
}
|
|
/// <summary>
|
/// 设置装备弹框按钮
|
/// </summary>
|
/// <param name="attrData"></param>
|
public void SetPutOnTipsBtn(ItemAttrData attrData)
|
{
|
if (attrData == null)
|
{
|
return;
|
}
|
|
RoleEquipType equipType = (RoleEquipType)attrData.itemConfig.EquipPlace;
|
if (equipType == RoleEquipType.Wing)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.refine, (ItemWinBtnType, ItemAttrData) =>
|
{
|
WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.StrengthFunc3);
|
});
|
}
|
else if (equipType != RoleEquipType.Guard1)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.strength, (ItemWinBtnType, ItemAttrData) =>
|
{
|
WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.StrengthFunc1);
|
});
|
}
|
|
attrData.SetTipsFuncBtn(ItemOperateType.putOff, (ItemWinBtnType, ItemAttrData) =>
|
{
|
ItemOperateUtility.Instance.PutOffEquip(attrData.guid);
|
});
|
|
for (int i = 0; i < tryPutOnEquipIds.Length; i++)
|
{
|
if (tryPutOnEquipIds[i] == attrData.itemId)
|
{
|
if (PlayerDatas.Instance.baseData.coinPointTotal <= 0)
|
{
|
attrData.SetTipsFuncBtn(ItemOperateType.renewal, (ItemWinBtnType, ItemAttrData) => { WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.FirstRecharge); });
|
}
|
}
|
}
|
}
|
|
#endregion
|
|
#region 设置获取途径列表
|
private List<GetItemWaysConfig> getWayslist = new List<GetItemWaysConfig>();
|
public List<GetItemWaysConfig> GetWaysList(ItemAttrData attrData)
|
{
|
getWayslist.Clear();
|
if (attrData != null)
|
{
|
int[] waysArray = attrData.itemConfig.GetWay;
|
if (waysArray != null)
|
{
|
int i = 0;
|
for (i = 0; i < waysArray.Length; i++)
|
{
|
var config = GetItemWaysConfig.Get(waysArray[i]);
|
if (config != null)
|
{
|
getWayslist.Add(config);
|
}
|
}
|
}
|
}
|
|
return getWayslist;
|
}
|
#endregion
|
|
#region 设置基础属性
|
|
public string GetBasicAttr(ItemAttrData attrData)
|
{
|
switch ((RoleEquipType)attrData.itemConfig.EquipPlace)
|
{
|
case RoleEquipType.Wing:
|
return SetWingsBasicAttr(attrData);
|
case RoleEquipType.Guard1:
|
return SetGuardBasicAttr(attrData);
|
default:
|
return string.Empty;
|
}
|
}
|
|
private string SetWingsBasicAttr(ItemAttrData attrData)
|
{
|
if (attrData == null)
|
return "";
|
|
WingRefineAttrConfig wingRefine = WingRefineAttrConfig.GetWingRefineModel(attrData.itemConfig.LV);
|
if (wingRefine == null)
|
return "";
|
|
attrSB.Length = 0;
|
int maxHp = 0;
|
int maxHurt = 0;
|
int curHp = 0;
|
int curHurt = 0;
|
|
Dictionary<int, int> itemEffectDict = GetItemEffectDict(attrData.itemConfig);
|
Dictionary<int, int> wingAttrModelDict = ConfigParse.GetDic<int, int>(wingRefine.attrupper);
|
|
foreach (var key in itemEffectDict.Keys)
|
{
|
playerProModel = PlayerPropertyConfig.Get(key);
|
string rangeStr = "";
|
if (key == 23)
|
{
|
rangeStr = playerProModel.Name + "+" + PlayerPropertyConfig.GetValueDescription(key, itemEffectDict[key]);
|
}
|
else if (key == 6)
|
{
|
if (wingAttrModelDict.ContainsKey(key))
|
{
|
maxHp = itemEffectDict[key] + wingAttrModelDict[key];
|
}
|
|
if (attrData.GetUseDataModel(42) != null)
|
{
|
curHp = itemEffectDict[key] + (int)strengthengmodel.BackpackWings(attrData.itemId, attrData.GetUseDataModel(42)[0])[1];
|
}
|
else
|
{
|
curHp = itemEffectDict[key];
|
}
|
|
rangeStr = playerProModel.Name + "+"
|
+ PlayerPropertyConfig.GetValueDescription(key, curHp) + "["
|
+ PlayerPropertyConfig.GetValueDescription(key, itemEffectDict[key]) + "-"
|
+ PlayerPropertyConfig.GetValueDescription(key, maxHp) + "]";
|
}
|
else if (key == 19)
|
{
|
if (wingAttrModelDict.ContainsKey(key))
|
{
|
maxHurt = itemEffectDict[key] + wingAttrModelDict[key];
|
}
|
|
if (attrData.GetUseDataModel(42) != null)
|
{
|
curHurt = itemEffectDict[key] + (int)strengthengmodel.BackpackWings(attrData.itemId, attrData.GetUseDataModel(42)[0])[0];
|
}
|
else
|
{
|
curHurt = itemEffectDict[key];
|
}
|
rangeStr = playerProModel.Name + "+"
|
+ PlayerPropertyConfig.GetValueDescription(key, curHurt) + "["
|
+ PlayerPropertyConfig.GetValueDescription(key, itemEffectDict[key]) + "-"
|
+ PlayerPropertyConfig.GetValueDescription(key, maxHurt) + "]";
|
}
|
|
if (rangeStr != "")
|
{
|
if (attrSB.Length <= 0)
|
{
|
attrSB.Append(rangeStr);
|
}
|
else
|
{
|
attrSB.Append("\n" + rangeStr);
|
}
|
|
}
|
}
|
|
return attrSB.ToString();
|
}
|
|
private string SetGuardBasicAttr(ItemAttrData attrData)
|
{
|
string s = "";
|
return s;
|
}
|
|
private string SetAttrColor(string attrStr, int atkSpeed, int equipPlace)
|
{
|
string color = string.Empty;
|
bool isColor = TryGetAtkSpeedColor(atkSpeed, out color);
|
if (isColor)
|
{
|
return StringUtility.Contact("<color=#", color, ">", attrStr, "</color>");
|
}
|
return attrStr;
|
}
|
|
public int GetProValueType(int precentType, int value)
|
{
|
switch (precentType)
|
{
|
case 1:
|
case 2:
|
return Mathf.RoundToInt(value / 100);
|
default:
|
return value;
|
}
|
}
|
#endregion
|
|
#region 设置传奇属性
|
private Dictionary<int, int> attrDict = new Dictionary<int, int>();
|
|
public string GetLegendAttr(ItemAttrData attrData)
|
{
|
if (!attrData.isPreview)
|
{
|
return SetLegendAttr(attrData.legendDataDict.Keys.ToList(), attrData.legendDataDict.Values.ToList(), attrData.itemConfig);
|
}
|
else
|
{
|
return SetLegendAttr(attrData.legendDataDict.Keys.ToList(), attrData.legendDataDict.Values.ToList(),
|
attrData.itemConfig, true, attrData.isCustom);
|
}
|
}
|
|
public string GetDogzLegendAttrCntPreview(ItemAttrData attrData)
|
{
|
string s = "";
|
if (attrData.isCustom)
|
{
|
s = Language.Get("LegendAttPreview_MustTitle", attrData.legendDataDict.Count);
|
}
|
else
|
{
|
var quality = attrData.itemConfig.ItemColor;
|
var starLevel = attrData.itemConfig.StarLevel;
|
var count = LegendPropertyUtility.GetDogzPropertyCount(quality, starLevel, LegendAttrType.Normal);
|
count += LegendPropertyUtility.GetDogzPropertyCount(quality, starLevel, LegendAttrType.Pursuit);
|
count += LegendPropertyUtility.GetDogzPropertyCount(quality, starLevel, LegendAttrType.Fixed);
|
|
if (attrData.itemConfig.StarLevel > 2)
|
{
|
s = Language.Get("LegendAttPreview_MustTitle", count);
|
}
|
else
|
{
|
s = Language.Get("LegendAttPreview_MightTitle", count);
|
}
|
}
|
|
return s;
|
}
|
|
public string GetWingsLegendAttrCntPreview(ItemAttrData attrData)
|
{
|
var description = "";
|
if (attrData.isCustom)
|
{
|
description = Language.Get("LegendAttPreview_MustTitle", attrData.legendDataDict.Count);
|
}
|
else
|
{
|
int attrCnt = LegendPropertyUtility.GetWingPropertyCount(attrData.itemConfig.LV);
|
if (attrCnt > 0)
|
{
|
if (attrCnt > 1)
|
{
|
description = Language.Get("LegendAttPreview_MustTitle", attrCnt);
|
}
|
else
|
{
|
description = Language.Get("LegendAttPreview_MightTitle", attrCnt);
|
}
|
}
|
}
|
|
return description;
|
}
|
|
private string SetLegendAttr(List<int> idlist, List<int> valuelist, ItemConfig itemConfig, bool isPreview = false, bool isCustom = false)
|
{
|
if (idlist == null)
|
return "";
|
|
attrDict.Clear();
|
int i = 0;
|
attrSB.Length = 0;
|
for (i = 0; i < idlist.Count; i++)
|
{
|
int attrId = idlist[i];
|
int attrValue = valuelist[i];
|
attrDict.Add(attrId, attrValue);
|
}
|
|
switch (itemConfig.EquipPlace)
|
{
|
case 101:
|
case 102:
|
case 103:
|
case 104:
|
case 105:
|
idlist.Sort(CompareDogzLegendAttrType);
|
break;
|
}
|
|
return attrSB.ToString();
|
}
|
|
private int CompareDogzLegendAttrType(int start, int end)
|
{
|
int type1 = GetDogzLegendType(start);
|
int type2 = GetDogzLegendType(end);
|
if (type1.CompareTo(type2) != 0) return -type1.CompareTo(type2);
|
|
return 0;
|
}
|
|
private int GetDogzLegendType(int id)
|
{
|
return (int)LegendPropertyUtility.GetDogzPropertyType(id);
|
}
|
#endregion
|
|
#region 设置翅膀精炼材料
|
public string GetWingsRefineMatStr(ItemAttrData attrData)
|
{
|
if (attrData.wingsRefineMatDict == null) return "";
|
|
attrSB.Length = 0;
|
foreach (var id in attrData.wingsRefineMatDict.Keys)
|
{
|
ItemConfig itemConfig = ItemConfig.Get(id);
|
if (itemConfig != null)
|
{
|
string des = StringUtility.Contact(itemConfig.ItemName, "X", attrData.wingsRefineMatDict[id]);
|
if (attrSB.Length <= 0)
|
{
|
attrSB.Append(des);
|
}
|
else
|
{
|
attrSB.Append("\n" + des);
|
}
|
}
|
}
|
return attrSB.ToString();
|
}
|
#endregion
|
|
#region 设置绝版属性
|
public string GetExhaustedAtrr(ItemAttrData attrData)
|
{
|
return SetExhaustedAttr(attrData, attrData.exhaustedMaxDataDict.Keys.ToList(), attrData.exhaustedMaxDataDict.Values.ToList());
|
}
|
|
private string SetExhaustedAttr(ItemAttrData attrData, List<int> idlist, List<int> valuelist)
|
{
|
if (idlist == null)
|
return "";
|
|
int i = 0;
|
attrSB.Length = 0;
|
for (i = 0; i < idlist.Count; i++)
|
{
|
playerProModel = PlayerPropertyConfig.Get(idlist[i]);
|
if (playerProModel != null)
|
{
|
string s = "";
|
switch ((PropertyType)idlist[i])
|
{
|
case PropertyType.OnlyFinalHurt:
|
s = Language.Get("EquipTip_ExtraDamage", GetExhaustedAttrValue(idlist[i], valuelist[i]), GetExhaustedMaxLv(attrData.itemConfig.LV), valuelist[i]);
|
break;
|
case PropertyType.PVPAtkBackHP:
|
s = Language.Get("EquipTip_ExtraHpBack", GetExhaustedAttrValue(idlist[i], valuelist[i]), GetExhaustedMaxLv(attrData.itemConfig.LV), valuelist[i]);
|
break;
|
}
|
|
if (attrSB.Length <= 0)
|
{
|
attrSB.Append(s);
|
}
|
else
|
{
|
attrSB.Append("\n" + s);
|
}
|
|
}
|
}
|
return attrSB.ToString();
|
}
|
|
private int GetExhaustedAttrValue(int attrId, int value)
|
{
|
Equation.Instance.Clear();
|
Equation.Instance.AddKeyValue("maxOOPValue", value);
|
Equation.Instance.AddKeyValue("lv", PlayerDatas.Instance.baseData.LV);
|
string formula = string.Empty;
|
if (exhaustedAttrFormula.ContainsKey(attrId))
|
{
|
formula = exhaustedAttrFormula[attrId];
|
}
|
return Equation.Instance.Eval<int>(formula);
|
}
|
|
public int GetExhaustedMaxLv(int equipLV)
|
{
|
int maxLv = 0;
|
exhaustedMaxLvDict.TryGetValue(equipLV, out maxLv);
|
return maxLv;
|
}
|
#endregion
|
|
Dictionary<int, int> GetItemEffectDict(ItemConfig config)
|
{
|
Dictionary<int, int> itemEffectDict = new Dictionary<int, int>();
|
if (config == null) return itemEffectDict;
|
|
try
|
{
|
if (config.Effect1 != 0)
|
itemEffectDict.Add(config.Effect1, config.EffectValueA1);
|
if (config.Effect2 != 0)
|
itemEffectDict.Add(config.Effect2, config.EffectValueA2);
|
if (config.Effect3 != 0)
|
itemEffectDict.Add(config.Effect3, config.EffectValueA3);
|
if (config.Effect4 != 0)
|
itemEffectDict.Add(config.Effect4, config.EffectValueA4);
|
if (config.Effect5 != 0)
|
itemEffectDict.Add(config.Effect5, config.EffectValueA5);
|
|
}
|
catch (Exception ex)
|
{
|
DebugEx.Log(ex.ToString());
|
}
|
|
return itemEffectDict;
|
}
|
|
#region 设置弹框位置
|
private RectTransform curTips = null;
|
private RectTransform compareTips = null;
|
public void SetCurTips(RectTransform rect)
|
{
|
curTips = rect;
|
SetTipsPos();
|
}
|
public void SetCompareTips(RectTransform rect)
|
{
|
compareTips = rect;
|
SetTipsPos();
|
}
|
|
public void SetTipsPos()
|
{
|
if (compareAttrData == null)
|
{
|
if (curTips != null)
|
{
|
curTips.anchoredPosition3D = new Vector3(curTips.rect.width / 2, curTips.rect.height / 2, 0);
|
}
|
}
|
else
|
{
|
if (curTips != null && compareTips != null)
|
{
|
if (curTips.rect.height >= compareTips.rect.height)
|
{
|
|
curTips.anchoredPosition3D = new Vector3(curTips.rect.width, curTips.rect.height / 2, 0);
|
compareTips.anchoredPosition3D = new Vector3(0, curTips.rect.height / 2, 0);
|
}
|
else
|
{
|
curTips.anchoredPosition3D = new Vector3(curTips.rect.width, compareTips.rect.height / 2, 0);
|
compareTips.anchoredPosition3D = new Vector3(0, compareTips.rect.height / 2, 0);
|
}
|
}
|
|
}
|
}
|
|
public void SetCommonTipPos(RectTransform rect)
|
{
|
float y = -750 / 2 + rect.sizeDelta.y / 2;
|
rect.anchoredPosition3D = new Vector3(rect.anchoredPosition3D.x, y, 0);
|
}
|
#endregion
|
|
#region 解锁背包格子数据
|
public int OpenCount {
|
get; private set;
|
}
|
|
public PackType packType { get; private set; }
|
|
public int Index {
|
get; private set;
|
}
|
|
public void SetExtendGirdModel(int openCount = 0, int index = -1, PackType type = PackType.Deleted)
|
{
|
this.OpenCount = openCount;
|
this.packType = type;
|
this.Index = index;
|
}
|
#endregion
|
|
#region 计算增加经验
|
public ulong GetAddExpValue(int timeValue, int maxExpLv)
|
{
|
PlayerLVConfig playerLVConfig = PlayerLVConfig.Get(PlayerDatas.Instance.baseData.LV);
|
PlayerLVConfig maxLvConfig = PlayerLVConfig.Get(maxExpLv);
|
int playerReExp = 0;
|
int maxReExp = 0;
|
if (playerLVConfig != null)
|
{
|
playerReExp = playerLVConfig.ReExp;
|
}
|
if (maxLvConfig != null)
|
{
|
maxReExp = maxLvConfig.ReExp;
|
}
|
else
|
{
|
if (maxExpLv <= 0)
|
{
|
maxReExp = playerReExp;
|
}
|
}
|
Equation.Instance.Clear();
|
Equation.Instance.AddKeyValue("PlayerReExp", playerReExp);
|
Equation.Instance.AddKeyValue("MaxReExp", maxReExp);
|
Equation.Instance.AddKeyValue("TimeValue", timeValue);
|
return Equation.Instance.Eval<ulong>(expValueFormula);
|
}
|
#endregion
|
|
#region 设置宠物和坐骑数据
|
public Dictionary<int, int> GetPetSkillDict(int unlockId)
|
{
|
if (unlockPetDict.ContainsKey(unlockId))
|
{
|
if (petSkillDict.ContainsKey(unlockPetDict[unlockId].ID))
|
{
|
return petSkillDict[unlockPetDict[unlockId].ID];
|
}
|
}
|
return null;
|
}
|
|
public string GetQualityName(int quality)
|
{
|
string nameStr = string.Empty;
|
petAndMountQualityDict.TryGetValue(quality, out nameStr);
|
return nameStr;
|
}
|
|
public Dictionary<int, List<int>> GetMountSkillDict(int unlockId)
|
{
|
if (unlockMountDict.ContainsKey(unlockId))
|
{
|
if (mountSkillDict.ContainsKey(unlockMountDict[unlockId].HorseID))
|
{
|
return mountSkillDict[unlockMountDict[unlockId].HorseID];
|
}
|
}
|
|
return null;
|
}
|
|
public void SetPetAttrStr(int attrId, int attrValue, out string attrName, out string attrValueStr, string contanctStr = "")
|
{
|
attrName = "";
|
attrValueStr = "";
|
PlayerPropertyConfig playerProModel = null;
|
if (attrId == (int)PropertyType.MaxAtk || attrId == (int)PropertyType.PetMaxAtk)
|
{
|
playerProModel = PlayerPropertyConfig.Get((int)PropertyType.ATK);
|
}
|
else
|
{
|
playerProModel = PlayerPropertyConfig.Get(attrId);
|
}
|
|
if (playerProModel != null)
|
{
|
attrName = playerProModel.Name;
|
if (contanctStr == "")
|
{
|
attrValueStr = PlayerPropertyConfig.GetValueDescription(attrId, attrValue);
|
}
|
else
|
{
|
attrValueStr = StringUtility.Contact(contanctStr, "-", PlayerPropertyConfig.GetValueDescription(attrId, attrValue));
|
}
|
}
|
}
|
#endregion
|
|
#region 设置物品使用的限制条件
|
#endregion
|
|
#region 物品增加战斗力
|
MountModel mountDatas { get { return ModelCenter.Instance.GetModel<MountModel>(); } }
|
public StrengthenModel strengthengmodel { get { return ModelCenter.Instance.GetModel<StrengthenModel>(); } }
|
|
public bool TryGetFightPowerByItemId(int itemId, out int fightPower)
|
{
|
fightPower = 0;
|
ItemConfig itemConfig = ItemConfig.Get(itemId);
|
if (itemConfig == null) return false;
|
|
var attrIdlist = PlayerPropertyConfig.GetKeys();
|
var fruitlist = AttrFruitConfig.GetKeys();
|
|
Dictionary<int, int> attrDict = new Dictionary<int, int>();
|
Dictionary<int, int> itemEffectDict = GetItemEffectDict(itemConfig);
|
int atk = 0;
|
int hp = 0;
|
int def = 0;
|
foreach (var attrId in itemEffectDict.Keys)
|
{
|
var attrValue = itemEffectDict[attrId];
|
switch ((PropertyType)attrId)
|
{
|
case PropertyType.ATK:
|
atk += attrValue;
|
break;
|
case PropertyType.HP:
|
hp += attrValue;
|
break;
|
case PropertyType.DEF:
|
def += attrValue;
|
break;
|
case PropertyType.HorseAtkPer:
|
float mountAtk = mountDatas.GetAllMountAttack();
|
atk += Mathf.RoundToInt(mountAtk * ((float)attrValue / 10000));
|
break;
|
case PropertyType.StoneBasePer:
|
var stoneDict = GetStoneAttrDict();
|
foreach (var key in stoneDict.Keys)
|
{
|
var stoneValue = stoneDict[key];
|
switch ((PropertyType)key)
|
{
|
case PropertyType.ATK:
|
atk += Mathf.RoundToInt(stoneValue * ((float)attrValue / 10000));
|
break;
|
case PropertyType.HP:
|
hp += Mathf.RoundToInt(stoneValue * ((float)attrValue / 10000));
|
break;
|
case PropertyType.DEF:
|
def += Mathf.RoundToInt(stoneValue * ((float)attrValue / 10000));
|
break;
|
}
|
}
|
break;
|
case PropertyType.RealmBasePer:
|
var realmDict = GetRealmAttrDict();
|
foreach (var key in realmDict.Keys)
|
{
|
var realmValue = realmDict[key];
|
switch ((PropertyType)key)
|
{
|
case PropertyType.ATK:
|
atk += Mathf.RoundToInt(realmValue * ((float)attrValue / 10000));
|
break;
|
case PropertyType.HP:
|
hp += Mathf.RoundToInt(realmValue * ((float)attrValue / 10000));
|
break;
|
case PropertyType.DEF:
|
def += Mathf.RoundToInt(realmValue * ((float)attrValue / 10000));
|
break;
|
}
|
}
|
break;
|
case PropertyType.PetSkillAtkRate:
|
break;
|
case PropertyType.PlusBaseAtkPer:
|
var strengthDict = GetStrengthAttrDict();
|
if (strengthDict.ContainsKey((int)PropertyType.ATK))
|
{
|
var strengthValue = strengthDict[(int)PropertyType.ATK];
|
atk += Mathf.RoundToInt(strengthValue * ((float)attrValue / 10000));
|
}
|
break;
|
default:
|
if (attrIdlist.Contains(attrId.ToString()))
|
{
|
attrDict.Add(attrId, attrValue);
|
}
|
break;
|
}
|
}
|
|
if (atk > 0)
|
{
|
attrDict.Add((int)PropertyType.ATK, atk);
|
}
|
|
if (def > 0)
|
{
|
attrDict.Add((int)PropertyType.DEF, def);
|
}
|
|
if (hp > 0)
|
{
|
attrDict.Add((int)PropertyType.HP, hp);
|
}
|
|
fightPower = UIHelper.GetFightPower(attrDict);
|
if (fruitlist.Contains(itemId.ToString()))
|
{
|
var fruitConfig = AttrFruitConfig.Get(itemId);
|
fightPower += fruitConfig.FightPowerEx;
|
}
|
return fightPower > 0;
|
}
|
|
private Dictionary<int, int> GetStoneAttrDict()
|
{
|
Dictionary<int, int> attrDict = new Dictionary<int, int>();
|
//var stoneDict = PlayerStoneData.Instance.GetAllStone();
|
//foreach (var key in stoneDict.Keys)
|
//{
|
// var stoneIds = stoneDict[key];
|
// var itemModel = playerPack.GetItemByIndex(PackType.Equip, key);
|
// if (itemModel != null && stoneIds != null)
|
// {
|
// for (int i = 0; i < stoneIds.Length; i++)
|
// {
|
// int stoneId = (int)stoneIds[i];
|
// ItemConfig itemConfig = ItemConfig.Get(stoneId);
|
// if (itemConfig != null)
|
// {
|
// var itemEffectDict = SetItemEffectDict(itemConfig);
|
// foreach (var attrId in itemEffectDict.Keys)
|
// {
|
// var attrValue = itemEffectDict[attrId];
|
// if (!attrDict.ContainsKey(attrId))
|
// {
|
// attrDict.Add(attrId, attrValue);
|
// }
|
// else
|
// {
|
// attrDict[attrId] += attrValue;
|
// }
|
// }
|
// }
|
// }
|
// }
|
//}
|
return attrDict;
|
}
|
|
private Dictionary<int, int> GetRealmAttrDict()
|
{
|
Dictionary<int, int> attrDict = new Dictionary<int, int>();
|
int realmLv = PlayerDatas.Instance.baseData.realmLevel;
|
var realmConfig = RealmConfig.Get(realmLv);
|
if (realmConfig != null)
|
{
|
var attrIds = realmConfig.AddAttrType;
|
var attrValues = realmConfig.AddAttrNum;
|
if (attrIds != null && attrValues != null
|
&& attrIds.Length == attrValues.Length)
|
{
|
for (int i = 0; i < attrIds.Length; i++)
|
{
|
var attrId = attrIds[i];
|
var attrValue = attrValues[i];
|
if (attrValue > 0)
|
{
|
if (!attrDict.ContainsKey(attrId))
|
{
|
attrDict.Add(attrId, attrValue);
|
}
|
else
|
{
|
attrDict[attrId] += attrValue;
|
}
|
}
|
}
|
}
|
}
|
return attrDict;
|
}
|
|
private Dictionary<int, int> GetStrengthAttrDict()
|
{
|
Dictionary<int, int> attrDict = new Dictionary<int, int>();
|
//var strengthDict = strengthengmodel._EqInfo;
|
//foreach (var index in strengthDict.Keys)
|
//{
|
// var itemModel = playerPack.GetItemByIndex(PackType.Equip, index);
|
// if (itemModel != null)
|
// {
|
// int lv = strengthengmodel.StrengthenTheCeiling(index);
|
// int type = strengthengmodel.GameDefineIndex(index);
|
// //var itemPlus = ItemPlusConfig.GetItemPlusData(type, lv);
|
// //if (itemPlus != null)
|
// //{
|
// // int[] attrIDs = itemPlus.attrIds;
|
// // int[] attrValues = itemPlus.attrValues;
|
// // for (int i = 0; i < attrIDs.Length; i++)
|
// // {
|
// // var attrId = attrIDs[i];
|
// // var attrValue = attrValues[i];
|
// // if (attrValue > 0)
|
// // {
|
// // if (!attrDict.ContainsKey(attrId))
|
// // {
|
// // attrDict.Add(attrId, attrValue);
|
// // }
|
// // else
|
// // {
|
// // attrDict[attrId] += attrValue;
|
// // }
|
// // }
|
// // }
|
// //}
|
// }
|
//}
|
return attrDict;
|
}
|
#endregion
|
|
#region 绝版武器战力
|
|
public bool IsPeerlessEquip(int itemId)
|
{
|
if (PeerlessEquipIds == null) return false;
|
|
return PeerlessEquipIds.Contains(itemId);
|
}
|
|
public int GetEquipFightPower(int equipScore)
|
{
|
var funcConfig = FuncConfigConfig.Get("FightpowerFormula");
|
Equation.Instance.Clear();
|
if (funcConfig != null)
|
{
|
Equation.Instance.AddKeyValue("equipScoreTotal", equipScore);
|
return Equation.Instance.Eval<int>(funcConfig.Numerical2);
|
}
|
return 0;
|
}
|
#endregion
|
|
#region 共享开启次数
|
public string GetShareNumItemDes(int itemId)
|
{
|
string shareNumDes = string.Empty;
|
List<int> idlist = null;
|
bool isShare = playerPack.TryGetShareNumItem(itemId, out idlist);
|
if (isShare)
|
{
|
foreach (var id in idlist)
|
{
|
ItemConfig itemConfig = ItemConfig.Get(id);
|
TextColType colType = itemConfig.ItemColor < 2 ? TextColType.White : (TextColType)itemConfig.ItemColor;
|
string des = UIHelper.AppendColor(colType, itemConfig.ItemName);
|
if (shareNumDes.Length > 0)
|
{
|
shareNumDes = StringUtility.Contact(shareNumDes, "</r>", des);
|
}
|
else
|
{
|
shareNumDes = des;
|
}
|
}
|
}
|
return shareNumDes;
|
}
|
#endregion
|
|
#region 判断是否展示模型
|
public Dictionary<int, int> showModelAttrDict = new Dictionary<int, int>();
|
public bool IsShowModel(int itemId, ModelShowPerfab showPerfab)
|
{
|
var config = ItemConfig.Get(itemId);
|
if (config == null) return false;
|
|
int fightPower = 0;
|
switch (config.Type)
|
{
|
case 125:
|
PetInfoConfig petInfo = unlockPetDict[config.EffectValueA1];
|
fightPower = petInfo.ShowFightPower;
|
showPerfab.SetModelShow(petInfo.ID, ModelShowType.Pet, Language.Get("TreasureEffect103"), fightPower);
|
return true;
|
case 124:
|
HorseConfig horseConfig = unlockMountDict[config.EffectValueA1];
|
fightPower = horseConfig.ShowFightPower;
|
showPerfab.SetModelShow(horseConfig.Model, ModelShowType.Mount, Language.Get("TreasureEffect103"), fightPower);
|
return true;
|
}
|
bool isFashion = TryGetFashionFightPower(config, out fightPower);
|
if (isFashion)
|
{
|
showPerfab.SetModelShow(itemId, ModelShowType.FashionDress, Language.Get("TreasureEffect103"), fightPower);
|
return true;
|
}
|
|
return false;
|
}
|
|
private bool TryGetFashionFightPower(ItemConfig itemConfig, out int fightPower)
|
{
|
showModelAttrDict.Clear();
|
fightPower = 0;
|
if (itemConfig == null) return false;
|
|
int fashionType = 0;
|
int fashionId = 0;
|
bool isFashion = TryGetItemFashionData(itemConfig.ID, out fashionType, out fashionId);
|
if (isFashion)
|
{
|
List<int> fashionIds = null;
|
fashionDress.TryGetFashionIds(fashionType, out fashionIds);
|
if (fashionId == 0)
|
{
|
if (fashionIds != null)
|
{
|
foreach (var id in fashionIds)
|
{
|
Dictionary<int, int> dict = null;
|
fashionDress.TryGetFashionDressProperty(id, 1, out dict);
|
if (dict != null)
|
{
|
foreach (var attrId in dict.Keys)
|
{
|
var attrValue = dict[attrId];
|
if (!showModelAttrDict.ContainsKey(attrId))
|
{
|
showModelAttrDict.Add(attrId, attrValue);
|
}
|
else
|
{
|
showModelAttrDict[attrId] += attrValue;
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
{
|
Dictionary<int, int> dict = null;
|
fashionDress.TryGetFashionDressProperty(fashionId, 1, out dict);
|
if (dict != null)
|
{
|
foreach (var attrId in dict.Keys)
|
{
|
var attrValue = dict[attrId];
|
if (!showModelAttrDict.ContainsKey(attrId))
|
{
|
showModelAttrDict.Add(attrId, attrValue);
|
}
|
else
|
{
|
showModelAttrDict[attrId] += attrValue;
|
}
|
}
|
}
|
}
|
fightPower = UIHelper.GetFightPower(showModelAttrDict);
|
return true;
|
}
|
return false;
|
}
|
|
public bool TryGetItemFashionData(int itemId, out int fashionType, out int fashionId)
|
{
|
fashionType = 0;
|
fashionId = 0;
|
Dictionary<int, List<int>> effectDict = null;
|
GetItemEffectDict(itemId, out effectDict);
|
foreach (var key in effectDict.Keys)
|
{
|
var valueList = effectDict[key];
|
if (key == 244)
|
{
|
fashionType = valueList[0];
|
fashionId = valueList[1];
|
return true;
|
}
|
}
|
return false;
|
}
|
|
private void GetItemEffectDict(int itemId, out Dictionary<int, List<int>> dict)
|
{
|
var config = ItemConfig.Get(itemId);
|
dict = new Dictionary<int, List<int>>();
|
if (config == null) return;
|
|
if (config.Effect1 != 0)
|
{
|
List<int> valuelist = new List<int>();
|
valuelist.Add(config.EffectValueA1);
|
valuelist.Add(config.EffectValueB1);
|
valuelist.Add(config.EffectValueC1);
|
dict.Add(config.Effect1, valuelist);
|
}
|
|
if (config.Effect2 != 0)
|
{
|
List<int> valuelist = new List<int>();
|
valuelist.Add(config.EffectValueA2);
|
valuelist.Add(config.EffectValueB2);
|
valuelist.Add(config.EffectValueC2);
|
dict.Add(config.Effect2, valuelist);
|
}
|
|
if (config.Effect3 != 0)
|
{
|
List<int> valuelist = new List<int>();
|
valuelist.Add(config.EffectValueA3);
|
valuelist.Add(config.EffectValueB3);
|
valuelist.Add(config.EffectValueC3);
|
dict.Add(config.Effect3, valuelist);
|
}
|
|
if (config.Effect4 != 0)
|
{
|
List<int> valuelist = new List<int>();
|
valuelist.Add(config.EffectValueA4);
|
valuelist.Add(config.EffectValueB4);
|
valuelist.Add(config.EffectValueC4);
|
dict.Add(config.Effect4, valuelist);
|
}
|
|
if (config.Effect5 != 0)
|
{
|
List<int> valuelist = new List<int>();
|
valuelist.Add(config.EffectValueA5);
|
valuelist.Add(config.EffectValueB5);
|
valuelist.Add(config.EffectValueC5);
|
dict.Add(config.Effect5, valuelist);
|
}
|
}
|
|
#endregion
|
}
|
|
public class ItemAttrData
|
{
|
public PackType packType { get; private set; }
|
public string guid { get; private set; }
|
public int itemId { get; private set; }
|
public int index { get; private set; }
|
public ulong count { get; private set; }
|
public int[] stones { get; private set; } //可镶嵌宝石数组 长度为0 未镶嵌 数值为0 未镶嵌
|
public int score { get; private set; }
|
public bool isCompare { get; private set; } //是否进行装备比较
|
public bool isPreview { get; private set; }//是否预览
|
public ItemConfig itemConfig { get; private set; }
|
public bool isCustom { get; private set; } //是否是定制物品
|
public int level { get; private set; }//等级
|
public int equipHole { get; private set; }//聚魂孔
|
public ItemTipChildType ChildType { get; private set; } //决定当前面板打开哪个
|
public Dictionary<int, List<int>> useDataDict { get; private set; }
|
public Dictionary<int, int> strengthDataDict { get; private set; }
|
public Dictionary<int, int> washDataDict { get; private set; }
|
public Dictionary<int, int> legendDataDict { get; private set; }
|
public Dictionary<int, int> exhaustedMaxDataDict { get; private set; }
|
public Dictionary<int, int> wingsRefineMatDict { get; private set; }
|
public Dictionary<ItemOperateType, Action<ItemOperateType, string>> tipsFuncBtnDic { get; private set; }
|
|
public bool isHavePutLimit { get; private set; }
|
|
GodBeastModel beastModel { get { return ModelCenter.Instance.GetModel<GodBeastModel>(); } }
|
|
public ItemAttrData(int id, bool isPreview = false, ulong count = 0, int index = -1, bool isCompare = false, PackType type = PackType.Deleted, string guid = "", Dictionary<int, List<int>> useDataDict = null, ItemTipChildType childType = ItemTipChildType.Normal)
|
{
|
this.packType = type;
|
this.itemConfig = ItemConfig.Get(id);
|
this.tipsFuncBtnDic = new Dictionary<ItemOperateType, Action<ItemOperateType, string>>();
|
this.guid = guid;
|
this.itemId = id;
|
this.count = count;
|
this.index = index;
|
this.isPreview = isPreview;
|
this.isCompare = isCompare;
|
this.useDataDict = useDataDict;
|
this.StrengthLV = 0;
|
this.ChildType = childType;
|
this.isCustom = false;
|
this.extraInfos = null;
|
isHavePutLimit = true;
|
this.level = 1;
|
this.equipHole = -1;
|
this.isCustom = ItemLogicUtility.Instance.IsCustomItem(id);
|
if (isCustom)
|
{
|
var appointItemConfig = AppointItemConfig.Get(itemId);
|
if (appointItemConfig != null)
|
{
|
if (appointItemConfig.CancelUseLimit == 1)
|
{
|
isHavePutLimit = false;
|
}
|
SetCustomAttrData(appointItemConfig);
|
}
|
this.itemId = itemConfig.EffectValueA1;
|
this.itemConfig = ItemConfig.Get(this.itemId);
|
}
|
else
|
{
|
if (isPreview)
|
{
|
List<int> legendIdlist = null;
|
List<int> legendValuelist = null;
|
switch (itemConfig.EquipPlace)
|
{
|
case 11:
|
SetWingsLegendAttrPreview(out legendIdlist, out legendValuelist);
|
break;
|
case 101:
|
case 102:
|
case 103:
|
case 104:
|
case 105:
|
SetDogzEquipLegendAttrPreview(out legendIdlist, out legendValuelist);
|
break;
|
}
|
|
if (legendIdlist != null && legendValuelist != null)
|
{
|
if (legendIdlist.Count == legendValuelist.Count)
|
{
|
SetLegendData(legendIdlist, legendValuelist);
|
}
|
}
|
}
|
else
|
{
|
if (GetUseDataModel(20) != null)
|
{
|
if (GetUseDataModel(20)[0] == 1)
|
{
|
isHavePutLimit = false;
|
}
|
}
|
|
switch (type)
|
{
|
case PackType.Equip:
|
int[] equipGems = null;
|
var equipGemModel = ModelCenter.Instance.GetModel<EquipGemModel>();
|
if (equipGemModel.TryGetEquipGems(index, out equipGems))
|
{
|
SetGemModel(equipGems);
|
}
|
break;
|
}
|
|
SetLegendData(GetUseDataModel(17), GetUseDataModel(19));
|
SetExhaustedData(GetUseDataModel(21), GetUseDataModel(23));
|
SetWingsRefineMat(GetUseDataModel((int)ItemUseDataKey.wingMaterialItemID), GetUseDataModel((int)ItemUseDataKey.wingMaterialItemCount));
|
}
|
}
|
|
this.score = ItemLogicUtility.Instance.GetEquipScore(type, id, useDataDict, isPreview);
|
if (type == PackType.DogzEquip || type == PackType.DogzItem)
|
{
|
strengthDataDict = new Dictionary<int, int>();
|
if (GetUseDataModel((int)ItemUseDataKey.dogzEquipPlus) != null)
|
{
|
StrengthLV = GetUseDataModel((int)ItemUseDataKey.dogzEquipPlus)[0];
|
}
|
Dictionary<int, int> getStregthDict = beastModel.SiteEnhancementAttribute(type, index);
|
foreach (var key in getStregthDict.Keys)
|
{
|
strengthDataDict.Add(key, getStregthDict[key]);
|
}
|
}
|
|
SetWinType();
|
}
|
|
public string[] extraInfos { get; private set; }
|
public void SetExtraInfos(params string[] extraInfos)
|
{
|
this.extraInfos = extraInfos;
|
}
|
|
private void SetWingsLegendAttrPreview(out List<int> ids, out List<int> values)
|
{
|
ids = new List<int>();
|
values = new List<int>();
|
var level = itemConfig.LV;
|
var count = LegendPropertyUtility.GetWingPropertyCount(level);
|
var properties = LegendPropertyUtility.GetWingProperties(level);
|
if (properties != null)
|
{
|
for (var i = 0; ids.Count < count && i < properties.Count; i++)
|
{
|
var propertyId = properties[i];
|
ids.Add(propertyId);
|
values.Add(LegendPropertyUtility.GetWingPropertyValues(level, propertyId)[0]);
|
}
|
}
|
}
|
|
private void SetDogzEquipLegendAttrPreview(out List<int> legendIdlist, out List<int> legendValuelist)
|
{
|
legendIdlist = new List<int>();
|
legendValuelist = new List<int>();
|
|
var place = itemConfig.EquipPlace;
|
if (LegendPropertyUtility.HasDogzPlace(place))
|
{
|
var ids = LegendPropertyUtility.GetDogzPlaceProperties(place);
|
for (var i = ids.Count - 1; i >= 0; i--)
|
{
|
if (LegendPropertyUtility.GetDogzPropertyType(ids[i]) == LegendAttrType.Normal)
|
{
|
ids.RemoveAt(i);
|
}
|
}
|
|
legendIdlist.AddRange(ids);
|
}
|
|
for (var i = 0; i < legendIdlist.Count; i++)
|
{
|
var propertyId = legendIdlist[i];
|
var value = LegendPropertyUtility.GetDogzQualityPropertyValue(propertyId, itemConfig.ItemColor);
|
legendValuelist.Add(value);
|
}
|
|
}
|
|
private StringBuilder _extraInfoBuider = new StringBuilder();
|
private StringBuilder _allInfoDesBuider = new StringBuilder();
|
public string GetExtraInfos()
|
{
|
_extraInfoBuider.Length = 0;
|
if (extraInfos == null)
|
return "";
|
|
int i = 0;
|
for (i = 0; i < extraInfos.Length; i++)
|
{
|
_extraInfoBuider.Append(extraInfos[i] + "\n");
|
}
|
return _extraInfoBuider.ToString();
|
}
|
|
public string GetAllInfoDes()
|
{
|
if (itemConfig == null)
|
return "";
|
|
_allInfoDesBuider.Length = 0;
|
_allInfoDesBuider.Append(itemConfig.Description + "\n");
|
_allInfoDesBuider.Append(GetExtraInfos());
|
return _allInfoDesBuider.ToString();
|
}
|
|
/// <summary>
|
/// 设置强化数据
|
/// </summary>
|
//private ItemPlusConfig.ItemPlusData itemPlus;
|
public int StrengthLV { get; private set; }
|
public void SetStrengthData(int lv, int type)
|
{
|
this.StrengthLV = lv;
|
strengthDataDict = null;
|
if (lv <= 0) return;
|
|
strengthDataDict = new Dictionary<int, int>();
|
}
|
|
/// <summary>
|
/// 设置传奇属性数据
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="values"></param>
|
private void SetLegendData(List<int> ids, List<int> values)
|
{
|
legendDataDict = null;
|
if (ids == null || ids.Count < 1) return;
|
|
legendDataDict = new Dictionary<int, int>();
|
int i = 0;
|
for (i = 0; i < ids.Count; i++)
|
{
|
legendDataDict.Add(ids[i], values[i]);
|
}
|
}
|
|
private void SetWingsRefineMat(List<int> ids, List<int> nums)
|
{
|
wingsRefineMatDict = null;
|
if (ids == null || ids.Count < 1) return;
|
|
wingsRefineMatDict = new Dictionary<int, int>();
|
for (int i = 0; i < ids.Count; i++)
|
{
|
wingsRefineMatDict.Add(ids[i], nums[i]);
|
}
|
}
|
|
/// <summary>
|
/// 设置绝版属性数据
|
/// </summary>
|
/// <param name="ids"></param>
|
/// <param name="values"></param>
|
private void SetExhaustedData(List<int> ids, List<int> values)
|
{
|
exhaustedMaxDataDict = null;
|
if (ids == null || ids.Count < 1) return;
|
|
exhaustedMaxDataDict = new Dictionary<int, int>();
|
int i = 0;
|
for (i = 0; i < ids.Count; i++)
|
{
|
exhaustedMaxDataDict.Add(ids[i], values[i]);
|
}
|
}
|
|
//设置弹框的宝石数据
|
public void SetGemModel(params int[] stones)
|
{
|
this.stones = stones;
|
}
|
|
public bool TryGetItemRemainTime(out double remainTime)
|
{
|
ItemCDCool cool = KnapsackTimeCDMgr.Instance.GetItemCoolById(guid);
|
if (cool != null)
|
{
|
remainTime = cool.GetRemainTime();
|
return true;
|
}
|
else
|
{
|
remainTime = itemConfig.ExpireTime;
|
var getTimes = GetUseDataModel((int)ItemUseDataKey.createTime);
|
var serverSurplusTimes = GetUseDataModel((int)ItemUseDataKey.totalTime);
|
if (remainTime > 0)
|
{
|
if (getTimes != null)
|
{
|
int getTime = getTimes[0];
|
int serverSurplusTime = serverSurplusTimes != null ? serverSurplusTimes[0] : 0;
|
if (getTime > 0)
|
{
|
double time = ItemLogicUtility.Instance.GetTimeOffest(TimeUtility.GetTime((uint)getTime));
|
time = time > 0 ? time : 0;
|
remainTime = (serverSurplusTime > 0 ? serverSurplusTime : itemConfig.ExpireTime) - time;
|
}
|
}
|
return true;
|
}
|
|
}
|
return false;
|
}
|
|
#region 预览定制属性逻辑处理
|
|
/// <summary>
|
/// 设置定制属性的数据
|
/// </summary>
|
private void SetCustomAttrData(AppointItemConfig appointItemConfig)
|
{
|
if (appointItemConfig == null)
|
return;
|
|
List<int> legendIdlist = null;
|
List<int> legendValuelist = null;
|
List<int> exhaustedIdlist = null;
|
List<int> exhaustedValuelist = null;
|
int i = 0;
|
if (appointItemConfig.LegendAttrID.Length > 0)
|
{
|
legendIdlist = new List<int>();
|
legendValuelist = new List<int>();
|
for (i = 0; i < appointItemConfig.LegendAttrID.Length; i++)
|
{
|
if (appointItemConfig.LegendAttrID[i] != 0)
|
{
|
legendIdlist.Add(appointItemConfig.LegendAttrID[i]);
|
legendValuelist.Add(appointItemConfig.LegendAttrValue[i]);
|
}
|
}
|
}
|
|
if (appointItemConfig.OutOfPrintAttr.Length > 0)
|
{
|
exhaustedIdlist = new List<int>();
|
exhaustedValuelist = new List<int>();
|
for (i = 0; i < appointItemConfig.OutOfPrintAttr.Length; i++)
|
{
|
if (appointItemConfig.OutOfPrintAttr[i] != 0)
|
{
|
exhaustedIdlist.Add(appointItemConfig.OutOfPrintAttr[i]);
|
exhaustedValuelist.Add(appointItemConfig.OutOfPrintAttrValue[i]);
|
}
|
}
|
}
|
SetLegendData(legendIdlist, legendValuelist);
|
SetExhaustedData(exhaustedIdlist, exhaustedValuelist);
|
|
}
|
#endregion
|
|
public List<int> GetUseDataModel(int key)
|
{
|
List<int> list = null;
|
if (useDataDict != null)
|
{
|
useDataDict.TryGetValue(key, out list);
|
}
|
return list;
|
}
|
|
/// <summary>
|
/// 设置弹框功能按钮
|
/// </summary>
|
/// <param name="type"></param>
|
/// <param name="func"></param>
|
public void SetTipsFuncBtn(ItemOperateType type, Action<ItemOperateType, string> func)
|
{
|
tipsFuncBtnDic.Add(type, func);
|
}
|
|
public void SetGatherSoul(int level, int equipHole, PackType packType = PackType.Deleted, int index = -1)
|
{
|
this.level = level;
|
this.equipHole = equipHole;
|
this.packType = packType;
|
this.index = index;
|
}
|
/// <summary>
|
/// 设置该物品的弹框类型
|
/// </summary>
|
public ItemWinType winType { get; private set; }
|
public void SetWinType()
|
{
|
if (this.itemConfig == null)
|
return;
|
|
switch (this.itemConfig.Template.Trim())
|
{
|
case "ItemInfoPanel":
|
switch (ChildType)
|
{
|
case ItemTipChildType.Normal:
|
winType = ItemWinType.itemWin;
|
break;
|
case ItemTipChildType.Buy:
|
winType = ItemWinType.buyItemWin;
|
break;
|
}
|
break;
|
case "BoxInfoWin":
|
switch (ChildType)
|
{
|
case ItemTipChildType.Normal:
|
winType = ItemWinType.boxWin;
|
break;
|
case ItemTipChildType.Buy:
|
winType = ItemWinType.buyBoxWin;
|
break;
|
}
|
break;
|
case "PetMatInfoWin":
|
switch (ChildType)
|
{
|
case ItemTipChildType.Normal:
|
winType = ItemWinType.petMatWin;
|
break;
|
case ItemTipChildType.Buy:
|
winType = ItemWinType.buyPetMatWin;
|
break;
|
}
|
break;
|
case "EquipPanel":
|
winType = ItemWinType.equipWin;
|
break;
|
case "WingsPanel":
|
winType = ItemWinType.wingsWin;
|
break;
|
case "GuardPanel":
|
winType = ItemWinType.guardWin;
|
break;
|
case "GatherSoul":
|
winType = ItemWinType.gatherSoul;
|
break;
|
case "KingTreasureShow":
|
winType = ItemWinType.kingTreasure;
|
break;
|
default:
|
DebugEx.Log("没有此物品的弹框类型" + this.itemConfig.Template.Trim());
|
break;
|
}
|
}
|
}
|
|
}
|
