From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../Assets/Scripts/XMainClient/XEmblemDocument.cs | 1042 ++++++++++++++++++++ 1 file changed, 1042 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/XEmblemDocument.cs (limited to 'Client/Assets/Scripts/XMainClient/XEmblemDocument.cs') 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.singleton.IsSystemOpened(XSysDefine.XSys_Char_Emblem) & this._bCanBePowerful; + } + set + { + this._bCanBePowerful = value; + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_Char_Emblem, true); + } + } + + public XNewItemTipsMgr NewItems + { + get + { + return this._NewItems; + } + } + + public bool IsEquipEmblem + { + get + { + XBodyBag emblemBag = XSingleton.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.ToInt(ItemType.EMBLEM)); + if (flag) + { + return true; + } + } + return false; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("EmblemDocument"); + + public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader(); + + public static int Position_AttrStart = XBagDocument.BodyPosition(EmblemPosition.EMBLEM_START); + + public static int Position_AttrEnd = XBagDocument.BodyPosition(EmblemPosition.EMBLEMIX); + + public static int Position_SkillStart = XBagDocument.BodyPosition(EmblemPosition.EMBLEMIX); + + public static int Position_SkillEnd = XBagDocument.BodyPosition(EmblemPosition.EMBLEM_END); + + public static int Position_NoPaySkillStart = XBagDocument.BodyPosition(EmblemPosition.EMBLEMIX); + + public static int Position_NoPaySkillEnd = XBagDocument.BodyPosition(EmblemPosition.EMBLEMXIII); + + public static int Position_PaySkillStart = XBagDocument.BodyPosition(EmblemPosition.EMBLEMXIII); + + public static int Position_PaySkillEnd = XBagDocument.BodyPosition(EmblemPosition.EMBLEM_END); + + public static int Position_TotalStart = XBagDocument.BodyPosition(EmblemPosition.EMBLEM_START); + + public static int Position_TotalEnd = XBagDocument.BodyPosition(EmblemPosition.EMBLEM_END); + + public EmblemBagView _BagHandler = null; + + public EmblemEquipView _EquipHandler = null; + + private static SkillEmblem _emblemSkillReader = new SkillEmblem(); + + private static string emblemSkillAttrFmt = ""; + + private List[] _emblemLevels = new List[6]; + + private List m_needMoneyList = new List(); + + private EmblemSlotStatus[] m_equipLock; + + public List emblemSlotUnlockLevel = new List(); + + public static int Level_Count = 0; + + public HashSet selectedItems = new HashSet(); + + public uint selectedItemsTotalExp = 0u; + + public ulong currentEmblemUID = 0UL; + + private bool _bCanBePowerful = false; + + private bool _bShouldUpdateRedPoints = false; + + private XNewItemTipsMgr _NewItems = new XNewItemTipsMgr(); + + private List m_ItemList = new List(); + + public static int HadSlottingNum = 0; + + private List 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.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.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.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.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.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.singleton.OnGetInvalidRequest(fullName); + } + else + { + bool flag2 = oRes.result > ErrorCode.ERR_SUCCESS; + if (flag2) + { + XSingleton.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 GetEmblemItems() + { + ulong typeFilter = 1UL << XFastEnumIntEqualityComparer.ToInt(ItemType.EMBLEM); + this.m_ItemList.Clear(); + XSingleton.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 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.singleton.GetSkillID(emblemSkillConf.SkillName, 0u); + bool flag4 = skillID == skillHash; + if (flag4) + { + row.Add(emblemSkillConf); + } + bool flag5 = emblemSkillConf.ExSkillScript != string.Empty; + if (flag5) + { + skillID = XSingleton.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 AttriDataList() + { + this.ShowAttriDataLst = new List(); + XBodyBag emblemBag = XSingleton.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.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.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.singleton.MainItemUID; + if (flag2) + { + DlgBase.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.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.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.singleton.MainItemUID; + if (flag4) + { + DlgBase.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.singleton.Doc.XBagDoc.GetItemByUID(uid) as XEmblemItem, XSingleton.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.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.uuID); + SkillEmblem.RowData emblemSkillConf = XEmblemDocument.GetEmblemSkillConf((uint)emblem.itemID); + bool flag9 = emblemSkillConf != null && emblemSkillConf.SkillPPT > 0u; + if (flag9) + { + List skillNames = new List + { + 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.uuID); + List list = new List + { + 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.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.singleton.XPlayerData.Level); + } + + public void UpdateRedPoints(uint playerLevel) + { + this._bCanBePowerful = false; + List 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.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.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.singleton.XHash(byEmblemID.SkillName); + bool flag4 = num2 != skillID; + if (flag4) + { + uint num3 = XSingleton.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); + } + } +} -- cgit v1.1-26-g67d0