rg1/server/GameServer/LogicSrc/Activity/System/HandBookAct/HandBookAct.cs

using System.Collections.Generic;
using ProtoCSStruct;
using Sog;

namespace Game
{
    public class HandBookAct : AbstractActivity
    {
        public override void OnRoleEnter(PlayerOnGame player)
        {
            CheckNewQuest(player);
        }

        protected override void OnStateChange(PlayerOnGame player, int actId, ActivityState state)
        {
            switch (state)
            {
                case ActivityState.InProgress:
                    Init(player, actId);
                    break;
                case ActivityState.GameplayEnded:
                case ActivityState.ActivityEnded:
                    OnEnd(player, actId);
                    break;
            }
        }


        protected override void OnTickCheck(PlayerOnGame player)
        {
            ref var handBookData = ref player.RoleData.ActExtraInfo.HandBookData;
            for (var i = 0; i < handBookData.Count; i++)
            {
                var actId = handBookData[i].ActId;
                var state = ActivitySvc.GetActivityState(player, actId);
                if (state == ActivityState.InProgress)
                {
                    CheckState(player, ref handBookData[i]);
                }
            }
        }


        private static void Init(PlayerOnGame player, int actId)
        {
            ref var handBookData = ref player.RoleData.ActExtraInfo.HandBookData;
            var index = -1;
            for (var i = 0; i < handBookData.Count; i++)
            {
                if (handBookData[i].ActId != actId) continue;
                index = i;
                break;
            }

            if (index > -1)
            {
                CheckState(player, ref handBookData[index]);
                return;
            }

            handBookData.Add(new HandBookData() { ActId = actId, Stage = 1 });
            AddQuest(player, actId, 1);
            player.MakeDirty();
            SyncData(player);
        }

        private static void CheckNewQuest(PlayerOnGame player)
        {
            ref var handBookData = ref player.RoleData.ActExtraInfo.HandBookData;
            for (var i = 0; i < handBookData.Count; i++)
            {
                var actId = handBookData[i].ActId;
                var state = ActivitySvc.GetActivityState(player, actId);
                if (state != ActivityState.InProgress)
                {
                    continue;
                }

                var group = ActivityDescMgr.Instance.GetConfig(actId).subType;
                if (group == 0)
                {
                    continue;
                }

                var handBookDesc = HandBookDescMgr.Instance.GetConfig(group, handBookData[i].Stage);
                var questList = handBookDesc.questList;
                foreach (var questId in questList)
                {
                    var accept = TaskEXSvc.IsAcceptEdTask(player, questId);
                    if (!accept)
                    {
                        var ret = TaskEXSvc.ProcessAcceptTask(player, questId, true, out var index);
                        if (ret == CSErrCode.None)
                        {
                            TaskEXEvent.NotifyClientNoneDoth(questId, player);
                        }
                    }
                }
            }
        }


        //检测当前进度的所有任务是否完成
        private static void CheckState(PlayerOnGame player, ref HandBookData data)
        {
            var group = ActivityDescMgr.Instance.GetConfig(data.ActId).subType;
            if (group == 0)
            {
                return;
            }

            var handBookDesc = HandBookDescMgr.Instance.GetConfig(group, data.Stage);
            if (handBookDesc == null)
            {
                return;
            }

            if (handBookDesc.nextStage == 0)
            {
                return;
            }

            var nextHandBookDesc = HandBookDescMgr.Instance.GetConfig(group, handBookDesc.nextStage);
            if (nextHandBookDesc == null)
            {
                return;
            }

            var questList = handBookDesc.questList;
            var complete = true;
            foreach (var questId in questList)
            {
                complete &= TaskEXSvc.IsCompleteTask(player, questId) || TaskEXSvc.IsFinishTask(player, questId);
            }

            if (!complete)
            {
                return;
            }

            data.Stage = nextHandBookDesc.stage;
            AddQuest(player, data.ActId, data.Stage);
            player.MakeDirty();
            SyncData(player);
        }

        private static void OnEnd(PlayerOnGame player, int actId)
        {
            ref var handBookData = ref player.RoleData.ActExtraInfo.HandBookData;
            var index = -1;
            for (var i = 0; i < handBookData.Count; i++)
            {
                if (handBookData[i].ActId != actId) continue;
                index = i;
                break;
            }

            if (index < 0)
            {
                return;
            }

            ref var bookData = ref handBookData[index];
            SendMail(player, ref bookData);
            RemoveQuest(player, ref bookData);
            handBookData.RemoveAt(index);
            player.MakeDirty();
            SyncData(player);
        }

        private static void AddQuest(PlayerOnGame player, int actId, int state)
        {
            var desc = ActivityDescMgr.Instance.GetConfig(actId);
            if (desc == null || desc.subType == 0)
            {
                return;
            }

            var handBookDesc = HandBookDescMgr.Instance.GetConfig(desc.subType, state);
            if (handBookDesc == null)
            {
                return;
            }

            foreach (var questId in handBookDesc.questList)
            {
                var ret = TaskEXSvc.ProcessAcceptTask(player, questId, true, out var index);
                if (ret == CSErrCode.None)
                {
                    TaskEXEvent.NotifyClientNoneDoth(questId, player);
                }
            }
        }

        private static void RemoveQuest(PlayerOnGame player, ref HandBookData data)
        {
            var desc = ActivityDescMgr.Instance.GetConfig(data.ActId);
            if (desc == null || desc.subType == 0)
            {
                return;
            }

            var groupDesc = HandBookDescMgr.Instance.GetGroup(desc.subType);
            foreach (var hand in groupDesc)
            {
                if (hand.Value.stage > data.Stage)
                {
                    break;
                }

                foreach (var questId in hand.Value.questList)
                {
                    TaskEXSvc.ProcessGiveupTask2(player, questId, out var index);
                }
            }
        }

        public static void Award(PlayerOnGame player, StructPacket packet)
        {
            ref var req = ref packet.GetMessage<CSHandBookGetAwardReq>();
            var res = new CSHandBookGetAwardRes();
            var cmd = (int)CSGameMsgID.HandbookGetAwardRes;
            var activityDesc = ActivityDescMgr.Instance.GetConfig(req.ActId);
            if (req.Stage < 0)
            {
                res.Ret = (int)CSErrCode.Fail;
                player.SendToClient(cmd, ref res);
                return;
            }

            if (activityDesc == null || activityDesc.type != ActivityType.HandBook)
            {
                res.Ret = (int)CSErrCode.Fail;
                player.SendToClient(cmd, ref res);
                return;
            }

            var activityState = ActivitySvc.GetActivityState(player, req.ActId);
            if (activityState != ActivityState.InProgress)
            {
                res.Ret = (int)CSErrCode.Fail;
                player.SendToClient(cmd, ref res);
                return;
            }

            ref var handBookData = ref player.RoleData.ActExtraInfo.HandBookData;
            var index = -1;
            for (int i = 0; i < handBookData.Count; i++)
            {
                if (handBookData[i].ActId == req.ActId)
                {
                    index = i;
                }
            }

            if (index == -1)
            {
                res.Ret = (int)CSErrCode.Fail;
                player.SendToClient(cmd, ref res);
                return;
            }

            ref var handBook = ref handBookData[index];
            var stage = handBook.Stage;
            if (req.Stage > stage)
            {
                res.Ret = (int)CSErrCode.Fail;
                player.SendToClient(cmd, ref res);
                return;
            }

            for (int i = 0; i < handBook.Record.Count; i++)
            {
                if (handBook.Record[i] == req.Stage)
                {
                    res.Ret = (int)CSErrCode.Fail;
                    player.SendToClient(cmd, ref res);
                    return;
                }
            }


            var handBookDesc = HandBookDescMgr.Instance.GetConfig(activityDesc.subType, req.Stage);
            var questList = handBookDesc.questList;
            var complete = true;
            foreach (var questId in questList)
            {
                complete &= (TaskEXSvc.IsCompleteTask(player, questId) || TaskEXSvc.IsFinishTask(player, questId));
            }

            if (!complete)
            {
                res.Ret = (int)CSErrCode.Fail;
                player.SendToClient(cmd, ref res);
                return;
            }

            var unify = new UnifyOp(player, BillChangeItemReason.HandBook);
            foreach (var reward in handBookDesc.reward)
            {
                unify.AddGoods(reward.Type, reward.Id, reward.Count);
            }

            unify.DoOp(sendGetItemMsg: true);

            handBook.Record.Add(req.Stage);
            res.Ret = (int)CSErrCode.None;
            SyncData(player);
            player.MakeDirty();
            player.SendToClient(cmd, ref res);
        }


        public static void DoneAllTask(PlayerOnGame player, int actId)
        {
            ref var data = ref player.RoleData.ActExtraInfo.HandBookData;
            var index = -1;
            for (int i = 0; i < data.Count; i++)
            {
                if (data[i].ActId == actId)
                {
                    index = i;
                    break;
                }
            }

            if (index < 0)
            {
                return;
            }

            var stage = data[index].Stage;
            var desc = ActivityDescMgr.Instance.GetConfig(actId);
            var groupDesc = HandBookDescMgr.Instance.GetGroup(desc.subType);
            CSTaskEXChangeNotify chgNotify = new CSTaskEXChangeNotify();
            foreach (var bookDesc in groupDesc.Values)
            {
                if (bookDesc.stage != stage)
                {
                    continue;
                }

                var quest = bookDesc.questList;
                for (var i = 0; i < quest.Length; i++)
                {
                    var questId = quest[i];
                    ref var taskList = ref player.RoleData.TaskEXData.TaskList;
                    for (var j = 0; j < taskList.Count; j++)
                    {
                        var taskId = taskList[j].TaskId;
                        if (taskId == questId)
                        {
                            taskList[j].Status = (int)TaskEXCfg.TaskStatusComplete;
                            for (int k = 0; k < taskList[j].Condition.Count; k++)
                            {
                                ref var c = ref taskList[j].Condition[k];
                                c.Done = true;
                            }

                            chgNotify.ChgTaskList.Add(ref taskList[j]);
                        }
                    }
                }
            }

            if (chgNotify.ChgTaskList.GetCount() > 0)
            {
                player.SendToClient((int)CSGameMsgID.TaskexChangeNotify, ref chgNotify);
            }

            player.MakeDirty();
        }

        private static void SendMail(PlayerOnGame player, ref HandBookData data)
        {
            var activityDesc = ActivityDescMgr.Instance.GetConfig(data.ActId);
            if (activityDesc == null || activityDesc.subType == 0 || activityDesc.type != ActivityType.HandBook)
            {
                return;
            }

            var group = HandBookDescMgr.Instance.GetGroup(activityDesc.subType);
            if (group == null)
            {
                return;
            }

            List<RewardItemRW> list = new List<RewardItemRW>();
            foreach (var bookDesc in group.Values)
            {
                if (bookDesc.stage > data.Stage)
                {
                    break;
                }

                var complete = true;

                foreach (var questId in bookDesc.questList)
                {
                    var isCompleteTask = TaskEXSvc.IsCompleteTask(player, questId);
                    if (isCompleteTask)
                    {
                        var questExDesc = QuestEXDescMgr.Instance.GetConfig(questId);
                        for (int i = 0; i < questExDesc.rewardType.Length; i++)
                        {
                            if (questExDesc.rewardType[i] == 0 || questExDesc.rewardCount[i] == 0)
                            {
                                break;
                            }

                            list.Add(new RewardItemRW()
                            {
                                type = (int)questExDesc.rewardType[i],
                                code = questExDesc.rewardId[i],
                                amount = questExDesc.rewardCount[i]
                            });
                        }
                    }

                    var isFinish = TaskEXSvc.IsFinishTask(player, questId);
                    complete &= isCompleteTask || isFinish;
                }

                if (complete)
                {
                    var index = -1;
                    for (int i = 0; i < data.Record.Count; i++)
                    {
                        if (data.Record[i] == bookDesc.stage)
                        {
                            index = i;
                            break;
                        }
                    }

                    if (index < 0)
                    {
                        foreach (var reward in bookDesc.reward)
                        {
                            list.Add(new RewardItemRW()
                            {
                                type = reward.Type,
                                code = reward.Id,
                                amount = reward.Count
                            });
                        }
                    }
                }
            }

            if (list.Count > 0)
            {
                MailSender.SendNewMailToPlayer(player, activityDesc.mailId, list);
            }
        }

        public override void OnSystemUnlock(PlayerOnGame player, int sysId)
        {
        }

        protected override void OnDailyRefresh(PlayerOnGame player, ref DBActInfo activityInfo)
        {
            Init(player, activityInfo.ActID);
        }


        private static void SyncData(PlayerOnGame player)
        {
            var info = new HandBookInfoSync() { HandBookData = player.RoleData.ActExtraInfo.HandBookData };
            player.SendToClient((int)CSGameMsgID.HandbookInfoSync, ref info);
        }
    }
}