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/XForgeDocument.cs | 409 +++++++++++++++++++++ 1 file changed, 409 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/XForgeDocument.cs (limited to 'Client/Assets/Scripts/XMainClient/XForgeDocument.cs') diff --git a/Client/Assets/Scripts/XMainClient/XForgeDocument.cs b/Client/Assets/Scripts/XMainClient/XForgeDocument.cs new file mode 100644 index 00000000..408e9618 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XForgeDocument.cs @@ -0,0 +1,409 @@ +using System; +using System.Collections.Generic; +using System.Reflection; +using KKSG; +using XMainClient.UI; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XForgeDocument : XDocComponent + { + public override uint ID + { + get + { + return XForgeDocument.uuID; + } + } + + public static XForgeDocument Doc + { + get + { + return XSingleton.singleton.Doc.GetXComponent(XForgeDocument.uuID) as XForgeDocument; + } + } + + public static EquipAttrDataMgr ForgeAttrMgr + { + get + { + return XForgeDocument.m_forgeAttrMgr; + } + } + + public EquipList.RowData EquipRow + { + get + { + return this.m_equipRow; + } + } + + public ulong CurUid + { + get + { + return this.m_curUid; + } + } + + public int TransRate + { + get + { + bool flag = this.m_transRate == -1; + if (flag) + { + this.m_transRate = XSingleton.singleton.GetInt("ForgeSmeltTransRate"); + XSingleton.singleton.AddGreenLog(string.Format("m_transRate = {0}", this.m_transRate), null, null, null, null, null); + } + return this.m_transRate; + } + } + + public Dictionary> AttackTypeDic + { + get + { + bool flag = this.m_attackTypeDic == null; + if (flag) + { + this.m_attackTypeDic = new Dictionary>(); + SeqList sequenceList = XSingleton.singleton.GetSequenceList("AttackTypeAndAttributeId", true); + for (int i = 0; i < (int)sequenceList.Count; i++) + { + bool flag2 = this.m_attackTypeDic.ContainsKey(sequenceList[i, 0]); + if (flag2) + { + this.m_attackTypeDic[sequenceList[i, 0]].Add(sequenceList[i, 1]); + } + else + { + this.m_attackTypeDic.Add(sequenceList[i, 0], new List + { + sequenceList[i, 1] + }); + } + } + } + return this.m_attackTypeDic; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("XForgeDocument"); + + public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader(); + + private static ForgeAttributes m_forgeAttrTab = new ForgeAttributes(); + + private static EquipAttrDataMgr m_forgeAttrMgr; + + private ulong m_curUid = 0UL; + + private EquipList.RowData m_equipRow = null; + + private bool m_bRedDotIsDirty = false; + + public ForgeMainHandler View; + + public bool IsUsedStone = false; + + public bool IsSelect = false; + + public bool IsShowTips = true; + + private int m_transRate = -1; + + private Dictionary> m_attackTypeDic; + + public static void Execute(OnLoadedCallback callback = null) + { + XForgeDocument.AsyncLoader.AddTask("Table/ForgeAttributes", XForgeDocument.m_forgeAttrTab, false); + XForgeDocument.AsyncLoader.Execute(callback); + } + + public static void OnTableLoaded() + { + XForgeDocument.m_forgeAttrMgr = new ForgeAttrDataMgr(XForgeDocument.m_forgeAttrTab); + } + + public override void OnAttachToHost(XObject host) + { + this.IsSelect = false; + base.OnAttachToHost(host); + } + + protected override void EventSubscribe() + { + 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_LoadEquip, new XComponent.XEventHandler(this.OnLoadEquip)); + base.RegisterEvent(XEventDefine.XEvent_UnloadEquip, new XComponent.XEventHandler(this.OnUnloadEquip)); + base.RegisterEvent(XEventDefine.XEvent_SwapItem, new XComponent.XEventHandler(this.OnSwapItem)); + base.RegisterEvent(XEventDefine.XEvent_ItemChangeFinished, new XComponent.XEventHandler(this.OnItemChangedFinished)); + base.EventSubscribe(); + } + + public override void OnDetachFromHost() + { + base.OnDetachFromHost(); + this.IsSelect = false; + this.Clear(); + } + + protected override void OnReconnected(XReconnectedEventArgs arg) + { + bool flag = this.View != null && this.View.IsVisible(); + if (flag) + { + this.View.ShowUI(); + } + } + + public override void OnEnterSceneFinally() + { + base.OnEnterSceneFinally(); + XForgeDocument.m_forgeAttrMgr.DataClear(); + } + + public bool OnUpdateItem(XEventArgs args) + { + XUpdateItemEventArgs xupdateItemEventArgs = args as XUpdateItemEventArgs; + bool flag = this.View != null && this.View.IsVisible(); + if (flag) + { + } + return true; + } + + public bool OnVirtualItemChanged(XEventArgs args) + { + XVirtualItemChangedEventArgs xvirtualItemChangedEventArgs = args as XVirtualItemChangedEventArgs; + bool flag = this.View != null && this.View.IsVisible(); + if (flag) + { + } + this.m_bRedDotIsDirty = true; + return true; + } + + public bool OnSwapItem(XEventArgs args) + { + XSwapItemEventArgs xswapItemEventArgs = args as XSwapItemEventArgs; + bool flag = xswapItemEventArgs.itemNowOnBody.Type == ItemType.EQUIP; + if (flag) + { + this.m_bRedDotIsDirty = true; + } + return true; + } + + public bool OnLoadEquip(XEventArgs args) + { + XLoadEquipEventArgs xloadEquipEventArgs = args as XLoadEquipEventArgs; + bool flag = xloadEquipEventArgs.item.Type == ItemType.EQUIP; + if (flag) + { + this.m_bRedDotIsDirty = true; + } + return true; + } + + public bool OnUnloadEquip(XEventArgs args) + { + XUnloadEquipEventArgs xunloadEquipEventArgs = args as XUnloadEquipEventArgs; + bool flag = xunloadEquipEventArgs.item.Type == ItemType.EQUIP; + if (flag) + { + this.m_bRedDotIsDirty = true; + } + return true; + } + + public bool OnAddItem(XEventArgs args) + { + XAddItemEventArgs xaddItemEventArgs = args as XAddItemEventArgs; + for (int i = 0; i < xaddItemEventArgs.items.Count; i++) + { + bool flag = xaddItemEventArgs.items[i].Type == ItemType.EQUIP; + if (flag) + { + this.m_bRedDotIsDirty = true; + } + } + return true; + } + + public bool OnRemoveItem(XEventArgs args) + { + XRemoveItemEventArgs xremoveItemEventArgs = args as XRemoveItemEventArgs; + return true; + } + + public bool OnItemChangedFinished(XEventArgs args) + { + return true; + } + + public void Clear() + { + this.m_curUid = 0UL; + bool flag = !this.m_bRedDotIsDirty; + if (flag) + { + this.m_bRedDotIsDirty = true; + } + } + + private void InitData(ulong uid) + { + this.m_curUid = uid; + XEquipItem xequipItem = XBagDocument.BagDoc.GetItemByUID(this.CurUid) as XEquipItem; + bool flag = xequipItem == null; + if (flag) + { + XSingleton.singleton.AddGreenLog(string.Format("not find item ,curUid = {0}", this.CurUid), null, null, null, null, null); + } + else + { + this.m_equipRow = XBagDocument.GetEquipConf(xequipItem.itemID); + } + } + + public void SelectEquip(ulong uid) + { + bool flag = uid == 0UL; + if (!flag) + { + bool flag2 = uid == this.m_curUid; + if (!flag2) + { + XItem itemByUID = XBagDocument.BagDoc.GetItemByUID(uid); + bool flag3 = itemByUID.Type != ItemType.EQUIP; + if (flag3) + { + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("OnlyEquipCanForge"), "fece00"); + } + else + { + bool flag4 = !XForgeDocument.ForgeAttrMgr.IsHadThisEquip(itemByUID.itemID); + if (flag4) + { + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("ThisEquipCannotForge"), "fece00"); + } + else + { + this.InitData(uid); + bool flag5 = !DlgBase.singleton.IsVisible(); + if (!flag5) + { + bool flag6 = this.View != null && this.View.IsVisible(); + if (flag6) + { + this.View.ShowUI(); + } + else + { + DlgBase.singleton.ShowRightPopView(DlgBase.singleton._ForgeMainHandler); + } + bool flag7 = DlgBase.singleton._equipHandler != null; + if (flag7) + { + DlgBase.singleton._equipHandler.SelectEquip(uid); + } + } + } + } + } + } + } + + public void ReqForgeEquip(ForgeOpType type) + { + RpcC2G_ForgeEquip rpcC2G_ForgeEquip = new RpcC2G_ForgeEquip(); + rpcC2G_ForgeEquip.oArg.uid = this.CurUid; + rpcC2G_ForgeEquip.oArg.isUsedStone = this.IsUsedStone; + rpcC2G_ForgeEquip.oArg.type = type; + XSingleton.singleton.Send(rpcC2G_ForgeEquip); + } + + public void OnForgeEquipBack(ForgeOpType type, ForgeEquipRes oRes) + { + bool flag = oRes == null; + if (flag) + { + XSingleton.singleton.ShowSystemTip(ErrorCode.ERR_FAILED, "fece00"); + } + else + { + bool flag2 = oRes.errorcode == ErrorCode.ERR_INVALID_REQUEST; + if (flag2) + { + string fullName = MethodBase.GetCurrentMethod().ReflectedType.FullName; + XSingleton.singleton.OnGetInvalidRequest(fullName); + } + else + { + bool flag3 = oRes.errorcode != ErrorCode.ERR_SUCCESS && oRes.errorcode != ErrorCode.ERR_EQUIP_FORGE_FAILED; + if (flag3) + { + XSingleton.singleton.ShowSystemTip(oRes.errorcode, "fece00"); + } + else + { + bool flag4 = this.View != null && this.View.IsVisible(); + if (flag4) + { + bool flag5 = type == ForgeOpType.Forge_Replace; + if (flag5) + { + this.View.ShowUI(); + this.View.ShowEffect(true); + } + else + { + bool flag6 = type == ForgeOpType.Forge_Equip; + if (flag6) + { + XItem itemByUID = XBagDocument.BagDoc.GetItemByUID(this.CurUid); + bool flag7 = itemByUID == null; + if (!flag7) + { + XEquipItem xequipItem = itemByUID as XEquipItem; + bool flag8 = xequipItem.forgeAttrInfo.UnSavedAttrid != 0u && xequipItem.forgeAttrInfo.ForgeAttr.Count > 0; + if (flag8) + { + this.View.ShowReplaceHandler(); + } + else + { + this.View.ShowUI(); + bool flag9 = oRes.errorcode == ErrorCode.ERR_EQUIP_FORGE_FAILED; + if (flag9) + { + this.View.ShowEffect(false); + } + else + { + this.View.ShowEffect(true); + } + } + } + } + else + { + this.View.ShowUI(); + } + } + } + } + } + } + } + } +} -- cgit v1.1-26-g67d0