From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- Client/Assets/Scripts/XMainClient/XTaskDocument.cs | 1085 ++++++++++++++++++++ 1 file changed, 1085 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/XTaskDocument.cs (limited to 'Client/Assets/Scripts/XMainClient/XTaskDocument.cs') diff --git a/Client/Assets/Scripts/XMainClient/XTaskDocument.cs b/Client/Assets/Scripts/XMainClient/XTaskDocument.cs new file mode 100644 index 00000000..664c39b5 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XTaskDocument.cs @@ -0,0 +1,1085 @@ +using System; +using System.Collections.Generic; +using System.Text; +using KKSG; +using UnityEngine; +using XMainClient.UI; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XTaskDocument : XDocComponent + { + public override uint ID + { + get + { + return XTaskDocument.uuID; + } + } + + public XTaskRecord TaskRecord + { + get + { + return this.m_TaskRecord; + } + } + + public uint CurrentSelect { get; set; } + + public Dictionary TaskMonstersKilled + { + get + { + return this.m_TaskMonstersKilled; + } + } + + public int NaviTarget + { + get + { + return this.m_NaviTarget; + } + } + + public uint NaviScene + { + get + { + return this.m_NaviScene; + } + } + + public uint NaviTask + { + get + { + return this.m_NaviTask; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("TaskDocument"); + + private string FX_TASK_BEGIN = "Effects/FX_Particle/Scene/Lzg_scene/rwts_01"; + + private string FX_TASK_INPROCESS = "Effects/FX_Particle/Scene/Lzg_scene/rwts_02"; + + private string FX_TASK_END = "Effects/FX_Particle/Scene/Lzg_scene/rwts_03"; + + private List m_Fxes = new List(); + + public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader(); + + private static TaskTableNew _TaskTable = new TaskTableNew(); + + private Dictionary> m_AppearNpcs = new Dictionary>(); + + private Dictionary> m_DisappearNpcs = new Dictionary>(); + + private XTaskRecord m_TaskRecord = new XTaskRecord(); + + private static uint[] TypeSortValue = new uint[20]; + + private string m_TempTarget; + + private uint[] m_TempNpcData; + + private Dictionary m_TempNpcTopTask = new Dictionary(); + + private List m_TempTasks = new List(); + + private Dictionary m_TaskMonstersKilled = new Dictionary(); + + private int m_NaviTarget; + + private uint m_NaviScene; + + private uint m_NaviTask; + + private static uint _HighestPriorityTask = 0u; + + public static void Execute(OnLoadedCallback callback = null) + { + XTaskDocument.AsyncLoader.AddTask("Table/TaskListNew", XTaskDocument._TaskTable, false); + XTaskDocument.AsyncLoader.Execute(callback); + } + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + string[] andSeparateValue = XSingleton.singleton.GetAndSeparateValue("TaskTypeSort", XGlobalConfig.ListSeparator); + uint num = 0u; + while ((ulong)num < (ulong)((long)andSeparateValue.Length)) + { + XTaskDocument.TypeSortValue[(int)uint.Parse(andSeparateValue[(int)num])] = num; + num += 1u; + } + this.m_AppearNpcs.Clear(); + this.m_DisappearNpcs.Clear(); + XNpcInfo npcInfo = XSingleton.singleton.NpcInfo; + for (int i = 0; i < npcInfo.Table.Length; i++) + { + XNpcInfo.RowData rowData = npcInfo.Table[i]; + bool flag = rowData.RequiredTaskID > 0u; + if (flag) + { + List list; + bool flag2 = !this.m_AppearNpcs.TryGetValue(rowData.RequiredTaskID, out list); + if (flag2) + { + list = new List(); + this.m_AppearNpcs.Add(rowData.RequiredTaskID, list); + } + list.Add(rowData.ID); + } + bool flag3 = rowData.DisappearTask > 0u; + if (flag3) + { + List list2; + bool flag4 = !this.m_DisappearNpcs.TryGetValue(rowData.DisappearTask, out list2); + if (flag4) + { + list2 = new List(); + this.m_DisappearNpcs.Add(rowData.DisappearTask, list2); + } + list2.Add(rowData.ID); + } + } + } + + protected override void EventSubscribe() + { + base.EventSubscribe(); + base.RegisterEvent(XEventDefine.XEvent_RealDead, new XComponent.XEventHandler(this._OnEntityDie)); + base.RegisterEvent(XEventDefine.XEvent_TaskStateChange, new XComponent.XEventHandler(this._OnTaskStateChanged)); + base.RegisterEvent(XEventDefine.XEvent_NpcFavorFxChange, new XComponent.XEventHandler(this._NotifyXTaskDocFx)); + } + + public static TaskTableNew.RowData GetTaskData(uint taskID) + { + return XTaskDocument._TaskTable.GetByTaskID(taskID); + } + + public void ResetNavi() + { + this.m_NaviScene = 0u; + this.m_NaviTarget = 0; + } + + public XTaskInfo GetTaskInfo(uint taskID) + { + for (int i = 0; i < this.TaskRecord.Tasks.Count; i++) + { + bool flag = this.TaskRecord.Tasks[i].ID == taskID; + if (flag) + { + return this.TaskRecord.Tasks[i]; + } + } + return null; + } + + public TaskStatus GetTaskStatue() + { + TaskStatus taskStatus = TaskStatus.TaskStatus_Over; + for (int i = 0; i < this.TaskRecord.Tasks.Count; i++) + { + TaskTableNew.RowData taskData = XTaskDocument.GetTaskData(this.TaskRecord.Tasks[i].ID); + bool flag = taskData == null || (ulong)this.TaskRecord.Tasks[i].TableData.TaskType != (ulong)((long)XFastEnumIntEqualityComparer.ToInt(XTaskType.TT_GuildDailyTask)); + if (!flag) + { + taskStatus = this.TaskRecord.Tasks[i].Status; + bool flag2 = taskStatus == TaskStatus.TaskStatus_Taked || taskStatus == TaskStatus.TaskStatus_Finish; + if (flag2) + { + break; + } + } + } + return taskStatus; + } + + private bool _GetNpcData(TaskTableNew.RowData data, XTaskInfo info) + { + bool flag = data == null; + bool result; + if (flag) + { + result = false; + } + else + { + bool flag2 = info == null; + if (flag2) + { + this.m_TempNpcData = data.BeginTaskNPCID; + } + else + { + TaskStatus status = info.Status; + if (status - TaskStatus.TaskStatus_Taked > 1) + { + this.m_TempNpcData = data.BeginTaskNPCID; + } + else + { + this.m_TempNpcData = data.EndTaskNPCID; + } + } + result = true; + } + return result; + } + + private bool _GetTempData(TaskTableNew.RowData data, XTaskInfo info) + { + bool flag = data == null; + bool result; + if (flag) + { + result = false; + } + else + { + bool flag2 = info == null; + if (flag2) + { + this.m_TempNpcData = data.BeginTaskNPCID; + this.m_TempTarget = data.BeginDesc; + } + else + { + TaskStatus status = info.Status; + if (status != TaskStatus.TaskStatus_Taked) + { + if (status != TaskStatus.TaskStatus_Finish) + { + this.m_TempNpcData = data.BeginTaskNPCID; + this.m_TempTarget = data.BeginDesc; + } + else + { + this.m_TempTarget = data.EndDesc; + this.m_TempNpcData = data.EndTaskNPCID; + } + } + else + { + this.m_TempTarget = data.InprocessDesc; + this.m_TempNpcData = null; + } + } + result = true; + } + return result; + } + + public string ParseTaskDesc(TaskTableNew.RowData data, XTaskInfo info, bool bCRLF) + { + bool flag = !this._GetTempData(data, info); + string result; + if (flag) + { + result = string.Empty; + } + else + { + StringBuilder stringBuilder = new StringBuilder(this.m_TempTarget); + if (bCRLF) + { + stringBuilder.Replace("{n}", "\n"); + } + else + { + stringBuilder.Replace("{n}", " "); + } + uint key = XSingleton.singleton.ChooseProfData(this.m_TempNpcData, 0u); + XNpcInfo.RowData byNPCID = XSingleton.singleton.NpcInfo.GetByNPCID(key); + bool flag2 = byNPCID != null; + if (flag2) + { + stringBuilder = stringBuilder.Replace("{npc}", byNPCID.Name); + } + bool flag3 = info == null; + if (flag3) + { + uint num = XSingleton.singleton.ChooseProfData(ref data.PassScene, 0u, 0); + SceneTable.RowData rowData = null; + bool flag4 = num > 0u; + if (flag4) + { + rowData = XSingleton.singleton.GetSceneData(num); + } + bool flag5 = rowData != null; + if (flag5) + { + stringBuilder.Replace("{scene}", rowData.Comment); + } + } + else + { + for (int i = 0; i < info.Conds.Count; i++) + { + TaskConditionInfo taskConditionInfo = info.Conds[i]; + switch (taskConditionInfo.type) + { + case TaskConnType.TaskConn_ItemID: + { + ItemList.RowData itemConf = XBagDocument.GetItemConf((int)taskConditionInfo.id); + bool flag6 = itemConf != null; + if (flag6) + { + stringBuilder.Replace("{item}", XSingleton.singleton.ChooseProfString(itemConf.ItemName, 0u)); + } + break; + } + case TaskConnType.TaskConn_StageID: + { + SceneTable.RowData sceneData = XSingleton.singleton.GetSceneData(taskConditionInfo.id); + bool flag7 = sceneData != null; + if (flag7) + { + stringBuilder.Replace("{scene}", sceneData.Comment); + } + break; + } + case TaskConnType.TaskConn_MonsterID: + { + XEntityStatistics.RowData byID = XSingleton.singleton.EntityStatistics.GetByID(taskConditionInfo.id); + bool flag8 = byID != null; + if (flag8) + { + stringBuilder.Replace("{monster}", byID.Name); + } + break; + } + } + this._FormatCount(stringBuilder, taskConditionInfo); + } + } + result = stringBuilder.ToString(); + } + return result; + } + + private void _FormatCount(StringBuilder sb, TaskConditionInfo cond) + { + bool flag = cond != null; + if (flag) + { + string newValue = XSingleton.singleton.StringCombine(cond.step.ToString(), "/", cond.max_step.ToString()); + switch (cond.type) + { + case TaskConnType.TaskConn_ItemID: + sb.Replace("{itemcount}", newValue); + break; + case TaskConnType.TaskConn_StageID: + sb.Replace("{scenecount}", newValue); + break; + case TaskConnType.TaskConn_MonsterID: + sb.Replace("{monstercount}", newValue); + break; + } + } + } + + public void OnTaskStatusUpdate(TaskInfo info) + { + bool flag = false; + for (int i = 0; i < this.TaskRecord.Tasks.Count; i++) + { + bool flag2 = this.TaskRecord.Tasks[i].ID == info.id; + if (flag2) + { + flag = true; + this.TaskRecord.Tasks[i].Init(info); + bool flag3 = info.status == TaskStatus.TaskStatus_Over; + if (flag3) + { + this.TaskRecord.Tasks.RemoveAt(i); + this.TaskRecord.FinishTask(info.id); + bool flag4 = info.id == XTaskDocument._HighestPriorityTask; + if (flag4) + { + this._ResetHighestPriorityTask(false); + } + } + break; + } + } + bool flag5 = !flag; + if (flag5) + { + bool flag6 = info.status == TaskStatus.TaskStatus_Over; + if (flag6) + { + this.TaskRecord.FinishTask(info.id); + } + else + { + this.TaskRecord.AddTask(info); + } + } + this._RefreshUI(); + this.SetupNpcHeadFx(); + XTaskStatusChangeArgs @event = XEventPool.GetEvent(); + @event.id = info.id; + @event.status = info.status; + @event.Firer = XSingleton.singleton.Doc; + XSingleton.singleton.FireEvent(@event); + } + + private void _RefreshUI() + { + bool flag = DlgBase.singleton.IsVisible(); + if (flag) + { + DlgBase.singleton.RefreshPage(); + } + bool flag2 = DlgBase.singleton.IsVisible(); + if (flag2) + { + bool flag3 = DlgBase.singleton._TaskNaviHandler.TaskHandler.IsVisible(); + if (flag3) + { + DlgBase.singleton._TaskNaviHandler.TaskHandler.RefreshData(); + } + } + } + + public void SetHighestPriorityTask(uint taskID) + { + XTaskDocument._HighestPriorityTask = taskID; + this._OnHighestPriorityTaskChanged(true); + } + + private void _ResetHighestPriorityTask(bool bUpdateUI) + { + bool flag = XTaskDocument._HighestPriorityTask > 0u; + if (flag) + { + XTaskDocument._HighestPriorityTask = 0u; + this._OnHighestPriorityTaskChanged(bUpdateUI); + } + } + + private void _OnHighestPriorityTaskChanged(bool bUpdateUI) + { + this.TaskRecord.Tasks.Sort(new Comparison(XTaskDocument.SortInTaskList)); + if (bUpdateUI) + { + this._RefreshUI(); + this.SetupNpcHeadFx(); + } + } + + public void DoTask(uint id) + { + XTaskInfo taskInfo = this.GetTaskInfo(id); + bool flag = taskInfo == null; + if (!flag) + { + TaskTableNew.RowData tableData = taskInfo.TableData; + bool flag2 = !this._GetTempData(tableData, taskInfo); + if (!flag2) + { + uint num = XSingleton.singleton.ChooseProfData(this.m_TempNpcData, 0u); + uint sceneID = XTaskDocument.GetSceneID(ref tableData.TaskScene); + bool flag3 = sceneID != 0u && taskInfo.Status == TaskStatus.TaskStatus_Taked; + if (flag3) + { + XExpeditionDocument specificDocument = XDocuments.GetSpecificDocument(XExpeditionDocument.uuID); + int expIDBySceneID = specificDocument.GetExpIDBySceneID(sceneID); + bool flag4 = expIDBySceneID != 0; + if (flag4) + { + XTeamDocument specificDocument2 = XDocuments.GetSpecificDocument(XTeamDocument.uuID); + specificDocument2.SetAndMatch(expIDBySceneID); + } + else + { + PtcC2G_EnterSceneReq ptcC2G_EnterSceneReq = new PtcC2G_EnterSceneReq(); + ptcC2G_EnterSceneReq.Data.sceneID = sceneID; + XSingleton.singleton.Send(ptcC2G_EnterSceneReq); + } + } + else + { + bool flag5 = num == 0u && tableData.TaskType == 4u; + if (flag5) + { + DlgBase.singleton.SetVisibleWithAnimation(true, null); + } + else + { + bool flag6 = num == 0u && tableData.TaskType == 7u; + if (flag6) + { + DlgBase.singleton.SetVisibleWithAnimation(true, null); + } + else + { + bool flag7 = num == 0u && tableData.TaskID == XCampDuelDocument.Doc.TaskID; + if (flag7) + { + DlgBase.singleton.Show(XSysDefine.XSys_CampDuel, false); + } + else + { + uint sceneID2 = XTaskDocument.GetSceneID(ref tableData.PassScene); + this.NaviToNpc(num, sceneID2); + this.m_NaviTask = id; + } + } + } + } + } + } + } + + public void NaviToNpc(uint npcid, uint sceneid) + { + bool flag = npcid == 0u; + if (flag) + { + DlgBase.singleton.IsTaskMode = true; + this._NavigateToBattle(); + this.m_NaviTarget = 1; + this.m_NaviScene = sceneid; + } + else + { + XSingleton.singleton.LastNpc = XSingleton.singleton.GetNpc(npcid); + } + } + + private void _NavigateToBattle() + { + bool flag = XSingleton.singleton.Player == null || XSingleton.singleton.Player.Deprecated; + if (!flag) + { + XSingleton.singleton.LastNpc = null; + Vector3 normalized = (XSingleton.singleton.Player.EngineObject.Position - XSingleton.singleton.BattleTargetPoint).normalized; + Vector3 dest = XSingleton.singleton.BattleTargetPoint + normalized * 5.8f; + XNavigationEventArgs @event = XEventPool.GetEvent(); + @event.Firer = XSingleton.singleton.Player; + @event.Dest = dest; + XSingleton.singleton.FireEvent(@event); + } + } + + public List GetSceneTaskState(uint sceneid) + { + this.m_TempTasks.Clear(); + for (int i = 0; i < this.TaskRecord.Tasks.Count; i++) + { + XTaskInfo xtaskInfo = this.TaskRecord.Tasks[i]; + bool flag = xtaskInfo == null || xtaskInfo.TableData == null; + if (!flag) + { + bool flag2 = sceneid == XTaskDocument.GetSceneID(ref xtaskInfo.TableData.PassScene); + if (flag2) + { + this.m_TempTasks.Add(xtaskInfo.ID); + } + else + { + bool flag3 = sceneid == XTaskDocument.GetSceneID(ref xtaskInfo.TableData.TaskScene); + if (flag3) + { + this.m_TempTasks.Add(xtaskInfo.ID); + } + } + } + } + return this.m_TempTasks; + } + + public NpcTaskState GetNpcTaskState(uint npcid, ref XTaskInfo task) + { + task = null; + for (int i = 0; i < this.TaskRecord.Tasks.Count; i++) + { + XTaskInfo xtaskInfo = this.TaskRecord.Tasks[i]; + TaskTableNew.RowData tableData = xtaskInfo.TableData; + bool flag = !this._GetNpcData(tableData, xtaskInfo); + if (!flag) + { + bool flag2 = tableData != null && XSingleton.singleton.ChooseProfData(this.m_TempNpcData, 0u) == npcid; + if (flag2) + { + bool flag3 = xtaskInfo.ID == this.m_NaviTask; + if (flag3) + { + task = xtaskInfo; + return xtaskInfo.NpcState; + } + bool flag4 = XTaskDocument.SortInDialog(xtaskInfo, task) < 0; + if (flag4) + { + task = xtaskInfo; + } + } + } + } + bool flag5 = task != null; + if (flag5) + { + return task.NpcState; + } + return NpcTaskState.Normal; + } + + private XTaskInfo FindTaskInfo(uint npcId) + { + XTaskInfo xtaskInfo = null; + for (int i = 0; i < this.TaskRecord.Tasks.Count; i++) + { + XTaskInfo xtaskInfo2 = this.TaskRecord.Tasks[i]; + bool flag = !this._GetNpcData(xtaskInfo2.TableData, xtaskInfo2); + if (!flag) + { + uint num = XSingleton.singleton.ChooseProfData(this.m_TempNpcData, 0u); + bool flag2 = npcId != num; + if (!flag2) + { + bool flag3 = xtaskInfo == null; + if (flag3) + { + xtaskInfo = xtaskInfo2; + } + else + { + bool flag4 = XTaskDocument.SortInDialog(xtaskInfo2, xtaskInfo) < 0; + if (flag4) + { + xtaskInfo = xtaskInfo2; + } + } + } + } + } + return xtaskInfo; + } + + private bool _NotifyXTaskDocFx(XEventArgs e) + { + this.SetupNpcHeadFx(); + return true; + } + + protected void SetupNpcHeadFx() + { + List npcs = XSingleton.singleton.GetNpcs(XSingleton.singleton.SceneID); + this.m_TempNpcTopTask.Clear(); + this.ClearFx(); + bool flag = npcs == null; + if (!flag) + { + for (int i = 0; i < this.TaskRecord.Tasks.Count; i++) + { + XTaskInfo xtaskInfo = this.TaskRecord.Tasks[i]; + bool flag2 = !this._GetNpcData(xtaskInfo.TableData, xtaskInfo); + if (!flag2) + { + uint key = XSingleton.singleton.ChooseProfData(this.m_TempNpcData, 0u); + XTaskInfo task; + bool flag3 = this.m_TempNpcTopTask.TryGetValue(key, out task); + if (flag3) + { + bool flag4 = XTaskDocument.SortInDialog(xtaskInfo, task) < 0; + if (flag4) + { + this.m_TempNpcTopTask[key] = xtaskInfo; + } + } + else + { + this.m_TempNpcTopTask[key] = xtaskInfo; + } + } + } + for (int j = 0; j < npcs.Count; j++) + { + XTaskInfo xtaskInfo2; + bool flag5 = !this.m_TempNpcTopTask.TryGetValue(npcs[j], out xtaskInfo2); + if (!flag5) + { + XNpc npc = XSingleton.singleton.GetNpc(npcs[j]); + bool flag6 = npc == null; + if (!flag6) + { + NpcTaskState npcState = xtaskInfo2.NpcState; + XFx xfx = null; + bool flag7 = npcState == NpcTaskState.TaskBegin; + if (flag7) + { + xfx = XSingleton.singleton.CreateFx(this.FX_TASK_BEGIN, null, true); + } + else + { + bool flag8 = npcState == NpcTaskState.TaskInprocess; + if (flag8) + { + bool flag9 = false; + bool flag10 = XSingleton.singleton.IsSystemOpened(XSysDefine.XSys_NPCFavor); + if (flag10) + { + XNPCFavorDocument specificDocument = XDocuments.GetSpecificDocument(XNPCFavorDocument.uuID); + flag9 = specificDocument.IsShowFavorFx(npcs[j]); + } + bool flag11 = !flag9; + if (flag11) + { + xfx = XSingleton.singleton.CreateFx(this.FX_TASK_INPROCESS, null, true); + } + } + else + { + bool flag12 = npcState == NpcTaskState.TaskEnd; + if (flag12) + { + xfx = XSingleton.singleton.CreateFx(this.FX_TASK_END, null, true); + } + } + } + bool flag13 = xfx != null; + if (flag13) + { + this.m_Fxes.Add(xfx); + xfx.Play(npc.EngineObject, new Vector3(-0.05f, npc.Height + 0.7f, 0f), Vector3.one, 1f, true, false, "", 0f); + } + } + } + } + this.m_TempNpcTopTask.Clear(); + } + } + + public void CreateFx(XNpc npc, uint npcId) + { + XTaskInfo xtaskInfo = this.FindTaskInfo(npcId); + bool flag = xtaskInfo != null; + if (flag) + { + NpcTaskState npcState = xtaskInfo.NpcState; + XFx xfx = null; + bool flag2 = npcState == NpcTaskState.TaskBegin; + if (flag2) + { + xfx = XSingleton.singleton.CreateFx(this.FX_TASK_BEGIN, null, true); + } + else + { + bool flag3 = npcState == NpcTaskState.TaskInprocess; + if (flag3) + { + xfx = XSingleton.singleton.CreateFx(this.FX_TASK_INPROCESS, null, true); + } + else + { + bool flag4 = npcState == NpcTaskState.TaskEnd; + if (flag4) + { + xfx = XSingleton.singleton.CreateFx(this.FX_TASK_END, null, true); + } + } + } + bool flag5 = xfx != null; + if (flag5) + { + this.m_Fxes.Add(xfx); + xfx.Play(npc.EngineObject, new Vector3(-0.05f, npc.Height + 0.7f, 0f), Vector3.one, 1f, true, false, "", 0f); + } + } + } + + protected void ClearFx() + { + for (int i = 0; i < this.m_Fxes.Count; i++) + { + XSingleton.singleton.DestroyFx(this.m_Fxes[i], true); + } + this.m_Fxes.Clear(); + } + + private void _ResetTaskMonsters() + { + this.m_TaskMonstersKilled.Clear(); + } + + private void _InitTaskMonsters() + { + for (int i = 0; i < this.TaskRecord.Tasks.Count; i++) + { + XTaskInfo xtaskInfo = this.TaskRecord.Tasks[i]; + for (int j = 0; j < xtaskInfo.Conds.Count; j++) + { + TaskConditionInfo taskConditionInfo = xtaskInfo.Conds[j]; + bool flag = taskConditionInfo.type == TaskConnType.TaskConn_MonsterID && !this.m_TaskMonstersKilled.ContainsKey(taskConditionInfo.id); + if (flag) + { + this.m_TaskMonstersKilled.Add(taskConditionInfo.id, 0u); + } + } + } + } + + private bool _OnEntityDie(XEventArgs arg) + { + bool syncMode = XSingleton.singleton.SyncMode; + bool result; + if (syncMode) + { + result = true; + } + else + { + XRealDeadEventArgs xrealDeadEventArgs = arg as XRealDeadEventArgs; + bool flag = xrealDeadEventArgs.TheDead.IsEnemy && this.m_TaskMonstersKilled.ContainsKey(xrealDeadEventArgs.TheDead.TypeID); + if (flag) + { + Dictionary taskMonstersKilled = this.m_TaskMonstersKilled; + uint typeID = xrealDeadEventArgs.TheDead.TypeID; + uint value = taskMonstersKilled[typeID] + 1u; + taskMonstersKilled[typeID] = value; + } + result = true; + } + return result; + } + + private bool _OnTaskStateChanged(XEventArgs arg) + { + XTaskStatusChangeArgs xtaskStatusChangeArgs = arg as XTaskStatusChangeArgs; + bool flag = xtaskStatusChangeArgs.status == TaskStatus.TaskStatus_Over; + if (flag) + { + List list; + bool flag2 = this.m_AppearNpcs.TryGetValue(xtaskStatusChangeArgs.id, out list); + if (flag2) + { + for (int i = 0; i < list.Count; i++) + { + XSingleton.singleton.CreateNpc(list[i], true); + } + } + bool flag3 = this.m_DisappearNpcs.TryGetValue(xtaskStatusChangeArgs.id, out list); + if (flag3) + { + for (int j = 0; j < list.Count; j++) + { + XSingleton.singleton.DestroyNpc(list[j]); + } + } + } + return true; + } + + public static NpcTaskState TaskStatus2TaskState(TaskStatus status) + { + NpcTaskState result; + switch (status) + { + case TaskStatus.TaskStatus_CanTake: + result = NpcTaskState.TaskBegin; + break; + case TaskStatus.TaskStatus_Taked: + result = NpcTaskState.TaskInprocess; + break; + case TaskStatus.TaskStatus_Finish: + result = NpcTaskState.TaskEnd; + break; + case TaskStatus.TaskStatus_Over: + result = NpcTaskState.Normal; + break; + default: + result = NpcTaskState.Invalid; + break; + } + return result; + } + + public static uint GetSceneID(ref SeqListRef sceneData) + { + return XSingleton.singleton.ChooseProfData(ref sceneData, 0u, 0); + } + + public static int SortByType(int type0, int type1) + { + return XTaskDocument.TypeSortValue[type0].CompareTo(XTaskDocument.TypeSortValue[type1]); + } + + public static int SortByNpcState(NpcTaskState state0, NpcTaskState state1) + { + return state0.CompareTo(state1); + } + + public static int SortInTaskList(XTaskInfo task0, XTaskInfo task1) + { + bool flag = task0 == null; + int result; + if (flag) + { + result = 1; + } + else + { + bool flag2 = task1 == null; + if (flag2) + { + result = -1; + } + else + { + bool flag3 = XTaskDocument._HighestPriorityTask > 0u; + if (flag3) + { + bool flag4 = task0.ID == task1.ID; + if (flag4) + { + return 0; + } + bool flag5 = task0.ID == XTaskDocument._HighestPriorityTask; + if (flag5) + { + return -1; + } + bool flag6 = task1.ID == XTaskDocument._HighestPriorityTask; + if (flag6) + { + return 1; + } + } + int num = XTaskDocument.SortByType((int)task0.TableData.TaskType, (int)task1.TableData.TaskType); + bool flag7 = num == 0; + if (flag7) + { + num = XTaskDocument.SortByNpcState(task0.NpcState, task1.NpcState); + } + bool flag8 = num == 0; + if (flag8) + { + num = task0.ID.CompareTo(task1.ID); + } + result = num; + } + } + return result; + } + + public static int SortInDialog(XTaskInfo task0, XTaskInfo task1) + { + bool flag = task0 == null; + int result; + if (flag) + { + result = 1; + } + else + { + bool flag2 = task1 == null; + if (flag2) + { + result = -1; + } + else + { + bool flag3 = XTaskDocument._HighestPriorityTask > 0u; + if (flag3) + { + bool flag4 = task0.ID == task1.ID; + if (flag4) + { + return 0; + } + bool flag5 = task0.ID == XTaskDocument._HighestPriorityTask; + if (flag5) + { + return -1; + } + bool flag6 = task0.ID == XTaskDocument._HighestPriorityTask; + if (flag6) + { + return 1; + } + } + int num = XTaskDocument.SortByNpcState(task0.NpcState, task1.NpcState); + bool flag7 = num == 0; + if (flag7) + { + num = XTaskDocument.SortByType((int)task0.TableData.TaskType, (int)task1.TableData.TaskType); + } + bool flag8 = num == 0; + if (flag8) + { + num = task0.ID.CompareTo(task1.ID); + } + result = num; + } + } + return result; + } + + protected override void OnReconnected(XReconnectedEventArgs arg) + { + this.TaskRecord.InitFromServerData(arg.PlayerInfo.task_record); + this._RefreshUI(); + this.SetupNpcHeadFx(); + } + + public override void OnEnterScene() + { + base.OnEnterScene(); + this.SetupNpcHeadFx(); + bool flag = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag) + { + this._ResetTaskMonsters(); + } + else + { + bool flag2 = XSingleton.singleton.CurrentStage.Stage == EXStage.World; + if (flag2) + { + this._InitTaskMonsters(); + } + } + } + + public override void OnLeaveScene() + { + this.ClearFx(); + this._ResetHighestPriorityTask(false); + base.OnLeaveScene(); + } + + public bool ShouldNpcExist(uint npcID) + { + XNpcInfo.RowData byNPCID = XSingleton.singleton.NpcInfo.GetByNPCID(npcID); + bool flag = byNPCID == null; + bool result; + if (flag) + { + result = false; + } + else + { + bool flag2 = byNPCID.DisappearTask != 0u && this.TaskRecord.IsTaskFinished(byNPCID.DisappearTask); + if (flag2) + { + result = false; + } + else + { + bool flag3 = byNPCID.RequiredTaskID == 0u || this.TaskRecord.IsTaskFinished(byNPCID.RequiredTaskID); + result = flag3; + } + } + return result; + } + } +} -- cgit v1.1-26-g67d0