diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XCombatStatisticsDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XCombatStatisticsDocument.cs | 394 |
1 files changed, 394 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XCombatStatisticsDocument.cs b/Client/Assets/Scripts/XMainClient/XCombatStatisticsDocument.cs new file mode 100644 index 00000000..f60ba858 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XCombatStatisticsDocument.cs @@ -0,0 +1,394 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using XMainClient.UI;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XCombatStatisticsDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XCombatStatisticsDocument.uuID;
+ }
+ }
+
+ public bool bShowDps
+ {
+ get
+ {
+ return this.m_bShowDps;
+ }
+ }
+
+ public List<XCombatStatisticsInfo> StatisticsList
+ {
+ get
+ {
+ return this.m_StatisticsList;
+ }
+ }
+
+ public double TotalDamage { get; set; }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("CombatStatisticsDocument");
+
+ public BattleDpsHandler DpsHandler;
+
+ public BattleStatisticsHandler StatisticsHandler;
+
+ private bool m_bShowDps;
+
+ private double m_DpsBase;
+
+ private double m_DpsDenominator;
+
+ private double m_RankBase;
+
+ public bool bShowDamage;
+
+ private List<XCombatStatisticsInfo> m_StatisticsList = new List<XCombatStatisticsInfo>();
+
+ private Dictionary<string, XCombatStatisticsInfo> m_DicStatistics = new Dictionary<string, XCombatStatisticsInfo>();
+
+ private XSecuritySkillInfo m_ServerSkillStatistics = new XSecuritySkillInfo();
+
+ private XSecurityMobInfo m_ServerMobStatistics = new XSecurityMobInfo();
+
+ private XSecuritySkillInfo m_SkillStatistics = new XSecuritySkillInfo();
+
+ private XSecurityMobInfo m_MobStatistics = new XSecurityMobInfo();
+
+ private XSecuritySkillInfo m_SkillReset = new XSecuritySkillInfo();
+
+ private XSecurityMobInfo m_MobReset = new XSecurityMobInfo();
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ this.m_RankBase = double.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("DpsBaseRank"));
+ }
+
+ public override void OnEnterScene()
+ {
+ base.OnEnterScene();
+ SceneTable.RowData sceneData = XSingleton<XScene>.singleton.SceneData;
+ this.m_DpsBase = sceneData.DPS[0];
+ this.m_DpsDenominator = sceneData.DPS[1];
+ this.m_bShowDps = (this.m_DpsDenominator > 0.0);
+ this.bShowDamage = false;
+ }
+
+ public override void OnEnterSceneFinally()
+ {
+ base.OnEnterSceneFinally();
+ XSingleton<XAttributeMgr>.singleton.XPlayerData.CombatReset();
+ this.m_SkillReset.Reset();
+ this.m_MobReset.Reset();
+ }
+
+ public void ReqDps()
+ {
+ bool syncMode = XSingleton<XGame>.singleton.SyncMode;
+ if (!syncMode)
+ {
+ bool flag = this.bShowDamage;
+ if (flag)
+ {
+ bool flag2 = this.DpsHandler != null && this.DpsHandler.IsVisible();
+ if (flag2)
+ {
+ this.DpsHandler.SetInfo(XSingleton<XAttributeMgr>.singleton.XPlayerData.PrintDamage.ToString("F1"));
+ }
+ }
+ else
+ {
+ double dps = XSingleton<XAttributeMgr>.singleton.XPlayerData.Dps;
+ this._SetDps(dps);
+ }
+ }
+ }
+
+ public void OnGetDps(double dps)
+ {
+ this._SetDps(dps);
+ }
+
+ private void _SetDps(double dps)
+ {
+ bool flag = !this.bShowDps;
+ if (!flag)
+ {
+ double dps2 = 0.0;
+ double num = 0.0;
+ bool flag2 = dps > 0.0;
+ if (flag2)
+ {
+ num = this.m_RankBase;
+ dps2 = dps;
+ bool flag3 = dps > this.m_DpsBase;
+ if (flag3)
+ {
+ num += (dps - this.m_DpsBase) / this.m_DpsDenominator;
+ }
+ }
+ num = Math.Min(num, 99.0);
+ bool flag4 = this.DpsHandler != null && this.DpsHandler.IsVisible();
+ if (flag4)
+ {
+ this.DpsHandler.SetDps(dps2, num);
+ }
+ }
+ }
+
+ private void _ClearStatistics()
+ {
+ for (int i = 0; i < this.m_StatisticsList.Count; i++)
+ {
+ this.m_StatisticsList[i].Recycle();
+ }
+ this.m_StatisticsList.Clear();
+ this.m_DicStatistics.Clear();
+ }
+
+ private void _BuildPlayerStatistics(BattleStatisticsNtf data)
+ {
+ bool flag = XSingleton<XEntityMgr>.singleton.Player == null;
+ if (!flag)
+ {
+ XSkillMgr skillMgr = XSingleton<XEntityMgr>.singleton.Player.SkillMgr;
+ bool flag2 = skillMgr == null;
+ if (!flag2)
+ {
+ bool flag3 = data.skillCount.Count != data.skillID.Count || data.skillID.Count != data.skillValue.Count;
+ if (flag3)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Count not the same. ", data.skillID.Count.ToString(), " ", data.skillCount.Count.ToString(), " ", data.skillValue.Count.ToString());
+ }
+ else
+ {
+ this.m_ServerSkillStatistics.Reset();
+ for (int i = 0; i < data.skillID.Count; i++)
+ {
+ this.m_ServerSkillStatistics.OnCast(data.skillID[i], data.skillCount[i]);
+ this.m_ServerSkillStatistics.OnCastDamage(data.skillID[i], data.skillValue[i]);
+ }
+ this.m_SkillStatistics.Reset();
+ this.m_ServerSkillStatistics.EndTo(XSingleton<XEntityMgr>.singleton.Player, this.m_SkillStatistics, false);
+ this._ProcessSkillStatistics();
+ }
+ }
+ }
+ }
+
+ private void _BuildPlayerStatistics()
+ {
+ XSecuritySkillInfo xsecuritySkillInfo = XSecuritySkillInfo.TryGetStatistics(XSingleton<XEntityMgr>.singleton.Player);
+ bool flag = xsecuritySkillInfo == null;
+ if (!flag)
+ {
+ XAttributes attributes = XSingleton<XEntityMgr>.singleton.Player.Attributes;
+ XSkillMgr skillMgr = XSingleton<XEntityMgr>.singleton.Player.SkillMgr;
+ bool flag2 = attributes == null || skillMgr == null;
+ if (!flag2)
+ {
+ this.m_SkillStatistics.Reset();
+ xsecuritySkillInfo.EndTo(XSingleton<XEntityMgr>.singleton.Player, this.m_SkillStatistics, false);
+ this._ProcessSkillStatistics();
+ }
+ }
+ }
+
+ private void _ProcessSkillStatistics()
+ {
+ XCombatStatisticsInfo data = XDataPool<XCombatStatisticsInfo>.GetData();
+ bool flag = !data.Set(this.m_SkillStatistics.NormalAttackInfo, XSingleton<XEntityMgr>.singleton.Player, this.m_SkillReset.NormalAttackInfo);
+ if (flag)
+ {
+ data.Recycle();
+ }
+ else
+ {
+ data.name = XStringDefineProxy.GetString("PhysicalAttack");
+ data.CutName();
+ this.m_StatisticsList.Add(data);
+ this.m_DicStatistics[data.name] = data;
+ }
+ for (int i = 0; i < this.m_SkillStatistics.SkillInfoList.Count; i++)
+ {
+ XCombatStatisticsInfo data2 = XDataPool<XCombatStatisticsInfo>.GetData();
+ bool flag2 = !data2.Set(this.m_SkillStatistics.SkillInfoList[i], XSingleton<XEntityMgr>.singleton.Player, this.m_SkillReset.GetSkillInfoByID(this.m_SkillStatistics.SkillInfoList[i]._SkillID));
+ if (flag2)
+ {
+ data2.Recycle();
+ }
+ else
+ {
+ this.m_StatisticsList.Add(data2);
+ this.m_DicStatistics[data2.name] = data2;
+ }
+ }
+ }
+
+ private void _BuildMobsStatistics(BattleStatisticsNtf data)
+ {
+ bool flag = data.mobCount.Count != data.mobID.Count || data.mobID.Count != data.mobValue.Count;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Count not the same. ", data.mobID.Count.ToString(), " ", data.mobCount.Count.ToString(), " ", data.mobValue.Count.ToString());
+ }
+ else
+ {
+ this.m_ServerMobStatistics.Reset();
+ for (int i = 0; i < data.mobID.Count; i++)
+ {
+ this.m_ServerMobStatistics.OnCast(data.mobID[i], data.mobCount[i]);
+ this.m_ServerMobStatistics.OnCastDamage(data.mobID[i], data.mobValue[i]);
+ }
+ this.m_MobStatistics.Reset();
+ this.m_MobStatistics.Merge(this.m_ServerMobStatistics);
+ this._ProcessMobStatistics();
+ }
+ }
+
+ private void _BuildMobsStatistics()
+ {
+ XSecurityMobInfo xsecurityMobInfo = XSecurityMobInfo.TryGetStatistics(XSingleton<XEntityMgr>.singleton.Player);
+ bool flag = xsecurityMobInfo == null;
+ if (!flag)
+ {
+ this.m_MobStatistics.Reset();
+ this.m_MobStatistics.Merge(xsecurityMobInfo);
+ XSkillComponent skill = XSingleton<XEntityMgr>.singleton.Player.Skill;
+ bool flag2 = skill != null && skill.SkillMobs != null;
+ if (flag2)
+ {
+ for (int i = 0; i < skill.SkillMobs.Count; i++)
+ {
+ this.m_MobStatistics.Append(skill.SkillMobs[i]);
+ }
+ }
+ XBuffComponent buffs = XSingleton<XEntityMgr>.singleton.Player.Buffs;
+ bool flag3 = buffs != null;
+ if (flag3)
+ {
+ for (int j = 0; j < buffs.BuffList.Count; j++)
+ {
+ XBuff xbuff = buffs.BuffList[j];
+ bool flag4 = !xbuff.Valid || xbuff.EffectData.MobID == 0UL;
+ if (!flag4)
+ {
+ XEntity entity = XSingleton<XEntityMgr>.singleton.GetEntity(xbuff.EffectData.MobID);
+ bool flag5 = entity == null;
+ if (!flag5)
+ {
+ this.m_MobStatistics.Append(entity);
+ }
+ }
+ }
+ }
+ this._ProcessMobStatistics();
+ }
+ }
+
+ private void _ProcessMobStatistics()
+ {
+ for (int i = 0; i < this.m_MobStatistics.MobInfoList.Count; i++)
+ {
+ XCombatStatisticsInfo data = XDataPool<XCombatStatisticsInfo>.GetData();
+ bool flag = !data.Set(this.m_MobStatistics.MobInfoList[i], XSingleton<XEntityMgr>.singleton.Player, this.m_MobReset.GetMobInfoByID(this.m_MobStatistics.MobInfoList[i]._TemplateID));
+ if (flag)
+ {
+ data.Recycle();
+ }
+ else
+ {
+ XCombatStatisticsInfo xcombatStatisticsInfo;
+ bool flag2 = this.m_DicStatistics.TryGetValue(data.name, out xcombatStatisticsInfo);
+ if (flag2)
+ {
+ xcombatStatisticsInfo.MergeValue(data);
+ data.Recycle();
+ }
+ else
+ {
+ this.m_StatisticsList.Add(data);
+ this.m_DicStatistics[data.name] = data;
+ }
+ }
+ }
+ }
+
+ public void ReqStatistics()
+ {
+ bool syncMode = XSingleton<XGame>.singleton.SyncMode;
+ if (syncMode)
+ {
+ PtcC2G_BattleStatisticsReport proto = new PtcC2G_BattleStatisticsReport();
+ XSingleton<XClientNetwork>.singleton.Send(proto);
+ }
+ else
+ {
+ this._ClearStatistics();
+ this._BuildPlayerStatistics();
+ this._BuildMobsStatistics();
+ this.m_StatisticsList.Sort();
+ this._BuildPercentage();
+ this._RefreshUI();
+ }
+ }
+
+ public void OnGetStatistics(BattleStatisticsNtf data)
+ {
+ bool flag = data == null;
+ if (!flag)
+ {
+ this._ClearStatistics();
+ this._BuildPlayerStatistics(data);
+ this._BuildMobsStatistics(data);
+ this.m_StatisticsList.Sort();
+ this._BuildPercentage();
+ this._RefreshUI();
+ }
+ }
+
+ public void ResetStatistics()
+ {
+ this.m_SkillReset.Reset();
+ this.m_SkillReset.Merge(this.m_SkillStatistics);
+ this.m_MobReset.Reset();
+ this.m_MobReset.Merge(this.m_MobStatistics);
+ }
+
+ private void _BuildPercentage()
+ {
+ this.TotalDamage = 0.0;
+ for (int i = 0; i < this.m_StatisticsList.Count; i++)
+ {
+ XCombatStatisticsInfo xcombatStatisticsInfo = this.m_StatisticsList[i];
+ this.TotalDamage += xcombatStatisticsInfo.value;
+ }
+ for (int j = 0; j < this.m_StatisticsList.Count; j++)
+ {
+ XCombatStatisticsInfo xcombatStatisticsInfo2 = this.m_StatisticsList[j];
+ xcombatStatisticsInfo2.percent = ((this.TotalDamage == 0.0) ? 0f : ((float)(xcombatStatisticsInfo2.value / this.TotalDamage)));
+ }
+ }
+
+ public void _RefreshUI()
+ {
+ bool flag = this.StatisticsHandler != null && this.StatisticsHandler.IsVisible();
+ if (flag)
+ {
+ this.StatisticsHandler.RefreshData();
+ }
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ }
+ }
+}
|