From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../XMainClient/ArtifactDeityStoveDocument.cs | 647 +++++++++++++++++++++ 1 file changed, 647 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/ArtifactDeityStoveDocument.cs (limited to 'Client/Assets/Scripts/XMainClient/ArtifactDeityStoveDocument.cs') diff --git a/Client/Assets/Scripts/XMainClient/ArtifactDeityStoveDocument.cs b/Client/Assets/Scripts/XMainClient/ArtifactDeityStoveDocument.cs new file mode 100644 index 00000000..e344729a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/ArtifactDeityStoveDocument.cs @@ -0,0 +1,647 @@ +using System; +using System.Collections.Generic; +using XMainClient.UI; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class ArtifactDeityStoveDocument : XDocComponent + { + public override uint ID + { + get + { + return ArtifactDeityStoveDocument.uuID; + } + } + + public static ArtifactDeityStoveDocument Doc + { + get + { + return XSingleton.singleton.Doc.GetXComponent(ArtifactDeityStoveDocument.uuID) as ArtifactDeityStoveDocument; + } + } + + public XNewItemTipsMgr NewItems + { + get + { + return this.m_newItems; + } + } + + public Dictionary LevelDic + { + get + { + bool flag = this.m_levelDic == null; + if (flag) + { + this.m_levelDic = new Dictionary(); + int @int = XSingleton.singleton.GetInt("ArtifactLevelMax"); + for (int i = 0; i < @int; i++) + { + int targetLevel = this.GetTargetLevel(i, this.TabLevels); + this.m_levelDic.Add(i, targetLevel); + } + } + return this.m_levelDic; + } + } + + private List TabLevels + { + get + { + bool flag = this.m_tabLevels == null; + if (flag) + { + this.m_tabLevels = XSingleton.singleton.GetIntList("ArtifactLevels"); + } + return this.m_tabLevels; + } + } + + private Dictionary ShowMinLevel + { + get + { + bool flag = this.m_showMinLevel == null; + if (flag) + { + this.m_showMinLevel = new Dictionary(); + SeqList sequenceList = XSingleton.singleton.GetSequenceList("TabMinLevel", true); + for (int i = 0; i < (int)sequenceList.Count; i++) + { + this.m_showMinLevel.Add(sequenceList[i, 0], sequenceList[i, 1]); + } + } + return this.m_showMinLevel; + } + } + + public XSysDefine SysType + { + get + { + return this.m_sysType; + } + set + { + this.m_sysType = value; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("ArtifactDeityStoveDocument"); + + public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader(); + + public int CurSelectTabLevel = 0; + + public ArtifactItemsHandler ItemsHandler; + + private List m_itemList = new List(); + + private XNewItemTipsMgr m_newItems = new XNewItemTipsMgr(); + + private Dictionary m_levelDic = null; + + private List m_tabLevels; + + private Dictionary m_showMinLevel = null; + + private List m_tempList = new List(); + + private XSysDefine m_sysType = XSysDefine.XSys_Artifact_Comepose; + + public List GetTabLevels() + { + this.m_tempList.Clear(); + int num = 0; + this.ShowMinLevel.TryGetValue(XFastEnumIntEqualityComparer.ToInt(this.m_sysType), out num); + for (int i = 0; i < this.TabLevels.Count; i++) + { + int num2 = this.TabLevels[i]; + bool flag = num2 >= num; + if (flag) + { + this.m_tempList.Add(num2); + } + } + return this.m_tempList; + } + + public static void Execute(OnLoadedCallback callback = null) + { + ArtifactDeityStoveDocument.AsyncLoader.Execute(callback); + } + + public override void OnAttachToHost(XObject host) + { + this.m_newItems.ClearItemType(); + this.m_newItems.Filter.AddItemType(ItemType.ARTIFACT); + base.OnAttachToHost(host); + } + + protected override void EventSubscribe() + { + base.EventSubscribe(); + base.RegisterEvent(XEventDefine.XEvent_AddItem, new XComponent.XEventHandler(this.OnAddItem)); + base.RegisterEvent(XEventDefine.XEvent_RemoveItem, new XComponent.XEventHandler(this.OnRemoveItem)); + base.RegisterEvent(XEventDefine.XEvent_UpdateItem, new XComponent.XEventHandler(this.OnUpdateItem)); + base.RegisterEvent(XEventDefine.XEvent_ItemChangeFinished, new XComponent.XEventHandler(this.OnItemChangeFinished)); + } + + public override void OnDetachFromHost() + { + base.OnDetachFromHost(); + this.Clear(); + } + + protected override void OnReconnected(XReconnectedEventArgs arg) + { + this.RefreshUi(); + } + + public override void OnEnterSceneFinally() + { + base.OnEnterSceneFinally(); + } + + public void Additem(ulong uid) + { + bool flag = uid == 0UL; + if (!flag) + { + switch (this.m_sysType) + { + case XSysDefine.XSys_Artifact_Comepose: + ArtifactComposeDocument.Doc.Additem(uid); + break; + case XSysDefine.XSys_Artifact_Recast: + ArtifactRecastDocument.Doc.AddItem(uid); + break; + case XSysDefine.XSys_Artifact_Fuse: + ArtifactFuseDocument.Doc.AddItem(uid); + break; + case XSysDefine.XSys_Artifact_Inscription: + ArtifactInscriptionDocument.Doc.AddItem(uid); + break; + case XSysDefine.XSys_Artifact_Refined: + ArtifactRefinedDocument.Doc.AddItem(uid); + break; + } + } + } + + public void TakeOut(ulong uid) + { + bool flag = uid == 0UL; + if (!flag) + { + switch (this.m_sysType) + { + case XSysDefine.XSys_Artifact_Comepose: + ArtifactComposeDocument.Doc.ToggleItemSelect(uid); + break; + case XSysDefine.XSys_Artifact_Recast: + ArtifactRecastDocument.Doc.TakeOut(uid); + break; + case XSysDefine.XSys_Artifact_Fuse: + ArtifactFuseDocument.Doc.TakeOut(uid); + break; + case XSysDefine.XSys_Artifact_Inscription: + ArtifactInscriptionDocument.Doc.TakeOut(uid); + break; + case XSysDefine.XSys_Artifact_Refined: + ArtifactRefinedDocument.Doc.TakeOut(uid); + break; + } + } + } + + public void ResetSelection(bool isRefreshUi) + { + switch (this.m_sysType) + { + case XSysDefine.XSys_Artifact_Comepose: + ArtifactComposeDocument.Doc.ResetSelection(isRefreshUi); + break; + case XSysDefine.XSys_Artifact_Recast: + ArtifactRecastDocument.Doc.ResetSelectUid(isRefreshUi); + break; + case XSysDefine.XSys_Artifact_Fuse: + ArtifactFuseDocument.Doc.ResetSelectUid(isRefreshUi, FuseEffectType.None); + break; + case XSysDefine.XSys_Artifact_Inscription: + ArtifactInscriptionDocument.Doc.ResetSelectUid(isRefreshUi); + break; + case XSysDefine.XSys_Artifact_Refined: + ArtifactRefinedDocument.Doc.ResetSelectUid(isRefreshUi); + break; + } + } + + public bool IsSelected(ulong uid) + { + switch (this.m_sysType) + { + case XSysDefine.XSys_Artifact_Comepose: + return ArtifactComposeDocument.Doc.IsSelected(uid); + case XSysDefine.XSys_Artifact_Recast: + return ArtifactRecastDocument.Doc.IsSelectUid(uid); + case XSysDefine.XSys_Artifact_Fuse: + return ArtifactFuseDocument.Doc.IsSelectUid(uid); + case XSysDefine.XSys_Artifact_Inscription: + return ArtifactInscriptionDocument.Doc.IsSelectUid(uid); + case XSysDefine.XSys_Artifact_Refined: + return ArtifactRefinedDocument.Doc.IsSelectUid(uid); + } + return false; + } + + public void RefreshAllHandlerUi() + { + switch (this.m_sysType) + { + case XSysDefine.XSys_Artifact_Comepose: + ArtifactComposeDocument.Doc.RefreshUi(); + break; + case XSysDefine.XSys_Artifact_Recast: + ArtifactRecastDocument.Doc.RefreshUi(); + break; + case XSysDefine.XSys_Artifact_Fuse: + ArtifactFuseDocument.Doc.RefreshUi(FuseEffectType.None); + break; + case XSysDefine.XSys_Artifact_Inscription: + ArtifactInscriptionDocument.Doc.RefreshUi(); + break; + case XSysDefine.XSys_Artifact_Refined: + ArtifactRefinedDocument.Doc.RefreshUi(); + break; + } + } + + public void RefreshUi() + { + bool flag = this.ItemsHandler != null && this.ItemsHandler.IsVisible(); + if (flag) + { + this.ItemsHandler.RefreshUi(); + } + } + + public List GetArtifactByTabLevel() + { + return this.GetArtifactByTabLevel(this.CurSelectTabLevel); + } + + public List GetArtifactByTabLevel(int level) + { + this.m_itemList.Clear(); + XBag itemBag = XBagDocument.BagDoc.ItemBag; + ulong filter = 1UL << XFastEnumIntEqualityComparer.ToInt(ItemType.ARTIFACT); + switch (this.m_sysType) + { + case XSysDefine.XSys_Artifact_Comepose: + this.GetComposeItems(level, itemBag, filter); + break; + case XSysDefine.XSys_Artifact_Recast: + this.GetEquipedArtifacts(level); + this.GetRecastItems(level, itemBag, filter); + break; + case XSysDefine.XSys_Artifact_Fuse: + this.GetEquipedArtifacts(level); + this.GetFuseItems(level, itemBag, filter); + break; + case XSysDefine.XSys_Artifact_Inscription: + this.GetEquipedArtifacts(level); + this.GetInscriptionItems(level, itemBag, filter); + break; + case XSysDefine.XSys_Artifact_Refined: + this.GetEquipedArtifacts(level); + this.GetRefinedItems(level, itemBag, filter); + break; + } + return this.m_itemList; + } + + public bool IsSelectUid(ulong uid) + { + bool result; + switch (this.m_sysType) + { + case XSysDefine.XSys_Artifact_Recast: + result = (ArtifactRecastDocument.Doc.LastSelectUid == uid); + break; + case XSysDefine.XSys_Artifact_Fuse: + result = (ArtifactFuseDocument.Doc.LastSelectUid == uid); + break; + case XSysDefine.XSys_Artifact_Inscription: + result = (ArtifactInscriptionDocument.Doc.LastSelectUid == uid); + break; + default: + result = true; + break; + } + return result; + } + + private void GetEquipedArtifacts(int level) + { + int num = 0; + for (int i = 0; i < XBagDocument.BagDoc.ArtifactBag.Length; i++) + { + XItem xitem = XBagDocument.BagDoc.ArtifactBag[i]; + bool flag = xitem == null || xitem.itemConf == null; + if (!flag) + { + bool flag2 = this.LevelDic.TryGetValue((int)xitem.itemConf.ReqLevel, out num); + if (flag2) + { + bool flag3 = num == level; + if (flag3) + { + ArtifactListTable.RowData artifactListRowData = ArtifactDocument.GetArtifactListRowData((uint)xitem.itemID); + bool flag4 = artifactListRowData != null && artifactListRowData.IsCanFuse == 1u; + if (flag4) + { + this.m_itemList.Add(xitem); + } + } + } + } + } + } + + private void GetComposeItems(int level, XBag bag, ulong filter) + { + int num = 0; + List intList = XSingleton.singleton.GetIntList("CanComposeArtifactQuanlity"); + for (int i = 0; i < bag.Count; i++) + { + bool flag = bag[i] == null; + if (!flag) + { + bool flag2 = this.LevelDic.TryGetValue((int)bag[i].itemConf.ReqLevel, out num); + if (flag2) + { + ulong num2 = 1UL << (int)bag[i].type; + bool flag3 = (num2 & filter) > 0UL && num == level; + if (flag3) + { + bool flag4 = bag[i].itemConf != null && intList.Contains((int)bag[i].itemConf.ItemQuality); + if (flag4) + { + this.m_itemList.Add(bag[i]); + } + } + } + } + } + } + + private void GetRecastItems(int level, XBag bag, ulong filter) + { + int num = 0; + for (int i = 0; i < bag.Count; i++) + { + bool flag = bag[i] == null; + if (!flag) + { + bool flag2 = this.LevelDic.TryGetValue((int)bag[i].itemConf.ReqLevel, out num); + if (flag2) + { + ulong num2 = 1UL << (int)bag[i].type; + bool flag3 = (num2 & filter) > 0UL && num == level; + if (flag3) + { + ArtifactListTable.RowData artifactListRowData = ArtifactDocument.GetArtifactListRowData((uint)bag[i].itemID); + bool flag4 = artifactListRowData != null && artifactListRowData.IsCanRecast == 1u; + if (flag4) + { + this.m_itemList.Add(bag[i]); + } + } + } + } + } + } + + private void GetFuseItems(int level, XBag bag, ulong filter) + { + int num = 0; + for (int i = 0; i < bag.Count; i++) + { + bool flag = bag[i] == null; + if (!flag) + { + bool flag2 = this.LevelDic.TryGetValue((int)bag[i].itemConf.ReqLevel, out num); + if (flag2) + { + ulong num2 = 1UL << (int)bag[i].type; + bool flag3 = (num2 & filter) > 0UL && num == level; + if (flag3) + { + ArtifactListTable.RowData artifactListRowData = ArtifactDocument.GetArtifactListRowData((uint)bag[i].itemID); + bool flag4 = artifactListRowData != null && artifactListRowData.IsCanFuse == 1u; + if (flag4) + { + this.m_itemList.Add(bag[i]); + } + } + } + } + } + } + + private void GetInscriptionItems(int level, XBag bag, ulong filter) + { + int num = 0; + ulong num2 = 1UL << XFastEnumIntEqualityComparer.ToInt(ItemType.Inscription); + for (int i = 0; i < bag.Count; i++) + { + bool flag = bag[i] == null; + if (!flag) + { + bool flag2 = this.LevelDic.TryGetValue((int)bag[i].itemConf.ReqLevel, out num); + if (flag2) + { + ulong num3 = 1UL << (int)bag[i].type; + bool flag3 = (num3 & num2) > 0UL && num == level; + if (flag3) + { + this.m_itemList.Add(bag[i]); + } + else + { + num3 = 1UL << (int)bag[i].type; + bool flag4 = (num3 & filter) > 0UL && num == level; + if (flag4) + { + ArtifactListTable.RowData artifactListRowData = ArtifactDocument.GetArtifactListRowData((uint)bag[i].itemID); + bool flag5 = artifactListRowData != null && artifactListRowData.IsCanFuse == 1u; + if (flag5) + { + this.m_itemList.Add(bag[i]); + } + } + } + } + } + } + } + + private void GetRefinedItems(int level, XBag bag, ulong filter) + { + int num = 0; + for (int i = 0; i < bag.Count; i++) + { + bool flag = bag[i] == null; + if (!flag) + { + bool flag2 = this.LevelDic.TryGetValue((int)bag[i].itemConf.ReqLevel, out num); + if (flag2) + { + ulong num2 = 1UL << (int)bag[i].type; + bool flag3 = (num2 & filter) > 0UL && num == level; + if (flag3) + { + ArtifactListTable.RowData artifactListRowData = ArtifactDocument.GetArtifactListRowData((uint)bag[i].itemID); + bool flag4 = artifactListRowData != null && artifactListRowData.IsCanRefined == 1; + if (flag4) + { + this.m_itemList.Add(bag[i]); + } + } + } + } + } + } + + private List GetQuanlityList() + { + List result; + switch (this.m_sysType) + { + case XSysDefine.XSys_Artifact_Recast: + result = XSingleton.singleton.GetIntList("CanReCastArtifactQuanlity"); + break; + case XSysDefine.XSys_Artifact_Fuse: + result = XSingleton.singleton.GetIntList("CanFuseArtifactQuanlity"); + break; + case XSysDefine.XSys_Artifact_Inscription: + result = XSingleton.singleton.GetIntList("CanInscriptionArtifactQuanlity"); + break; + default: + result = new List(); + break; + } + return result; + } + + private int GetTargetLevel(int level, List lst) + { + bool flag = lst == null || lst.Count == 0; + int result; + if (flag) + { + result = 0; + } + else + { + int count = lst.Count; + int i = 0; + while (i < count) + { + bool flag2 = level < lst[i]; + if (flag2) + { + bool flag3 = i == 0; + if (flag3) + { + return lst[i]; + } + return lst[i - 1]; + } + else + { + i++; + } + } + result = lst[count - 1]; + } + return result; + } + + private void Clear() + { + bool flag = this.m_tabLevels != null; + if (flag) + { + this.m_tabLevels.Clear(); + this.m_tabLevels = null; + } + bool flag2 = this.m_levelDic != null; + if (flag2) + { + this.m_levelDic.Clear(); + this.m_levelDic = null; + } + } + + private bool OnItemChangeFinished(XEventArgs args) + { + bool flag = this.ItemsHandler != null && this.ItemsHandler.IsVisible(); + if (flag) + { + this.ItemsHandler.RefreshUi(); + } + return true; + } + + protected bool OnAddItem(XEventArgs args) + { + XAddItemEventArgs xaddItemEventArgs = args as XAddItemEventArgs; + bool flag = this.ItemsHandler != null && this.ItemsHandler.IsVisible(); + bool result; + if (flag) + { + bool bNew = xaddItemEventArgs.bNew; + if (bNew) + { + this.m_newItems.AddItems(xaddItemEventArgs.items, false); + } + result = false; + } + else + { + result = true; + } + return result; + } + + protected bool OnRemoveItem(XEventArgs args) + { + XRemoveItemEventArgs xremoveItemEventArgs = args as XRemoveItemEventArgs; + this.m_newItems.RemoveItems(xremoveItemEventArgs.uids, xremoveItemEventArgs.types, true); + return true; + } + + protected bool OnUpdateItem(XEventArgs args) + { + XUpdateItemEventArgs xupdateItemEventArgs = args as XUpdateItemEventArgs; + bool flag = this.ItemsHandler != null && this.ItemsHandler.IsVisible() && xupdateItemEventArgs.item != null; + if (flag) + { + bool flag2 = this.IsSelectUid(xupdateItemEventArgs.item.uid); + if (flag2) + { + this.m_newItems.AddItem(xupdateItemEventArgs.item, false); + } + } + return true; + } + } +} -- cgit v1.1-26-g67d0