unity 单机任务模块

using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

namespace ETModel
{
    /// <summary>
    /// 任务模块
    /// </summary>
    public class GameTaskComponent : Component
    {
        public bool isUpdateDailyTask;
        public DateTime dateTime;
        public Dictionary<int, IGameTask> tasks = new Dictionary<int, IGameTask>();
        public List<IGameTask> dailyTask = new List<IGameTask>();
        public Dictionary<string, List<IGameTask>> checks = new Dictionary<string, List<IGameTask>>();
    }
    [ObjectSystem]
    public class GameTaskComponentAwakeSystem : AwakeSystem<GameTaskComponent>
    {
        public override void Awake(GameTaskComponent self)
        {
            self.dateTime = DateTime.Now;
        }
    }

    [ObjectSystem]
    public class GameTaskComponentUpdateSystem : UpdateSystem<GameTaskComponent>
    {
        /// <summary>
        /// 过零点刷新每日任务
        /// </summary>
        /// <param name="self"></param>
        public override void Update(GameTaskComponent self)
        {
            //检查是否同一天
            if (TimeHelper.IsSameDateLogin(self.dateTime))
                return;

            self.dateTime = DateTime.Now;
            self.isUpdateDailyTask = true;
            self.UpdateDailyTask();
            self.isUpdateDailyTask = false;
        }
    }

    public static class GameTaskComponentExpend
    {
        const string lastTime = "lastTime";
        public static void AddTasks(this GameTaskComponent self,GameTask [] tasks)
        {
            foreach(var task in tasks)
            {
                self.tasks.Add(task.taskId, task);

                foreach(var condition in task.taskCondition)
                {
                    if(!self.checks.ContainsKey(condition.id))
                    {
                        self.checks.Add(condition.id, new List<IGameTask>());
                    }
                    self.checks[condition.id].Add(task);
                }

                if(task.taskType == GameTasktype.DailyTask)
                {
                    self.dailyTask.Add(task);
                }
            }

            #region 不是同一天登录刷新每日任务
            var str = self.LoadString(lastTime, DateTime.Today.AddDays(-1).ToString());

            if (!TimeHelper.IsSameDateLogin(str))
            {
                self.UpdateDailyTask();
            }

            self.SaveString(lastTime,DateTime.Now.ToString());
            #endregion
        }

        /// <summary>
        /// 接取任务
        /// </summary>
        /// <param name="self"></param>
        /// <param name="taskId"></param>
        /// <returns></returns>
        public static bool AcceptTask(this GameTaskComponent self,int taskId)
        {
            if (!self.tasks.ContainsKey(taskId))
                return false;

            if (self.GetState(taskId) != GameTaskStateType.Node)
                return false;

            #region 同一天只可接取一次任务
            if (self.tasks[taskId].taskType == GameTasktype.DailyRepetition)
            {
                var timeKey = $"{taskId}-AcceptTime";
                var str = self.LoadString(timeKey, DateTime.Today.AddDays(-1).ToString());
                if (TimeHelper.IsSameDateLogin(str))
                    return false;

                self.SaveString(timeKey, DateTime.Now.ToString());
            }
            #endregion

            self.UpdateState(taskId, GameTaskStateType.Accept);

            return true;
        }

        /// <summary>
        /// 刷新每日任务
        /// </summary>
        /// <param name="self"></param>
        public static void UpdateDailyTask(this GameTaskComponent self)
        {
            foreach (var task in self.dailyTask)
            {
                self.UpdateTask(task.taskId, GameTaskStateType.Accept);
            }
        }

        /// <summary>
        /// 任务回归初始状态
        /// </summary>
        /// <param name="self"></param>
        /// <param name="taskId"></param>
        /// <param name="state"></param>
        public static void UpdateTask(this GameTaskComponent self, int taskId, GameTaskStateType state)
        {
            if (!self.tasks.ContainsKey(taskId))
                return;
            var task = self.tasks[taskId];

            foreach (var condition in task.taskCondition)
            {
                self.UpdateCondition(task.taskId, condition.id, 0);
            }
            self.UpdateState(task, state);
        }

       
        public static GameTaskStateType GetState(this GameTaskComponent self, IGameTask task)
        {
            return self.GetState(task.taskId);
        }

        /// <summary>
        /// 任务某个条件是否完成
        /// </summary>
        /// <param name="self"></param>
        /// <param name="taskId"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public static bool IsComplete(this GameTaskComponent self,int taskId, TaskCondition condition)
        {
            return self.LoadInt($"{taskId}-{condition.id}", 0) >= condition.number;
        }

        /// <summary>
        /// 更新任务条件
        /// </summary>
        /// <param name="self"></param>
        /// <param name="taskId"></param>
        /// <param name="id"></param>
        /// <param name="count"></param>
        public static void UpdateCondition(this GameTaskComponent self, int taskId, string id,int count)
        {
            if (!self.tasks.ContainsKey(taskId))
                return;

            var task = self.tasks[taskId];
            //如果是每日任务并且每日任务状态正在更新，不处理
            if (self.isUpdateDailyTask && task.taskType == GameTasktype.DailyTask)
                return;

            var condition = task.taskCondition.Where(item => item.id == id).FirstOrDefault();
            if (condition == null)
                return;

            self.SaveInt($"{taskId}-{id}", Math.Min(count, condition.number));
        }

        /// <summary>
        /// 获取任务条件当前完成数量
        /// </summary>
        /// <param name="self"></param>
        /// <param name="taskId"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public static int GetConditionCount(this GameTaskComponent self, int taskId, string id)
        {
            return self.LoadInt($"{taskId}-{id}", 0);
        }

        public static void UpdateState(this GameTaskComponent self, IGameTask task, GameTaskStateType state)
        {
            self.UpdateState(task.taskId, state);
        }

        /// <summary>
        /// 更新任务状态
        /// </summary>
        /// <param name="self"></param>
        /// <param name="taskId"></param>
        /// <param name="state"></param>
        /// <returns></returns>
        public static bool UpdateState(this GameTaskComponent self,int taskId, GameTaskStateType state)
        {
            if (!self.tasks.ContainsKey(taskId))
                return false;

            if (self.isUpdateDailyTask && self.tasks[taskId].taskType == GameTasktype.DailyTask)
                return false;

            self.SaveInt(taskId.ToString(), (int)state);

            return true;
        }
        /// <summary>
        /// 获取任务状态
        /// </summary>
        /// <param name="self"></param>
        /// <param name="task"></param>
        /// <returns></returns>
        public static GameTaskStateType GetState(this GameTaskComponent self,int taskId)
        {
            return (GameTaskStateType)self.LoadInt(taskId.ToString(), (int)GameTaskStateType.Node);
        }

        /// <summary>
        /// 获取奖励
        /// </summary>
        /// <param name="self"></param>
        /// <param name="taskId"></param>
        /// <returns></returns>
        public static GameTaskAward[] GetGameTaskAwards(this GameTaskComponent self, int taskId)
        {  
            if (!self.tasks.ContainsKey(taskId))
                return default;

            return self.tasks[taskId].taskAwards;
        }

        public static IGameTask[] GetTasks(this GameTaskComponent self)
        {
            return self.tasks.Values.ToArray();
        }

        public static IGameTask GetTask(this GameTaskComponent self,int taskId)
        {
            if (!self.tasks.ContainsKey(taskId))
                return default;
            return self.tasks[taskId];
        }
    }

    /// <summary>
    /// 检查任务完成状态
    /// </summary>
    [Event(EventIdType.TaskCheck)]
    public class TaskCheckEvent : AEvent<string, int>
    {
        async public override ETVoid Run(string id, int number)
        {
            var self = Game.Scene.GetComponent<GameTaskComponent>();
            if (!self.checks.ContainsKey(id))
                return;

            var list = self.checks[id];
            GameTaskStateType state;
            foreach (var item in list)
            {
                state = self.GetState(item.taskId);
                if (state != GameTaskStateType.Accept)
                    continue;

                self.UpdateCondition(item.taskId, id, number);
            }

            foreach(var item in list)
            {
                number = 0;
                foreach(var check in item.taskCondition)
                {
                    if(self.IsComplete(item.taskId,check))
                    {
                        number++;
                    }
                }
                if(number == item.taskCondition.Length)
                {
                    self.UpdateState(item, GameTaskStateType.Complete);
                }
            }
        }
    }

    [Service(ServiceIdType.ReceiveTaskAward)]
    public class ReceiveTaskAwardService : AService<int>
    {
        async public override ETTask<object> Run(int taskId)
        {
            var self = Game.Scene.GetComponent<GameTaskComponent>();
            if (!self.tasks.ContainsKey(taskId))
                return false;

            var task = self.GetTask(taskId);
            if (self.GetState(taskId) != GameTaskStateType.Complete)
                return false;

            var result = self.UpdateState(taskId, GameTaskStateType.Received);

            if(result)
            {
                if (task.taskType == GameTasktype.Repetition || task.taskType == GameTasktype.DailyRepetition)
                {
                    self.UpdateTask(taskId, GameTaskStateType.Node);
                }

                Game.EventSystem.Run(EventIdType.ReceiveGameTaskAward,taskId);
            }
            return result;
        }
    }
}