diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XEnchantDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XEnchantDocument.cs | 856 |
1 files changed, 856 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XEnchantDocument.cs b/Client/Assets/Scripts/XMainClient/XEnchantDocument.cs new file mode 100644 index 00000000..4d12d475 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XEnchantDocument.cs @@ -0,0 +1,856 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XEnchantDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XEnchantDocument.uuID;
+ }
+ }
+
+ public ulong SelectedEquipUID
+ {
+ get
+ {
+ return this.m_SelectedEquip;
+ }
+ }
+
+ public int SelectedItemID
+ {
+ get
+ {
+ return this.m_SelectedItemID;
+ }
+ }
+
+ public List<XItem> ItemList
+ {
+ get
+ {
+ return this.m_ItemList;
+ }
+ }
+
+ public bool[] RedPointStates
+ {
+ get
+ {
+ return this.m_RedPointStates;
+ }
+ }
+
+ public XItemChangeAttr LastEnchantAttr
+ {
+ get
+ {
+ return this._lastEnchantAttr;
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("EnchantDocument");
+
+ public static uint EnchantMinLevel = 0u;
+
+ public static uint[] EnchantNeedLevel;
+
+ private static EnchantEquip _EnchantEquipTable = new EnchantEquip();
+
+ private static XItemFilter _ItemFilter = new XItemFilter();
+
+ private static Dictionary<uint, XPrefixAttributes> _EnchantAttrs = new Dictionary<uint, XPrefixAttributes>();
+
+ private ulong m_SelectedEquip;
+
+ private ItemList.RowData m_SelectEquipItemConf;
+
+ private int m_SelectedItemID = 0;
+
+ private List<XItem> m_ItemList = new List<XItem>();
+
+ private List<XItem> m_TempItemList = new List<XItem>();
+
+ private List<XItem> m_TempItemList2 = new List<XItem>();
+
+ private EquipList.RowData[] m_TempEquipConfList = new EquipList.RowData[XBagDocument.EquipMax];
+
+ private XItemRequiredCollector m_TempItemRequired = new XItemRequiredCollector();
+
+ private bool[] m_RedPointStates = new bool[XBagDocument.EquipMax];
+
+ private XItemChangeAttr _lastEnchantAttr;
+
+ private Dictionary<ulong, EnchantEquip.RowData> m_TempDataDic = new Dictionary<ulong, EnchantEquip.RowData>();
+
+ public EnchantOperateHandler _EnchantOperateHandler;
+
+ public EnchantBagHandler _EnchantBagHandler;
+
+ public EnchantActiveHandler _EnchantActiveHandler;
+
+ public EnchantResultHandler _EnchantResultHandler;
+
+ private bool _bCostDirty = false;
+
+ private bool _bShouldUpdateRedPoint = false;
+
+ private XEnchantInfo _preInfo = default(XEnchantInfo);
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ XEnchantDocument.AsyncLoader.AddTask("Table/EnchantEquip", XEnchantDocument._EnchantEquipTable, false);
+ XEnchantDocument.AsyncLoader.Execute(callback);
+ }
+
+ public static void OnTableLoaded()
+ {
+ XEnchantDocument._ItemFilter.Clear();
+ XEnchantDocument._EnchantAttrs.Clear();
+ for (int i = 0; i < XEnchantDocument._EnchantEquipTable.Table.Length; i++)
+ {
+ EnchantEquip.RowData rowData = XEnchantDocument._EnchantEquipTable.Table[i];
+ XEnchantDocument._ItemFilter.AddItemID((int)rowData.EnchantID);
+ for (int j = 0; j < rowData.Cost.Count; j++)
+ {
+ XEnchantDocument._ItemFilter.AddItemID((int)rowData.Cost[j, 0]);
+ }
+ XPrefixAttributes xprefixAttributes = new XPrefixAttributes();
+ XEnchantDocument._EnchantAttrs.Add(rowData.EnchantID, xprefixAttributes);
+ for (int k = 0; k < rowData.Attribute.Count; k++)
+ {
+ XPrefixAttribute xprefixAttribute = null;
+ for (int l = 0; l < xprefixAttributes.AttributeList.Count; l++)
+ {
+ bool flag = xprefixAttributes.AttributeList[l].attrid == rowData.Attribute[k, 0];
+ if (flag)
+ {
+ xprefixAttribute = xprefixAttributes.AttributeList[l];
+ break;
+ }
+ }
+ bool flag2 = xprefixAttribute == null;
+ if (flag2)
+ {
+ xprefixAttribute = new XPrefixAttribute();
+ xprefixAttribute.attrid = rowData.Attribute[k, 0];
+ xprefixAttribute.minValue = float.MaxValue;
+ xprefixAttributes.AttributeList.Add(xprefixAttribute);
+ }
+ xprefixAttribute.maxValue = Math.Max(xprefixAttribute.maxValue, rowData.Attribute[k, 2]);
+ xprefixAttribute.minValue = Math.Min(xprefixAttribute.minValue, rowData.Attribute[k, 1]);
+ }
+ }
+ }
+
+ public static void InitFromGlobalConfig()
+ {
+ string[] array = XSingleton<XGlobalConfig>.singleton.GetValue("EnchantNeedLevel").Split(XGlobalConfig.ListSeparator);
+ bool flag = XEnchantDocument.EnchantNeedLevel == null || XEnchantDocument.EnchantNeedLevel.Length != array.Length + 1;
+ if (flag)
+ {
+ XEnchantDocument.EnchantNeedLevel = new uint[array.Length + 1];
+ XEnchantDocument.EnchantNeedLevel[0] = 0u;
+ }
+ for (int i = 0; i < array.Length; i++)
+ {
+ XEnchantDocument.EnchantNeedLevel[i + 1] = uint.Parse(array[i]);
+ }
+ bool flag2 = XEnchantDocument.EnchantNeedLevel.Length > 1;
+ if (flag2)
+ {
+ XEnchantDocument.EnchantMinLevel = XEnchantDocument.EnchantNeedLevel[1];
+ }
+ else
+ {
+ XEnchantDocument.EnchantMinLevel = 0u;
+ }
+ }
+
+ public EnchantEquip.RowData GetEnchantEquipData(int itemid)
+ {
+ return XEnchantDocument._EnchantEquipTable.GetByEnchantID((uint)itemid);
+ }
+
+ public XPrefixAttributes GetEnchantAttrs(uint itemid)
+ {
+ XPrefixAttributes xprefixAttributes = null;
+ bool flag = XEnchantDocument._EnchantAttrs.TryGetValue(itemid, out xprefixAttributes);
+ XPrefixAttributes result;
+ if (flag)
+ {
+ result = xprefixAttributes;
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.EventSubscribe();
+ base.RegisterEvent(XEventDefine.XEvent_LoadEquip, new XComponent.XEventHandler(this.OnLoadEquip));
+ base.RegisterEvent(XEventDefine.XEvent_UnloadEquip, new XComponent.XEventHandler(this.OnUnloadEquip));
+ base.RegisterEvent(XEventDefine.XEvent_UpdateItem, new XComponent.XEventHandler(this.OnUpdateItem));
+ base.RegisterEvent(XEventDefine.XEvent_VirtualItemChanged, new XComponent.XEventHandler(this.OnVirtualItemChanged));
+ base.RegisterEvent(XEventDefine.XEvent_AddItem, new XComponent.XEventHandler(this.OnAddItem));
+ base.RegisterEvent(XEventDefine.XEvent_RemoveItem, new XComponent.XEventHandler(this.OnRemoveItem));
+ base.RegisterEvent(XEventDefine.XEvent_ItemNumChanged, new XComponent.XEventHandler(this.OnItemNumChanged));
+ base.RegisterEvent(XEventDefine.XEvent_ItemChangeFinished, new XComponent.XEventHandler(this.OnFinishItemChange));
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ bool flag = this._EnchantOperateHandler != null && this._EnchantOperateHandler.IsVisible();
+ if (flag)
+ {
+ this.ToggleBlock(false);
+ this._EnchantOperateHandler.RefreshData();
+ }
+ bool flag2 = this._EnchantBagHandler != null && this._EnchantBagHandler.IsVisible();
+ if (flag2)
+ {
+ this._EnchantBagHandler.RefreshData();
+ }
+ }
+
+ public bool OnLoadEquip(XEventArgs args)
+ {
+ XLoadEquipEventArgs xloadEquipEventArgs = args as XLoadEquipEventArgs;
+ bool flag = xloadEquipEventArgs.item.Type == ItemType.EQUIP;
+ if (flag)
+ {
+ this._bShouldUpdateRedPoint = true;
+ }
+ return true;
+ }
+
+ public bool OnUnloadEquip(XEventArgs args)
+ {
+ XUnloadEquipEventArgs xunloadEquipEventArgs = args as XUnloadEquipEventArgs;
+ bool flag = xunloadEquipEventArgs.item.Type == ItemType.EQUIP;
+ if (flag)
+ {
+ this._bShouldUpdateRedPoint = true;
+ }
+ return true;
+ }
+
+ public bool OnUpdateItem(XEventArgs args)
+ {
+ XUpdateItemEventArgs xupdateItemEventArgs = args as XUpdateItemEventArgs;
+ bool flag = xupdateItemEventArgs.item.Type == ItemType.EQUIP;
+ if (flag)
+ {
+ this._bShouldUpdateRedPoint = true;
+ }
+ return true;
+ }
+
+ public bool OnVirtualItemChanged(XEventArgs args)
+ {
+ XVirtualItemChangedEventArgs xvirtualItemChangedEventArgs = args as XVirtualItemChangedEventArgs;
+ bool flag = this._RelatedItemUpdated(xvirtualItemChangedEventArgs.itemID);
+ if (flag)
+ {
+ this._bCostDirty |= this._IsUIShowed();
+ this._bShouldUpdateRedPoint = true;
+ }
+ return true;
+ }
+
+ protected bool OnAddItem(XEventArgs args)
+ {
+ XAddItemEventArgs xaddItemEventArgs = args as XAddItemEventArgs;
+ for (int i = 0; i < xaddItemEventArgs.items.Count; i++)
+ {
+ bool flag = this._RelatedItemUpdated(xaddItemEventArgs.items[i].itemID);
+ if (flag)
+ {
+ this._bCostDirty |= this._IsUIShowed();
+ this._bShouldUpdateRedPoint = true;
+ break;
+ }
+ }
+ return true;
+ }
+
+ protected bool OnRemoveItem(XEventArgs args)
+ {
+ XRemoveItemEventArgs xremoveItemEventArgs = args as XRemoveItemEventArgs;
+ for (int i = 0; i < xremoveItemEventArgs.ids.Count; i++)
+ {
+ bool flag = this._RelatedItemUpdated(xremoveItemEventArgs.ids[i]);
+ if (flag)
+ {
+ this._bCostDirty |= this._IsUIShowed();
+ this._bShouldUpdateRedPoint = true;
+ break;
+ }
+ }
+ return true;
+ }
+
+ public bool OnItemNumChanged(XEventArgs args)
+ {
+ XItemNumChangedEventArgs xitemNumChangedEventArgs = args as XItemNumChangedEventArgs;
+ bool flag = this._RelatedItemUpdated(xitemNumChangedEventArgs.item.itemID);
+ if (flag)
+ {
+ this._bCostDirty |= this._IsUIShowed();
+ this._bShouldUpdateRedPoint = true;
+ }
+ return true;
+ }
+
+ public bool OnFinishItemChange(XEventArgs args)
+ {
+ bool bShouldUpdateRedPoint = this._bShouldUpdateRedPoint;
+ if (bShouldUpdateRedPoint)
+ {
+ this.UpdateRedPoints();
+ this._bShouldUpdateRedPoint = false;
+ }
+ bool bCostDirty = this._bCostDirty;
+ if (bCostDirty)
+ {
+ this._bCostDirty = false;
+ bool flag = this._EnchantOperateHandler != null && this._EnchantOperateHandler.IsVisible();
+ if (flag)
+ {
+ this._EnchantOperateHandler.RefreshItems();
+ }
+ bool flag2 = this._EnchantBagHandler != null && this._EnchantBagHandler.IsVisible();
+ if (flag2)
+ {
+ this._EnchantBagHandler.RefreshData();
+ }
+ }
+ return true;
+ }
+
+ public void UpdateRedPoints()
+ {
+ this.UpdateRedPoints(XSingleton<XAttributeMgr>.singleton.XPlayerData.Level);
+ }
+
+ public void UpdateRedPoints(uint playerLevel)
+ {
+ bool bState = false;
+ bool flag = false;
+ XBodyBag equipBag = XSingleton<XGame>.singleton.Doc.XBagDoc.EquipBag;
+ for (int i = 0; i < XBagDocument.EquipMax; i++)
+ {
+ this.m_TempEquipConfList[i] = null;
+ this.m_RedPointStates[i] = false;
+ XEquipItem xequipItem = equipBag[i] as XEquipItem;
+ bool flag2 = xequipItem == null || xequipItem.itemID == 0 || xequipItem.itemConf == null;
+ if (!flag2)
+ {
+ bool flag3 = xequipItem.itemConf.ItemQuality < 3;
+ if (!flag3)
+ {
+ EquipSuitTable.RowData suit = XCharacterEquipDocument.SuitManager.GetSuit(xequipItem.itemID, true);
+ bool flag4 = suit == null;
+ if (!flag4)
+ {
+ this.m_TempEquipConfList[i] = XBagDocument.GetEquipConf(xequipItem.itemID);
+ flag |= (this.m_TempEquipConfList[i] != null);
+ }
+ }
+ }
+ }
+ bool flag5 = flag;
+ if (flag5)
+ {
+ List<XItem> allEnchantItemsTemporarily = this.GetAllEnchantItemsTemporarily();
+ for (int j = 0; j < allEnchantItemsTemporarily.Count; j++)
+ {
+ EnchantEquip.RowData enchantEquipData = this.GetEnchantEquipData(allEnchantItemsTemporarily[j].itemID);
+ bool flag6 = enchantEquipData == null;
+ if (!flag6)
+ {
+ bool flag7 = (long)allEnchantItemsTemporarily[j].itemCount < (long)((ulong)enchantEquipData.Num);
+ if (!flag7)
+ {
+ bool flag8 = true;
+ for (int k = 0; k < (int)enchantEquipData.Cost.count; k++)
+ {
+ bool flag9 = XSingleton<XGame>.singleton.Doc.XBagDoc.GetItemCount((int)enchantEquipData.Cost[k, 0]) < (ulong)enchantEquipData.Cost[k, 1];
+ if (flag9)
+ {
+ flag8 = false;
+ break;
+ }
+ }
+ bool flag10 = !flag8;
+ if (!flag10)
+ {
+ bool flag11 = false;
+ for (int l = 0; l < XBagDocument.EquipMax; l++)
+ {
+ EquipList.RowData rowData = this.m_TempEquipConfList[l];
+ bool flag12 = rowData == null || this.m_RedPointStates[l];
+ if (!flag12)
+ {
+ XEquipItem xequipItem2 = equipBag[l] as XEquipItem;
+ bool bHasEnchant = xequipItem2.enchantInfo.bHasEnchant;
+ if (!bHasEnchant)
+ {
+ flag11 = true;
+ bool flag13 = !XEnchantDocument.IsEnchantMatched(rowData, enchantEquipData);
+ if (!flag13)
+ {
+ bool flag14 = XEnchantDocument.CanEnchant((int)equipBag[l].itemConf.ReqLevel, enchantEquipData.EnchantLevel) == EnchantCheckResult.ECR_OK;
+ if (flag14)
+ {
+ this.m_RedPointStates[l] = true;
+ bState = true;
+ }
+ }
+ }
+ }
+ }
+ bool flag15 = !flag11;
+ if (flag15)
+ {
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ XSingleton<XGameSysMgr>.singleton.SetSysRedState(XSysDefine.XSys_Item_Enchant, bState);
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_Item_Enchant, true);
+ bool flag16 = DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._EquipBagHandler != null && DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._EquipBagHandler.IsVisible();
+ if (flag16)
+ {
+ DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._EquipBagHandler.RefreshRedPoints();
+ }
+ }
+
+ private bool _IsUIShowed()
+ {
+ bool flag = this._EnchantOperateHandler == null || !this._EnchantOperateHandler.IsVisible();
+ return !flag;
+ }
+
+ private bool _RelatedItemUpdated(int itemid)
+ {
+ return XEnchantDocument._ItemFilter.Contains(itemid);
+ }
+
+ public List<XItem> GetAllEnchantItemsTemporarily()
+ {
+ this.m_TempItemList.Clear();
+ for (int i = 0; i < this.m_TempItemList2.Count; i++)
+ {
+ this.m_TempItemList2[i].Recycle();
+ }
+ this.m_TempItemList2.Clear();
+ ulong typeFilter = 1UL << XFastEnumIntEqualityComparer<ItemType>.ToInt(ItemType.ENCHANT);
+ XSingleton<XGame>.singleton.Doc.XBagDoc.GetItemsByType(typeFilter, ref this.m_TempItemList);
+ this.m_TempItemList.Sort(new Comparison<XItem>(this._SortByID));
+ this._MergeItemsWithSameID(this.m_TempItemList, this.m_TempItemList2);
+ return this.m_TempItemList2;
+ }
+
+ public List<XItem> GetEnchantItems()
+ {
+ ulong typeFilter = 1UL << XFastEnumIntEqualityComparer<ItemType>.ToInt(ItemType.ENCHANT);
+ for (int i = 0; i < this.m_ItemList.Count; i++)
+ {
+ this.m_ItemList[i].Recycle();
+ }
+ this.m_ItemList.Clear();
+ this.m_TempItemList.Clear();
+ this.m_TempDataDic.Clear();
+ bool flag = this.m_SelectEquipItemConf == null;
+ List<XItem> itemList;
+ if (flag)
+ {
+ itemList = this.m_ItemList;
+ }
+ else
+ {
+ EquipList.RowData equipConf = XBagDocument.GetEquipConf(this.m_SelectEquipItemConf.ItemID);
+ XSingleton<XGame>.singleton.Doc.XBagDoc.GetItemsByType(typeFilter, ref this.m_TempItemList);
+ int num = this.m_TempItemList.Count;
+ int j = 0;
+ while (j < num)
+ {
+ XItem xitem = this.m_TempItemList[j];
+ EnchantEquip.RowData enchantEquipData = this.GetEnchantEquipData(xitem.itemID);
+ bool flag2 = XEnchantDocument.IsEnchantMatched(equipConf, enchantEquipData);
+ if (flag2)
+ {
+ this.m_TempDataDic[xitem.uid] = enchantEquipData;
+ j++;
+ }
+ else
+ {
+ bool flag3 = --num > j;
+ if (flag3)
+ {
+ XItem value = this.m_TempItemList[j];
+ this.m_TempItemList[j] = this.m_TempItemList[num];
+ this.m_TempItemList[num] = value;
+ }
+ }
+ }
+ bool flag4 = num < this.m_TempItemList.Count;
+ if (flag4)
+ {
+ this.m_TempItemList.RemoveRange(num, this.m_TempItemList.Count - num);
+ }
+ this.m_TempItemList.Sort(new Comparison<XItem>(this._SortEnchantItems));
+ this._MergeItemsWithSameID(this.m_TempItemList, this.m_ItemList);
+ itemList = this.m_ItemList;
+ }
+ return itemList;
+ }
+
+ private void _MergeItemsWithSameID(List<XItem> from, List<XItem> to)
+ {
+ XItem xitem = null;
+ for (int i = 0; i < from.Count; i++)
+ {
+ XItem xitem2 = from[i];
+ bool flag = xitem == null || xitem.itemID != xitem2.itemID;
+ if (flag)
+ {
+ xitem = XDataPool<XNormalItem>.GetData();
+ to.Add(xitem);
+ xitem.itemID = xitem2.itemID;
+ xitem.itemConf = xitem2.itemConf;
+ }
+ xitem.itemCount += xitem2.itemCount;
+ }
+ }
+
+ private int _SortByID(XItem left, XItem right)
+ {
+ return left.itemID.CompareTo(right.itemID);
+ }
+
+ private int _SortEnchantItems(XItem left, XItem right)
+ {
+ bool flag = this.m_SelectEquipItemConf == null;
+ int result;
+ if (flag)
+ {
+ result = 0;
+ }
+ else
+ {
+ ItemList.RowData itemConf = left.itemConf;
+ ItemList.RowData itemConf2 = right.itemConf;
+ EnchantEquip.RowData rowData;
+ this.m_TempDataDic.TryGetValue(left.uid, out rowData);
+ EnchantEquip.RowData rowData2;
+ this.m_TempDataDic.TryGetValue(right.uid, out rowData2);
+ bool flag2 = itemConf == null || rowData == null;
+ if (flag2)
+ {
+ result = 1;
+ }
+ else
+ {
+ bool flag3 = itemConf2 == null || rowData2 == null;
+ if (flag3)
+ {
+ result = -1;
+ }
+ else
+ {
+ EnchantCheckResult enchantCheckResult = XEnchantDocument.CanEnchant((int)this.m_SelectEquipItemConf.ReqLevel, rowData.EnchantLevel);
+ EnchantCheckResult enchantCheckResult2 = XEnchantDocument.CanEnchant((int)this.m_SelectEquipItemConf.ReqLevel, rowData2.EnchantLevel);
+ bool flag4 = (enchantCheckResult == EnchantCheckResult.ECR_OK && enchantCheckResult2 == EnchantCheckResult.ECR_OK) || (enchantCheckResult != EnchantCheckResult.ECR_OK && enchantCheckResult2 > EnchantCheckResult.ECR_OK);
+ if (flag4)
+ {
+ int num = -itemConf.ReqLevel.CompareTo(itemConf2.ReqLevel);
+ bool flag5 = num != 0;
+ if (flag5)
+ {
+ result = num;
+ }
+ else
+ {
+ num = -itemConf.ItemQuality.CompareTo(itemConf2.ItemQuality);
+ bool flag6 = num != 0;
+ if (flag6)
+ {
+ result = num;
+ }
+ else
+ {
+ num = itemConf.ItemID.CompareTo(itemConf2.ItemID);
+ bool flag7 = num != 0;
+ if (flag7)
+ {
+ result = num;
+ }
+ else
+ {
+ result = left.uid.CompareTo(right.uid);
+ }
+ }
+ }
+ }
+ else
+ {
+ bool flag8 = enchantCheckResult == EnchantCheckResult.ECR_OK;
+ if (flag8)
+ {
+ result = -1;
+ }
+ else
+ {
+ bool flag9 = enchantCheckResult2 == EnchantCheckResult.ECR_OK;
+ if (flag9)
+ {
+ result = 1;
+ }
+ else
+ {
+ result = 0;
+ }
+ }
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ public static EnchantCheckResult CanEnchant(int equipLevel, uint enchantItemLevel)
+ {
+ bool flag = (ulong)enchantItemLevel > (ulong)((long)XEnchantDocument.EnchantNeedLevel.Length);
+ EnchantCheckResult result;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("enchantItemLevel ", enchantItemLevel.ToString(), " > EnchantNeedLevel.Length ", XEnchantDocument.EnchantNeedLevel.Length.ToString(), null, null);
+ result = EnchantCheckResult.ECR_INVALID;
+ }
+ else
+ {
+ bool flag2 = (long)equipLevel < (long)((ulong)XEnchantDocument.EnchantNeedLevel[(int)enchantItemLevel]);
+ if (flag2)
+ {
+ result = EnchantCheckResult.ECR_ITEM_TOO_HIGH;
+ }
+ else
+ {
+ result = EnchantCheckResult.ECR_OK;
+ }
+ }
+ return result;
+ }
+
+ public static bool CanEquipEnchant(int equipLevel)
+ {
+ return (long)equipLevel >= (long)((ulong)XEnchantDocument.EnchantMinLevel);
+ }
+
+ public static bool IsEnchantMatched(EquipList.RowData equipData, EnchantEquip.RowData enchantData)
+ {
+ bool flag = equipData == null || enchantData == null;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ for (int i = 0; i < enchantData.Pos.Length; i++)
+ {
+ bool flag2 = enchantData.Pos[i] == (uint)equipData.EquipPos;
+ if (flag2)
+ {
+ return true;
+ }
+ }
+ result = false;
+ }
+ return result;
+ }
+
+ public EnchantCheckResult CanEnchant(EnchantEquip.RowData enchantConf)
+ {
+ bool flag = this.m_SelectEquipItemConf == null || enchantConf == null;
+ EnchantCheckResult result;
+ if (flag)
+ {
+ result = EnchantCheckResult.ECR_INVALID;
+ }
+ else
+ {
+ result = XEnchantDocument.CanEnchant((int)this.m_SelectEquipItemConf.ReqLevel, enchantConf.EnchantLevel);
+ }
+ return result;
+ }
+
+ public void SelectEquip(ulong uid)
+ {
+ XItem itemByUID = XSingleton<XGame>.singleton.Doc.XBagDoc.GetItemByUID(uid);
+ bool flag = itemByUID == null || itemByUID.itemConf == null;
+ if (!flag)
+ {
+ bool flag2 = !XEnchantDocument.CanEquipEnchant((int)itemByUID.itemConf.ReqLevel);
+ if (flag2)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("EnchantMinLevelRequired", new object[]
+ {
+ XEnchantDocument.EnchantMinLevel
+ }), "fece00");
+ }
+ else
+ {
+ this.m_SelectEquipItemConf = itemByUID.itemConf;
+ this.m_SelectedEquip = uid;
+ bool flag3 = !DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton.IsVisible();
+ if (!flag3)
+ {
+ bool flag4 = DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._equipHandler != null;
+ if (flag4)
+ {
+ DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._equipHandler.SelectEquip(uid);
+ }
+ bool flag5 = DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._EnchantHandler != null && DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._EnchantHandler.IsVisible();
+ if (flag5)
+ {
+ DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._EnchantHandler.RefreshData();
+ }
+ else
+ {
+ DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton.ShowRightPopView(DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._EnchantHandler);
+ }
+ }
+ }
+ }
+ }
+
+ public void SelectEnchantItem(int itemID)
+ {
+ this.m_SelectedItemID = itemID;
+ bool flag = this._EnchantBagHandler != null && this._EnchantBagHandler.IsVisible();
+ if (flag)
+ {
+ this._EnchantBagHandler.SetVisible(false);
+ }
+ bool flag2 = this._EnchantOperateHandler != null && this._EnchantOperateHandler.IsVisible();
+ if (flag2)
+ {
+ this._EnchantOperateHandler.RefreshData();
+ }
+ }
+
+ public XEnchantInfo GetPreEnchantInfo()
+ {
+ return this._preInfo;
+ }
+
+ public void SetPreEnchantInfo(XEnchantInfo info)
+ {
+ this._preInfo.Init();
+ this._preInfo.AttrList = new List<XItemChangeAttr>(info.AttrList);
+ this._preInfo.ChooseAttr = info.ChooseAttr;
+ this._preInfo.EnchantIDList = new List<uint>(info.EnchantIDList);
+ }
+
+ public void ToggleBlock(bool bBlock)
+ {
+ XMainInterfaceDocument specificDocument = XDocuments.GetSpecificDocument<XMainInterfaceDocument>(XMainInterfaceDocument.uuID);
+ specificDocument.AttrEventBlocker.bBlockReceiver = bBlock;
+ }
+
+ public void ReqEnchant()
+ {
+ RpcC2G_EnchantEquip rpcC2G_EnchantEquip = new RpcC2G_EnchantEquip();
+ rpcC2G_EnchantEquip.oArg.enchantid = (uint)this.m_SelectedItemID;
+ rpcC2G_EnchantEquip.oArg.uid = this.m_SelectedEquip;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_EnchantEquip);
+ XEquipItem xequipItem = XSingleton<XGame>.singleton.Doc.XBagDoc.GetItemByUID(this.SelectedEquipUID) as XEquipItem;
+ this.ToggleBlock(true);
+ bool flag = xequipItem == null;
+ if (!flag)
+ {
+ this.SetPreEnchantInfo(xequipItem.enchantInfo);
+ }
+ }
+
+ public void OnGetEnchant(EnchantEquipArg oArg, EnchantEquipRes oRes)
+ {
+ bool flag = oRes.errorcode > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ this.ToggleBlock(false);
+ bool flag2 = this._EnchantOperateHandler != null && this._EnchantOperateHandler.IsVisible();
+ if (flag2)
+ {
+ this._EnchantOperateHandler.ResetOKCD();
+ }
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.errorcode, "fece00");
+ }
+ else
+ {
+ bool flag3 = oRes.attr != null;
+ if (flag3)
+ {
+ this._lastEnchantAttr.AttrID = oRes.attr.id;
+ this._lastEnchantAttr.AttrValue = oRes.attr.value;
+ }
+ bool flag4 = this._EnchantResultHandler != null && this._EnchantResultHandler.IsVisible();
+ if (flag4)
+ {
+ this._EnchantResultHandler.RefreshData();
+ }
+ bool flag5 = this._EnchantOperateHandler != null && this._EnchantOperateHandler.IsVisible();
+ if (flag5)
+ {
+ this._EnchantOperateHandler.RefreshData();
+ }
+ }
+ }
+
+ public void SendEnchantActiveAttribute(uint curSelectedAttribute)
+ {
+ RpcC2G_EnchantActiveAttribute rpcC2G_EnchantActiveAttribute = new RpcC2G_EnchantActiveAttribute();
+ rpcC2G_EnchantActiveAttribute.oArg.uid = this.m_SelectedEquip;
+ rpcC2G_EnchantActiveAttribute.oArg.attrID = curSelectedAttribute;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_EnchantActiveAttribute);
+ }
+
+ public void OnGetEnchantActiveAttr(EnchantActiveAttributeArg oArg, EnchantActiveAttributeRes oRes)
+ {
+ bool flag = this._EnchantActiveHandler != null && this._EnchantActiveHandler.IsVisible();
+ if (flag)
+ {
+ this._EnchantActiveHandler.RefreshData();
+ }
+ bool flag2 = this._EnchantOperateHandler != null && this._EnchantOperateHandler.IsVisible();
+ if (flag2)
+ {
+ this._EnchantOperateHandler.RefreshData();
+ }
+ }
+ }
+}
|