456 lines
11 KiB
C#
456 lines
11 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using cfg.ActorCfg;
|
||
using Cysharp.Threading.Tasks;
|
||
using Framework;
|
||
using Gameplay;
|
||
using Gameplay.Net;
|
||
using NLDPB;
|
||
using PhxhSDK;
|
||
public class TaskManager: Singlenton<TaskManager>, IInitable, IUpdatable
|
||
{
|
||
private Dictionary<TaskType, TaskMap> _taskDic = new Dictionary<TaskType, TaskMap>();
|
||
|
||
private const int UpdateMaxCount = 5;
|
||
private const int EachFrameCount = 30;
|
||
private int _updateFrameCount = 0;
|
||
private bool _isStartUpdate = false;
|
||
|
||
public Dictionary<TaskType, TaskMap> TaskDic => _taskDic;
|
||
|
||
public void Init()
|
||
{
|
||
EventManager.Instance.Register(EventManager.EventName.UpdateAllTask, StartUpdateTask);
|
||
}
|
||
|
||
public void Release()
|
||
{
|
||
EventManager.Instance.Unregister(EventManager.EventName.UpdateAllTask, StartUpdateTask);
|
||
}
|
||
|
||
//分帧刷新任务
|
||
public void Update(float dt)
|
||
{
|
||
if (_isStartUpdate && _updateFrameCount < UpdateMaxCount)
|
||
{
|
||
_UpdateCheckTask();
|
||
++_updateFrameCount;
|
||
}
|
||
|
||
if (_updateFrameCount >= UpdateMaxCount)
|
||
{
|
||
_EndCheckTask();
|
||
//刷新完毕
|
||
}
|
||
}
|
||
|
||
//打开任务界面
|
||
public static async UniTask OpenTaskUI()
|
||
{
|
||
await UIManager.Instance.OpenWindow(UINameConst.UITask);
|
||
}
|
||
|
||
private void _LoadTaskData()
|
||
{
|
||
//_taskDic = new Dictionary<TaskType, TaskMap>();
|
||
for (TaskType i = TaskType.Normal; i < TaskType.Max; i++)
|
||
{
|
||
_taskDic.Add(i, new TaskMap(i));
|
||
}
|
||
|
||
var taskData = TableManager.Instance.Tables.TaskMain;
|
||
var dataList = taskData.DataList;
|
||
for (int i = 0; i < dataList.Count; i++)
|
||
{
|
||
var data = dataList[i];
|
||
var taskInfo = new TaskInfo(data.ID, data);
|
||
var taskMap = _taskDic[data.TaskType];
|
||
taskMap.AddTask(taskInfo);
|
||
taskMap.AddTaskInList(taskInfo);
|
||
}
|
||
|
||
//InitAllTaskStatus();
|
||
}
|
||
|
||
private void _OnTaskUpdateStart()
|
||
{
|
||
_updateFrameCount = 0;
|
||
_isStartUpdate = true;
|
||
}
|
||
|
||
private void _UpdateCheckTask()
|
||
{
|
||
var startIdx = _updateFrameCount * EachFrameCount;
|
||
var endIdx = startIdx + EachFrameCount;
|
||
_CheckTasks(startIdx, endIdx);
|
||
}
|
||
|
||
private void _EndCheckTask()
|
||
{
|
||
_updateFrameCount = 0;
|
||
_isStartUpdate = false;
|
||
EventManager.Instance.Send(EventManager.EventName.UpdateTaskCompleted);
|
||
}
|
||
|
||
private void _CheckTasks(int startIdx, int endIdx)
|
||
{
|
||
var taskConfig = TableManager.Instance.Tables.TaskMain;
|
||
var dataList = taskConfig.DataList;
|
||
for (int i = startIdx; i < endIdx; i++)
|
||
{
|
||
if (i >= dataList.Count)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var data = dataList[i];
|
||
CheckTaskByType(data.ID, data.CheckType);
|
||
_SetTaskStatus(data);
|
||
}
|
||
}
|
||
|
||
private DataTaskMain GetCfgByID(int taskID)
|
||
{
|
||
foreach (var map in _taskDic)
|
||
{
|
||
var taskMap = map.Value;
|
||
if (taskMap.Contains(taskID))
|
||
{
|
||
return taskMap.Get(taskID).Cfg;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
private void _SetTaskStatus(DataTaskMain taskData, bool isOnLogin = false)
|
||
{
|
||
TaskStatus pbStatus = GetTaskPbStatus(taskData);
|
||
TaskState status = TaskState.InValid;
|
||
if (taskData == null || !_taskDic.TryGetValue(taskData.TaskType, out var map))
|
||
{
|
||
return;
|
||
}
|
||
var taskMap = _taskDic[taskData.TaskType];
|
||
|
||
//前置任务未完成, 置为Invalid
|
||
if (taskData.PreTaskID > 0)
|
||
{
|
||
var frontTaskData = GetCfgByID(taskData.PreTaskID);
|
||
TaskStatus frontPbStatus = GetTaskPbStatus(frontTaskData);
|
||
if (frontPbStatus != TaskStatus.Tsclaimed)
|
||
{
|
||
taskMap.SetTaskStatus(taskData.ID, status);
|
||
return;
|
||
}
|
||
}
|
||
|
||
switch (pbStatus)
|
||
{
|
||
case (TaskStatus.NewTask):
|
||
{
|
||
status = TaskState.Uncompleted;
|
||
break;
|
||
}
|
||
case (TaskStatus.Tsclaimed):
|
||
{
|
||
status = TaskState.Claimed;
|
||
break;
|
||
}
|
||
case (TaskStatus.Done):
|
||
{
|
||
status = TaskState.Available;
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
|
||
taskMap.SetTaskStatus(taskData.ID, status);
|
||
}
|
||
|
||
private void _ClaimTaskReward(uint[] taskIds)
|
||
{
|
||
NetHelper.ClaimTaskReward(taskIds);
|
||
}
|
||
|
||
public bool CheckTaskByType(int taskID, TaskCheckType checkType)
|
||
{
|
||
var dataTask = TableManager.Instance.Tables.TaskMain.GetOrDefault(taskID);
|
||
if (dataTask == null)
|
||
|
||
{
|
||
return false;
|
||
}
|
||
return ITaskCheck.GetCheck((int)checkType).Check(dataTask);
|
||
}
|
||
|
||
public TaskMap GetTaskMap(TaskType taskType)
|
||
{
|
||
return _taskDic[taskType];
|
||
}
|
||
|
||
public TaskStatus GetTaskPbStatus(DataTaskMain dataTask)
|
||
{
|
||
//Check的时候会刷新状态
|
||
return Actor.Instance.Task.Check(dataTask);
|
||
}
|
||
|
||
public void OnLoginOk()
|
||
{
|
||
_LoadTaskData();
|
||
}
|
||
|
||
public void StartUpdateTask()
|
||
{
|
||
_OnTaskUpdateStart();
|
||
}
|
||
|
||
//领取任务奖励
|
||
public void ClaimTaskReward(int taskId)
|
||
{
|
||
uint[] taskIds = {(uint)taskId};
|
||
_ClaimTaskReward(taskIds);
|
||
}
|
||
|
||
public void ClaimTaskTypeRewards(TaskType type)
|
||
{
|
||
var taskMap = _taskDic[type];
|
||
var list = taskMap.List;
|
||
var taskClaimIDList = new List<uint>();
|
||
for (int i = 0; i < list.Count; i++)
|
||
{
|
||
if (list[i].Status == TaskState.Available)
|
||
{
|
||
taskClaimIDList.Add((uint)list[i].TaskID);
|
||
}
|
||
}
|
||
|
||
if (taskClaimIDList.Count > 0)
|
||
{
|
||
var taskIds = taskClaimIDList.ToArray();
|
||
_ClaimTaskReward(taskIds);
|
||
}
|
||
}
|
||
|
||
public uint GetTaskCountById(int taskId)
|
||
{
|
||
return Actor.Instance.Task.GetCount((uint)taskId);
|
||
}
|
||
|
||
public bool CheckCanGetAll(TaskType taskType)
|
||
{
|
||
var taskMap = _taskDic[taskType];
|
||
for (int i = 0; i < taskMap.List.Count; i++)
|
||
{
|
||
var taskInfo = taskMap.List[i];
|
||
if (taskInfo.Status == TaskState.Available)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
public void SetTaskRequestCount(TaskInfo taskInfo, out uint curCount, out uint maxCount)
|
||
{
|
||
var cfg = taskInfo.Cfg;
|
||
ITaskCheck.GetCheck((int)cfg.CheckType).SetTaskRequestCount(cfg, out curCount, out maxCount);
|
||
}
|
||
}
|
||
|
||
public interface ITask
|
||
{
|
||
void SetStatus(TaskState status);
|
||
}
|
||
|
||
public enum TaskState
|
||
{
|
||
InValid,
|
||
Uncompleted,
|
||
Available,
|
||
Claimed
|
||
}
|
||
|
||
/// <summary>
|
||
/// 任务类，包含配置信息
|
||
/// </summary>
|
||
public class TaskInfo : ITask
|
||
{
|
||
private readonly int _taskId;
|
||
private readonly DataTaskMain _cfg;
|
||
private readonly List<RewardItem> _itemList;
|
||
private TaskState _status;
|
||
|
||
public DataTaskMain Cfg => _cfg;
|
||
public int TaskID => _taskId;
|
||
|
||
public TaskState Status => _status;
|
||
|
||
public List<RewardItem> ItemList => _itemList;
|
||
|
||
private TaskInfo()
|
||
{
|
||
|
||
}
|
||
|
||
public TaskInfo(int taskId)
|
||
{
|
||
_taskId = taskId;
|
||
var cfg = TableManager.Instance.Tables.TaskMain.GetOrDefault(taskId);
|
||
if (cfg == null)
|
||
{
|
||
DebugUtil.LogError($"=== 创建任务时传入ID有误，ID: {taskId} ===");
|
||
}
|
||
|
||
_cfg = cfg;
|
||
_status = TaskState.Uncompleted;
|
||
for (int i = 0; i < _cfg.RewardID.Length; i++)
|
||
{
|
||
var reward = RewardManager.Instance.Get(_cfg.RewardID[i]);
|
||
_itemList = reward.ItemList.Get();
|
||
}
|
||
|
||
}
|
||
|
||
public TaskInfo(int taskId, DataTaskMain cfg, TaskState status = TaskState.InValid)
|
||
{
|
||
_taskId = taskId;
|
||
_cfg = cfg;
|
||
_status = status;
|
||
for (int i = 0; i < _cfg.RewardID.Length; i++)
|
||
{
|
||
var reward = RewardManager.Instance.Get(_cfg.RewardID[i]);
|
||
_itemList = reward.ItemList.Get();
|
||
}
|
||
}
|
||
|
||
// private int _ParseReward(int rewardId)
|
||
// {
|
||
// var rewardData = ;
|
||
// }
|
||
|
||
public void SetStatus(TaskState status)
|
||
{
|
||
_status = status;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 某一种任务的map对象
|
||
/// </summary>
|
||
public class TaskMap
|
||
{
|
||
private TaskType _typeKey;
|
||
private Dictionary<int, TaskInfo> _values;
|
||
private List<TaskInfo> _list;
|
||
|
||
public TaskType Key => _typeKey;
|
||
public Dictionary<int, TaskInfo> Value => _values;
|
||
|
||
public List<TaskInfo> List => _list;
|
||
|
||
public TaskMap(TaskType key, bool isAutoLoad = false)
|
||
{
|
||
_typeKey = key;
|
||
_values = new Dictionary<int, TaskInfo>();
|
||
_list = new List<TaskInfo>();
|
||
|
||
if (isAutoLoad)
|
||
{
|
||
var table = TableManager.Instance.Tables.TaskMain;
|
||
for (int i = 0; i < table.DataList.Count; i++)
|
||
{
|
||
var data = table.DataList[i];
|
||
if (key == data.TaskType)
|
||
{
|
||
var taskInfo = new TaskInfo(data.ID, data);
|
||
_values.Add(data.ID, taskInfo);
|
||
_list.Add(taskInfo);;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
public void AddTask(TaskInfo task)
|
||
{
|
||
_values.Add(task.TaskID, task);
|
||
}
|
||
|
||
public void AddTaskInList(TaskInfo task)
|
||
{
|
||
_list.Add(task);
|
||
}
|
||
|
||
public TaskInfo Get(int taskId)
|
||
{
|
||
if (_values.TryGetValue(taskId, out var value))
|
||
{
|
||
return value;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
public TaskState GetTaskStatus(int taskId)
|
||
{
|
||
if (_values.TryGetValue(taskId, out var value))
|
||
{
|
||
return value.Status;
|
||
}
|
||
|
||
return default;
|
||
}
|
||
|
||
public void SetTaskStatus(int taskId, TaskState status)
|
||
{
|
||
if (_values.TryGetValue(taskId, out var value))
|
||
{
|
||
if (value.Status == TaskState.Uncompleted && status == TaskState.Available)
|
||
{
|
||
//TODO 展示完成弹框
|
||
DebugUtil.Log($"--- <color=green>完成任务：ID={taskId}</color> ---");
|
||
}
|
||
value.SetStatus(status);
|
||
}
|
||
}
|
||
|
||
public bool Contains(int idx)
|
||
{
|
||
return _values.ContainsKey(idx);
|
||
}
|
||
|
||
public bool Contains(TaskInfo val)
|
||
{
|
||
return _values.ContainsValue(val);
|
||
}
|
||
|
||
public void Foreach(Action<TaskInfo> action)
|
||
{
|
||
foreach (var taskItem in _values)
|
||
{
|
||
var taskInfo = taskItem.Value;
|
||
action(taskInfo);
|
||
}
|
||
}
|
||
|
||
//统一设置所有任务状态
|
||
public void ForeachSetStatus(TaskState status)
|
||
{
|
||
foreach (var val in _values)
|
||
{
|
||
val.Value.SetStatus(status);
|
||
}
|
||
}
|
||
|
||
public int Count()
|
||
{
|
||
if (_values == null)
|
||
{
|
||
return 0;
|
||
}
|
||
return _values.Count;
|
||
}
|
||
} |