diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/Equip/EquipFusionDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/Equip/EquipFusionDocument.cs | 685 |
1 files changed, 685 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/Equip/EquipFusionDocument.cs b/Client/Assets/Scripts/XMainClient/Equip/EquipFusionDocument.cs new file mode 100644 index 00000000..dfa7c898 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Equip/EquipFusionDocument.cs @@ -0,0 +1,685 @@ +using System;
+using System.Collections.Generic;
+using System.Reflection;
+using KKSG;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class EquipFusionDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return EquipFusionDocument.uuID;
+ }
+ }
+
+ public static EquipFusionDocument Doc
+ {
+ get
+ {
+ return XSingleton<XGame>.singleton.Doc.GetXComponent(EquipFusionDocument.uuID) as EquipFusionDocument;
+ }
+ }
+
+ public EquipFusionHandler Handler { get; set; }
+
+ public int NeedNum
+ {
+ get
+ {
+ return this.m_needNum;
+ }
+ }
+
+ public int MaterialId
+ {
+ get
+ {
+ return this.m_materialId;
+ }
+ }
+
+ public ulong SelectUid
+ {
+ get
+ {
+ return this.m_selectUid;
+ }
+ }
+
+ public List<EquipFuseData> FuseDataList
+ {
+ get
+ {
+ return this.m_fuseDataList;
+ }
+ }
+
+ public bool IsBreak { get; set; }
+
+ public bool IsMax { get; set; }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("EquipFusionDocument");
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ public static EquipFusionExpTable m_equipFusionExpTab = new EquipFusionExpTable();
+
+ public static EquipFusionTable m_equipfusionTab = new EquipFusionTable();
+
+ private ulong m_selectUid = 0UL;
+
+ private int m_materialId = 0;
+
+ private int m_needNum = 0;
+
+ private List<EquipFuseData> m_fuseDataList = new List<EquipFuseData>();
+
+ private Dictionary<uint, string> m_effectPathDic;
+
+ private Dictionary<uint, string> m_fuseIconNameDic;
+
+ public static bool IsEquipDown = false;
+
+ private Dictionary<uint, XTuple<uint, uint>> m_addAttrDic = new Dictionary<uint, XTuple<uint, uint>>();
+
+ private static Dictionary<ulong, EquipFusionTable.RowData> m_equipFusionDic = new Dictionary<ulong, EquipFusionTable.RowData>();
+
+ public bool GetEffectPath(uint breakLevel, out string path)
+ {
+ bool flag = this.m_effectPathDic == null;
+ if (flag)
+ {
+ this.m_effectPathDic = new Dictionary<uint, string>();
+ string[] andSeparateValue = XSingleton<XGlobalConfig>.singleton.GetAndSeparateValue("EquipfuseLevelEffectPath", XGlobalConfig.AllSeparators);
+ for (int i = 0; i < andSeparateValue.Length; i += 2)
+ {
+ bool flag2 = i + 1 == andSeparateValue.Length;
+ if (flag2)
+ {
+ break;
+ }
+ uint key;
+ bool flag3 = uint.TryParse(andSeparateValue[i], out key);
+ if (flag3)
+ {
+ bool flag4 = !this.m_effectPathDic.ContainsKey(key);
+ if (flag4)
+ {
+ this.m_effectPathDic.Add(key, andSeparateValue[i + 1]);
+ }
+ }
+ }
+ }
+ int num = 0;
+ uint key2 = 0u;
+ foreach (KeyValuePair<uint, string> keyValuePair in this.m_effectPathDic)
+ {
+ bool flag5 = num == 0;
+ if (flag5)
+ {
+ bool flag6 = breakLevel < keyValuePair.Key;
+ if (flag6)
+ {
+ break;
+ }
+ key2 = keyValuePair.Key;
+ }
+ else
+ {
+ bool flag7 = breakLevel >= keyValuePair.Key;
+ if (flag7)
+ {
+ key2 = keyValuePair.Key;
+ }
+ }
+ num++;
+ }
+ path = string.Empty;
+ bool flag8 = this.m_effectPathDic.ContainsKey(key2);
+ bool result;
+ if (flag8)
+ {
+ path = this.m_effectPathDic[key2];
+ result = true;
+ }
+ else
+ {
+ result = false;
+ }
+ return result;
+ }
+
+ public string GetFuseIconName(uint breakLevel)
+ {
+ bool flag = this.m_fuseIconNameDic == null;
+ if (flag)
+ {
+ this.m_fuseIconNameDic = new Dictionary<uint, string>();
+ string[] andSeparateValue = XSingleton<XGlobalConfig>.singleton.GetAndSeparateValue("EquipFuseIconNames", XGlobalConfig.AllSeparators);
+ for (int i = 0; i < andSeparateValue.Length; i += 2)
+ {
+ bool flag2 = i + 1 == andSeparateValue.Length;
+ if (flag2)
+ {
+ break;
+ }
+ uint key;
+ bool flag3 = uint.TryParse(andSeparateValue[i], out key);
+ if (flag3)
+ {
+ bool flag4 = !this.m_fuseIconNameDic.ContainsKey(key);
+ if (flag4)
+ {
+ this.m_fuseIconNameDic.Add(key, andSeparateValue[i + 1]);
+ }
+ }
+ }
+ }
+ int num = 0;
+ uint key2 = 0u;
+ foreach (KeyValuePair<uint, string> keyValuePair in this.m_fuseIconNameDic)
+ {
+ bool flag5 = num == 0;
+ if (flag5)
+ {
+ bool flag6 = breakLevel < keyValuePair.Key;
+ if (flag6)
+ {
+ break;
+ }
+ key2 = keyValuePair.Key;
+ }
+ else
+ {
+ bool flag7 = breakLevel >= keyValuePair.Key;
+ if (flag7)
+ {
+ key2 = keyValuePair.Key;
+ }
+ }
+ num++;
+ }
+ bool flag8 = this.m_fuseIconNameDic.ContainsKey(key2);
+ string result;
+ if (flag8)
+ {
+ result = this.m_fuseIconNameDic[key2];
+ }
+ else
+ {
+ result = "";
+ }
+ return result;
+ }
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ EquipFusionDocument.AsyncLoader.AddTask("Table/EquipFusion", EquipFusionDocument.m_equipfusionTab, false);
+ EquipFusionDocument.AsyncLoader.AddTask("Table/EquipFusionExp", EquipFusionDocument.m_equipFusionExpTab, false);
+ EquipFusionDocument.AsyncLoader.Execute(callback);
+ }
+
+ public static void OnTableLoaded()
+ {
+ for (int i = 0; i < EquipFusionDocument.m_equipfusionTab.Table.Length; i++)
+ {
+ EquipFusionTable.RowData rowData = EquipFusionDocument.m_equipfusionTab.Table[i];
+ bool flag = rowData == null;
+ if (!flag)
+ {
+ ulong key = EquipFusionDocument.MakeKey(rowData.Profession, (uint)rowData.Slot, (uint)rowData.EquipType, (uint)rowData.BreakNum);
+ bool flag2 = !EquipFusionDocument.m_equipFusionDic.ContainsKey(key);
+ if (flag2)
+ {
+ EquipFusionDocument.m_equipFusionDic.Add(key, rowData);
+ }
+ }
+ }
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.RegisterEvent(XEventDefine.XEvent_AddItem, new XComponent.XEventHandler(this.OnAddItem));
+ base.EventSubscribe();
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ EquipFusionDocument.IsEquipDown = false;
+ }
+
+ public override void OnDetachFromHost()
+ {
+ base.OnDetachFromHost();
+ }
+
+ public void SelectEquip(ulong uid)
+ {
+ XItem itemByUID = XBagDocument.BagDoc.GetItemByUID(uid);
+ bool flag = itemByUID == null;
+ if (!flag)
+ {
+ EquipList.RowData equipConf = XBagDocument.GetEquipConf(itemByUID.itemID);
+ bool flag2 = equipConf == null;
+ if (!flag2)
+ {
+ bool flag3 = equipConf.FuseCanBreakNum == 0;
+ if (flag3)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("CanNotFusion"), "fece00");
+ }
+ else
+ {
+ this.m_selectUid = uid;
+ this.SetFuseData();
+ bool flag4 = !DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton.IsVisible();
+ if (!flag4)
+ {
+ bool flag5 = this.Handler != null && this.Handler.IsVisible();
+ if (flag5)
+ {
+ this.ClearSelectMaterial();
+ this.Handler.ShowUI(false);
+ }
+ else
+ {
+ DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton.ShowRightPopView(DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._equipFusionHandler);
+ }
+ bool flag6 = DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._equipHandler != null;
+ if (flag6)
+ {
+ DlgBase<ItemSystemDlg, TabDlgBehaviour>.singleton._equipHandler.SelectEquip(uid);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ public void AddMaterial(int itemId)
+ {
+ this.m_materialId = itemId;
+ bool flag = this.Handler != null && this.Handler.IsVisible();
+ if (flag)
+ {
+ this.Handler.UpdateItem();
+ }
+ }
+
+ public void ReqEquipFuseMes()
+ {
+ RpcC2G_FuseEquip rpcC2G_FuseEquip = new RpcC2G_FuseEquip();
+ rpcC2G_FuseEquip.oArg.uid = this.m_selectUid;
+ bool flag = !this.IsBreak;
+ if (flag)
+ {
+ rpcC2G_FuseEquip.oArg.type = 0u;
+ }
+ else
+ {
+ rpcC2G_FuseEquip.oArg.type = 1u;
+ }
+ rpcC2G_FuseEquip.oArg.itemID = (uint)this.MaterialId;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_FuseEquip);
+ }
+
+ public void OnGetEquipFuseInfo(FuseEquipRes oRes)
+ {
+ bool flag = oRes == null;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(ErrorCode.ERR_FAILED, "fece00");
+ }
+ else
+ {
+ bool flag2 = oRes.errorcode == ErrorCode.ERR_INVALID_REQUEST;
+ if (flag2)
+ {
+ string fullName = MethodBase.GetCurrentMethod().ReflectedType.FullName;
+ XSingleton<UiUtility>.singleton.OnGetInvalidRequest(fullName);
+ }
+ else
+ {
+ bool flag3 = oRes.errorcode > ErrorCode.ERR_SUCCESS;
+ if (flag3)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.errorcode, "fece00");
+ }
+ else
+ {
+ bool isBreak = this.IsBreak;
+ this.SetFuseData();
+ bool flag4 = isBreak || this.IsBreak;
+ if (flag4)
+ {
+ this.ClearSelectMaterial();
+ }
+ bool flag5 = this.Handler != null && this.Handler.IsVisible();
+ if (flag5)
+ {
+ this.Handler.ShowUI(isBreak);
+ }
+ }
+ }
+ }
+ }
+
+ private void ClearSelectMaterial()
+ {
+ this.m_materialId = 0;
+ this.m_needNum = 0;
+ }
+
+ public List<EquipFuseData> GetNowFuseData(XItem item, uint profession)
+ {
+ List<EquipFuseData> list = new List<EquipFuseData>();
+ bool flag = item == null || item.Type != ItemType.EQUIP;
+ List<EquipFuseData> result;
+ if (flag)
+ {
+ result = list;
+ }
+ else
+ {
+ EquipList.RowData equipConf = XBagDocument.GetEquipConf(item.itemID);
+ bool flag2 = equipConf == null;
+ if (flag2)
+ {
+ result = list;
+ }
+ else
+ {
+ XEquipItem xequipItem = item as XEquipItem;
+ this.GetTotalAddAttr(xequipItem.fuseInfo, equipConf, profession, false);
+ for (int i = 0; i < xequipItem.changeAttr.Count; i++)
+ {
+ EquipFuseData equipFuseData = new EquipFuseData();
+ equipFuseData.Init();
+ equipFuseData.AttrId = xequipItem.changeAttr[i].AttrID;
+ equipFuseData.BeforeBaseAttrNum = xequipItem.changeAttr[i].AttrValue;
+ bool flag3 = this.m_addAttrDic.ContainsKey(equipFuseData.AttrId);
+ if (flag3)
+ {
+ equipFuseData.BeforeAddNum = this.m_addAttrDic[equipFuseData.AttrId].Item1;
+ this.m_addAttrDic.Remove(equipFuseData.AttrId);
+ }
+ list.Add(equipFuseData);
+ }
+ foreach (KeyValuePair<uint, XTuple<uint, uint>> keyValuePair in this.m_addAttrDic)
+ {
+ EquipFuseData equipFuseData2 = new EquipFuseData();
+ equipFuseData2.Init();
+ equipFuseData2.AttrId = keyValuePair.Key;
+ equipFuseData2.BeforeBaseAttrNum = keyValuePair.Value.Item1;
+ equipFuseData2.IsExtra = true;
+ list.Add(equipFuseData2);
+ }
+ result = list;
+ }
+ }
+ return result;
+ }
+
+ private void SetFuseData()
+ {
+ XItem itemByUID = XBagDocument.BagDoc.GetItemByUID(this.m_selectUid);
+ bool flag = itemByUID == null || itemByUID.Type != ItemType.EQUIP;
+ if (!flag)
+ {
+ bool flag2 = XSingleton<XEntityMgr>.singleton.Player == null;
+ if (!flag2)
+ {
+ EquipList.RowData equipConf = XBagDocument.GetEquipConf(itemByUID.itemID);
+ bool flag3 = equipConf == null;
+ if (!flag3)
+ {
+ this.m_fuseDataList.Clear();
+ XEquipItem xequipItem = itemByUID as XEquipItem;
+ int breakNum = (int)xequipItem.fuseInfo.BreakNum;
+ EquipFusionTable.RowData fuseData = this.GetFuseData(XSingleton<XEntityMgr>.singleton.Player.BasicTypeID, equipConf, (uint)breakNum);
+ bool flag4 = fuseData == null;
+ if (!flag4)
+ {
+ this.IsBreak = (xequipItem.fuseInfo.FuseExp >= fuseData.LevelNum * fuseData.NeedExpPerLevel);
+ this.IsMax = (this.IsBreak && breakNum >= (int)equipConf.FuseCanBreakNum);
+ this.GetTotalAddAttr(xequipItem.fuseInfo, equipConf, XSingleton<XEntityMgr>.singleton.Player.BasicTypeID, true);
+ foreach (KeyValuePair<uint, XTuple<uint, uint>> keyValuePair in this.m_addAttrDic)
+ {
+ EquipFuseData equipFuseData = new EquipFuseData();
+ equipFuseData.Init();
+ equipFuseData.AttrId = keyValuePair.Key;
+ equipFuseData.BeforeAddNum = keyValuePair.Value.Item1;
+ equipFuseData.AfterAddNum = keyValuePair.Value.Item2;
+ this.m_fuseDataList.Add(equipFuseData);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ private void GetTotalAddAttr(XequipFuseInfo info, EquipList.RowData equipRow, uint profession, bool needNextAttr)
+ {
+ this.m_addAttrDic.Clear();
+ int num = 0;
+ while ((long)num < (long)((ulong)(info.BreakNum + 1u)))
+ {
+ EquipFusionTable.RowData fuseData = this.GetFuseData(profession, equipRow, (uint)num);
+ bool flag = fuseData == null;
+ if (!flag)
+ {
+ bool flag2 = (long)num == (long)((ulong)info.BreakNum);
+ if (flag2)
+ {
+ for (int i = 0; i < (int)fuseData.LevelAddAttr.count; i++)
+ {
+ uint num2 = info.FuseExp / fuseData.NeedExpPerLevel;
+ num2 = ((num2 > fuseData.LevelNum) ? fuseData.LevelNum : num2);
+ bool flag3 = !this.m_addAttrDic.ContainsKey(fuseData.LevelAddAttr[i, 0]);
+ if (flag3)
+ {
+ XTuple<uint, uint> xtuple = new XTuple<uint, uint>();
+ xtuple.Item1 = fuseData.LevelAddAttr[i, 1] * num2;
+ this.m_addAttrDic.Add(fuseData.LevelAddAttr[i, 0], xtuple);
+ }
+ else
+ {
+ this.m_addAttrDic[fuseData.LevelAddAttr[i, 0]].Item1 += fuseData.LevelAddAttr[i, 1] * num2;
+ }
+ }
+ }
+ else
+ {
+ for (int j = 0; j < (int)fuseData.LevelAddAttr.count; j++)
+ {
+ bool flag4 = !this.m_addAttrDic.ContainsKey(fuseData.LevelAddAttr[j, 0]);
+ if (flag4)
+ {
+ XTuple<uint, uint> xtuple2 = new XTuple<uint, uint>();
+ xtuple2.Item1 = fuseData.LevelAddAttr[j, 1] * fuseData.LevelNum;
+ this.m_addAttrDic.Add(fuseData.LevelAddAttr[j, 0], xtuple2);
+ }
+ else
+ {
+ this.m_addAttrDic[fuseData.LevelAddAttr[j, 0]].Item1 += fuseData.LevelAddAttr[j, 1] * fuseData.LevelNum;
+ }
+ }
+ for (int k = 0; k < (int)fuseData.BreakAddAttr.count; k++)
+ {
+ bool flag5 = !this.m_addAttrDic.ContainsKey(fuseData.BreakAddAttr[k, 0]);
+ if (flag5)
+ {
+ XTuple<uint, uint> xtuple3 = new XTuple<uint, uint>();
+ xtuple3.Item1 = fuseData.BreakAddAttr[k, 1];
+ this.m_addAttrDic.Add(fuseData.BreakAddAttr[k, 0], xtuple3);
+ }
+ else
+ {
+ this.m_addAttrDic[fuseData.BreakAddAttr[k, 0]].Item1 += fuseData.BreakAddAttr[k, 1];
+ }
+ }
+ }
+ }
+ num++;
+ }
+ foreach (KeyValuePair<uint, XTuple<uint, uint>> keyValuePair in this.m_addAttrDic)
+ {
+ keyValuePair.Value.Item2 = keyValuePair.Value.Item1;
+ }
+ bool flag6 = needNextAttr && !this.IsMax;
+ if (flag6)
+ {
+ this.GetNextTotalAddAttr(info, equipRow, profession);
+ }
+ }
+
+ private void GetNextTotalAddAttr(XequipFuseInfo info, EquipList.RowData equipRow, uint profession)
+ {
+ EquipFusionTable.RowData fuseData = this.GetFuseData(profession, equipRow, info.BreakNum);
+ bool flag = fuseData == null;
+ if (!flag)
+ {
+ bool flag2 = info.FuseExp >= fuseData.LevelNum * fuseData.NeedExpPerLevel;
+ if (flag2)
+ {
+ for (int i = 0; i < (int)fuseData.BreakAddAttr.count; i++)
+ {
+ bool flag3 = !this.m_addAttrDic.ContainsKey(fuseData.BreakAddAttr[i, 0]);
+ if (flag3)
+ {
+ XTuple<uint, uint> xtuple = new XTuple<uint, uint>();
+ xtuple.Item2 = fuseData.BreakAddAttr[i, 1];
+ this.m_addAttrDic.Add(fuseData.BreakAddAttr[i, 0], xtuple);
+ }
+ else
+ {
+ this.m_addAttrDic[fuseData.BreakAddAttr[i, 0]].Item2 += fuseData.BreakAddAttr[i, 1];
+ }
+ }
+ }
+ else
+ {
+ for (int j = 0; j < (int)fuseData.LevelAddAttr.count; j++)
+ {
+ bool flag4 = !this.m_addAttrDic.ContainsKey(fuseData.LevelAddAttr[j, 0]);
+ if (flag4)
+ {
+ XTuple<uint, uint> xtuple2 = new XTuple<uint, uint>();
+ xtuple2.Item2 = fuseData.LevelAddAttr[j, 1];
+ this.m_addAttrDic.Add(fuseData.LevelAddAttr[j, 0], xtuple2);
+ }
+ else
+ {
+ this.m_addAttrDic[fuseData.LevelAddAttr[j, 0]].Item2 += fuseData.LevelAddAttr[j, 1];
+ }
+ }
+ }
+ }
+ }
+
+ private bool IsNewAttr(uint attrId, uint attrNum)
+ {
+ for (int i = 0; i < this.m_fuseDataList.Count; i++)
+ {
+ bool flag = this.m_fuseDataList[i].AttrId == attrId;
+ if (flag)
+ {
+ this.m_fuseDataList[i].AfterAddNum += attrNum;
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private bool OnAddItem(XEventArgs args)
+ {
+ bool flag = this.Handler != null && this.Handler.IsVisible();
+ if (flag)
+ {
+ this.Handler.UpdateButtom();
+ }
+ return true;
+ }
+
+ public uint GetAddExp(uint coreItemId)
+ {
+ EquipFusionExpTable.RowData byCoreItemId = EquipFusionDocument.m_equipFusionExpTab.GetByCoreItemId(coreItemId);
+ bool flag = byCoreItemId != null;
+ uint result;
+ if (flag)
+ {
+ result = byCoreItemId.AddExp;
+ }
+ else
+ {
+ result = 0u;
+ }
+ return result;
+ }
+
+ public SeqListRef<uint> GetAssistItems(uint coreItemId)
+ {
+ EquipFusionExpTable.RowData byCoreItemId = EquipFusionDocument.m_equipFusionExpTab.GetByCoreItemId(coreItemId);
+ bool flag = byCoreItemId != null;
+ SeqListRef<uint> result;
+ if (flag)
+ {
+ result = byCoreItemId.AssistItemId;
+ }
+ else
+ {
+ result = default(SeqListRef<uint>);
+ }
+ return result;
+ }
+
+ private static ulong MakeKey(uint profession, uint slot, uint equipType, uint breakNum)
+ {
+ return (ulong)profession << 48 | (ulong)slot << 32 | (ulong)((ulong)equipType << 16) | (ulong)breakNum;
+ }
+
+ public EquipFusionTable.RowData GetFuseData(uint profession, uint slot, uint equipType, uint breakNum)
+ {
+ ulong key = EquipFusionDocument.MakeKey(profession, slot, equipType, breakNum);
+ EquipFusionTable.RowData result = null;
+ bool flag = !EquipFusionDocument.m_equipFusionDic.TryGetValue(key, out result);
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog(string.Format("the data not exit int equipFusion.txt,profession = {0},slot = {1},equipType = {2},breakNum = {3}", new object[]
+ {
+ profession,
+ slot,
+ equipType,
+ breakNum
+ }), null, null, null, null, null);
+ }
+ return result;
+ }
+
+ public EquipFusionTable.RowData GetFuseData(uint profession, EquipList.RowData row, uint breakNum)
+ {
+ bool flag = row == null;
+ EquipFusionTable.RowData result;
+ if (flag)
+ {
+ result = null;
+ }
+ else
+ {
+ result = this.GetFuseData(profession, (uint)row.EquipPos, (uint)row.EquipType, breakNum);
+ }
+ return result;
+ }
+ }
+}
|