Example #1
0
 /// <summary>
 /// 移除任务
 /// </summary>
 /// <param name="taskId"></param>
 public void RemoveTask(long taskId)
 {
     if (this.m_taskDict.ContainsKey(taskId))
     {
         TaskBase removeTask = this.m_taskDict[taskId];
         this.m_taskDict.Remove(taskId);
         this.m_taskIndexDict.Remove(removeTask.TaskConfID);
     }
 }
Example #2
0
        public bool IsCompleteTask(long taskUUID)
        {
            TaskBase task = this.m_playerTaskSet.GetTaskById(taskUUID);

            if (task != null)
            {
                return(task.TaskCurrentStatus == TaskStatus.REWARDED);
            }

            return(false);
        }
Example #3
0
        private void OnSyncTaskProgress(TaskInfo info_)
        {
            long taskUUID = info_.PlayerTaskId;

            TaskBase task = this.m_playerTaskSet.GetTaskById(taskUUID);

            if (task != null)
            {
                task.SyncTaskInfo(info_);
            }
        }
Example #4
0
        private void OnAcceptNewTasksByLocalData(long task_config_id_)
        {
            if (this.m_currentTaskList.Where(item => item.TaskConfID == task_config_id_).Count() > 0)
            {
                return;
            }

            TaskBase task = CreateNormalTaskInstance(task_config_id_);

            task.TaskUUID = -1L;

            //m_playerTaskSet.AddTask(task.TaskUUID, task);

            task.TaskCurrentStatus = TaskStatus.PROGRESSING;
            task.TaskSyncStatus    = TaskSyncStatus.LOCAL;

            this.m_currentTaskList.Add(task);

            GameEvents.TaskEvents.OnAcceptNewTask.SafeInvoke(task.TaskUUID);
            GameEvents.TaskEvents.OnSyncedTaskList.SafeInvoke(1);
        }
Example #5
0
        /// <summary>
        /// 同步任务详细数据
        /// </summary>
        /// <param name="message"></param>
        private void OnSyncTaskProgress(object message)
        {
            SCTaskListResponse msg = message as SCTaskListResponse;

            HashSet <long> currentProgressingTaskIDs = new HashSet <long>();

            for (int i = 0; i < msg.TaskInfos.Count; ++i)
            {
                long taskUUID = msg.TaskInfos[i].PlayerTaskId;

                TaskBase task = this.m_playerTaskSet.GetTaskById(taskUUID);
                if (task != null)
                {
                    task.SyncTaskInfo(msg.TaskInfos[i]);

                    if (task.TaskCurrentStatus == TaskStatus.PROGRESSING || task.TaskCurrentStatus == TaskStatus.COMPLETED)
                    {
                        if (task.TaskCurrentStatus == TaskStatus.PROGRESSING)
                        {
                            currentProgressingTaskIDs.Add(task.TaskConfID);
                        }

                        if (!this.m_currentTaskList.Contains(task))
                        {
                            this.m_currentTaskList.Add(task);
                        }
                    }
                }
            }

            if (currentProgressingTaskIDs.Count > 0)
            {
                FindObjSceneDataManager.RefreshSceneIDsForTasks(currentProgressingTaskIDs);
            }

            if (this.m_currentTaskList.Count > 0)
            {
                GameEvents.TaskEvents.OnSyncedTaskList.SafeInvoke(this.m_currentTaskList.Count);
            }
        }
 private void OnCompletedTask(TaskBase task)
 {
     UnityEngine.Debug.Log("task complete === " + task.TaskConfID);
     AddCompleteTask(task.TaskConfID, ConfTask.Get(task.TaskConfID).type);
     GameEvents.BigWorld_Event.OnReflashBuidTask.SafeInvoke();
 }
Example #7
0
        /// <summary>
        /// 交任务相应
        /// </summary>
        /// <param name="message"></param>
        private void OnCommitTask(object message)
        {
            SCTaskCommitResponse msg = message as SCTaskCommitResponse;

            if (!MsgStatusCodeUtil.OnError(msg.Result))
            {
                TaskBase commitTaskInfo = this.m_playerTaskSet.GetTaskById(msg.TaskId);
                if (commitTaskInfo == null)
                {
                    Debug.LogError($"commit task :{msg.TaskId} not found");
                }
                GameEvents.TaskEvents.OnReceiveTask.SafeInvoke(commitTaskInfo);

                GameEvents.PlayerEvents.OnExpChanged.SafeInvoke(null, msg.Exp);

                commitTaskInfo.TaskCurrentStatus = TaskStatus.REWARDED;
                commitTaskInfo.TaskSyncStatus    = TaskSyncStatus.SYNCED;

                if (this.m_currentTaskList.Contains(commitTaskInfo))
                {
                    this.m_currentTaskList.Remove(commitTaskInfo);
                }

                //同步玩家最新信息
                GameEvents.PlayerEvents.RequestLatestPlayerInfo.SafeInvoke();

                //同步背包
                //GlobalInfo.MY_PLAYER_INFO.SyncPlayerBag();
                NormalTask taskInfo = commitTaskInfo as NormalTask;
                for (int i = 0; i < taskInfo.RewardList.Count; ++i)
                {
                    TaskRewardBase taskReward     = taskInfo.RewardList[i];
                    TaskRewardMode taskRewardType = (taskReward.GetType().GetCustomAttributes(typeof(TaskRewardAttribute), true)[0] as TaskRewardAttribute).RewardMode;

                    if (TaskRewardMode.ITEM == taskRewardType)
                    {
                        TaskRewardItem     rewardItem     = taskReward as TaskRewardItem;
                        RewardItemDataWrap rewardItemData = rewardItem.RewardData;

                        if (RewardItemType.ITEM == rewardItemData.ItemType)
                        {
                            GlobalInfo.MY_PLAYER_INFO.AddSingleBagInfo(rewardItemData.ItemID, rewardItemData.ItemNum);
                        }
                    }
                }

                GameEvents.UIEvents.UI_GameEntry_Event.Listen_OnCombinePropCollected.SafeInvoke();
                //>

                BigWorldManager.Instance.EnterBigWorld();
                GameEvents.TaskEvents.OnCompletedTask.SafeInvoke(msg.Result, commitTaskInfo);

                HttpPingModule.Instance.SendPing();

                //TODO : 放在主界面onshow
                //if (C_FIRST_TASK_ID == commitTaskInfo.TaskConfID)
                //{
                //    SignInManager sm = new SignInManager();
                //}
            }
            else
            {
                GameEvents.TaskEvents.OnSyncedTaskList.SafeInvoke(1);
            }
        }
Example #8
0
        /// <summary>
        /// 接收新的任务
        /// </summary>
        /// <param name="message"></param>
        private void OnAcceptNewTasks(object message)
        {
#if true
            TimeModule.Instance.SetTimeout(
                () =>
            {
                SCAcceptTaskNotice msg = message as SCAcceptTaskNotice;

                IList <AcceptTaskInfo> acceptTaskInfos = msg.AcceptTasks;
                for (int i = 0; i < acceptTaskInfos.Count; ++i)
                {
                    AcceptTaskInfo taskInfo = acceptTaskInfos[i];
                    long taskUUID           = taskInfo.PlayerTaskId;

                    this.m_currentTaskList.RemoveAll(item => item.TaskConfID == taskInfo.TaskId && TaskSyncStatus.LOCAL == item.TaskSyncStatus);

                    TaskBase task = m_playerTaskSet.GetTaskById(taskUUID);
                    if (task == null)
                    {
                        task          = CreateNormalTaskInstance(taskInfo.TaskId);
                        task.TaskUUID = taskUUID;
                        m_playerTaskSet.AddTask(taskUUID, task);
                    }

                    task.TaskCurrentStatus = (TaskStatus)taskInfo.Status;
                    task.TaskSyncStatus    = TaskSyncStatus.SYNCED;

                    if (this.m_currentTaskList.Where(item => item.TaskUUID == task.TaskUUID).Count() > 0)
                    {
                        Debug.LogWarning($"accept new task duplicate task{task.TaskUUID}");
                    }
                    else
                    {
                        this.m_currentTaskList.Add(task);

                        GameEvents.TaskEvents.OnAcceptNewTask.SafeInvoke(taskUUID);
                        GameEvents.TaskEvents.OnSyncedTaskList.SafeInvoke(1);
                    }
                }
            }, 3.0f);
#else
            SCAcceptTaskNotice msg = message as SCAcceptTaskNotice;

            IList <AcceptTaskInfo> acceptTaskInfos = msg.AcceptTasks;
            for (int i = 0; i < acceptTaskInfos.Count; ++i)
            {
                AcceptTaskInfo taskInfo = acceptTaskInfos[i];
                long           taskUUID = taskInfo.PlayerTaskId;

                this.m_currentTaskList.RemoveAll(item => item.TaskConfID == taskInfo.TaskId && TaskSyncStatus.LOCAL == item.TaskSyncStatus);

                TaskBase task = m_playerTaskSet.GetTaskById(taskUUID);
                if (task == null)
                {
                    task          = CreateNormalTaskInstance(taskInfo.TaskId);
                    task.TaskUUID = taskUUID;
                    m_playerTaskSet.AddTask(taskUUID, task);
                }

                task.TaskCurrentStatus = (TaskStatus)taskInfo.Status;
                task.TaskSyncStatus    = TaskSyncStatus.SYNCED;

                if (this.m_currentTaskList.Where(item => item.TaskUUID == task.TaskUUID).Count() > 0)
                {
                    Debug.LogWarning($"accept new task duplicate task{task.TaskUUID}");
                }
                else
                {
                    this.m_currentTaskList.Add(task);

                    GameEvents.TaskEvents.OnAcceptNewTask.SafeInvoke(taskUUID);
                    GameEvents.TaskEvents.OnSyncedTaskList.SafeInvoke(1);
                }
            }
#endif
        }