//--------------------------------------------------------
|
// [Author]: 第二世界
|
// [ Date ]: Tuesday, March 12, 2019
|
//--------------------------------------------------------
|
using UnityEngine;
|
using System.Collections;
|
using UnityEngine.UI;
|
using System.Collections.Generic;
|
|
namespace Snxxz.UI
|
{
|
[XLua.LuaCallCSharp]
|
public class ItemTipUtility
|
{
|
public enum TipType
|
{
|
Item,
|
Equip,
|
Dogz,
|
GatherSoul,
|
KingTreasure,
|
PetMount,
|
Wing,
|
SpiritWeapon,
|
}
|
|
public class TipData
|
{
|
public string guid;
|
public int itemId;
|
public int goodId;
|
|
public BaseInfo baseInfo;
|
public BaseProperty baseProperty;
|
public BaseProperty petMountBaseProperty;
|
public SpiritWeaponProperty spiritWeaponProperty;
|
public LegendProperty legendProperty;
|
public SkillInfo skillInfo;
|
public SuitInfo suitInfo;
|
public StarInfo starInfo;
|
public StrengthenProperty strengthenProperty;
|
public GemInfo gemInfo;
|
public TrainProperty trainProperty;
|
public List<ItemOperateType> operates;
|
public WingRefineMaterials refineMaterials;
|
public GetWay getWay;
|
public GatherSoulInfo gatherSoul;
|
}
|
|
public struct BaseInfo
|
{
|
public int itemId;
|
public int count;
|
public bool isAuction;
|
public bool isEquiped;
|
public bool isPreview;
|
|
public int star;
|
public int strengthenLevel;
|
public int score;
|
public bool isOverdue;
|
public int auctionSurplusTime;
|
public int overdueSurplusTime;
|
public int levelLimit;
|
public int realmLimit;
|
public int moneyLimit;
|
}
|
|
public struct BaseProperty
|
{
|
public List<Int2> baseProperties;
|
public int star;
|
public List<Int2> starProperties;
|
}
|
|
public struct SpiritWeaponProperty
|
{
|
public List<Int3> properties;
|
}
|
|
public struct LegendProperty
|
{
|
public bool isPreview;
|
public int trueCount;
|
public List<Int2> properties;
|
}
|
|
public struct SuitInfo
|
{
|
public int job;
|
public string name;
|
public int level;
|
public int maxSuitLevel;
|
public List<int> places;
|
public Dictionary<int, int> placeStars;
|
public Dictionary<int, EquipSuitPropertyEntry> twoSuitProperties;
|
public Dictionary<int, EquipSuitPropertyEntry> fiveSuitProperties;
|
public Dictionary<int, bool> eightSuits;
|
}
|
|
public struct StarInfo
|
{
|
public Int2 equipPosition;
|
public int starLevel;
|
public int maxLevel;
|
}
|
|
public struct StrengthenProperty
|
{
|
public int strengthenLevel;
|
public List<Int2> properties;
|
}
|
|
public struct GemInfo
|
{
|
public Dictionary<int, bool> activeStates;
|
public Dictionary<int, int> gems;
|
}
|
|
public struct TrainProperty
|
{
|
public int level;
|
public List<Int2> properties;
|
}
|
|
public struct SkillInfo
|
{
|
public List<int> skills;
|
}
|
|
public struct WingRefineMaterials
|
{
|
public List<Int2> materials;
|
}
|
|
public struct GetWay
|
{
|
public List<int> ways;
|
}
|
|
public struct GatherSoulInfo
|
{
|
public PackType packType;
|
public int index;
|
public int level;
|
}
|
|
public struct CustomEquipInfo
|
{
|
public int job;
|
public int itemId;
|
public int score;
|
public bool isEquiped;
|
public List<Int2> legendProperties;
|
public List<int> suitPlaces;
|
public Dictionary<int, int> placeStars;
|
public Dictionary<EquipSuitType, int> suitLevels;
|
public int strengthenLevel;
|
public int starLevel;
|
public List<Int2> trainProperties;
|
public Dictionary<int, bool> gemHoleActiveStates;
|
public Dictionary<int, int> gems;
|
}
|
|
public struct CustomItemPlus
|
{
|
public int ItemID;
|
public int count;
|
public int Equipped;
|
public int Preview;
|
public int Star;
|
public int PlusLV;
|
public int EvolveLV;
|
public string UserData;
|
public int[] Stone;
|
public CustomEquipWash Wash;
|
public int[][] Equips;
|
public int[] suitPlaces;
|
public int[] suitLevels;
|
public int[] placeStars;
|
}
|
|
public struct CustomEquipWash
|
{
|
public int LV;
|
public int[] Value;
|
}
|
|
static PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
|
static EquipModel equipModel { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }
|
static EquipStarModel starModel { get { return ModelCenter.Instance.GetModel<EquipStarModel>(); } }
|
static EquipGemModel gemModel { get { return ModelCenter.Instance.GetModel<EquipGemModel>(); } }
|
static EquipTrainModel trainModel { get { return ModelCenter.Instance.GetModel<EquipTrainModel>(); } }
|
static EquipStrengthModel strengthenModel { get { return ModelCenter.Instance.GetModel<EquipStrengthModel>(); } }
|
static MountModel mountModel { get { return ModelCenter.Instance.GetModel<MountModel>(); } }
|
static PetModel petModel { get { return ModelCenter.Instance.GetModel<PetModel>(); } }
|
static ComposeWinModel composeModel { get { return ModelCenter.Instance.GetModel<ComposeWinModel>(); } }
|
static StoreModel storeModel { get { return ModelCenter.Instance.GetModel<StoreModel>(); } }
|
static GatheringSoulModel gatherSoulModel { get { return ModelCenter.Instance.GetModel<GatheringSoulModel>(); } }
|
static VirtualPackModel virtualPackModel { get { return ModelCenter.Instance.GetModel<VirtualPackModel>(); } }
|
static GatherSoulComposeModel gatherSoulComposeModel { get { return ModelCenter.Instance.GetModel<GatherSoulComposeModel>(); } }
|
static ItemOverdueModel itemOverdueModel { get { return ModelCenter.Instance.GetModel<ItemOverdueModel>(); } }
|
|
public static TipData mainTipData { get; private set; }
|
public static TipData secondaryData { get; private set; }
|
|
public static void Show(int itemId)
|
{
|
secondaryData = null;
|
|
var config = ItemConfig.Get(itemId);
|
PrintItemBrief(itemId);
|
|
var tipType = GetTipType(itemId);
|
switch (tipType)
|
{
|
case TipType.Equip:
|
mainTipData = CreateNormalEquipData(itemId);
|
break;
|
case TipType.Dogz:
|
mainTipData = CreateDogzEquipData(itemId);
|
break;
|
default:
|
mainTipData = CreateItemData(itemId);
|
break;
|
}
|
|
switch (tipType)
|
{
|
case TipType.Equip:
|
WindowCenter.Instance.Open<EquipTipWin>();
|
break;
|
case TipType.Dogz:
|
WindowCenter.Instance.Open<EquipTipWin>();
|
break;
|
case TipType.GatherSoul:
|
ShowGatherSoul(itemId, 0);
|
break;
|
case TipType.KingTreasure:
|
var kingTreasureShow = ModelCenter.Instance.GetModel<KingTreasureShowModel>();
|
kingTreasureShow.SetInitData(itemId);
|
break;
|
case TipType.PetMount:
|
WindowCenter.Instance.Open<PetMountTipWin>();
|
break;
|
case TipType.Wing:
|
WindowCenter.Instance.Open<WingTipWin>();
|
break;
|
case TipType.SpiritWeapon:
|
WindowCenter.Instance.Open<SpiritWeaponTipWin>();
|
break;
|
default:
|
WindowCenter.Instance.Open<ItemTipWin>();
|
break;
|
}
|
}
|
|
public static void Show(string guid, bool operatable = true)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return;
|
}
|
|
PrintItemBrief(item.itemId, guid);
|
|
secondaryData = null;
|
var tipType = GetTipType(item.itemId);
|
switch (tipType)
|
{
|
case TipType.Equip:
|
var packType = item.packType;
|
switch (packType)
|
{
|
case PackType.Equip:
|
mainTipData = CreateNormalEquipData(guid, operatable);
|
break;
|
default:
|
if (item.isAuction)
|
{
|
mainTipData = CreateEquipAuctionData(guid, operatable);
|
}
|
else
|
{
|
mainTipData = CreateNormalEquipData(guid, operatable);
|
var equipedGuid = equipModel.GetEquip(new Int2(item.config.LV, item.config.EquipPlace));
|
if (equipedGuid != guid)
|
{
|
secondaryData = CreateNormalEquipData(equipedGuid, false);
|
}
|
}
|
break;
|
}
|
break;
|
case TipType.Dogz:
|
mainTipData = CreateDogzEquipData(guid);
|
break;
|
default:
|
mainTipData = CreateItemData(guid, operatable);
|
break;
|
}
|
|
switch (tipType)
|
{
|
case TipType.Equip:
|
WindowCenter.Instance.Open<EquipTipWin>();
|
break;
|
case TipType.Dogz:
|
WindowCenter.Instance.Open<EquipTipWin>();
|
break;
|
case TipType.GatherSoul:
|
ShowGatherSoul(item.itemId, 0);
|
break;
|
case TipType.KingTreasure:
|
var kingTreasureShow = ModelCenter.Instance.GetModel<KingTreasureShowModel>();
|
kingTreasureShow.SetInitData(item.itemId);
|
break;
|
case TipType.PetMount:
|
WindowCenter.Instance.Open<PetMountTipWin>();
|
break;
|
case TipType.Wing:
|
WindowCenter.Instance.Open<WingTipWin>();
|
break;
|
case TipType.SpiritWeapon:
|
WindowCenter.Instance.Open<SpiritWeaponTipWin>();
|
break;
|
default:
|
WindowCenter.Instance.Open<ItemTipWin>();
|
break;
|
}
|
|
}
|
|
public static void ShowGood(int goodId, int itemId)
|
{
|
secondaryData = null;
|
|
var isEquip = ItemLogicUtility.Instance.IsRealmEquip(itemId);
|
if (isEquip)
|
{
|
mainTipData = CreateGoodEquipData(itemId, goodId);
|
}
|
else
|
{
|
mainTipData = CreateGoodItemData(itemId, goodId);
|
}
|
|
BuyItemController.Instance.SetGood(goodId);
|
var itemConfig = ItemConfig.Get(itemId);
|
if (isEquip)
|
{
|
WindowCenter.Instance.Open<EquipTipWin>();
|
}
|
else
|
{
|
switch (itemConfig.Type)
|
{
|
case 26:
|
case 41:
|
case 42:
|
WindowCenter.Instance.Open<PetMountTipWin>();
|
break;
|
case 113:
|
WindowCenter.Instance.Open<WingTipWin>();
|
break;
|
case 114:
|
WindowCenter.Instance.Open<SpiritWeaponTipWin>();
|
break;
|
default:
|
WindowCenter.Instance.Open<ItemTipWin>();
|
break;
|
}
|
}
|
}
|
|
public static void ShowCustomEquip(CustomEquipInfo info)
|
{
|
secondaryData = null;
|
mainTipData = CreateCustomEquipData(info);
|
WindowCenter.Instance.Open<EquipTipWin>();
|
}
|
|
public static void ShowGatherSoul(PackType packType, int index)
|
{
|
if (packType == PackType.GatherSoul || packType == PackType.InterimPack)
|
{
|
mainTipData = CreateGatherSoulData(packType, index);
|
}
|
WindowCenter.Instance.Open<GatherSoulTipWin>();
|
}
|
|
public static void ShowGatherSoul(int itemId, int level)
|
{
|
mainTipData = new TipData()
|
{
|
itemId = itemId,
|
gatherSoul = new GatherSoulInfo()
|
{
|
index = -1,
|
level = level,
|
packType = PackType.Deleted,
|
},
|
};
|
WindowCenter.Instance.Open<GatherSoulTipWin>();
|
}
|
|
static TipData CreateNormalEquipData(string guid, bool operatable)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return default(TipData);
|
}
|
|
return new TipData()
|
{
|
itemId = item.itemId,
|
guid = guid,
|
|
baseInfo = GetBaseInfo(guid),
|
baseProperty = GetBaseProperty(guid),
|
spiritWeaponProperty = GetSpiritWeaponProperty(item.itemId),
|
legendProperty = GetLegendProperty(guid),
|
skillInfo = GetSkillInfo(item.itemId),
|
suitInfo = GetSuitInfo(guid),
|
starInfo = GetStarInfo(guid),
|
strengthenProperty = GetStrengthenProperty(guid),
|
gemInfo = GetGemInfo(guid),
|
trainProperty = GetTrainProperty(guid),
|
operates = operatable ? GetOperates(guid) : null,
|
};
|
}
|
|
static TipData CreateNormalEquipData(int itemId)
|
{
|
return new TipData()
|
{
|
itemId = itemId,
|
guid = string.Empty,
|
|
baseInfo = GetBaseInfo(itemId),
|
baseProperty = GetBaseProperty(itemId),
|
legendProperty = GetLegendProperty(itemId),
|
spiritWeaponProperty = GetSpiritWeaponProperty(itemId),
|
skillInfo = GetSkillInfo(itemId),
|
suitInfo = GetSuitInfo(itemId),
|
gemInfo = GetGemInfo(itemId),
|
starInfo = GetStarInfo(itemId),
|
getWay = GetGetWay(itemId)
|
};
|
}
|
|
static TipData CreateDogzEquipData(string guid)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return default(TipData);
|
}
|
|
return new TipData()
|
{
|
itemId = item.itemId,
|
guid = guid,
|
|
baseInfo = GetBaseInfo(guid),
|
baseProperty = GetBaseProperty(guid),
|
legendProperty = GetLegendProperty(guid),
|
};
|
}
|
|
static TipData CreateDogzEquipData(int itemId)
|
{
|
return new TipData()
|
{
|
itemId = itemId,
|
guid = string.Empty,
|
|
baseInfo = GetBaseInfo(itemId),
|
baseProperty = GetBaseProperty(itemId),
|
legendProperty = GetLegendProperty(itemId),
|
getWay = GetGetWay(itemId)
|
};
|
}
|
|
static TipData CreateCustomEquipData(CustomEquipInfo info)
|
{
|
var config = ItemConfig.Get(info.itemId);
|
var baseInfo = new BaseInfo()
|
{
|
itemId = info.itemId,
|
star = info.starLevel,
|
strengthenLevel = info.strengthenLevel,
|
score = info.score,
|
isEquiped = info.isEquiped,
|
};
|
|
var baseProperty = GetBaseProperty(info.itemId);
|
if (info.starLevel > 0)
|
{
|
var starProperties = new List<Int2>();
|
baseProperty.star = info.starLevel;
|
var starConfig = EquipStarConfig.Get(config.LV, config.EquipPlace, info.starLevel);
|
starProperties.AddRange(starConfig.BaseAttrInfo);
|
baseProperty.starProperties = starProperties;
|
}
|
|
var legendProperty = new LegendProperty()
|
{
|
properties = info.legendProperties,
|
};
|
|
var skillInfo = GetSkillInfo(info.itemId);
|
|
var job = config.JobLimit;
|
var twoConfigs = EquipSuitConfig.GetConfigs(job, config.LV, EquipSuitType.TwoSuit);
|
var name = twoConfigs[0].name;
|
var level = config.LV;
|
var maxSuitLevel = EquipStarModel.GetMaxStarLevel(level);
|
|
var twoSuitProperties = new Dictionary<int, EquipSuitPropertyEntry>();
|
var fiveSuitProperties = new Dictionary<int, EquipSuitPropertyEntry>();
|
var eightSuits = new Dictionary<int, bool>();
|
var eightSuitLevel = info.suitLevels[EquipSuitType.EightSuit];
|
|
for (var i = 0; i <= 9; i++, i++, i++)
|
{
|
var configs = EquipSuitConfig.GetConfigs(job, level, EquipSuitType.TwoSuit);
|
var actived = info.suitLevels[EquipSuitType.TwoSuit] >= i;
|
var properties = new List<Int2>();
|
foreach (var item in configs)
|
{
|
if (item.star == i)
|
{
|
properties.AddRange(item.attr);
|
break;
|
}
|
}
|
|
twoSuitProperties[i] = new EquipSuitPropertyEntry()
|
{
|
type = EquipSuitType.TwoSuit,
|
actived = actived,
|
properties = properties,
|
};
|
|
configs = EquipSuitConfig.GetConfigs(job, level, EquipSuitType.FiveSuit);
|
actived = info.suitLevels[EquipSuitType.FiveSuit] >= i;
|
properties = new List<Int2>();
|
foreach (var item in configs)
|
{
|
if (item.star == i)
|
{
|
properties.AddRange(item.attr);
|
break;
|
}
|
}
|
|
fiveSuitProperties[i] = new EquipSuitPropertyEntry()
|
{
|
type = EquipSuitType.TwoSuit,
|
actived = actived,
|
properties = properties,
|
};
|
|
eightSuits[i] = eightSuitLevel >= i;
|
}
|
|
var suitInfo = new SuitInfo()
|
{
|
name = name,
|
level = level,
|
job = job,
|
maxSuitLevel = maxSuitLevel,
|
places = info.suitPlaces,
|
placeStars=info.placeStars,
|
twoSuitProperties = twoSuitProperties,
|
fiveSuitProperties = fiveSuitProperties,
|
eightSuits = eightSuits
|
};
|
|
var starInfo = new StarInfo()
|
{
|
equipPosition = new Int2(config.LV, config.EquipPlace),
|
starLevel = info.starLevel,
|
maxLevel = EquipStarModel.GetMaxStarLevel(config.ItemColor, config.LV),
|
};
|
|
var type = EquipStrengthModel.GetEquipStrengthType(config.EquipPlace);
|
var strengthenConfig = ItemPlusConfig.GetTypeAndLevel(type, info.strengthenLevel);
|
var strengthenProperties = new List<Int2>();
|
for (int i = 0; i < strengthenConfig.attType.Length; i++)
|
{
|
strengthenProperties.Add(new Int2(strengthenConfig.attType[i], strengthenConfig.attValue[i]));
|
}
|
var strengthenProperty = new StrengthenProperty()
|
{
|
strengthenLevel = info.strengthenLevel,
|
properties = strengthenProperties
|
};
|
|
var gemInfo = new GemInfo()
|
{
|
activeStates = info.gemHoleActiveStates,
|
gems = info.gems,
|
};
|
|
var trainProperty = new TrainProperty()
|
{
|
properties = info.trainProperties,
|
};
|
|
return new TipData()
|
{
|
itemId = info.itemId,
|
baseInfo = baseInfo,
|
baseProperty = baseProperty,
|
legendProperty = legendProperty,
|
skillInfo = skillInfo,
|
suitInfo = suitInfo,
|
starInfo = starInfo,
|
strengthenProperty = strengthenProperty,
|
gemInfo = gemInfo,
|
trainProperty = trainProperty,
|
};
|
}
|
|
static TipData CreateGoodEquipData(int itemId, int goodId)
|
{
|
return new TipData()
|
{
|
itemId = itemId,
|
guid = string.Empty,
|
goodId = goodId,
|
|
baseInfo = GetBaseInfo(itemId),
|
baseProperty = GetBaseProperty(itemId),
|
spiritWeaponProperty = GetSpiritWeaponProperty(itemId),
|
legendProperty = GetLegendProperty(itemId),
|
skillInfo = GetSkillInfo(itemId),
|
suitInfo = GetSuitInfo(itemId),
|
gemInfo = GetGemInfo(itemId),
|
starInfo = GetStarInfo(itemId),
|
operates = GetGoodOperates(goodId)
|
};
|
}
|
|
static TipData CreateEquipAuctionData(string guid, bool operatable)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return default(TipData);
|
}
|
|
return new TipData()
|
{
|
itemId = item.itemId,
|
guid = guid,
|
|
baseInfo = GetBaseInfo(guid),
|
baseProperty = GetBaseProperty(item.itemId),
|
spiritWeaponProperty = GetSpiritWeaponProperty(item.itemId),
|
legendProperty = GetLegendProperty(item.itemId),
|
skillInfo = GetSkillInfo(item.itemId),
|
suitInfo = GetSuitInfo(item.itemId),
|
operates = operatable ? GetOperates(guid) : null,
|
};
|
}
|
|
static TipData CreateItemData(string guid, bool operatable)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return default(TipData);
|
}
|
|
return new TipData()
|
{
|
itemId = item.itemId,
|
guid = guid,
|
|
baseInfo = GetBaseInfo(guid),
|
baseProperty = GetBaseProperty(item.itemId),
|
spiritWeaponProperty = GetSpiritWeaponProperty(item.itemId),
|
legendProperty = GetLegendProperty(guid),
|
petMountBaseProperty = GetPetMountBaseProperty(item.itemId),
|
operates = operatable ? GetOperates(guid) : null,
|
refineMaterials = GetWingRefineMaterials(guid),
|
};
|
}
|
|
static TipData CreateItemData(int itemId)
|
{
|
return new TipData()
|
{
|
itemId = itemId,
|
baseInfo = GetBaseInfo(itemId),
|
baseProperty = GetBaseProperty(itemId),
|
spiritWeaponProperty = GetSpiritWeaponProperty(itemId),
|
legendProperty = GetLegendProperty(itemId),
|
petMountBaseProperty = GetPetMountBaseProperty(itemId),
|
getWay = GetGetWay(itemId),
|
};
|
}
|
|
static TipData CreateGoodItemData(int itemId, int goodId)
|
{
|
return new TipData()
|
{
|
itemId = itemId,
|
goodId = goodId,
|
baseInfo = GetBaseInfo(itemId),
|
baseProperty = GetBaseProperty(itemId),
|
legendProperty = GetLegendProperty(itemId),
|
petMountBaseProperty = GetPetMountBaseProperty(itemId),
|
operates = GetGoodOperates(goodId),
|
};
|
}
|
|
static TipData CreateGatherSoulData(PackType packType, int index)
|
{
|
GatherSoulItem soulItem;
|
if (packType == PackType.GatherSoul)
|
{
|
virtualPackModel.TryGetItem(PackType.GatherSoul, index, out soulItem);
|
}
|
else
|
{
|
gatherSoulModel.TryGetItem(index, out soulItem);
|
}
|
return new TipData()
|
{
|
itemId = soulItem.id,
|
gatherSoul = new GatherSoulInfo()
|
{
|
packType = packType,
|
level = soulItem.level,
|
index = soulItem.index,
|
},
|
operates = GetGatherSoulOperates(packType, index),
|
};
|
}
|
|
public static void Operate(ItemOperateType type, string guid)
|
{
|
switch (type)
|
{
|
case ItemOperateType.putOn:
|
ItemOperateUtility.Instance.PutOnItem(guid);
|
break;
|
case ItemOperateType.gotoPuton:
|
ItemOperateUtility.Instance.GotoPutOnEquip(guid);
|
break;
|
case ItemOperateType.putOff:
|
ItemOperateUtility.Instance.PutOffEquip(guid);
|
break;
|
case ItemOperateType.putAway:
|
ItemOperateUtility.Instance.PutAway(guid);
|
break;
|
case ItemOperateType.putIn:
|
ItemOperateUtility.Instance.PutInWareHouse(guid);
|
break;
|
case ItemOperateType.putOut:
|
ItemOperateUtility.Instance.TakeOutFromWarehouse(guid);
|
break;
|
case ItemOperateType.sell:
|
ItemOperateUtility.Instance.SellItem(guid);
|
break;
|
case ItemOperateType.strength:
|
ItemOperateUtility.Instance.GotoStrengthen(guid);
|
break;
|
case ItemOperateType.star:
|
ItemOperateUtility.Instance.GotoStarUpgrade(guid);
|
break;
|
case ItemOperateType.inlay:
|
ItemOperateUtility.Instance.GotoInlayItem(guid);
|
break;
|
case ItemOperateType.train:
|
ItemOperateUtility.Instance.GotoTrain(guid);
|
break;
|
case ItemOperateType.makeUse:
|
ItemOperateUtility.Instance.GotoUseItem(guid);
|
break;
|
case ItemOperateType.split:
|
ItemOperateUtility.Instance.OnClickSplitBtn(guid);
|
break;
|
case ItemOperateType.compose:
|
var wannaComposeItem = packModel.GetItemByGuid(guid);
|
var jumpId = 0;
|
var isUnlock = composeModel.CheckComposeItemById(wannaComposeItem.itemId, out jumpId);
|
if (isUnlock)
|
{
|
ItemOperateUtility.Instance.GotoComposeItem(jumpId);
|
}
|
break;
|
case ItemOperateType.renewal:
|
ItemOperateUtility.Instance.RenewalItem(guid);
|
break;
|
}
|
}
|
|
public static void GoodOperate(ItemOperateType type, int goodId, int count)
|
{
|
var config = StoreConfig.Get(goodId);
|
storeModel.SendBuyShopItem(config, count);
|
}
|
|
public static void GatherSoulOperate(ItemOperateType type)
|
{
|
if (mainTipData == null)
|
{
|
WindowCenter.Instance.Close<GatherSoulTipWin>();
|
return;
|
}
|
if (mainTipData.gatherSoul.packType == PackType.GatherSoul)
|
{
|
GatherSoulItem item;
|
if (!virtualPackModel.TryGetItem(mainTipData.gatherSoul.packType,
|
mainTipData.gatherSoul.index, out item))
|
{
|
WindowCenter.Instance.Close<GatherSoulTipWin>();
|
return;
|
}
|
gatherSoulModel.HandleSoulTipFunc(type, item);
|
}
|
else if (mainTipData.gatherSoul.packType == PackType.InterimPack)
|
{
|
GatherSoulItem item;
|
if (!gatherSoulModel.TryGetItem(mainTipData.gatherSoul.index, out item))
|
{
|
return;
|
}
|
switch (type)
|
{
|
case ItemOperateType.compose:
|
{
|
gatherSoulModel.HandleSoulTipFunc(type, item);
|
}
|
break;
|
case ItemOperateType.putOff:
|
{
|
WindowCenter.Instance.Close<GatherSoulTipWin>();
|
gatherSoulModel.ExecutePutOffSoul(item);
|
}
|
break;
|
case ItemOperateType.LevelUp:
|
WindowCenter.Instance.Close<GatherSoulTipWin>();
|
GatherSoulLevelUpWin.selectHole = item.index;
|
WindowCenter.Instance.Open<GatherSoulLevelUpWin>();
|
break;
|
case ItemOperateType.Replace:
|
WindowCenter.Instance.Close<GatherSoulTipWin>();
|
GatherSoulEquipListWin.selectHole = item.index;
|
WindowCenter.Instance.Open<GatherSoulEquipListWin>();
|
break;
|
}
|
}
|
}
|
|
private static BaseInfo GetBaseInfo(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
var money = 0;
|
if (config.Type == 81)
|
{
|
var chestConfig = ChestsConfig.Get(itemId);
|
money = chestConfig.OpenMoney;
|
}
|
|
var baseInfo = new BaseInfo()
|
{
|
itemId = itemId,
|
isAuction = false,
|
isEquiped = false,
|
isPreview = true,
|
score = ItemLogicUtility.Instance.GetEquipScore(PackType.Item, itemId, null, true),
|
auctionSurplusTime = 0,
|
levelLimit = config.UseLV,
|
realmLimit = config.RealmLimit,
|
moneyLimit = money,
|
};
|
|
return baseInfo;
|
}
|
|
private static BaseInfo GetBaseInfo(string guid)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
|
var level = item.config.LV;
|
var place = item.config.EquipPlace;
|
|
var isEquiped = equipModel.GetEquip(new Int2(level, place)) == guid;
|
|
var type = EquipStrengthModel.GetEquipStrengthType(place);
|
var star = starModel.GetEquipStarLevel(new Int2(level, place));
|
var maxStar = EquipStarModel.GetMaxStarLevel(item.config.ItemColor, level);
|
var maxStrengthenLevel = strengthenModel.GetEquipLevelMax(type, Mathf.Min(star, maxStar));
|
var placeStrengthenLevel = strengthenModel.GetStrengthLevel(level, place);
|
|
var money = 0;
|
if (item.config.Type == 81)
|
{
|
var chestConfig = ChestsConfig.Get(item.itemId);
|
money = chestConfig.OpenMoney;
|
}
|
|
var baseInfo = new BaseInfo()
|
{
|
itemId = item.itemId,
|
count = item.count,
|
isAuction = item.isAuction,
|
isEquiped = isEquiped,
|
isPreview = false,
|
score = item.score,
|
isOverdue = ItemLogicUtility.Instance.IsOverdue(guid),
|
auctionSurplusTime = item.isAuction ? item.auctionSurplusTime : 0,
|
overdueSurplusTime = item.overdueSurplusTime,
|
levelLimit = item.isAuction ? 0 : item.config.UseLV,
|
realmLimit = item.isAuction ? 0 : item.config.RealmLimit,
|
star = isEquiped ? star : -1,
|
strengthenLevel = isEquiped ? Mathf.Min(placeStrengthenLevel, maxStrengthenLevel) : 0,
|
moneyLimit = money,
|
};
|
|
return baseInfo;
|
}
|
|
private static BaseProperty GetBaseProperty(int itemId)
|
{
|
var baseProperties = new List<Int2>();
|
var config = ItemConfig.Get(itemId);
|
|
if (config.Effect1 == 220)
|
{
|
return GetBaseProperty(config.EffectValueA1);
|
}
|
|
if (!ItemLogicUtility.Instance.IsDogzEquip(itemId))
|
{
|
if (config.Effect1 != 0)
|
{
|
baseProperties.Add(new Int2(config.Effect1, config.EffectValueA1));
|
}
|
}
|
|
if (config.Effect2 != 0)
|
{
|
baseProperties.Add(new Int2(config.Effect2, config.EffectValueA2));
|
}
|
|
if (config.Effect3 != 0)
|
{
|
baseProperties.Add(new Int2(config.Effect3, config.EffectValueA3));
|
}
|
|
if (config.Effect4 != 0)
|
{
|
baseProperties.Add(new Int2(config.Effect4, config.EffectValueA4));
|
}
|
|
if (config.Effect5 != 0)
|
{
|
baseProperties.Add(new Int2(config.Effect5, config.EffectValueA5));
|
}
|
|
var baseProperty = new BaseProperty()
|
{
|
baseProperties = baseProperties,
|
};
|
|
return baseProperty;
|
}
|
|
private static BaseProperty GetBaseProperty(string guid)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
var equipPosition = new Int2(item.config.LV, item.config.EquipPlace);
|
var equiped = equipModel.GetEquip(equipPosition) == guid;
|
|
var baseProperty = GetBaseProperty(item.itemId);
|
|
if (equiped)
|
{
|
var starProperties = new List<Int2>();
|
var currentStar = starModel.GetEquipStarLevel(equipPosition);
|
var maxStar = EquipStarModel.GetMaxStarLevel(item.config.ItemColor, item.config.LV);
|
var star = Mathf.Min(currentStar, maxStar);
|
if (star > 0)
|
{
|
baseProperty.star = star;
|
var starConfig = EquipStarConfig.Get(item.config.LV, item.config.EquipPlace, star);
|
starProperties.AddRange(starConfig.BaseAttrInfo);
|
}
|
|
baseProperty.starProperties = starProperties;
|
}
|
|
return baseProperty;
|
}
|
|
private static BaseProperty GetPetMountBaseProperty(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
var baseProperty = new BaseProperty();
|
Dictionary<int, int> properties = null;
|
switch (config.Type)
|
{
|
case 26:
|
var petId = PetInfoConfig.GetItemUnLockPet(itemId);
|
properties = petModel.GetPetAttrAddDict(petId);
|
break;
|
case 41:
|
case 42:
|
var horseId = HorseConfig.GetItemUnLockHorse(itemId);
|
properties = mountModel.GetMountAttrAddDict(horseId);
|
break;
|
default:
|
break;
|
}
|
|
if (properties != null)
|
{
|
baseProperty.baseProperties = new List<Int2>();
|
foreach (var property in properties)
|
{
|
baseProperty.baseProperties.Add(new Int2(property.Key, property.Value));
|
}
|
}
|
|
return baseProperty;
|
}
|
|
private static LegendProperty GetLegendProperty(int itemId)
|
{
|
var data = new LegendProperty();
|
data.isPreview = true;
|
|
var config = ItemConfig.Get(itemId);
|
switch (config.Type)
|
{
|
case 119:
|
case 120:
|
case 121:
|
case 122:
|
case 123:
|
data.trueCount = LegendPropertyUtility.GetDogzPropertyCount(config.ItemColor, config.StarLevel, LegendAttrType.Normal);
|
data.properties = new List<Int2>();
|
var keys = LegendPropertyUtility.GetDogzPlaceProperties(config.EquipPlace);
|
foreach (var key in keys)
|
{
|
var value = LegendPropertyUtility.GetDogzQualityPropertyValue(key, config.ItemColor);
|
data.properties.Add(new Int2(key, value));
|
}
|
break;
|
default:
|
if (config.Effect1 == 220)
|
{
|
data.isPreview = false;
|
var appConfig = AppointItemConfig.Get(itemId);
|
data.trueCount = 0;
|
|
data.properties = new List<Int2>();
|
for (var i = 0; i < appConfig.LegendAttrID.Length; i++)
|
{
|
data.properties.Add(new Int2(appConfig.LegendAttrID[i], appConfig.LegendAttrValue[i]));
|
}
|
}
|
else
|
{
|
data.trueCount = LegendPropertyUtility.GetEquipPropertyCount(itemId);
|
data.properties = LegendPropertyUtility.GetEquipProperties(itemId);
|
}
|
break;
|
}
|
|
return data;
|
}
|
|
private static SpiritWeaponProperty GetSpiritWeaponProperty(int itemId)
|
{
|
var config = SpiritWeaponPropertyConfig.Get(itemId);
|
if (config == null)
|
{
|
return default(SpiritWeaponProperty);
|
}
|
|
var properties = new List<Int3>();
|
for (var i = 0; i < config.AttrIDList.Length; i++)
|
{
|
properties.Add(new Int3(config.AttrIDList[i], config.AttrValueList[i], config.AttrColorList[i]));
|
}
|
|
var spiritWeaponProperty = new SpiritWeaponProperty();
|
spiritWeaponProperty.properties = properties;
|
return spiritWeaponProperty;
|
}
|
|
private static LegendProperty GetLegendProperty(string guid)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return default(LegendProperty);
|
}
|
|
var data = new LegendProperty();
|
data.isPreview = false;
|
|
var ids = item.GetUseData(17);
|
var values = item.GetUseData(19);
|
if (!ids.IsNullOrEmpty() && !values.IsNullOrEmpty())
|
{
|
var properties = new List<Int2>();
|
var count = Mathf.Min(ids.Count, values.Count);
|
for (int i = 0; i < count; i++)
|
{
|
properties.Add(new Int2(ids[i], values[i]));
|
}
|
|
data.properties = properties;
|
}
|
|
return data;
|
}
|
|
private static SuitInfo GetSuitInfo(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
if (config == null || config.SuiteiD <= 0)
|
{
|
return default(SuitInfo);
|
}
|
|
var job = config.JobLimit;
|
var twoConfigs = EquipSuitConfig.GetConfigs(job, config.LV, EquipSuitType.TwoSuit);
|
|
var name = twoConfigs[0].name;
|
var level = config.LV;
|
var places = new List<int>();
|
places.Add(config.EquipPlace);
|
var suitInfo = new SuitInfo()
|
{
|
name = name,
|
level = level,
|
job = job,
|
places = places,
|
};
|
|
return suitInfo;
|
}
|
|
private static SuitInfo GetSuitInfo(string guid)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return default(SuitInfo);
|
}
|
|
var config = ItemConfig.Get(item.itemId);
|
if (config == null || config.SuiteiD <= 0)
|
{
|
return default(SuitInfo);
|
}
|
|
var equipPosition = new Int2(item.config.LV, item.config.EquipPlace);
|
var equiped = equipModel.GetEquip(equipPosition) == guid;
|
|
var job = config.JobLimit;
|
var twoConfigs = EquipSuitConfig.GetConfigs(job, config.LV, EquipSuitType.TwoSuit);
|
var name = twoConfigs[0].name;
|
|
var level = config.LV;
|
var maxSuitLevel = equiped ? EquipStarModel.GetMaxStarLevel(level) : -1;
|
|
var places = new List<int>();
|
var placeStars = new Dictionary<int, int>();
|
if (equiped)
|
{
|
for (int i = 1; i <= 8; i++)
|
{
|
var equip = packModel.GetItemByGuid(equipModel.GetEquip(new Int2(level, i)));
|
var hasSuit = equip != null && equip.config.SuiteiD > 0;
|
if (hasSuit)
|
{
|
places.Add(i);
|
placeStars[i] = starModel.GetEquipStarLevel(new Int2(level, i));
|
}
|
}
|
}
|
|
var twoSuitProperties = new Dictionary<int, EquipSuitPropertyEntry>();
|
var fiveSuitProperties = new Dictionary<int, EquipSuitPropertyEntry>();
|
var eightSuits = new Dictionary<int, bool>();
|
var eightSuitLevel = equiped ? equipModel.GetSuitLevel(config.LV, EquipSuitType.EightSuit) : -1;
|
|
var twoSuitProperties0 = equipModel.GetEquipSuitEntry(config.LV, 0, EquipSuitType.TwoSuit);
|
var fiveSuitProperties0 = equipModel.GetEquipSuitEntry(config.LV, 0, EquipSuitType.FiveSuit);
|
|
if (!equiped)
|
{
|
twoSuitProperties0.actived = false;
|
fiveSuitProperties0.actived = false;
|
}
|
|
twoSuitProperties[0] = twoSuitProperties0;
|
fiveSuitProperties[0] = fiveSuitProperties0;
|
eightSuits[0] = eightSuitLevel >= 0;
|
|
if (maxSuitLevel >= 3)
|
{
|
twoSuitProperties[3] = equipModel.GetEquipSuitEntry(config.LV, 3, EquipSuitType.TwoSuit);
|
fiveSuitProperties[3] = equipModel.GetEquipSuitEntry(config.LV, 3, EquipSuitType.FiveSuit);
|
eightSuits[3] = eightSuitLevel >= 3;
|
}
|
|
if (maxSuitLevel >= 6)
|
{
|
twoSuitProperties[6] = equipModel.GetEquipSuitEntry(config.LV, 6, EquipSuitType.TwoSuit);
|
fiveSuitProperties[6] = equipModel.GetEquipSuitEntry(config.LV, 6, EquipSuitType.FiveSuit);
|
eightSuits[6] = eightSuitLevel >= 3;
|
}
|
|
if (maxSuitLevel >= 9)
|
{
|
twoSuitProperties[9] = equipModel.GetEquipSuitEntry(config.LV, 9, EquipSuitType.TwoSuit);
|
fiveSuitProperties[9] = equipModel.GetEquipSuitEntry(config.LV, 9, EquipSuitType.FiveSuit);
|
eightSuits[9] = eightSuitLevel >= 9;
|
}
|
|
var suitInfo = new SuitInfo()
|
{
|
name = name,
|
level = level,
|
job = job,
|
maxSuitLevel = maxSuitLevel,
|
places = places,
|
placeStars = placeStars,
|
twoSuitProperties = twoSuitProperties,
|
fiveSuitProperties = fiveSuitProperties,
|
eightSuits = eightSuits
|
};
|
|
return suitInfo;
|
}
|
|
private static StarInfo GetStarInfo(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
if (!EquipModel.IsRealmEquip(config.EquipPlace))
|
{
|
return default(StarInfo);
|
}
|
|
var starInfo = new StarInfo();
|
starInfo.equipPosition = new Int2(config.LV, config.EquipPlace);
|
starInfo.maxLevel = EquipStarModel.GetMaxStarLevel(config.ItemColor, config.LV);
|
starInfo.starLevel = 0;
|
|
return starInfo;
|
}
|
|
private static StarInfo GetStarInfo(string guid)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return default(StarInfo);
|
}
|
|
if (!EquipModel.IsRealmEquip(item.config.EquipPlace))
|
{
|
return default(StarInfo);
|
}
|
|
var starInfo = new StarInfo();
|
var equipPosition = new Int2(item.config.LV, item.config.EquipPlace);
|
var equiped = equipModel.GetEquip(equipPosition) == guid;
|
starInfo.equipPosition = equipPosition;
|
starInfo.maxLevel = EquipStarModel.GetMaxStarLevel(item.config.ItemColor, item.config.LV);
|
starInfo.starLevel = equiped ? starModel.GetStarLevel(equipPosition) : 0;
|
|
return starInfo;
|
}
|
|
private static StrengthenProperty GetStrengthenProperty(string guid)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return default(StrengthenProperty);
|
}
|
|
var level = item.config.LV;
|
var place = item.config.EquipPlace;
|
var equiped = equipModel.GetEquip(new Int2(level, place)) == guid;
|
if (!equiped)
|
{
|
return default(StrengthenProperty);
|
}
|
|
var data = new StrengthenProperty();
|
|
var strengthenLevel = strengthenModel.GetStrengthLevel(level, place);
|
var type = EquipStrengthModel.GetEquipStrengthType(place);
|
var star = starModel.GetEquipStarLevel(new Int2(level, place));
|
var maxStar = EquipStarModel.GetMaxStarLevel(item.config.ItemColor, item.config.LV);
|
var maxStrengthenLevel = strengthenModel.GetEquipLevelMax(type, Mathf.Min(star, maxStar));
|
|
data.strengthenLevel = Mathf.Min(strengthenLevel, maxStrengthenLevel);
|
|
data.properties = new List<Int2>();
|
var config = ItemPlusConfig.GetTypeAndLevel(type, data.strengthenLevel);
|
for (int i = 0; i < config.attType.Length; i++)
|
{
|
data.properties.Add(new Int2(config.attType[i], config.attValue[i]));
|
}
|
|
return data;
|
}
|
|
private static GemInfo GetGemInfo(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
var level = config.LV;
|
var place = config.EquipPlace;
|
|
var gemInfo = new GemInfo();
|
var maxStar = EquipStarModel.GetMaxStarLevel(config.ItemColor, config.LV);
|
gemInfo.activeStates = new Dictionary<int, bool>();
|
for (int i = 0; i < 4; i++)
|
{
|
gemInfo.activeStates[i] = IsEquipGemHoleOpen(new Int2(level, place), maxStar, i);
|
}
|
|
return gemInfo;
|
}
|
|
private static GemInfo GetGemInfo(string guid)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return default(GemInfo);
|
}
|
|
var level = item.config.LV;
|
var place = item.config.EquipPlace;
|
|
var gemInfo = new GemInfo();
|
var maxStar = EquipStarModel.GetMaxStarLevel(item.config.ItemColor, item.config.LV);
|
gemInfo.activeStates = new Dictionary<int, bool>();
|
for (int i = 0; i < 4; i++)
|
{
|
gemInfo.activeStates[i] = IsEquipGemHoleOpen(new Int2(level, place), maxStar, i);
|
}
|
|
gemInfo.gems = new Dictionary<int, int>();
|
if (item.packType == PackType.Equip)
|
{
|
int[] gems;
|
if (gemModel.TryGetEquipGems(item.config.LV, item.config.EquipPlace, out gems))
|
{
|
for (int i = 0; i < gems.Length; i++)
|
{
|
gemInfo.gems[i] = gems[i];
|
}
|
}
|
}
|
|
return gemInfo;
|
}
|
|
private static TrainProperty GetTrainProperty(string guid)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return default(TrainProperty);
|
}
|
|
var equipPosition = new Int2(item.config.LV, item.config.EquipPlace);
|
var equiped = equipModel.GetEquip(equipPosition) == guid;
|
if (!equiped)
|
{
|
return default(TrainProperty);
|
}
|
|
var trainProperty = new TrainProperty();
|
var star = Mathf.Min(EquipStarModel.GetMaxStarLevel(item.config.ItemColor, item.config.LV), starModel.GetEquipStarLevel(equipPosition));
|
var type = EquipTrainModel.GetTrainType(equipPosition.y);
|
var maxConfig = WashLevelMaxConfig.Get(type, star);
|
var maxLevel = maxConfig == null ? 1 : maxConfig.levelMax;
|
var trainLevel = Mathf.Min(maxLevel, trainModel.GetTrainLevel(equipPosition));
|
trainProperty.level = trainLevel;
|
|
var trainConfig = EquipWashConfig.Get(type, trainLevel);
|
trainProperty.properties = new List<Int2>();
|
|
if (trainConfig == null)
|
{
|
var trainConfigLevel1 = EquipWashConfig.Get(type, 1);
|
trainProperty.properties.Add(new Int2(trainConfigLevel1.config.attType1, 0));
|
trainProperty.properties.Add(new Int2(trainConfigLevel1.config.attType2, 0));
|
trainProperty.properties.Add(new Int2(trainConfigLevel1.config.attType3, 0));
|
}
|
else
|
{
|
var trainedProperties = trainModel.GetTrainedProperties(equipPosition);
|
trainProperty.properties.Add(new Int2(trainConfig.config.attType1, Mathf.Min(trainedProperties.x, trainConfig.config.attMax1)));
|
trainProperty.properties.Add(new Int2(trainConfig.config.attType2, Mathf.Min(trainedProperties.y, trainConfig.config.attMax2)));
|
trainProperty.properties.Add(new Int2(trainConfig.config.attType3, Mathf.Min(trainedProperties.z, trainConfig.config.attMax3)));
|
}
|
|
return trainProperty;
|
}
|
|
private static SkillInfo GetSkillInfo(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
if (config == null)
|
{
|
return default(SkillInfo);
|
}
|
|
var skillInfo = new SkillInfo();
|
skillInfo.skills = new List<int>();
|
|
if (config.AddSkill1 != 0)
|
{
|
skillInfo.skills.Add(config.AddSkill1);
|
}
|
|
if (config.AddSkill2 != 0)
|
{
|
skillInfo.skills.Add(config.AddSkill2);
|
}
|
|
return skillInfo;
|
}
|
|
private static WingRefineMaterials GetWingRefineMaterials(string guid)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return default(WingRefineMaterials);
|
}
|
|
if (item.config.Type != 113)
|
{
|
return default(WingRefineMaterials);
|
}
|
|
var refineMaterials = new WingRefineMaterials();
|
refineMaterials.materials = new List<Int2>();
|
|
var ids = item.GetUseData((int)ItemUseDataKey.wingMaterialItemID);
|
var values = item.GetUseData((int)ItemUseDataKey.wingMaterialItemCount);
|
if (!ids.IsNullOrEmpty() && !values.IsNullOrEmpty())
|
{
|
var min = Mathf.Min(ids.Count, values.Count);
|
for (int i = 0; i < min; i++)
|
{
|
refineMaterials.materials.Add(new Int2(ids[i], values[i]));
|
}
|
}
|
|
return refineMaterials;
|
}
|
|
private static GetWay GetGetWay(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
var getWay = new GetWay();
|
getWay.ways = new List<int>();
|
foreach (var way in config.GetWay)
|
{
|
var wayConfig = GetItemWaysConfig.Get(way);
|
if (wayConfig.FuncOpenId == 0 || FuncOpen.Instance.IsFuncOpen(wayConfig.FuncOpenId))
|
{
|
if (wayConfig.ActiveType == -1 || OpenServerActivityCenter.Instance.IsActivityOpen(wayConfig.ActiveType))
|
{
|
getWay.ways.Add(way);
|
}
|
}
|
}
|
|
return getWay;
|
}
|
|
private static List<ItemOperateType> GetOperates(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
var operates = new List<ItemOperateType>();
|
if (config.CanSell == 1)
|
{
|
operates.Add(ItemOperateType.sell);
|
}
|
|
if (config.UseTag == 1)
|
{
|
operates.Add(ItemOperateType.makeUse);
|
}
|
|
if (config.Type == 25 || config.Effect1 == 225)
|
{
|
operates.Add(ItemOperateType.inlay);
|
}
|
|
if (!config.JumpComposeCondi.IsNullOrEmpty())
|
{
|
var jumpId = 0;
|
if (composeModel.CheckComposeItemById(itemId, out jumpId))
|
{
|
operates.Add(ItemOperateType.compose);
|
}
|
}
|
|
return operates;
|
}
|
|
private static List<ItemOperateType> GetOperates(string guid)
|
{
|
var item = packModel.GetItemByGuid(guid);
|
if (item == null)
|
{
|
return null;
|
}
|
|
var operates = new List<ItemOperateType>();
|
|
var packType = item.packType;
|
if (WindowCenter.Instance.IsOpen("DepotWin"))
|
{
|
switch (packType)
|
{
|
case PackType.Warehouse:
|
operates.Add(ItemOperateType.putOut);
|
break;
|
default:
|
operates.Add(ItemOperateType.putIn);
|
break;
|
}
|
|
return operates;
|
}
|
|
if (packType == PackType.Equip)
|
{
|
if (WindowCenter.Instance.IsOpen("RealmEquipWin"))
|
{
|
operates.Add(ItemOperateType.putOff);
|
|
if (FuncOpen.Instance.IsFuncOpen(1))
|
{
|
operates.Add(ItemOperateType.strength);
|
}
|
|
if (FuncOpen.Instance.IsFuncOpen(172))
|
{
|
operates.Add(ItemOperateType.star);
|
}
|
|
if (FuncOpen.Instance.IsFuncOpen(2))
|
{
|
operates.Add(ItemOperateType.inlay);
|
}
|
|
if (FuncOpen.Instance.IsFuncOpen(91))
|
{
|
operates.Add(ItemOperateType.train);
|
}
|
|
return operates;
|
}
|
|
if (WindowCenter.Instance.IsOpen("RoleEquipWin"))
|
{
|
operates.Add(ItemOperateType.putOff);
|
|
return operates;
|
}
|
}
|
|
if (packType == PackType.Warehouse)
|
{
|
operates.Add(ItemOperateType.putOut);
|
return operates;
|
}
|
|
if (item.isAuction)
|
{
|
operates.Add(ItemOperateType.putAway);
|
return operates;
|
}
|
|
var isEquip = ItemLogicUtility.Instance.IsRealmEquip(item.itemId);
|
var isSpiritWeapon = ItemLogicUtility.Instance.IsSpiritWeapon(item.itemId);
|
if (isEquip || isSpiritWeapon)
|
{
|
var isOverdue = ItemLogicUtility.Instance.IsOverdue(guid);
|
if (item.config.CanSell == 1)
|
{
|
operates.Add(ItemOperateType.sell);
|
}
|
|
if (item.config.ExpireTime > 0 && isOverdue && itemOverdueModel.CanRenewal(item.itemId))
|
{
|
operates.Add(ItemOperateType.renewal);
|
}
|
|
if (!isOverdue && ItemLogicUtility.Instance.IsJobCompatibleItem(item.itemId))
|
{
|
if (isEquip && WindowCenter.Instance.IsOpen<RoleEquipWin>())
|
{
|
operates.Add(ItemOperateType.gotoPuton);
|
}
|
else
|
{
|
operates.Add(ItemOperateType.putOn);
|
}
|
}
|
|
return operates;
|
}
|
|
operates.AddRange(GetOperates(item.itemId));
|
if (item.count > 1)
|
{
|
operates.Add(ItemOperateType.split);
|
}
|
|
return operates;
|
}
|
|
public static List<ItemOperateType> GetGatherSoulOperates(PackType packType, int index)
|
{
|
var operates = new List<ItemOperateType>();
|
|
GatherSoulItem item;
|
|
if (packType == PackType.InterimPack)
|
{
|
gatherSoulModel.TryGetItem(index, out item);
|
operates.Add(ItemOperateType.putOff);
|
GatherSoulComposeModel.Compose compose;
|
bool requireCompose = gatherSoulComposeModel.ExistInComposeMat(item.id, out compose);
|
if (requireCompose)
|
{
|
operates.Add(ItemOperateType.compose);
|
}
|
if (!gatherSoulModel.IsGatherSoulMaxLevel(item.id, item.level))
|
{
|
operates.Add(ItemOperateType.LevelUp);
|
}
|
List<GatherSoulItem> list = new List<GatherSoulItem>();
|
gatherSoulModel.TryGetSatisfyReplaceSouls(item.index, ref list);
|
if (list.Count > 0)
|
{
|
operates.Add(ItemOperateType.Replace);
|
}
|
}
|
else if (packType == PackType.GatherSoul)
|
{
|
virtualPackModel.TryGetItem(PackType.GatherSoul, index, out item);
|
if (item.itemType != GatheringSoulModel.GATHERSOUL_ESSENCE_TYPE)
|
{
|
GatherSoulComposeModel.Compose compose;
|
if (gatherSoulComposeModel.TryGetCompose(item.id, out compose)
|
&& compose.requireItems.Count > 0)
|
{
|
operates.Add(ItemOperateType.dismantle);
|
}
|
else
|
{
|
operates.Add(ItemOperateType.Resolve);
|
}
|
GatherSoulComposeModel.Compose outCompose;
|
bool requireCompose = gatherSoulComposeModel.ExistInComposeMat(item.id, out outCompose);
|
if (requireCompose)
|
{
|
operates.Add(ItemOperateType.compose);
|
}
|
bool existSamePropertyHole = gatherSoulModel.IsSamePropertyCompareHoles(-1, item as GatherSoulItem) != -1;
|
bool existCoreHoleItem = false;
|
GatherSoulItem holeItem;
|
if (gatherSoulModel.TryGetItem(gatherSoulModel.coreHole, out holeItem))
|
{
|
existCoreHoleItem = true;
|
}
|
if (item.itemType == GatheringSoulModel.GATHERSOUL_CORE_TYPE)
|
{
|
operates.Add(existCoreHoleItem ? ItemOperateType.Replace : ItemOperateType.Wear);
|
}
|
else
|
{
|
operates.Add(existSamePropertyHole ? ItemOperateType.Replace : ItemOperateType.Wear);
|
}
|
}
|
else
|
{
|
operates.Add(ItemOperateType.Resolve);
|
}
|
}
|
|
return operates;
|
}
|
|
private static List<ItemOperateType> GetGoodOperates(int goodId)
|
{
|
var operates = new List<ItemOperateType>();
|
var countLimit = BuyItemController.Instance.GetBuyCountLimit(goodId, PlayerDatas.Instance.baseData.VIPLv);
|
if (countLimit == -1 || countLimit > 0)
|
{
|
operates.Add(ItemOperateType.buy);
|
}
|
|
return operates;
|
}
|
|
private static bool IsEquipGemHoleOpen(Int2 equipPosition, int maxStar, int hole)
|
{
|
GemHoleCondition condition;
|
if (gemModel.TryGetGemHoleCondition(hole, out condition))
|
{
|
var star = starModel.GetStarLevel(equipPosition);
|
if (Mathf.Min(star, maxStar) < condition.equipStar)
|
{
|
return false;
|
}
|
|
var vipLevel = PlayerDatas.Instance.baseData.VIPLv;
|
if (vipLevel < condition.vipLevel)
|
{
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
private static TipType GetTipType(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
|
switch (config.Type)
|
{
|
case 101:
|
case 102:
|
case 103:
|
case 104:
|
case 105:
|
case 106:
|
case 107:
|
case 108:
|
case 109:
|
case 110:
|
case 111:
|
case 112:
|
return TipType.Equip;
|
case 119:
|
case 120:
|
case 121:
|
case 122:
|
case 123:
|
return TipType.Dogz;
|
case 61:
|
case 62:
|
case 63:
|
return TipType.GatherSoul;
|
case 53:
|
return TipType.KingTreasure;
|
case 26:
|
case 41:
|
case 42:
|
return TipType.PetMount;
|
case 113:
|
return TipType.Wing;
|
case 114:
|
case 116:
|
case 117:
|
return TipType.SpiritWeapon;
|
default:
|
return TipType.Item;
|
}
|
|
}
|
|
[System.Diagnostics.Conditional("UNITY_EDITOR")]
|
private static void PrintItemBrief(int itemId)
|
{
|
var config = ItemConfig.Get(itemId);
|
Debug.LogFormat("你查看的物品是：itemId->{0} ;name->{1}", itemId, config.ItemName);
|
}
|
|
[System.Diagnostics.Conditional("UNITY_EDITOR")]
|
private static void PrintItemBrief(int itemId, string guid)
|
{
|
var config = ItemConfig.Get(itemId);
|
Debug.LogFormat("你查看的物品是：itemId->{0};name->{1};guid->{2};", itemId, config.ItemName, string.IsNullOrEmpty(guid) ? "" : guid);
|
}
|
|
}
|
|
}
|
