diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/ArtifactBagDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/ArtifactBagDocument.cs | 583 |
1 files changed, 583 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/ArtifactBagDocument.cs b/Client/Assets/Scripts/XMainClient/ArtifactBagDocument.cs new file mode 100644 index 00000000..e1d2f8ec --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ArtifactBagDocument.cs @@ -0,0 +1,583 @@ +using System;
+using System.Collections.Generic;
+using System.Text;
+using KKSG;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class ArtifactBagDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return ArtifactBagDocument.uuID;
+ }
+ }
+
+ public static ArtifactBagDocument Doc
+ {
+ get
+ {
+ return XSingleton<XGame>.singleton.Doc.GetXComponent(ArtifactBagDocument.uuID) as ArtifactBagDocument;
+ }
+ }
+
+ public XNewItemTipsMgr NewItems
+ {
+ get
+ {
+ return this.m_newItems;
+ }
+ }
+
+ public ArtifactBagHandler BagHandler
+ {
+ get
+ {
+ return this.m_bagHandler;
+ }
+ set
+ {
+ this.m_bagHandler = value;
+ }
+ }
+
+ public bool CanBePowerful
+ {
+ get
+ {
+ return this.m_canBePowerful;
+ }
+ set
+ {
+ this.m_canBePowerful = value;
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_Artifact, true);
+ }
+ }
+
+ public List<string> SuitEffectPosNames
+ {
+ get
+ {
+ bool flag = this.m_suitEffectPosNames == null;
+ if (flag)
+ {
+ this.m_suitEffectPosNames = XSingleton<XGlobalConfig>.singleton.GetStringList("ArtifactSuitEffectNames");
+ bool flag2 = this.m_suitEffectPosNames.Count < XBagDocument.ArtifactMax;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog(string.Format("artifact pos effect length not enough,at last need {0},but it only had {1}", XBagDocument.ArtifactMax, this.m_suitEffectPosNames.Count), null, null, null, null, null);
+ }
+ }
+ return this.m_suitEffectPosNames;
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("ArtifactBagDocument");
+
+ private ArtifactBagHandler m_bagHandler;
+
+ private List<XItem> m_ItemList = new List<XItem>();
+
+ private XNewItemTipsMgr m_newItems = new XNewItemTipsMgr();
+
+ private bool m_shouldUpdateRedPoints = false;
+
+ private bool m_shouldCalcMorePowerfulTip = false;
+
+ private bool m_canBePowerful = false;
+
+ private Dictionary<ulong, string> m_quantityEffectPath;
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ private static ArtifactEffect m_artifactEffectTable = new ArtifactEffect();
+
+ private List<string> m_suitEffectPosNames;
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ ArtifactBagDocument.AsyncLoader.AddTask("Table/ArtifactEffect", ArtifactBagDocument.m_artifactEffectTable, false);
+ ArtifactBagDocument.AsyncLoader.Execute(callback);
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ this.m_newItems.ClearItemType();
+ this.m_newItems.Filter.AddItemType(ItemType.ARTIFACT);
+ XSingleton<XCombatEffectManager>.singleton.Init();
+ }
+
+ 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.OnFinishItemChange));
+ }
+
+ public override void OnDetachFromHost()
+ {
+ base.OnDetachFromHost();
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ bool flag = this.BagHandler != null && this.BagHandler.IsVisible();
+ if (flag)
+ {
+ this.BagHandler.RefreshData();
+ XSingleton<XCombatEffectManager>.singleton.SetDirty();
+ }
+ }
+
+ public override void OnLeaveScene()
+ {
+ base.OnLeaveScene();
+ XSingleton<XCombatEffectManager>.singleton.ArrangeEffectData();
+ }
+
+ public override void OnEnterSceneFinally()
+ {
+ base.OnEnterSceneFinally();
+ }
+
+ protected bool OnLoadEquip(XEventArgs args)
+ {
+ XLoadEquipEventArgs xloadEquipEventArgs = args as XLoadEquipEventArgs;
+ bool flag = xloadEquipEventArgs.item.Type == ItemType.ARTIFACT;
+ if (flag)
+ {
+ this.m_shouldUpdateRedPoints = true;
+ this.m_shouldCalcMorePowerfulTip = true;
+ XSingleton<XCombatEffectManager>.singleton.SetDirty();
+ bool flag2 = this.BagHandler != null && this.BagHandler.IsVisible();
+ if (flag2)
+ {
+ this.BagHandler.LoadEquip(xloadEquipEventArgs.item, xloadEquipEventArgs.slot);
+ }
+ this.ProcessSuitEquiped((uint)xloadEquipEventArgs.item.itemID);
+ }
+ return true;
+ }
+
+ protected bool OnUnloadEquip(XEventArgs args)
+ {
+ XUnloadEquipEventArgs xunloadEquipEventArgs = args as XUnloadEquipEventArgs;
+ bool flag = xunloadEquipEventArgs.type == ItemType.ARTIFACT;
+ if (flag)
+ {
+ this.m_shouldUpdateRedPoints = true;
+ this.m_shouldCalcMorePowerfulTip = true;
+ XSingleton<XCombatEffectManager>.singleton.SetDirty();
+ bool flag2 = this.BagHandler != null && this.BagHandler.active;
+ if (flag2)
+ {
+ this.BagHandler.UnloadEquip(xunloadEquipEventArgs.slot);
+ }
+ this.ProcessSuitUnEquiped((uint)xunloadEquipEventArgs.item.itemID);
+ }
+ return true;
+ }
+
+ protected bool OnAddItem(XEventArgs args)
+ {
+ XAddItemEventArgs xaddItemEventArgs = args as XAddItemEventArgs;
+ this.m_shouldUpdateRedPoints = this.m_newItems.AddItems(xaddItemEventArgs.items, !xaddItemEventArgs.bNew);
+ this.m_shouldCalcMorePowerfulTip = this.m_shouldUpdateRedPoints;
+ bool flag = this.BagHandler == null || !this.BagHandler.IsVisible();
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ this.BagHandler.AddItem(xaddItemEventArgs.items);
+ result = true;
+ }
+ return result;
+ }
+
+ protected bool OnRemoveItem(XEventArgs args)
+ {
+ XRemoveItemEventArgs xremoveItemEventArgs = args as XRemoveItemEventArgs;
+ this.m_newItems.RemoveItems(xremoveItemEventArgs.uids, xremoveItemEventArgs.types, true);
+ this.m_shouldUpdateRedPoints = this.m_newItems.RemoveItems(xremoveItemEventArgs.uids, xremoveItemEventArgs.types, true);
+ this.m_shouldCalcMorePowerfulTip = this.m_shouldUpdateRedPoints;
+ bool flag = this.BagHandler == null || !this.BagHandler.IsVisible();
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ this.BagHandler.RemoveItem(xremoveItemEventArgs.uids);
+ result = true;
+ }
+ return result;
+ }
+
+ protected bool OnUpdateItem(XEventArgs args)
+ {
+ XUpdateItemEventArgs xupdateItemEventArgs = args as XUpdateItemEventArgs;
+ bool flag = xupdateItemEventArgs.item.Type == ItemType.ARTIFACT;
+ if (flag)
+ {
+ this.m_shouldUpdateRedPoints = true;
+ this.m_shouldCalcMorePowerfulTip = true;
+ XSingleton<XCombatEffectManager>.singleton.SetDirty();
+ }
+ bool flag2 = this.BagHandler == null || !this.BagHandler.IsVisible();
+ bool result;
+ if (flag2)
+ {
+ result = false;
+ }
+ else
+ {
+ this.BagHandler.UpdateItem(xupdateItemEventArgs.item);
+ result = true;
+ }
+ return result;
+ }
+
+ protected bool OnItemNumChanged(XEventArgs args)
+ {
+ bool flag = this.BagHandler == null || !this.BagHandler.IsVisible();
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ XItemNumChangedEventArgs xitemNumChangedEventArgs = args as XItemNumChangedEventArgs;
+ this.BagHandler.ItemNumChanged(xitemNumChangedEventArgs.item);
+ result = true;
+ }
+ return result;
+ }
+
+ protected bool OnSwapItem(XEventArgs args)
+ {
+ XSwapItemEventArgs xswapItemEventArgs = args as XSwapItemEventArgs;
+ bool flag = xswapItemEventArgs.itemNowOnBody.Type != ItemType.ARTIFACT;
+ bool result;
+ if (flag)
+ {
+ result = true;
+ }
+ else
+ {
+ XSingleton<XCombatEffectManager>.singleton.SetDirty();
+ this.m_newItems.RemoveItem(xswapItemEventArgs.itemNowOnBody.uid, ItemType.ARTIFACT, false);
+ bool flag2 = this.BagHandler != null && this.BagHandler.IsVisible();
+ if (flag2)
+ {
+ this.BagHandler.SwapItem(xswapItemEventArgs.itemNowOnBody, xswapItemEventArgs.itemNowInBag, xswapItemEventArgs.slot);
+ }
+ bool flag3 = ArtifactDocument.SuitMgr.WillChangeEquipedCount(xswapItemEventArgs.itemNowInBag.itemID, xswapItemEventArgs.itemNowOnBody.itemID) || ArtifactDocument.SuitMgr.WillChangeEquipedCount(xswapItemEventArgs.itemNowOnBody.itemID, xswapItemEventArgs.itemNowInBag.itemID);
+ if (flag3)
+ {
+ this.ProcessSuitUnEquiped((uint)xswapItemEventArgs.itemNowInBag.itemID);
+ this.ProcessSuitEquiped((uint)xswapItemEventArgs.itemNowOnBody.itemID);
+ }
+ result = true;
+ }
+ return result;
+ }
+
+ public bool OnFinishItemChange(XEventArgs args)
+ {
+ bool shouldUpdateRedPoints = this.m_shouldUpdateRedPoints;
+ if (shouldUpdateRedPoints)
+ {
+ this.UpdateRedPoints();
+ this.m_shouldUpdateRedPoints = false;
+ }
+ bool shouldCalcMorePowerfulTip = this.m_shouldCalcMorePowerfulTip;
+ if (shouldCalcMorePowerfulTip)
+ {
+ bool flag = this.BagHandler != null && this.BagHandler.IsVisible();
+ if (flag)
+ {
+ this.BagHandler.Refresh();
+ }
+ this.m_shouldCalcMorePowerfulTip = false;
+ }
+ return true;
+ }
+
+ private void ProcessSuitEquiped(uint itemid)
+ {
+ ArtifactSuit suitByArtifactId = ArtifactDocument.SuitMgr.GetSuitByArtifactId(itemid);
+ bool flag = suitByArtifactId == null;
+ if (!flag)
+ {
+ List<int> artifactSuitPos = suitByArtifactId.GetArtifactSuitPos(XSingleton<XGame>.singleton.Doc.XBagDoc.ArtifactBag);
+ bool flag2 = artifactSuitPos != null && suitByArtifactId.IsEffectJustActivated(artifactSuitPos.Count);
+ if (flag2)
+ {
+ this.ShowSuitEffectTip(suitByArtifactId, artifactSuitPos.Count, true);
+ bool flag3 = DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton.IsVisible();
+ if (flag3)
+ {
+ ArtifactFrameHandler artifactFrameHandler = DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._ArtifactFrameHandler;
+ bool flag4 = artifactFrameHandler != null && artifactFrameHandler.IsVisible();
+ if (flag4)
+ {
+ artifactFrameHandler.PlaySuitFx(suitByArtifactId.Id);
+ }
+ }
+ }
+ }
+ }
+
+ private void ProcessSuitUnEquiped(uint itemid)
+ {
+ ArtifactSuit suitByArtifactId = ArtifactDocument.SuitMgr.GetSuitByArtifactId(itemid);
+ bool flag = suitByArtifactId == null;
+ if (flag)
+ {
+ }
+ }
+
+ private void ShowSuitEffectTip(ArtifactSuit suit, int effectIndex, bool active)
+ {
+ StringBuilder stringBuilder = new StringBuilder();
+ int count = suit.effects[effectIndex].Count;
+ for (int i = 0; i < count; i++)
+ {
+ SeqListRef<uint> seqListRef = suit.effects[effectIndex];
+ stringBuilder.Append(XAttributeCommon.GetAttrStr((int)seqListRef[i, 0]) + " " + XAttributeCommon.GetAttrValueStr((int)seqListRef[i, 0], seqListRef[i, 1]));
+ bool flag = i != count;
+ if (flag)
+ {
+ stringBuilder.Append("\n");
+ }
+ }
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("SUIT_EFFECT_CHANGED", new object[]
+ {
+ suit.Name,
+ effectIndex,
+ stringBuilder.ToString(),
+ XStringDefineProxy.GetString(active ? "HAS_EFFECT" : "NO_EFFECT")
+ }), "fece00");
+ }
+
+ public void UpdateRedPoints()
+ {
+ bool flag = XSingleton<XAttributeMgr>.singleton.XPlayerData != null;
+ if (flag)
+ {
+ this.UpdateRedPoints(XSingleton<XAttributeMgr>.singleton.XPlayerData.Level);
+ }
+ }
+
+ public void UpdateRedPoints(uint playerLevel)
+ {
+ this.m_canBePowerful = false;
+ List<XItem> artifacts = this.GetArtifacts();
+ for (int i = 0; i < artifacts.Count; i++)
+ {
+ XArtifactItem artifact = artifacts[i] as XArtifactItem;
+ bool flag = artifacts == null;
+ if (!flag)
+ {
+ EquipCompare equipCompare = this.IsEquipMorePowerful(artifact);
+ bool flag2 = (equipCompare & EquipCompare.EC_MORE_POWERFUL) > EquipCompare.EC_NONE;
+ if (flag2)
+ {
+ this.CanBePowerful = true;
+ break;
+ }
+ }
+ }
+ bool flag3 = !this.m_canBePowerful;
+ if (flag3)
+ {
+ this.CanBePowerful = false;
+ }
+ }
+
+ public EquipCompare IsEquipMorePowerful(ulong uid)
+ {
+ return this.IsEquipMorePowerful(XSingleton<XGame>.singleton.Doc.XBagDoc.GetItemByUID(uid) as XArtifactItem);
+ }
+
+ public EquipCompare IsEquipMorePowerful(XArtifactItem artifact)
+ {
+ bool flag = artifact == null;
+ EquipCompare result;
+ if (flag)
+ {
+ result = EquipCompare.EC_NONE;
+ }
+ else
+ {
+ ArtifactListTable.RowData artifactListRowData = ArtifactDocument.GetArtifactListRowData((uint)artifact.itemID);
+ bool flag2 = artifactListRowData == null;
+ if (flag2)
+ {
+ result = EquipCompare.EC_NONE;
+ }
+ else
+ {
+ bool flag3 = XSingleton<XAttributeMgr>.singleton.XPlayerData != null && artifact.itemConf != null;
+ if (flag3)
+ {
+ bool flag4 = (long)artifact.itemConf.ReqLevel > (long)((ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level);
+ if (flag4)
+ {
+ return EquipCompare.EC_NONE;
+ }
+ }
+ int artifactPos = (int)artifactListRowData.ArtifactPos;
+ XBagDocument xbagDoc = XSingleton<XGame>.singleton.Doc.XBagDoc;
+ XArtifactItem xartifactItem = xbagDoc.ArtifactBag[artifactPos] as XArtifactItem;
+ bool flag5 = xartifactItem == null;
+ if (flag5)
+ {
+ result = EquipCompare.EC_MORE_POWERFUL;
+ }
+ else
+ {
+ result = EquipCompare.EC_NONE;
+ }
+ }
+ }
+ return result;
+ }
+
+ public static EquipCompare GetFinal(EquipCompare mix)
+ {
+ bool flag = (mix & EquipCompare.EC_MORE_POWERFUL) > EquipCompare.EC_NONE;
+ EquipCompare result;
+ if (flag)
+ {
+ result = EquipCompare.EC_MORE_POWERFUL;
+ }
+ else
+ {
+ bool flag2 = (mix & EquipCompare.EC_CAN_EQUIP) > EquipCompare.EC_NONE;
+ if (flag2)
+ {
+ result = EquipCompare.EC_CAN_EQUIP;
+ }
+ else
+ {
+ bool flag3 = (mix & EquipCompare.EC_CAN_SMELT) > EquipCompare.EC_NONE;
+ if (flag3)
+ {
+ result = EquipCompare.EC_CAN_SMELT;
+ }
+ else
+ {
+ result = EquipCompare.EC_NONE;
+ }
+ }
+ }
+ return result;
+ }
+
+ public void OnUseItem(UseItemArg oArg, UseItemRes oRes)
+ {
+ }
+
+ public void RefreshBag()
+ {
+ bool flag = this.BagHandler != null && this.BagHandler.IsVisible();
+ if (flag)
+ {
+ this.BagHandler.Refresh();
+ }
+ }
+
+ public List<XItem> GetArtifacts()
+ {
+ ulong typeFilter = 1UL << XFastEnumIntEqualityComparer<ItemType>.ToInt(ItemType.ARTIFACT);
+ this.m_ItemList.Clear();
+ XSingleton<XGame>.singleton.Doc.XBagDoc.GetItemsByType(typeFilter, ref this.m_ItemList);
+ return this.m_ItemList;
+ }
+
+ public bool IsHadThisPosArtifact(uint position)
+ {
+ bool flag = this.m_ItemList.Count == 0;
+ if (flag)
+ {
+ ulong typeFilter = 1UL << XFastEnumIntEqualityComparer<ItemType>.ToInt(ItemType.ARTIFACT);
+ XSingleton<XGame>.singleton.Doc.XBagDoc.GetItemsByType(typeFilter, ref this.m_ItemList);
+ }
+ for (int i = 0; i < this.m_ItemList.Count; i++)
+ {
+ ArtifactListTable.RowData artifactListRowData = ArtifactDocument.GetArtifactListRowData((uint)this.m_ItemList[i].itemID);
+ bool flag2 = artifactListRowData != null && artifactListRowData.ArtifactPos == position;
+ if (flag2)
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public bool GetArtifactEffectPath(uint quanlity, uint attrType, out string path)
+ {
+ ulong key = this.MakeKey(quanlity, attrType);
+ return this.GetArtifactEffectPath(key, out path);
+ }
+
+ public bool GetArtifactEffectPath(ulong key, out string path)
+ {
+ bool flag = this.m_quantityEffectPath == null;
+ if (flag)
+ {
+ this.m_quantityEffectPath = new Dictionary<ulong, string>();
+ for (int i = 0; i < ArtifactBagDocument.m_artifactEffectTable.Table.Length; i++)
+ {
+ ArtifactEffect.RowData rowData = ArtifactBagDocument.m_artifactEffectTable.Table[i];
+ bool flag2 = rowData != null;
+ if (flag2)
+ {
+ ulong key2 = this.MakeKey(rowData.Quanlity, rowData.AttrTyte);
+ bool flag3 = !this.m_quantityEffectPath.ContainsKey(key2);
+ if (flag3)
+ {
+ this.m_quantityEffectPath.Add(key2, rowData.Path);
+ }
+ }
+ }
+ }
+ bool flag4 = this.m_quantityEffectPath.ContainsKey(key);
+ bool result;
+ if (flag4)
+ {
+ path = this.m_quantityEffectPath[key];
+ result = true;
+ }
+ else
+ {
+ path = string.Empty;
+ result = false;
+ }
+ return result;
+ }
+
+ public ulong MakeKey(uint quanlity, uint attrType)
+ {
+ return (ulong)(quanlity * 1000u + attrType);
+ }
+ }
+}
|