From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../XMainClient/Guild/XGuildSkillDocument.cs | 512 +++++++++++++++++++++ 1 file changed, 512 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/Guild/XGuildSkillDocument.cs (limited to 'Client/Assets/Scripts/XMainClient/Guild/XGuildSkillDocument.cs') diff --git a/Client/Assets/Scripts/XMainClient/Guild/XGuildSkillDocument.cs b/Client/Assets/Scripts/XMainClient/Guild/XGuildSkillDocument.cs new file mode 100644 index 00000000..73a36893 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Guild/XGuildSkillDocument.cs @@ -0,0 +1,512 @@ +using System; +using System.Collections.Generic; +using KKSG; +using XMainClient.UI; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XGuildSkillDocument : XDocComponent + { + public override uint ID + { + get + { + return XGuildSkillDocument.uuID; + } + } + + public XPlayerAttributes Player { get; set; } + + public XBagDocument BagDoc { get; set; } + + public XGuildDocument GuildDoc { get; set; } + + public uint CurrentSkillID { get; set; } + + public int LastGuildExp { get; set; } + + public bool RedPoint + { + get + { + return this.m_RedPoint; + } + set + { + this.m_RedPoint = value; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("GuildSkillDocument"); + + public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader(); + + public static GuildSkillTable m_guidlSkillTable = new GuildSkillTable(); + + public static Dictionary> GuildSkllDic = new Dictionary>(); + + private static Dictionary m_guildSkillMaxLevels = new Dictionary(); + + private static Dictionary m_guildSkillInitLevels = new Dictionary(); + + public static List GuildSkillIDs = new List(); + + private Dictionary m_guildSkillDataDic = new Dictionary(); + + private Dictionary m_curGuildSkillLevel = new Dictionary(); + + private static Dictionary _labSkillMaxLevel = new Dictionary(); + + private bool m_RedPoint = true; + + private bool m_SendPoint = false; + + public XGuildSkillView SKillView = null; + + public XGuildGrowthLabView LabView = null; + + protected override void EventSubscribe() + { + base.EventSubscribe(); + base.RegisterEvent(XEventDefine.XEvent_VirtualItemChanged, new XComponent.XEventHandler(this.GuildPointChanged)); + base.RegisterEvent(XEventDefine.XEvent_GuildInfoChange, new XComponent.XEventHandler(this.GuildStatusChanged)); + base.RegisterEvent(XEventDefine.XEvent_PlayerLevelChange, new XComponent.XEventHandler(this.OnPlayerLevelChange)); + base.RegisterEvent(XEventDefine.XEvent_InGuildStateChanged, new XComponent.XEventHandler(this.OnPlayerLeaveGuild)); + } + + public static void Execute(OnLoadedCallback callback = null) + { + XGuildSkillDocument.AsyncLoader.AddTask("Table/GuildSkill", XGuildSkillDocument.m_guidlSkillTable, false); + XGuildSkillDocument.AsyncLoader.Execute(callback); + XGuildSkillDocument.m_guildSkillMaxLevels.Clear(); + XGuildSkillDocument.m_guildSkillInitLevels.Clear(); + XGuildSkillDocument.GuildSkllDic.Clear(); + } + + public static void OnTableLoaded() + { + XGuildSkillDocument.GuildSkllDic.Clear(); + XGuildSkillDocument._labSkillMaxLevel.Clear(); + int i = 0; + int num = XGuildSkillDocument.m_guidlSkillTable.Table.Length; + while (i < num) + { + GuildSkillTable.RowData rowData = XGuildSkillDocument.m_guidlSkillTable.Table[i]; + bool flag = rowData.needtype == 2u; + if (flag) + { + uint num2 = 0u; + bool flag2 = XGuildSkillDocument._labSkillMaxLevel.TryGetValue(rowData.skillid, out num2); + if (flag2) + { + bool flag3 = num2 < rowData.level; + if (flag3) + { + XGuildSkillDocument._labSkillMaxLevel[rowData.skillid] = rowData.level; + } + } + else + { + XGuildSkillDocument._labSkillMaxLevel.Add(rowData.skillid, rowData.level); + } + } + Dictionary dictionary; + bool flag4 = !XGuildSkillDocument.GuildSkllDic.TryGetValue(rowData.skillid, out dictionary); + if (flag4) + { + XGuildSkillDocument.GuildSkillIDs.Add(rowData.skillid); + dictionary = new Dictionary(); + XGuildSkillDocument.GuildSkllDic.Add(rowData.skillid, dictionary); + } + bool flag5 = !dictionary.ContainsKey(rowData.level); + if (flag5) + { + dictionary.Add(rowData.level, rowData); + bool flag6 = XGuildSkillDocument.m_guildSkillMaxLevels.ContainsKey(rowData.skillid); + if (flag6) + { + XGuildSkillDocument.m_guildSkillMaxLevels[rowData.skillid] = Math.Max(rowData.level, XGuildSkillDocument.m_guildSkillMaxLevels[rowData.skillid]); + } + else + { + XGuildSkillDocument.m_guildSkillMaxLevels.Add(rowData.skillid, rowData.level); + } + bool flag7 = rowData.glevel > 0u; + if (!flag7) + { + bool flag8 = XGuildSkillDocument.m_guildSkillInitLevels.ContainsKey(rowData.skillid); + if (flag8) + { + XGuildSkillDocument.m_guildSkillInitLevels[rowData.skillid] = Math.Max(rowData.level, XGuildSkillDocument.m_guildSkillInitLevels[rowData.skillid]); + } + else + { + XGuildSkillDocument.m_guildSkillInitLevels.Add(rowData.skillid, rowData.level); + } + } + } + else + { + XSingleton.singleton.AddErrorLog(string.Format("the skill[{0}] has same level[{1}] in GuildSKill.txt", rowData.skillid, rowData.level), null, null, null, null, null); + } + i++; + } + } + + public uint GetGuildSkillInitLevel(uint skillID) + { + uint num = 0u; + bool flag = XGuildSkillDocument.m_guildSkillInitLevels.TryGetValue(skillID, out num); + uint result; + if (flag) + { + result = num; + } + else + { + result = 0u; + } + return result; + } + + public uint GetGuildSkillMaxLevel(uint skillID) + { + uint num = 0u; + bool flag = XGuildSkillDocument.m_guildSkillMaxLevels.TryGetValue(skillID, out num); + uint result; + if (flag) + { + result = num; + } + else + { + result = 0u; + } + return result; + } + + public bool TryGetGuildSkillMaxLevel(uint skillID, out uint maxLevel) + { + return XGuildSkillDocument.m_guildSkillMaxLevels.TryGetValue(skillID, out maxLevel); + } + + public GuildSkillTable.RowData GetGuildSkill(uint skillID, uint level) + { + GuildSkillTable.RowData rowData; + bool flag = this.TryGetGuildSkill(skillID, level, out rowData); + GuildSkillTable.RowData result; + if (flag) + { + result = rowData; + } + else + { + result = null; + } + return result; + } + + public bool TryGetGuildSkill(uint skillID, uint level, out GuildSkillTable.RowData skillData) + { + skillData = null; + Dictionary dictionary; + bool flag = XGuildSkillDocument.GuildSkllDic.TryGetValue(skillID, out dictionary) && dictionary.TryGetValue(level, out skillData); + bool result = false;//! + if (flag) + { + result = true; + } + else + { + skillData = null; + result = false; + } + return result; + } + + public uint GetCurGuildSkillLevel(uint skillID) + { + uint result = 0u; + this.m_curGuildSkillLevel.TryGetValue(skillID, out result); + return result; + } + + public void SendLearnGuildSkill() + { + RpcC2G_LearnGuildSkill rpcC2G_LearnGuildSkill = new RpcC2G_LearnGuildSkill(); + rpcC2G_LearnGuildSkill.oArg.skillId = this.CurrentSkillID; + XSingleton.singleton.Send(rpcC2G_LearnGuildSkill); + this.m_SendPoint = true; + } + + public void ReceiveLearnGuildSKill(LearnGuildSkillAgr oArg, LearnGuildSkillRes oRes) + { + bool flag = oRes.errorcode > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowErrorCode(oRes.errorcode); + } + else + { + bool sendPoint = this.m_SendPoint; + if (sendPoint) + { + this.m_SendPoint = false; + this.SetRedPointValid(); + } + bool flag2 = this.m_curGuildSkillLevel.ContainsKey(oArg.skillId); + if (flag2) + { + uint value = this.m_curGuildSkillLevel[oArg.skillId] + 1u; + this.m_curGuildSkillLevel[oArg.skillId] = value; + } + else + { + this.m_curGuildSkillLevel.Add(oArg.skillId, 1u); + } + this.Refresh(); + } + } + + public void GetSkillList() + { + RpcC2M_AskGuildSkillInfoNew rpc = new RpcC2M_AskGuildSkillInfoNew(); + XSingleton.singleton.Send(rpc); + } + + public void OnSkillList(AskGuildSkillInfoReq org) + { + bool flag = org.errorcode > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(org.errorcode, "fece00"); + } + else + { + this.LastGuildExp = org.LastGuildExp; + this.m_guildSkillDataDic.Clear(); + int i = 0; + int count = org.SkillLel.Count; + while (i < count) + { + this.m_guildSkillDataDic[(uint)org.SkillLel[i].SkillId] = (uint)org.SkillLel[i].MaxLvl; + i++; + } + this.m_curGuildSkillLevel.Clear(); + i = 0; + count = org.roleSkills.Count; + while (i < count) + { + this.m_curGuildSkillLevel[(uint)org.roleSkills[i].SkillId] = (uint)org.roleSkills[i].MaxLvl; + i++; + } + this.Refresh(); + } + } + + public void OnUpdateGuildSkillData(GuildSkillAllData org) + { + this.LastGuildExp = org.lastGuildExp; + int i = 0; + int count = org.skillLevel.Count; + while (i < count) + { + this.m_guildSkillDataDic[(uint)org.skillLevel[i].SkillId] = (uint)org.skillLevel[i].MaxLvl; + i++; + } + this.Refresh(); + } + + public void GetStudyGuildSkill(uint skillID) + { + RpcC2M_StudyGuildSkillNew rpcC2M_StudyGuildSkillNew = new RpcC2M_StudyGuildSkillNew(); + rpcC2M_StudyGuildSkillNew.oArg.skillId = skillID; + XSingleton.singleton.Send(rpcC2M_StudyGuildSkillNew); + } + + public void OnStudyGuildSkill(StudyGuildSkillRes oRes) + { + bool flag = oRes.errorcode > ErrorCode.ERR_SUCCESS; + if (flag) + { + XSingleton.singleton.ShowSystemTip(oRes.errorcode, "fece00"); + } + else + { + this.m_guildSkillDataDic[oRes.skillId] = oRes.skillLel; + this.LastGuildExp = (int)oRes.lastExp; + bool flag2 = DlgBase.singleton.IsVisible() && DlgBase.singleton._StudyHandle.active; + if (flag2) + { + DlgBase.singleton._StudyHandle.ShowEffectDetailInfo(); + } + bool flag3 = DlgBase.singleton.IsVisible(); + if (flag3) + { + DlgBase.singleton.RefreshList(true); + } + } + } + + public uint GetSkillMaxLevel(uint skillID) + { + uint result = 0u; + this.m_guildSkillDataDic.TryGetValue(skillID, out result); + return result; + } + + public uint GetLabSkillMaxLevel(uint skillID) + { + uint result = 0u; + XGuildSkillDocument._labSkillMaxLevel.TryGetValue(skillID, out result); + return result; + } + + public override void OnEnterScene() + { + base.OnEnterScene(); + bool flag = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag) + { + } + } + + public bool GuildPointChanged(XEventArgs args) + { + XVirtualItemChangedEventArgs xvirtualItemChangedEventArgs = args as XVirtualItemChangedEventArgs; + ItemEnum itemID = (ItemEnum)xvirtualItemChangedEventArgs.itemID; + bool flag = itemID != ItemEnum.GUILD_CONTRIBUTE; + bool result; + if (flag) + { + result = true; + } + else + { + this.RefreshRedPoint(); + result = true; + } + return result; + } + + public bool GuildStatusChanged(XEventArgs args) + { + this.RefreshRedPoint(); + return true; + } + + public void Refresh() + { + this.RefreshRedPoint(); + bool flag = !DlgBase.singleton.IsVisible(); + if (!flag) + { + DlgBase.singleton.SetupSkillList(false, false); + } + } + + public void RefreshRedPoint() + { + XGuildDocument specificDocument = XDocuments.GetSpecificDocument(XGuildDocument.uuID); + this.m_RedPoint = false; + bool flag = !specificDocument.bInGuild; + if (flag) + { + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_GuildHall_Skill, true); + } + else + { + int num = (int)XDocuments.GetSpecificDocument(XBagDocument.uuID).VirtualItems[22]; + for (int i = 0; i < XGuildSkillDocument.GuildSkillIDs.Count; i++) + { + uint curGuildSkillLevel = this.GetCurGuildSkillLevel(XGuildSkillDocument.GuildSkillIDs[i]); + GuildSkillTable.RowData rowData; + bool flag2 = this.TryGetGuildSkill(XGuildSkillDocument.GuildSkillIDs[i], curGuildSkillLevel, out rowData); + if (flag2) + { + uint skillMaxLevel = this.GetSkillMaxLevel(XGuildSkillDocument.GuildSkillIDs[i]); + bool flag3 = this.GetRedPointValid() && curGuildSkillLevel < skillMaxLevel && (ulong)rowData.need[0, 1] <= (ulong)((long)num) && rowData.roleLevel <= XSingleton.singleton.XPlayerData.Level && rowData.glevel <= specificDocument.Level; + if (flag3) + { + this.m_RedPoint = true; + break; + } + bool flag4 = specificDocument.IHavePermission(GuildPermission.GPEM_STUDY_SKILL) && this.CanMaxLevelUp(XGuildSkillDocument.GuildSkillIDs[i], skillMaxLevel); + if (flag4) + { + this.m_RedPoint = true; + break; + } + } + } + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_GuildHall_Skill, true); + } + } + + public bool GetRedPointValid() + { + return XDocuments.GetSpecificDocument(XOptionsDocument.uuID).GetValue(XOptionsDefine.OD_GUILD_SKILL_LOCK) == 1; + } + + public void SetRedPointValid() + { + XOptionsDocument specificDocument = XDocuments.GetSpecificDocument(XOptionsDocument.uuID); + bool flag = specificDocument.GetValue(XOptionsDefine.OD_GUILD_SKILL_LOCK) == 1; + if (flag) + { + specificDocument.SetValue(XOptionsDefine.OD_GUILD_SKILL_LOCK, 0, false); + } + } + + public bool CanMaxLevelUp(uint skillId, uint skillLevel) + { + uint num; + bool flag = !this.TryGetGuildSkillMaxLevel(skillId, out num) || num <= skillLevel; + bool result; + if (flag) + { + result = false; + } + else + { + GuildSkillTable.RowData rowData; + bool flag2 = !this.TryGetGuildSkill(skillId, num, out rowData); + if (flag2) + { + result = false; + } + else + { + XGuildDocument specificDocument = XDocuments.GetSpecificDocument(XGuildDocument.uuID); + uint num2 = XGuildDocument.GuildConfig.GetTotalStudyCount((int)rowData.glevel, (int)specificDocument.Level) + this.GetGuildSkillInitLevel(skillId); + result = (num2 > num && (ulong)rowData.rexp <= (ulong)((long)this.LastGuildExp)); + } + } + return result; + } + + private bool OnPlayerLevelChange(XEventArgs args) + { + this.RefreshRedPoint(); + return true; + } + + private bool OnPlayerLeaveGuild(XEventArgs args) + { + XInGuildStateChangedEventArgs xinGuildStateChangedEventArgs = args as XInGuildStateChangedEventArgs; + bool bIsEnter = xinGuildStateChangedEventArgs.bIsEnter; + if (bIsEnter) + { + RpcC2M_AskGuildSkillInfoNew rpc = new RpcC2M_AskGuildSkillInfoNew(); + XSingleton.singleton.Send(rpc); + } + return true; + } + + protected override void OnReconnected(XReconnectedEventArgs arg) + { + } + } +} -- cgit v1.1-26-g67d0