diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XEmblemDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XEmblemDocument.cs | 1042 |
1 files changed, 1042 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XEmblemDocument.cs b/Client/Assets/Scripts/XMainClient/XEmblemDocument.cs new file mode 100644 index 00000000..e3de8afa --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XEmblemDocument.cs @@ -0,0 +1,1042 @@ +using System;
+using System.Collections.Generic;
+using System.Reflection;
+using KKSG;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XEmblemDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XEmblemDocument.uuID;
+ }
+ }
+
+ public EmblemSlotStatus[] EquipLock
+ {
+ get
+ {
+ bool flag = this.m_equipLock == null;
+ if (flag)
+ {
+ this.m_equipLock = new EmblemSlotStatus[XEmblemDocument.Position_TotalEnd - XEmblemDocument.Position_TotalStart];
+ for (int i = XEmblemDocument.Position_TotalStart; i < XEmblemDocument.Position_TotalEnd; i++)
+ {
+ this.m_equipLock[i] = new EmblemSlotStatus(i);
+ }
+ }
+ return this.m_equipLock;
+ }
+ }
+
+ public bool bCanBePowerful
+ {
+ get
+ {
+ return XSingleton<XGameSysMgr>.singleton.IsSystemOpened(XSysDefine.XSys_Char_Emblem) & this._bCanBePowerful;
+ }
+ set
+ {
+ this._bCanBePowerful = value;
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_Char_Emblem, true);
+ }
+ }
+
+ public XNewItemTipsMgr NewItems
+ {
+ get
+ {
+ return this._NewItems;
+ }
+ }
+
+ public bool IsEquipEmblem
+ {
+ get
+ {
+ XBodyBag emblemBag = XSingleton<XGame>.singleton.Doc.XBagDoc.EmblemBag;
+ for (int i = 0; i < emblemBag.Length; i++)
+ {
+ bool flag = emblemBag[i] != null && emblemBag[i].itemID != 0 && (ulong)emblemBag[i].type == (ulong)((long)XFastEnumIntEqualityComparer<ItemType>.ToInt(ItemType.EMBLEM));
+ if (flag)
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("EmblemDocument");
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ public static int Position_AttrStart = XBagDocument.BodyPosition<EmblemPosition>(EmblemPosition.EMBLEM_START);
+
+ public static int Position_AttrEnd = XBagDocument.BodyPosition<EmblemPosition>(EmblemPosition.EMBLEMIX);
+
+ public static int Position_SkillStart = XBagDocument.BodyPosition<EmblemPosition>(EmblemPosition.EMBLEMIX);
+
+ public static int Position_SkillEnd = XBagDocument.BodyPosition<EmblemPosition>(EmblemPosition.EMBLEM_END);
+
+ public static int Position_NoPaySkillStart = XBagDocument.BodyPosition<EmblemPosition>(EmblemPosition.EMBLEMIX);
+
+ public static int Position_NoPaySkillEnd = XBagDocument.BodyPosition<EmblemPosition>(EmblemPosition.EMBLEMXIII);
+
+ public static int Position_PaySkillStart = XBagDocument.BodyPosition<EmblemPosition>(EmblemPosition.EMBLEMXIII);
+
+ public static int Position_PaySkillEnd = XBagDocument.BodyPosition<EmblemPosition>(EmblemPosition.EMBLEM_END);
+
+ public static int Position_TotalStart = XBagDocument.BodyPosition<EmblemPosition>(EmblemPosition.EMBLEM_START);
+
+ public static int Position_TotalEnd = XBagDocument.BodyPosition<EmblemPosition>(EmblemPosition.EMBLEM_END);
+
+ public EmblemBagView _BagHandler = null;
+
+ public EmblemEquipView _EquipHandler = null;
+
+ private static SkillEmblem _emblemSkillReader = new SkillEmblem();
+
+ private static string emblemSkillAttrFmt = "";
+
+ private List<uint>[] _emblemLevels = new List<uint>[6];
+
+ private List<int> m_needMoneyList = new List<int>();
+
+ private EmblemSlotStatus[] m_equipLock;
+
+ public List<uint> emblemSlotUnlockLevel = new List<uint>();
+
+ public static int Level_Count = 0;
+
+ public HashSet<ulong> selectedItems = new HashSet<ulong>();
+
+ public uint selectedItemsTotalExp = 0u;
+
+ public ulong currentEmblemUID = 0UL;
+
+ private bool _bCanBePowerful = false;
+
+ private bool _bShouldUpdateRedPoints = false;
+
+ private XNewItemTipsMgr _NewItems = new XNewItemTipsMgr();
+
+ private List<XItem> m_ItemList = new List<XItem>();
+
+ public static int HadSlottingNum = 0;
+
+ private List<ShowAttriData> ShowAttriDataLst;
+
+ public static bool isFullLevel(uint level)
+ {
+ return (ulong)level >= (ulong)((long)(XEmblemDocument.Level_Count - 1));
+ }
+
+ public static string GetDisplayLevel(uint level)
+ {
+ bool flag = XEmblemDocument.isFullLevel(level);
+ string result;
+ if (flag)
+ {
+ result = "MAX";
+ }
+ else
+ {
+ result = (level + 1u).ToString();
+ }
+ return result;
+ }
+
+ public static SkillEmblem.RowData GetEmblemSkillConf(uint dwItemId)
+ {
+ return XEmblemDocument._emblemSkillReader.GetByEmblemID(dwItemId);
+ }
+
+ public static string GetEmblemSkillAttrString(uint dwItemId)
+ {
+ bool flag = string.IsNullOrEmpty(XEmblemDocument.emblemSkillAttrFmt);
+ if (flag)
+ {
+ XEmblemDocument.emblemSkillAttrFmt = XStringDefineProxy.GetString("TOOLTIP_EMBLEM_IDENTIFY_SKILL_FMT");
+ }
+ SkillEmblem.RowData byEmblemID = XEmblemDocument._emblemSkillReader.GetByEmblemID(dwItemId);
+ bool flag2 = byEmblemID != null;
+ string result;
+ if (flag2)
+ {
+ result = string.Format(XEmblemDocument.emblemSkillAttrFmt, byEmblemID.SkillScript, XStringDefineProxy.GetString("TOOLTIP_EMBLEM_IDENTIFY_SKILL_" + byEmblemID.SkillType), byEmblemID.SkillPercent);
+ }
+ else
+ {
+ result = string.Empty;
+ }
+ return result;
+ }
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ XEmblemDocument.AsyncLoader.AddTask("Table/SkillEmblem", XEmblemDocument._emblemSkillReader, false);
+ XEmblemDocument.AsyncLoader.Execute(callback);
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ this.emblemSlotUnlockLevel.Clear();
+ string[] array = XSingleton<XGlobalConfig>.singleton.GetValue("AttributeEmblemSlotLevelLimit").Split(XGlobalConfig.ListSeparator);
+ int num = 0;
+ while (num < array.Length && num < XEmblemDocument.Position_AttrEnd)
+ {
+ this.emblemSlotUnlockLevel.Add(uint.Parse(array[num]));
+ num++;
+ }
+ array = XSingleton<XGlobalConfig>.singleton.GetValue("SkillEmblemSlotLevelLimit").Split(XGlobalConfig.ListSeparator);
+ int num2 = 0;
+ while (num2 < array.Length && num2 < XEmblemDocument.Position_NoPaySkillEnd - XEmblemDocument.Position_NoPaySkillStart + 1)
+ {
+ this.emblemSlotUnlockLevel.Add(uint.Parse(array[num2]));
+ num2++;
+ }
+ array = XSingleton<XGlobalConfig>.singleton.GetValue("ExtraSkillEmblemSlotLevelLimit").Split(XGlobalConfig.ListSeparator);
+ int num3 = 0;
+ while (num3 < array.Length && num3 < XEmblemDocument.Position_PaySkillEnd - XEmblemDocument.Position_PaySkillStart + 1)
+ {
+ this.emblemSlotUnlockLevel.Add(uint.Parse(array[num3]));
+ num3++;
+ }
+ array = XSingleton<XGlobalConfig>.singleton.GetValue("ExtraSkillEmblemSlotDragonCoin").Split(XGlobalConfig.ListSeparator);
+ int num4 = 0;
+ while (num4 < array.Length && num4 < XEmblemDocument.Position_PaySkillEnd - XEmblemDocument.Position_PaySkillStart + 1)
+ {
+ this.m_needMoneyList.Add(int.Parse(array[num4]));
+ num4++;
+ }
+ this._NewItems.ClearItemType();
+ this._NewItems.Filter.AddItemType(ItemType.EMBLEM);
+ }
+
+ 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_AddItem, new XComponent.XEventHandler(this.OnAddItem));
+ base.RegisterEvent(XEventDefine.XEvent_RemoveItem, new XComponent.XEventHandler(this.OnRemoveItem));
+ base.RegisterEvent(XEventDefine.XEvent_SwapItem, new XComponent.XEventHandler(this.OnSwapItem));
+ base.RegisterEvent(XEventDefine.XEvent_UpdateItem, new XComponent.XEventHandler(this.OnUpdateItem));
+ base.RegisterEvent(XEventDefine.XEvent_ItemNumChanged, new XComponent.XEventHandler(this.OnItemNumChanged));
+ base.RegisterEvent(XEventDefine.XEvent_ItemChangeFinished, new XComponent.XEventHandler(this.OnItemChangedFinished));
+ base.RegisterEvent(XEventDefine.XEvent_PlayerLevelChange, new XComponent.XEventHandler(this.OnPlayerLevelChange));
+ }
+
+ public int SlottingNeedMoney(int slot)
+ {
+ int num = slot - XEmblemDocument.Position_PaySkillStart;
+ bool flag = num < 0 || num >= this.m_needMoneyList.Count;
+ int result;
+ if (flag)
+ {
+ result = 0;
+ }
+ else
+ {
+ result = this.m_needMoneyList[num];
+ }
+ return result;
+ }
+
+ public int IsCanSlotting(int slot)
+ {
+ bool flag = XEmblemDocument.HadSlottingNum >= XEmblemDocument.Position_PaySkillEnd - XEmblemDocument.Position_PaySkillStart;
+ int result;
+ if (flag)
+ {
+ result = 2;
+ }
+ else
+ {
+ int num = slot - XEmblemDocument.Position_PaySkillStart + 1;
+ bool flag2 = num == 1;
+ if (flag2)
+ {
+ result = 0;
+ }
+ else
+ {
+ bool flag3 = num == XEmblemDocument.HadSlottingNum + 1;
+ if (flag3)
+ {
+ result = 0;
+ }
+ else
+ {
+ result = 1;
+ }
+ }
+ }
+ return result;
+ }
+
+ public void ReqEmbleSlotting(ulong slot)
+ {
+ RpcC2G_BuyExtraSkillEmblemSlot rpc = new RpcC2G_BuyExtraSkillEmblemSlot();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnEmbleSlottingBack(BuyExtraSkillEmblemSlotRes oRes)
+ {
+ bool flag = oRes.result == ErrorCode.ERR_INVALID_REQUEST;
+ if (flag)
+ {
+ string fullName = MethodBase.GetCurrentMethod().ReflectedType.FullName;
+ XSingleton<UiUtility>.singleton.OnGetInvalidRequest(fullName);
+ }
+ else
+ {
+ bool flag2 = oRes.result > ErrorCode.ERR_SUCCESS;
+ if (flag2)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.result, "fece00");
+ }
+ else
+ {
+ XEmblemDocument.HadSlottingNum = (int)oRes.extraSkillEmblemSlot;
+ bool flag3 = this._EquipHandler != null && this._EquipHandler.IsVisible();
+ if (flag3)
+ {
+ this._EquipHandler.ShowEquipments();
+ this._EquipHandler.PlayBuySlotFx(XEmblemDocument.HadSlottingNum + XEmblemDocument.Position_PaySkillStart - 1);
+ }
+ }
+ }
+ }
+
+ public void InitWhenCreateRole(uint playerLevel)
+ {
+ this.UpdateEquipLockState(playerLevel);
+ this.UpdateEquipSlottingState();
+ this.UpdateRedPoints(playerLevel);
+ }
+
+ public void UpdateEquipLockState(uint playerLevel)
+ {
+ for (int i = XEmblemDocument.Position_TotalStart; i < XEmblemDocument.Position_TotalEnd; i++)
+ {
+ bool flag = playerLevel >= this.emblemSlotUnlockLevel[i];
+ if (flag)
+ {
+ this.EquipLock[i].LevelIsdOpen = true;
+ }
+ else
+ {
+ this.EquipLock[i].LevelIsdOpen = false;
+ }
+ }
+ }
+
+ public void UpdateEquipSlottingState()
+ {
+ for (int i = XEmblemDocument.Position_TotalStart; i < XEmblemDocument.Position_NoPaySkillEnd; i++)
+ {
+ this.EquipLock[i].HadSlotting = true;
+ }
+ for (int j = XEmblemDocument.Position_PaySkillStart; j < XEmblemDocument.Position_PaySkillEnd; j++)
+ {
+ int num = j - XEmblemDocument.Position_PaySkillStart;
+ bool flag = XEmblemDocument.HadSlottingNum > num;
+ if (flag)
+ {
+ this.EquipLock[j].HadSlotting = true;
+ }
+ else
+ {
+ this.EquipLock[j].HadSlotting = false;
+ }
+ }
+ }
+
+ public List<XItem> GetEmblemItems()
+ {
+ ulong typeFilter = 1UL << XFastEnumIntEqualityComparer<ItemType>.ToInt(ItemType.EMBLEM);
+ this.m_ItemList.Clear();
+ XSingleton<XGame>.singleton.Doc.XBagDoc.GetItemsByType(typeFilter, ref this.m_ItemList);
+ bool flag = this.currentEmblemUID > 0UL;
+ if (flag)
+ {
+ foreach (XItem xitem in this.m_ItemList)
+ {
+ bool flag2 = this.currentEmblemUID == xitem.uid;
+ if (flag2)
+ {
+ this.m_ItemList.Remove(xitem);
+ break;
+ }
+ }
+ }
+ return this.m_ItemList;
+ }
+
+ public bool IsEquipThisSkillEmblem(uint skillHash, ref List<SkillEmblem.RowData> row)
+ {
+ row.Clear();
+ XBodyBag emblemBag = XBagDocument.BagDoc.EmblemBag;
+ bool flag = emblemBag == null;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ int i = XEmblemDocument.Position_SkillStart;
+ while (i < XEmblemDocument.Position_SkillEnd)
+ {
+ bool flag2 = emblemBag[i] != null && emblemBag[i].uid > 0UL;
+ if (flag2)
+ {
+ SkillEmblem.RowData emblemSkillConf = XEmblemDocument.GetEmblemSkillConf((uint)emblemBag[i].itemID);
+ bool flag3 = emblemSkillConf == null;
+ if (!flag3)
+ {
+ uint skillID = XSingleton<XSkillEffectMgr>.singleton.GetSkillID(emblemSkillConf.SkillName, 0u);
+ bool flag4 = skillID == skillHash;
+ if (flag4)
+ {
+ row.Add(emblemSkillConf);
+ }
+ bool flag5 = emblemSkillConf.ExSkillScript != string.Empty;
+ if (flag5)
+ {
+ skillID = XSingleton<XSkillEffectMgr>.singleton.GetSkillID(emblemSkillConf.ExSkillScript, 0u);
+ bool flag6 = skillID == skillHash;
+ if (flag6)
+ {
+ bool flag7 = !row.Contains(emblemSkillConf);
+ if (flag7)
+ {
+ row.Add(emblemSkillConf);
+ }
+ }
+ }
+ }
+ }
+ IL_F2:
+ i++;
+ continue;
+ goto IL_F2;
+ }
+ result = (row.Count > 0);
+ }
+ return result;
+ }
+
+ public List<ShowAttriData> AttriDataList()
+ {
+ this.ShowAttriDataLst = new List<ShowAttriData>();
+ XBodyBag emblemBag = XSingleton<XGame>.singleton.Doc.XBagDoc.EmblemBag;
+ for (int i = XEmblemDocument.Position_TotalStart; i < XEmblemDocument.Position_TotalEnd; i++)
+ {
+ bool flag = emblemBag[i] == null || emblemBag[i].itemID == 0 || emblemBag[i].Type != ItemType.EMBLEM;
+ if (!flag)
+ {
+ XEmblemItem xemblemItem = emblemBag[i] as XEmblemItem;
+ EmblemBasic.RowData emblemConf = XBagDocument.GetEmblemConf(xemblemItem.itemID);
+ bool flag2 = emblemConf != null;
+ if (flag2)
+ {
+ bool flag3 = XEmblemDocument.IsSkillEmblem(emblemConf.EmblemType);
+ if (flag3)
+ {
+ ShowAttriData showAttriData = new ShowAttriData(emblemConf);
+ this.ShowAttriDataLst.Add(showAttriData);
+ }
+ else
+ {
+ XAttrItem xattrItem = emblemBag[i] as XAttrItem;
+ for (int j = 0; j < xattrItem.changeAttr.Count; j++)
+ {
+ ShowAttriData showAttriData = this.FindTheSameAttri(xattrItem.changeAttr[j].AttrID);
+ bool flag4 = showAttriData == null;
+ if (flag4)
+ {
+ showAttriData = new ShowAttriData((uint)emblemBag[i].itemID, xattrItem.changeAttr[j]);
+ this.ShowAttriDataLst.Add(showAttriData);
+ }
+ else
+ {
+ showAttriData.Add(xattrItem.changeAttr[j].AttrValue);
+ }
+ }
+ }
+ }
+ }
+ }
+ return this.ShowAttriDataLst;
+ }
+
+ public ShowAttriData FindTheSameAttri(uint nameId)
+ {
+ for (int i = 0; i < this.ShowAttriDataLst.Count; i++)
+ {
+ bool flag = this.ShowAttriDataLst[i].NameId == nameId;
+ if (flag)
+ {
+ return this.ShowAttriDataLst[i];
+ }
+ }
+ return null;
+ }
+
+ public void RefreshBag()
+ {
+ bool flag = this._BagHandler != null && this._BagHandler.IsVisible();
+ if (flag)
+ {
+ this._BagHandler.Refresh();
+ }
+ }
+
+ public void ShowIdentifySucEffect()
+ {
+ bool flag = this._BagHandler != null && this._BagHandler.IsVisible();
+ if (flag)
+ {
+ this._BagHandler.ShowEmblemIdentifyEffect();
+ }
+ }
+
+ public bool OnLoadEquip(XEventArgs args)
+ {
+ bool flag = this._EquipHandler == null || !this._EquipHandler.active;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ XLoadEquipEventArgs xloadEquipEventArgs = args as XLoadEquipEventArgs;
+ DlgBase<EmblemTooltipDlg, EmblemTooltipDlgBehaviour>.singleton.HideToolTip(true);
+ this._bShouldUpdateRedPoints = true;
+ this._EquipHandler.SetSlot(xloadEquipEventArgs.slot, xloadEquipEventArgs.item, null);
+ result = true;
+ }
+ return result;
+ }
+
+ public bool OnAddItem(XEventArgs args)
+ {
+ XAddItemEventArgs xaddItemEventArgs = args as XAddItemEventArgs;
+ bool flag = this._BagHandler == null || !this._BagHandler.active;
+ bool result;
+ if (flag)
+ {
+ bool bNew = xaddItemEventArgs.bNew;
+ if (bNew)
+ {
+ this._bShouldUpdateRedPoints = (this._NewItems.AddItems(xaddItemEventArgs.items, false) || this._bShouldUpdateRedPoints);
+ }
+ result = false;
+ }
+ else
+ {
+ this._BagHandler.OnAddItem();
+ result = true;
+ }
+ return result;
+ }
+
+ public bool OnUnloadEquip(XEventArgs args)
+ {
+ bool flag = this._EquipHandler == null || !this._EquipHandler.active;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ XUnloadEquipEventArgs xunloadEquipEventArgs = args as XUnloadEquipEventArgs;
+ DlgBase<EmblemTooltipDlg, EmblemTooltipDlgBehaviour>.singleton.HideToolTip(true);
+ this._bShouldUpdateRedPoints = true;
+ this._EquipHandler.SetSlot(xunloadEquipEventArgs.slot, null, null);
+ result = true;
+ }
+ return result;
+ }
+
+ public bool OnRemoveItem(XEventArgs args)
+ {
+ XRemoveItemEventArgs xremoveItemEventArgs = args as XRemoveItemEventArgs;
+ this._bShouldUpdateRedPoints = (this._NewItems.RemoveItems(xremoveItemEventArgs.uids, xremoveItemEventArgs.types, true) || this._bShouldUpdateRedPoints);
+ bool flag = this._BagHandler == null || !this._BagHandler.active;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ this._BagHandler.OnRemoveItem();
+ foreach (ulong num in xremoveItemEventArgs.uids)
+ {
+ bool flag2 = num == DlgBase<EmblemTooltipDlg, EmblemTooltipDlgBehaviour>.singleton.MainItemUID;
+ if (flag2)
+ {
+ DlgBase<EmblemTooltipDlg, EmblemTooltipDlgBehaviour>.singleton.HideToolTip(false);
+ break;
+ }
+ }
+ result = true;
+ }
+ return result;
+ }
+
+ public bool OnItemNumChanged(XEventArgs args)
+ {
+ bool flag = this._BagHandler == null || !this._BagHandler.active;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ XItemNumChangedEventArgs xitemNumChangedEventArgs = args as XItemNumChangedEventArgs;
+ this._BagHandler.OnItemCountChanged(xitemNumChangedEventArgs.item);
+ result = true;
+ }
+ return result;
+ }
+
+ public bool OnSwapItem(XEventArgs args)
+ {
+ bool flag = this._EquipHandler == null || !this._EquipHandler.active || this._BagHandler == null || !this._BagHandler.active;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ XSwapItemEventArgs xswapItemEventArgs = args as XSwapItemEventArgs;
+ this._NewItems.RemoveItem(xswapItemEventArgs.itemNowOnBody.uid, xswapItemEventArgs.itemNowOnBody.Type, false);
+ DlgBase<EmblemTooltipDlg, EmblemTooltipDlgBehaviour>.singleton.HideToolTip(true);
+ this._EquipHandler.SetSlot(xswapItemEventArgs.slot, xswapItemEventArgs.itemNowOnBody, null);
+ this._BagHandler.OnSwapItem(xswapItemEventArgs.itemNowOnBody, xswapItemEventArgs.itemNowInBag, xswapItemEventArgs.slot);
+ this._bShouldUpdateRedPoints = true;
+ result = true;
+ }
+ return result;
+ }
+
+ public bool OnUpdateItem(XEventArgs args)
+ {
+ XUpdateItemEventArgs xupdateItemEventArgs = args as XUpdateItemEventArgs;
+ XItem item = xupdateItemEventArgs.item;
+ bool flag = item.Type != ItemType.EMBLEM;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ this._bShouldUpdateRedPoints = true;
+ bool flag2 = this._EquipHandler == null || !this._EquipHandler.active || this._BagHandler == null || !this._BagHandler.active;
+ if (flag2)
+ {
+ result = false;
+ }
+ else
+ {
+ int slot;
+ bool flag3 = !XSingleton<XGame>.singleton.Doc.XBagDoc.EmblemBag.GetItemPos(item.uid, out slot);
+ if (flag3)
+ {
+ this._BagHandler.OnUpdateItem(item);
+ }
+ else
+ {
+ this._EquipHandler.SetSlot(slot, item, null);
+ }
+ bool flag4 = item.uid == DlgBase<EmblemTooltipDlg, EmblemTooltipDlgBehaviour>.singleton.MainItemUID;
+ if (flag4)
+ {
+ DlgBase<EmblemTooltipDlg, EmblemTooltipDlgBehaviour>.singleton.HideToolTip(false);
+ }
+ result = true;
+ }
+ }
+ return result;
+ }
+
+ public bool OnItemChangedFinished(XEventArgs args)
+ {
+ bool bShouldUpdateRedPoints = this._bShouldUpdateRedPoints;
+ if (bShouldUpdateRedPoints)
+ {
+ this.UpdateRedPoints();
+ this._bShouldUpdateRedPoints = false;
+ }
+ return true;
+ }
+
+ public bool IsEmblemMorePowerful(ulong uid)
+ {
+ return this.IsEmblemMorePowerful(XSingleton<XGame>.singleton.Doc.XBagDoc.GetItemByUID(uid) as XEmblemItem, XSingleton<XAttributeMgr>.singleton.XPlayerData.Level);
+ }
+
+ public bool IsEmblemMorePowerful(XEmblemItem emblem, uint playerLevel)
+ {
+ bool flag = emblem == null;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ ItemList.RowData itemConf = XBagDocument.GetItemConf(emblem.itemID);
+ bool flag2 = itemConf == null;
+ if (flag2)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag3 = (long)itemConf.ReqLevel > (long)((ulong)playerLevel);
+ if (flag3)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag4 = XBagDocument.IsProfMatched(emblem.Prof);
+ bool flag5 = !flag4;
+ if (flag5)
+ {
+ result = false;
+ }
+ else
+ {
+ XBagDocument xbagDoc = XSingleton<XGame>.singleton.Doc.XBagDoc;
+ XEmblemItem xemblemItem = XEmblemDocument.CheckEquipedEmblemsAttrs(xbagDoc.EmblemBag, emblem) as XEmblemItem;
+ EmblemBasic.RowData emblemConf = XBagDocument.GetEmblemConf(emblem.itemID);
+ bool flag6 = xemblemItem == null && emblemConf != null;
+ if (flag6)
+ {
+ int num;
+ bool firstEmptyEmblemSlot = XEmblemDocument.GetFirstEmptyEmblemSlot(xbagDoc.EmblemBag, emblemConf.EmblemType, out num);
+ bool flag7 = !firstEmptyEmblemSlot;
+ if (flag7)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag8 = XEmblemDocument.IsSkillEmblem(emblemConf.EmblemType);
+ if (flag8)
+ {
+ XSkillTreeDocument specificDocument = XDocuments.GetSpecificDocument<XSkillTreeDocument>(XSkillTreeDocument.uuID);
+ SkillEmblem.RowData emblemSkillConf = XEmblemDocument.GetEmblemSkillConf((uint)emblem.itemID);
+ bool flag9 = emblemSkillConf != null && emblemSkillConf.SkillPPT > 0u;
+ if (flag9)
+ {
+ List<string> skillNames = new List<string>
+ {
+ emblemSkillConf.SkillName,
+ emblemSkillConf.ExSkillScript
+ };
+ result = specificDocument.IsEquipThisSkill(skillNames);
+ }
+ else
+ {
+ result = false;
+ }
+ }
+ else
+ {
+ result = (xbagDoc.GetItemPPT(emblem, ItemAttrCompareType.IACT_SELF) > 0u);
+ }
+ }
+ }
+ else
+ {
+ bool flag10 = emblemConf != null && XEmblemDocument.IsSkillEmblem(emblemConf.EmblemType);
+ if (flag10)
+ {
+ SkillEmblem.RowData emblemSkillConf2 = XEmblemDocument.GetEmblemSkillConf((uint)emblem.itemID);
+ SkillEmblem.RowData emblemSkillConf3 = XEmblemDocument.GetEmblemSkillConf((uint)xemblemItem.itemID);
+ bool flag11 = emblemSkillConf2 != null && emblemSkillConf3 != null;
+ if (flag11)
+ {
+ XSkillTreeDocument specificDocument2 = XDocuments.GetSpecificDocument<XSkillTreeDocument>(XSkillTreeDocument.uuID);
+ List<string> list = new List<string>
+ {
+ emblemSkillConf2.SkillName,
+ emblemSkillConf2.ExSkillScript
+ };
+ bool flag12 = specificDocument2.IsEquipThisSkill(list);
+ list.Clear();
+ list.Add(emblemSkillConf3.SkillName);
+ list.Add(emblemSkillConf3.ExSkillScript);
+ bool flag13 = specificDocument2.IsEquipThisSkill(list);
+ bool flag14 = flag12;
+ if (flag14)
+ {
+ bool flag15 = flag13;
+ result = (!flag15 || emblemSkillConf2.SkillPPT > emblemSkillConf3.SkillPPT);
+ }
+ else
+ {
+ result = false;
+ }
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("skillRowData == null || equipedSkillRowData == null, id = ", emblem.itemID.ToString(), " and ", xemblemItem.itemID.ToString(), null, null);
+ result = false;
+ }
+ }
+ else
+ {
+ result = (xbagDoc.IsAttrMorePowerful(emblem, xemblemItem, ItemAttrCompareType.IACT_SELF) == ItemAttrCompareResult.IACR_LARGER);
+ }
+ }
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ public void UpdateRedPoints()
+ {
+ this.UpdateRedPoints(XSingleton<XAttributeMgr>.singleton.XPlayerData.Level);
+ }
+
+ public void UpdateRedPoints(uint playerLevel)
+ {
+ this._bCanBePowerful = false;
+ List<XItem> emblemItems = this.GetEmblemItems();
+ for (int i = 0; i < emblemItems.Count; i++)
+ {
+ XEmblemItem xemblemItem = emblemItems[i] as XEmblemItem;
+ bool flag = xemblemItem == null;
+ if (!flag)
+ {
+ bool flag2 = this.IsEmblemMorePowerful(xemblemItem, playerLevel);
+ bool flag3 = flag2;
+ if (flag3)
+ {
+ this.bCanBePowerful = true;
+ break;
+ }
+ }
+ }
+ bool flag4 = !this._bCanBePowerful;
+ if (flag4)
+ {
+ this.bCanBePowerful = false;
+ }
+ }
+
+ public void RefreshTips(ulong uid)
+ {
+ bool flag = this._BagHandler != null && this._BagHandler.IsVisible();
+ if (flag)
+ {
+ this._BagHandler.RefreshTips(uid);
+ }
+ }
+
+ public static bool GetFirstEmptyEmblemSlot(XBodyBag bag, short emblemType, out int pos)
+ {
+ XEmblemDocument specificDocument = XDocuments.GetSpecificDocument<XEmblemDocument>(XEmblemDocument.uuID);
+ EmblemSlotStatus[] equipLock = specificDocument.EquipLock;
+ bool flag = !XEmblemDocument.IsSkillEmblem(emblemType);
+ int num;
+ int num2;
+ if (flag)
+ {
+ num = XEmblemDocument.Position_AttrStart;
+ num2 = XEmblemDocument.Position_AttrEnd;
+ }
+ else
+ {
+ num = XEmblemDocument.Position_SkillStart;
+ num2 = XEmblemDocument.Position_PaySkillEnd;
+ }
+ for (int i = num; i < num2; i++)
+ {
+ bool flag2 = !equipLock[i - XEmblemDocument.Position_TotalStart].IsLock && (bag[i] == null || bag[i].uid == 0UL);
+ if (flag2)
+ {
+ pos = i;
+ return true;
+ }
+ }
+ pos = XEmblemDocument.Position_TotalEnd;
+ return false;
+ }
+
+ public static XItem CheckEquipedEmblemsAttrs(XBodyBag bag, XItem newItem)
+ {
+ XEmblemItem xemblemItem = newItem as XEmblemItem;
+ bool flag = xemblemItem == null;
+ XItem result;
+ if (flag)
+ {
+ result = null;
+ }
+ else
+ {
+ bool flag2 = xemblemItem.changeAttr.Count > 0;
+ if (flag2)
+ {
+ XItemChangeAttr xitemChangeAttr = xemblemItem.changeAttr[0];
+ int i = XEmblemDocument.Position_TotalStart;
+ while (i < XEmblemDocument.Position_TotalEnd)
+ {
+ bool flag3 = bag[i] != null && bag[i].uid > 0UL;
+ if (flag3)
+ {
+ XEmblemItem xemblemItem2 = bag[i] as XEmblemItem;
+ bool flag4 = xemblemItem2 == null || xemblemItem2.changeAttr.Count == 0;
+ if (!flag4)
+ {
+ XItemChangeAttr xitemChangeAttr2 = xemblemItem2.changeAttr[0];
+ bool flag5 = xitemChangeAttr2.AttrID == xitemChangeAttr.AttrID;
+ if (flag5)
+ {
+ return xemblemItem2;
+ }
+ }
+ }
+ IL_C9:
+ i++;
+ continue;
+ goto IL_C9;
+ }
+ }
+ else
+ {
+ SkillEmblem.RowData emblemSkillConf = XEmblemDocument.GetEmblemSkillConf((uint)xemblemItem.itemID);
+ bool flag6 = emblemSkillConf != null;
+ if (flag6)
+ {
+ for (int j = XEmblemDocument.Position_TotalStart; j < XEmblemDocument.Position_TotalEnd; j++)
+ {
+ bool flag7 = bag[j] != null && bag[j].uid > 0UL;
+ if (flag7)
+ {
+ XEmblemItem xemblemItem3 = bag[j] as XEmblemItem;
+ bool flag8 = xemblemItem3 != null;
+ if (flag8)
+ {
+ SkillEmblem.RowData emblemSkillConf2 = XEmblemDocument.GetEmblemSkillConf((uint)xemblemItem3.itemID);
+ bool flag9 = emblemSkillConf2 != null;
+ if (flag9)
+ {
+ bool flag10 = emblemSkillConf2.SkillScript == emblemSkillConf.SkillScript;
+ if (flag10)
+ {
+ return xemblemItem3;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ result = null;
+ }
+ return result;
+ }
+
+ public static float GetSkillCDRatio(XBodyBag EmblemBag, uint skillID)
+ {
+ return XEmblemDocument.GetSkillEffectRatio(EmblemBag, skillID, 2u);
+ }
+
+ public static float GetSkillDamageRatio(XBodyBag EmblemBag, uint skillID)
+ {
+ return XEmblemDocument.GetSkillEffectRatio(EmblemBag, skillID, 1u);
+ }
+
+ public static float GetSkillEffectRatio(XBodyBag EmblemBag, uint skillID, uint type)
+ {
+ bool flag = EmblemBag == null || !XSingleton<XCombatEffectManager>.singleton.IsSkillEmblemEnabled() || skillID == 0u;
+ float result;
+ if (flag)
+ {
+ result = 0f;
+ }
+ else
+ {
+ float num = 0f;
+ int i = XEmblemDocument.Position_SkillStart;
+ while (i < XEmblemDocument.Position_SkillEnd)
+ {
+ bool flag2 = EmblemBag[i] != null && EmblemBag[i].uid > 0UL;
+ if (flag2)
+ {
+ SkillEmblem.RowData byEmblemID = XEmblemDocument._emblemSkillReader.GetByEmblemID((uint)EmblemBag[i].itemID);
+ bool flag3 = byEmblemID != null && (uint)byEmblemID.SkillType == type;
+ if (flag3)
+ {
+ uint num2 = XSingleton<XCommon>.singleton.XHash(byEmblemID.SkillName);
+ bool flag4 = num2 != skillID;
+ if (flag4)
+ {
+ uint num3 = XSingleton<XCommon>.singleton.XHash(byEmblemID.ExSkillScript);
+ bool flag5 = num3 != skillID;
+ if (flag5)
+ {
+ goto IL_102;
+ }
+ }
+ num = (float)byEmblemID.SkillPercent / 100f;
+ bool flag6 = byEmblemID.SkillType != 1;
+ if (flag6)
+ {
+ num = -num;
+ }
+ return num;
+ }
+ }
+ IL_102:
+ i++;
+ continue;
+ goto IL_102;
+ }
+ result = num;
+ }
+ return result;
+ }
+
+ public static bool IsSkillEmblem(short type)
+ {
+ return type > 1000;
+ }
+
+ private bool OnPlayerLevelChange(XEventArgs arg)
+ {
+ XPlayerLevelChangedEventArgs xplayerLevelChangedEventArgs = arg as XPlayerLevelChangedEventArgs;
+ this.UpdateEquipLockState(xplayerLevelChangedEventArgs.level);
+ return true;
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ this.InitWhenCreateRole(arg.PlayerInfo.Brief.level);
+ }
+ }
+}
|