--[[
	@description:任务模块
]]

require("game.task.TaskModel")
require("game.task.TaskNewBaseView")
require("game.task.TaskSubMainView")
require("game.task.TaskSubExtensionView")
require("game.task.TaskVerTabSubBtn")
require("game.task.TaskSubCommonView")

require("game.task.vo.TaskVo")
require("game.task.vo.TaskTipsVo")
require("game.task.TaskEvent")
require("game.task.TaskLang")
require("game.task.TaskFinishTipView")
require("game.task.TaskDailyView")
require("game.task.TaskDailyItem")
require("game.task.TaskBountyRewardView")

-------------------------
--新的
require("game.task.TaskCircleBuyTip")
require("game.task.FlyShoeBuyTip")
-------------------------

TaskController = TaskController or BaseClass(BaseController)
local TaskController = TaskController
local table_insert = table.insert

function TaskController:__init()
	TaskController.Instance = self
	self.taskModel = TaskModel:getInstance()
	self.taskModel.after_scene_start = false
	self:RegisterAllProtocals()
	self:EnableCheckoutClear()
	self:InitEvent()
end

function TaskController:RegisterAllProtocals()
	self:RegisterProtocal(30000, "handler30000")--可接任务和已接任务列表
	self:RegisterProtocal(30001, "handler30001")--完成任务某环节
	self:RegisterProtocal(30005, "handler30005")--放弃任务
	self:RegisterProtocal(30017, "handler30017")--已完成任务列表
	self:RegisterProtocal(30018, "handler30018")--快速完成任务
	self:RegisterProtocal(30019, "handler30019")--领取跑环额外奖励

end

function TaskController:InitEvent()
	local open_task_view = function (index,task_id,parent_index,sub_index)
		self:OpenTaskView(index,task_id,parent_index,sub_index)
	end
	GlobalEventSystem:Bind(EventName.OPEN_TASK_VIEW, open_task_view)

	--场景开始了
	local function loginComplete()
		if self.taskModel.game_start_request == true then
			self.taskModel.game_start_request = false
			self.taskModel:HideRoleWeapon() --可能30000第一次返回的时候主角还没创建，场景开始后，主角一定创建了，这里再判断是否隐藏武器
		end
	end
	GlobalEventSystem:Bind(SceneManager.START,loginComplete)

	local game_start_fun = function ()
		self.main_line_break_wait = nil
		self.not_guide_wait_accept_main_task = nil
		self.mark_main_line_list = nil
		self.first_call_new_tip = nil
		self.taskModel:ClearData()
		setTimeout(
				function()
				DialogueModel:getInstance():Fire(DialogueModel.REQUEST_CCMD_EVENT, 30012)
				DialogueModel:getInstance():Fire(DialogueModel.REQUEST_CCMD_EVENT, 30010, 6)
				DialogueModel:getInstance():Fire(DialogueModel.REQUEST_CCMD_EVENT, 30010, 7)
				self:request30000()
		end,0.6)

		if self.auto_check_do_task_timer then
			GlobalTimerQuest:CancelQuest(self.auto_check_do_task_timer)
			self.auto_check_do_task_timer = nil
		end

		if self.can_move_timer_id then 
			TimerQuest.CancelQuest(GlobalTimerQuest, self.can_move_timer_id)
			self.can_move_timer_id = false
		end

		self:ClearBreakLevelTimer()

	end
	GlobalEventSystem:Bind(EventName.GAME_START, game_start_fun)

	local function onRequeseTaskData(  )
		self:request30000()
	end
	GlobalEventSystem:Bind(EventName.REQUEST_TASK_DATA, onRequeseTaskData)

	local function CIRCLE_TASK_QUICK_FINISH( id )
		self:request30018(id)
	end
	GlobalEventSystem:Bind(TaskEventType.CIRCLE_TASK_QUICK_FINISH, CIRCLE_TASK_QUICK_FINISH)

	--@force_use_shoe:点击任务栏飞鞋按钮时强制使用飞鞋
	local find_way_fun = function (params, use_shoe,force_use_shoe)
		self:findElement(params,use_shoe,force_use_shoe)
	end
	GlobalEventSystem:Bind(EventName.WAYFINDING, find_way_fun)--寻路



	local function loadComplete()
		--必须npc加载完， 场景加载完，才能继续做任务
		self.taskModel.proto_count = self.taskModel.proto_count + 1
		self.delay_fly_down_to_do_task = false
		if self.taskModel.proto_count >= 2 then
			self.taskModel.proto_count = 0
			self:ClearAutoDoTaskTimer()
			if SceneManager:getInstance():IsMainCityorYieldScene() then
				--切场景后自动寻路
				print("tanar: [TaskController 117]=> self.taskModel.need_task: ",self.taskModel.need_task)
				print("tanar: [TaskController 118]=> guide_force_do_task: ",guide_force_do_task)
				local guide_force_do_task =	GuideModel:getInstance().need_force_do_task  --引导触发的自动任务				
				if self.taskModel.need_task or guide_force_do_task then
					if guide_force_do_task then
						GuideModel:getInstance().need_force_do_task = false
					end
					self.taskModel:SetNeedTaskFlag(false)
					self.taskModel:SetTaskAutoFlag(false)
					local onDelay = function(  )
						local mainRole = Scene.Instance:GetMainRole()
						if mainRole	and mainRole:IsInState(PoseState.FLY_SHOE_EFFECT) then
							self.delay_fly_down_to_do_task = true
						else
							GlobalEventSystem:Fire(EventName.FORCE_TO_DO_TASK, true)
						end					
					end
					setTimeout(onDelay, 1.1)
				end
			end
			GlobalEventSystem:Fire(EventName.CAN_FIND_NPC)
		end
	end
	GlobalEventSystem:Bind(EventName.NPC_LOAD_FINISH, loadComplete)

	local function scene_load_view_complete( )
		loadComplete()
		--需要清掉标志，不然副本挂机会找不到怪
		TaskModel:getInstance().need_check_monster = false
		--如果不在安全场景或者也要，停止做任务 寻路也停掉，避免无法挂机
		if not SceneManager:getInstance():IsMainCityorYieldScene() then
			GlobalEventSystem:Fire(EventName.FORCE_STOP_DO_TASK)
		else
			if self.taskModel.need_show_circle_tip then
				GlobalEventSystem:Fire(EventName.OPEN_TASK_CIRCLE_TIPS,self.taskModel.need_show_circle_tip)
				self.taskModel.need_show_circle_tip = false
			end
			if self.taskModel.wait_circle_show_award_data then
				-- GlobalEventSystem:Fire(NatureModel.OPEN_AWARD_RESULT_VIEW, self.taskModel.wait_circle_show_award_data)
				GlobalEventSystem:Fire(EventName.OPEN_TASK_CIRCLE_TIPS, self.taskModel.wait_circle_show_award_data)
				self.taskModel.wait_circle_show_award_data = false
			end
		end

		if self.auto_check_do_task_timer then
			GlobalTimerQuest:CancelQuest(self.auto_check_do_task_timer)
			self.auto_check_do_task_timer = nil
		end
	end
	GlobalEventSystem:Bind(EventName.SCENE_LOAD_VIEW_COMPLETE, scene_load_view_complete)

	local function doFlyShoeEffectFinishDown()
		if self.delay_fly_down_to_do_task then
			GlobalEventSystem:Fire(EventName.FORCE_TO_DO_TASK, true)
			self.delay_fly_down_to_do_task = false
		end
	end
	GlobalEventSystem:Bind(SceneEventType.DO_FLYSHOE_EFFECT_FINISH_DOWN,doFlyShoeEffectFinishDown)

	local function main_role_move_end()
		self:CreateAutoDoTaskTimer()
	end
	GlobalEventSystem:Bind(SceneEventType.MAIN_ROLE_MOVE_END, main_role_move_end)
	GlobalEventSystem:Bind(EventName.CREATE_MAIN_TASK_TIP, main_role_move_end)

	--是否继续开始任务
	local function reopen_fun(now)
		print("-------START_AUTO-------------", self.taskModel.now_task_id, self.taskModel.is_stop)
		-- local mainrole = Scene:getInstance():GetMainRole()
		-- if mainrole and mainrole:IsInState(PoseState.FLY) or mainrole:IsInState(PoseState.FLY_SHOE_EFFECT) or mainrole:IsInState(PoseState.FLY_SHOE) then
		-- 	-- Message.show("请落地后重试~")
		-- 	if self.taskModel.is_auto_task and self.taskModel.is_stop then
		-- 		local function task_load_scene_func( ... )
		-- 			GlobalEventSystem:Fire(EventName.START_AUTO_DO_TASK)
		-- 		end
		-- 		self.task_load_scene_func = task_load_scene_func--任务场景加载完后调什么
		-- 		self.task_load_scene_func_time = TimeUtil:getServerTime(  )--事件时间
		-- 	end
		-- 	return
		-- end--飞鞋状态下开始任务

		if self.taskModel.is_auto_task and self.taskModel.is_stop then
			local delay_fun = function ()
				self.taskModel.is_stop = false
			--	GlobalEventSystem:Fire(EventName.FINDWAY_ENDED)
				self:AutoDoTask()
			end
			if now then
				delay_fun()
			else
				self.later_time_id = GlobalTimerQuest:AddDelayQuest(delay_fun, 0.6)
			end
		end
	end
	GlobalEventSystem:Bind(EventName.START_AUTO_DO_TASK, reopen_fun)

	--暂停自动寻路
	local function close_fun()
		-- local mainrole = Scene:getInstance():GetMainRole()
		-- if mainrole and mainrole:IsInState(PoseState.FLY) or mainrole:IsInState(PoseState.FLY_SHOE_EFFECT) or mainrole:IsInState(PoseState.FLY_SHOE) then
		-- 	-- Message.show("请落地后重试~")
		-- 	if self.taskModel.is_auto_task and self.taskModel.is_stop then
		-- 		if self.task_load_scene_func_time and self.task_load_scene_func_time <= TimeUtil:getServerTime(  ) then--时间要满足先后顺序
		-- 			self.task_load_scene_func = nil--任务场景加载完后调什么
		-- 			self.task_load_scene_func_time = nil--事件时间
		-- 		end
		-- 	end
		-- end--飞鞋状态下停止任务

		self:ClearAutoDoTaskTimer()
		self.taskModel.is_stop = true--停止任务标记
		if not EscortModel:getInstance():IsEscortState() then--护送状态接着护送
			OperateManager.Instance:StopMove(true)  --先清掉当前场景的操作包，避免继续移动寻路
		end
		if self.later_time_id then
			GlobalTimerQuest:CancelQuest(self.later_time_id)
			self.later_time_id = nil
		end
	end
	GlobalEventSystem:Bind(EventName.STOP_AUTO_DO_TASK, close_fun)

	--不再做任务
	local function stop_fun()
		self:ClearAutoDoTaskTimer()
		-- print("---------NOT_TASK---------:", self.taskModel.now_task_id, self.taskModel.is_stop)
		TaskModel:getInstance():SetTaskAutoFlag(false)

		local is_fire_evt = OperateManager.Instance:StopMove(true)  --先清掉当前场景的操作包，避免继续移动寻路
		if not is_fire_evt then
			GlobalEventSystem:Fire(EventName.FINDWAY_ENDED)
		end
	end
	GlobalEventSystem:Bind(EventName.FORCE_STOP_DO_TASK, stop_fun)

	local do_first_task = function (force, is_force_main_line)
		TaskModel:getInstance():SetTaskAutoFlag(true)
		self.taskModel.is_stop = false
		self:AutoDoTask(force, is_force_main_line)
	end
	GlobalEventSystem:Bind(EventName.FORCE_TO_DO_TASK, do_first_task)

	local function onOpenTaskFinishView(show, task_type, task_id)
		if show then
			if self.TaskFinishTipView == nil then
				self.TaskFinishTipView = TaskFinishTipView.New()
			end
			self.TaskFinishTipView:Open(task_type, task_id)
		else
			if self.TaskFinishTipView and self.TaskFinishTipView:HasOpen() then
				self.TaskFinishTipView:Close()
			end
		end
	end
	GlobalEventSystem:Bind(EventName.OPEN_TASK_FINISH_TIP_VIEW, onOpenTaskFinishView)

	local function onOpenTaskDailyView(show)
		if show then
			if self.TaskDailyView == nil then
				self.TaskDailyView = TaskDailyView.New()
			end
			self.TaskDailyView:Open()
		else
			if self.TaskDailyView and self.TaskDailyView:HasOpen() then
				self.TaskDailyView:Close()
			end
		end
	end
	GlobalEventSystem:Bind(EventName.OPEN_TASK_DAILY_VIEW, onOpenTaskDailyView)

	local function onOpenTaskBountyRewardView(circle_num,is_close)
		if is_close then
			if self.TaskBountyRewardView and self.TaskBountyRewardView:HasOpen() then
				self.TaskBountyRewardView:Close()
			end
		else
			if GuideModel:getInstance():IsPromptViewOpen() or GuideModel:getInstance():IsHideSmallUI() then
				return
			end

			if self.TaskBountyRewardView == nil then
				self.TaskBountyRewardView = TaskBountyRewardView.New()
			end
			self.TaskBountyRewardView:Open(circle_num)
		end
	end
	GlobalEventSystem:Bind(EventName.OPEN_TASK_BOUNTY_REWARD_VIEW, onOpenTaskBountyRewardView)


	local function change_account()
		if self.auto_check_do_task_timer then
			GlobalTimerQuest:CancelQuest(self.auto_check_do_task_timer)
			self.auto_check_do_task_timer = nil
		end
		self:ClearBreakLevelTimer()
	end 
	GlobalEventSystem:Bind(EventName.CHANGE_ACCOUNT,change_account)
	GlobalEventSystem:Bind(EventName.CHANGE_ROLE,change_account)


	local function onShowBreakLevelTimer()
		self:ClearBreakLevelTimer()

		if SceneManager:getInstance():IsMainCityorYieldScene() then
			local function onTimer()
				local main_role = Scene.Instance.main_role
				if main_role and main_role.stand_init_time > 25 then
					if self.taskModel.showExtendTip then
						GuideModel:getInstance():TriggerBreakLevelGuide()
						self:ClearBreakLevelTimer()
					end
				end
			end
			self.show_break_level_timer = GlobalTimerQuest:AddPeriodQuest(onTimer,30)
		end
	end
	self.taskModel:Bind(TaskEvent.SHOW_BREAK_LEVEL_TIMER, onShowBreakLevelTimer)

	local function CONTINUE_TASK( task_type )
		local circle_data = self.taskModel:GetCircleTaskInfo(task_type)
		local task_data = self.taskModel:GetTaskByType( task_type )
		if circle_data and (not task_data) then
			if circle_data.task_type == TaskType.GUILD_LINE then
				task_data = self.taskModel:GetGuildTipTask()
			elseif circle_data.task_type == TaskType.BOUNTY_LINE then
				task_data = self.taskModel:GetBountyTipTask()
			end
		end
		-------------------------
		if task_data then
			local vip = RoleManager.Instance.mainRoleInfo.vip_flag
			if vip > 0 and self.taskModel:IsShowFlyShoe(task_data) then
				self.taskModel:TaskClickFun(task_data,true)
			else
				self.taskModel:TaskClickFun(task_data)
			end
			if task_type == TaskType.BOUNTY_LINE or task_type == TaskType.GUILD_LINE then
				GlobalEventSystem:Fire(KfActivityModel.OPEN_ACTIVITY_BASE_VIEW,nil,nil,true)--触发任务关闭活动界面
			end
		else
			if task_type == TaskType.GUILD_LINE then
				local guild_id = RoleManager.Instance.mainRoleInfo.guild_id
				if not guild_id or guild_id == 0 then
					Message.show("请先加入社团")
				end
			end
		end			
	end
	self.taskModel:Bind(TaskEvent.CONTINUE_TASK, CONTINUE_TASK)

	local function OPEN_QUICK_CIRCLE_TIPS( data )
		self.taskcirclebuytip = self.taskcirclebuytip or TaskCircleBuyTip.New()
		self.taskcirclebuytip:Open(data)
	end
	self.taskModel:Bind(TaskEvent.OPEN_QUICK_CIRCLE_TIPS,OPEN_QUICK_CIRCLE_TIPS)

	local function OPEN_BUY_SHOE_TIPS( buy_call )
		self.flyshoebuytip = self.flyshoebuytip or FlyShoeBuyTip.New()
		self.flyshoebuytip:Open(buy_call)
	end
	self.taskModel:Bind(TaskEvent.OPEN_BUY_SHOE_TIPS,OPEN_BUY_SHOE_TIPS)

	local function onGuildChange()
        self:DoTaskNotify()
    end
    RoleManager:getInstance():GetMainRoleVo():BindOne("guild_id", onGuildChange)  

end

function TaskController:ClearBreakLevelTimer()
	if self.show_break_level_timer then
		GlobalTimerQuest:CancelQuest(self.show_break_level_timer)
		self.show_break_level_timer = nil
	end
end

function TaskController:CheckAutoDoTaskTimer()
	do return end
	-- if self.auto_check_do_task_timer then
	-- 	GlobalTimerQuest:CancelQuest(self.auto_check_do_task_timer)
	-- 	self.auto_check_do_task_timer = nil
	-- end

	-- local playerLv = RoleManager:getInstance():GetMainRoleVo().level
	-- if playerLv <= 120 and SceneManager:getInstance():IsMainCityorYieldScene() then
	-- 	local function onTimer()
	-- 		local playerLv = RoleManager:getInstance():GetMainRoleVo().level
	-- 		if playerLv > 1 and playerLv <= 120 then
	-- 			local main_role = Scene.Instance.main_role
	-- 			if main_role and main_role.stand_init_time > 35 and lua_viewM.main_cancas_last_visible then
	-- 				local taskVo = TaskModel:getInstance():GetTaskByType(TaskType.MAIN_LINE) or TaskModel:getInstance():GetTaskByType(TaskType.BOUNTY_LINE) or TaskModel:getInstance():GetBountyTipTask()
	-- 				if taskVo then
	-- 					 TaskModel:getInstance().need_do_task_type = 0
	-- 					 TaskModel:getInstance().last_task_type_cache = false
	-- 					 TaskModel:getInstance().now_task_id = taskVo.id
	-- 					 GlobalEventSystem:Fire(EventName.FORCE_TO_DO_TASK, true)
	-- 				end
	-- 			end
	-- 		end
	-- 	end
	-- 	self.auto_check_do_task_timer = GlobalTimerQuest:AddPeriodQuest(onTimer,40)
	-- end
end

--创建自动开始任务定时器
function TaskController:CreateAutoDoTaskTimer()
	do return end
	self:ClearAutoDoTaskTimer()
	if self.taskModel.is_auto_task then
		local playerLv = RoleManager:getInstance():GetMainRoleVo().level
		if playerLv <= 120 then
			local function func()
				if self.taskModel.is_auto_task and Scene.Instance.main_role and Scene.Instance.main_role:IsInState(PoseState.STAND) then
					if Scene.Instance.main_role.stand_init_time and Scene.Instance.main_role.stand_init_time > 4 then
						self:AutoDoTask()
					end
				end
			end
			self.auto_do_timer = GlobalTimerQuest:AddDelayQuest(func, 5)
		end
	end
end

--自动开始任务  force 30000返回的时候，可能是接完支线，就算是打开界面的任务类型， 也自动做
function TaskController:AutoDoTask(force, is_force_main_line)
	--if ClientConfig.alpha_mode then return end
	self:ClearAutoDoTaskTimer()
	self.taskModel.guild_kill_monster_num = 0
	if Scene.Instance:IsSceneProloadFinish() then
		if SceneManager.Instance:IsMainCityorYieldScene() then
			local cur_task
			if is_force_main_line then
				cur_task = self.taskModel:GetMainTask()
			else
				cur_task = self.taskModel:GetCurTask()
			end
			print("Saber:TaskController [413] cur_task: ",cur_task)
			print("tanar: [TaskController 419]=> is_force_main_line: ",is_force_main_line)
			print("tanar: TaskController [386] ====== AutoDoTask parms: force = ", force)
			print("not self.taskModel:IsWaitProto(): ",not self.taskModel:IsWaitProto())
			print("self.taskModel:IsAutoDoTask(cur_task): ",self.taskModel:IsAutoDoTask(cur_task))
			print("cur_task and cur_task.mainTip == false: ",cur_task and cur_task.mainTip == false)
			print("self.taskModel.is_stop == false: ",self.taskModel.is_stop == false)
			print("self.taskModel.now_task_id: ",self.taskModel.now_task_id)
			print("not DialogueModel:getInstance().dialogue_is_open: ",not DialogueModel:getInstance().dialogue_is_open)
			print("not GuideModel:getInstance():IsNeedFinishGuideFirst(): ", not GuideModel:getInstance():IsNeedFinishGuideFirst())
			print("tanar: TaskController [395] ====== parms end")
			if not self.taskModel:IsWaitProto() and (self.taskModel:IsAutoDoTask(cur_task) or force) and cur_task and cur_task.mainTip == false and self.taskModel.is_stop == false
			 	and  UserMsgAdapter:getInstance().is_game_connected and not DialogueModel:getInstance().dialogue_is_open and not GuideModel:getInstance():IsNeedFinishGuideFirst() then
				--主线在等待升级的时候，不做任务，避免升级前去找开始npc，这个看网络
				print("tanar: [TaskController 413]=> cur_task.type: ",cur_task.type)
				if cur_task.type==TaskType.MAIN_LINE and TaskModel:getInstance().need_accept then
					print("tanar: [TaskController 417]=> TaskModel:getInstance().need_accept: ",TaskModel:getInstance().need_accept)
					return
				end
				if force and cur_task.tipParam and cur_task.tipParam[1] == TaskTipType.TYPE43 then
					--主线强制force参数会绕过TaskModel:getInstance()IsAutoDoTask的判断，引起部分界面类任务和引导重叠，这边特殊处理掉
					return
				end
				if cur_task.type == TaskType.TRUN_LINE then
					local last_is_main_yield_scene = SceneManager.Instance:IsMainCityorYieldScene(SceneManager.Instance:GetLastSceneId())
					local turn_task_needs_auto = self.taskModel:NeedAutoDoTurnTask(cur_task)
					-- local rein_task_finished = cur_task.taskTips and cur_task.taskTips[1] and cur_task.taskTips[1].isFinish == 1
					if ((self.delay_fly_down_to_do_task and not last_is_main_yield_scene) -- 防止在大世界切大世界场景也弹
						or (not self.delay_fly_down_to_do_task)) and not turn_task_needs_auto then -- 不能自动进行的任务需要弹出任务窗口确认
						-- and rein_task_finished then -- 转职任务不会自动执行，但切换场景进来的已完成转职任务的情况除外
						local turn = ReincarnationModel:getInstance():GetCurTurn()
						ReincarnationModel:getInstance():Fire(ReincarnationModel.OPEN_REIN_MAIN_TASK_VIEW, true, turn)
						return 
					end
				end
				-- 从副本里出来后（失败或者主动退出），自动任务又要重新进这个副本，那就不要再进去了，改到61003控制
				self.taskModel:TaskClickFun(cur_task)
			end
		end
	else
		self.taskModel.after_scene_start = true
	end
end
--清除自动开始任务定时器
function TaskController:ClearAutoDoTaskTimer()
	-- print("--------清除自动开始任务定时器-----")
	if self.auto_do_timer then
		GlobalTimerQuest:CancelQuest(self.auto_do_timer)
		self.auto_do_timer = nil
	end
end

-----------------协议相关---------------------

function TaskController:request30000()
	self:Clear30000Timer()
	self:SendFmtToGame(30000,"")
end

function TaskController:handler30000()
	self.taskModel.notMain = true --没接有主线任务
	local task_type = self:ReadFmt("c")
	if task_type == 0 then
		self.taskModel._canTaskList={}
		self.taskModel._receivedTaskList={}
		self.taskModel.all_task_list = {}
	else
		local list = self.taskModel._canTaskList
		for i = #list, 1, -1 do
			if list[i].type == task_type then
				table.remove(list,i)
			end
		end

		list = self.taskModel._receivedTaskList
		for i = #list, 1, -1 do
			if list[i].type == task_type then
				table.remove(list,i)
			end
		end

		list = self.taskModel.all_task_list
		for i = #list, 1, -1 do
			if list[i].type == task_type then
				table.remove(list,i)
			end
		end
	end
	local len = self:ReadFmt("h")

	for index = 1, len do
		local taskVO=TaskVo.New(true, false)
		taskVO.acceptType = 1
		if taskVO.level and taskVO.level <= RoleManager.Instance.mainRoleInfo.level then
			if not ClientConfig.alpha_mode or taskVO.type~=TaskType.EXTENSION_LINE then
				self.taskModel:MakeTaskTip(taskVO)
				table_insert(self.taskModel._canTaskList,taskVO)--保存可接任务vo
				table_insert(self.taskModel.all_task_list, taskVO)
				-------------------------
				--非新手流程的时候，有可接取的主线，就不要等了，直接接
				if Config.ConfigTaskEffect.GuideLevel < RoleManager.Instance.mainRoleInfo.level then
					if taskVO.type == TaskType.MAIN_LINE then
						print('Ych:TaskController.lua[552] data', taskVO.id)
						--GlobalEventSystem:Fire(TaskEventType.SEND_TASK_ACCEPT, taskVO.id)
						if self.main_line_break_wait then
							if not self.taskModel.sign_mask_not_guide_wait_accept_main_task then--完成任务导致升级的时候会从重合导致当前自动任务流程停止，用30004的标记处理掉
								self.not_guide_wait_accept_main_task = true--非新手流程等主线任务更新，这次更新不要自动进行任务
							end
							self.auto_accept_main_id = taskVO.id--保存一下自动接的任务id，给30003协议返回用
						else
							--如果已经不是断层任务了，这个就不用了
							self.not_guide_wait_accept_main_task = false
						end
					end
				end
				-------------------------
			end
		end
		if taskVO.type == TaskType.MAIN_LINE and ((RoleManager.Instance.mainRoleInfo.level == 0) or (taskVO.level<=RoleManager.Instance.mainRoleInfo.level)) then
			--20000比13001还快，这时候人物等级都木有
			self.taskModel.notMain=false
		end
	end

	local need_refresh_monster_name

	local len4 = self:ReadFmt("h")

	for index = 1, len4 do
		local taskVO = TaskVo.New(true, true)
		if not ClientConfig.alpha_mode or taskVO.type~=TaskType.EXTENSION_LINE then
			taskVO.acceptType=0
			self.taskModel:MakeTaskTip(taskVO)
			table_insert(self.taskModel._receivedTaskList,taskVO)--保存已接任务vo
			table_insert(self.taskModel.all_task_list, taskVO)
			if taskVO.task_kind == TaskKind.CAI_JI_KIND then  --采集任务，刷新采集怪的名字面板，有任务时才显示名字
				need_refresh_monster_name = true 
				self.monster_content_id = taskVO.content_id
			end
			if taskVO.type == TaskType.MAIN_LINE then
				self.taskModel.notMain = false
			end
		end
	end

	--可能只发了某个类型的过来。所以要全部判断下
	if task_type > 0 then
		local list = self.taskModel.all_task_list
		for index,taskVO in pairs(list) do
			if taskVO.type == TaskType.MAIN_LINE then
				if taskVO.acceptType == 1 then
					if ((RoleManager.Instance.mainRoleInfo.level == 0) or (taskVO.level <= RoleManager.Instance.mainRoleInfo.level)) then
						self.taskModel.notMain = false
						break
					end
				elseif taskVO.acceptType == 0 then
					self.taskModel.notMain = false
					break
				end
			end
		end
	end

	self.taskModel.showExtendTip = self.taskModel:NeedShowExtendTip()

	--当前任务做完后，马上做下一个主线任务
	if RoleManager.Instance.mainRoleInfo.level <= TaskModel.AutoDoNewMainTaskLv then
		local task_data = self.taskModel:GetMainUITaskData()
		if not self.taskModel.now_task_id and task_data and task_data[1] and task_data[1].mainTip == false then
			if task_data[1].id ~= self.taskModel.last_task_id_cache and task_data[1].type==TaskType.MAIN_LINE then --马上继续下一个任务
				self.taskModel.now_task_id = task_data[1].id
			end
		end
	end
	if self.taskModel.need_do_task_type~=0  then
		--马上做赏金或社团任务
		local taskVo = self.taskModel:GetTaskByType(self.taskModel.need_do_task_type)
		if taskVo then
			TaskModel:getInstance():SetTaskAutoFlag(true)
			TaskModel:getInstance().now_task_id = taskVo.id
		end
		self.taskModel.need_do_task_type = 0
	else
		if self.taskModel.last_task_type_cache then
			if self.taskModel.last_task_type_cache==TaskType.BOUNTY_LINE then
				--自动做
				local taskVo = self.taskModel:GetTaskByType(TaskType.BOUNTY_LINE)
				if taskVo then
					self.taskModel.now_task_id = taskVo.id
				end
				--请求进度
				DialogueModel:getInstance():Fire(DialogueModel.REQUEST_CCMD_EVENT, 30010, TaskType.BOUNTY_LINE)
			elseif self.taskModel.last_task_type_cache==TaskType.GUILD_LINE then
				if RoleManager.Instance.mainRoleInfo.vip_flag >= Config.ConfigTaskEffect.guildAutoTaskVip then
					local taskVo = self.taskModel:GetTaskByType(TaskType.GUILD_LINE)
					if taskVo then
						self.taskModel.now_task_id = taskVo.id
					end
				else
					--vip不足，停止做任务
					GlobalEventSystem:Fire(EventName.FORCE_STOP_DO_TASK)
				end
				--请求进度
				DialogueModel:getInstance():Fire(DialogueModel.REQUEST_CCMD_EVENT, 30010, TaskType.GUILD_LINE)
			elseif self.taskModel.last_task_type_cache==TaskType.TRUN_LINE then
				local taskVo = self.taskModel:GetTaskByType(TaskType.TRUN_LINE)
				if taskVo then -- 存在任务时，根据上次完成转职任务的等级判断玩家是否处于卡级阶段，是则不自动进行转职任务
					local is_in_turn_task_limit = self.taskModel:IsNewTurnTaskInLimitLv()
					self.taskModel.now_task_id = not is_in_turn_task_limit and taskVo.id or false
				else
					self.taskModel.now_task_id = false
				end
				-- 2021年7月27日修改 转职任务转阶段不自动进行下一阶段
				-- self.taskModel.now_task_id = false
			end
		end
	end

	if need_refresh_monster_name then
		self.taskModel:RefreshCollectMonsterName(self.monster_content_id)
	elseif self.monster_content_id then
		local temp_content_id = self.monster_content_id
		self.monster_content_id = false
		self.taskModel:RefreshCollectMonsterName(temp_content_id)
	end

	self:HandleTask()
	-------------------------
	--self:CheckNewMainLineTip()--检查是否需要显示新主线
	self:CheckWaitNewMainLineAccept()
	-------------------------
end

function TaskController:HandleTask(  )
	self:ClearAutoDoTaskTimer()
	self:Clear30000Timer()
	local delay_fun = function()
		if self.delay_id then
			GlobalTimerQuest:CancelQuest(self.delay_id)
			self.delay_id = nil
		end

		local function func()
			local task = self.taskModel:GetTaskById(self.taskModel.now_task_id)
			-------------------------
			--96级之后不用主动优先主线
			local auto_main_line = RoleManager.Instance.mainRoleInfo.level <= TaskModel.AutoDoNewMainTaskLv
			-------------------------
			if self.taskModel.notMain==true then
				self.taskModel:DefaultTask()
				if self.taskModel._nextMain then
					table_insert(self.taskModel._canTaskList,  self.taskModel._nextMain )
					table_insert(self.taskModel.all_task_list, self.taskModel._nextMain)
				end
			end
			-- self.taskModel:Fire(TaskEvent.TASK_LIST_INIT)
			self:DoTaskNotify()
			GlobalEventSystem:Fire(EventName.UPDATE_TASK_STATE)

			local curTipType = 0		--当前环的任务类型
			local lastTipType = 0		--上一环的任务类型
			local task_id = 0
			if task then
				curTipType = task.tipType
				lastTipType =  task:GetLastTaskTipsType()
				if curTipType == TaskTipType.TYPE59 then
					self.taskModel.accept_power_task_id = task.id
				end				
				if lastTipType == TaskTipType.TYPE59  then					
					--如果满足，则说明，战力任务领取的时候直接满足战力需求，继续做任务
					if self.taskModel.accept_power_task_id ~= task.id then
						lastTipType = 0
					end
				end
			end
			--当前环任务是战力引导任务，不自动做
			--上一环任务是战力引导任务，不自动做（但是如果如果领到任务，已经满足战力引导任务，则需要自动做）
			local can_do_task = curTipType ~= TaskTipType.TYPE59 and lastTipType ~= TaskTipType.TYPE59

			--如果这次次战力提升的任务，要重置 断层做主线的标志
			if not can_do_task and  task and task.type == TaskType.MAIN_LINE and  self.not_guide_wait_accept_main_task then
				 self.not_guide_wait_accept_main_task = false
			end
			if self.taskModel.first_receive and can_do_task then 
				--主线任务从无到有，需要自动做任务
				if auto_main_line and self.taskModel.last_notMain and not self.taskModel.notMain then
					self.not_guide_wait_accept_main_task = false
					self:AutoDoTask(true, true)
					return
				elseif task and task.type ~= TaskType.LIMIT_LINE 
					and task.type ~= TaskType.PSIONIC_LINE then
					if self.not_guide_wait_accept_main_task then
						--非新手流程等主线任务更新，这次更新不要自动进行任务
						self.not_guide_wait_accept_main_task = false
						return
					end
					--限时任务不自动做 2020/5/9新增：圣物任务不自动做
					-- 这里需要特殊处理转职任务，由于转职任务触发下面的函数会打开界面，因此要自动打开界面的前提必须是任务可完成
					-- if task.type ~= TaskType.TRUN_LINE or
					 -- (task.type == TaskType.TRUN_LINE and task.taskTips and task.taskTips[1] and task.taskTips[1].isFinish == 1) then 
					 -- (task.type == TaskType.TRUN_LINE and self.taskModel:NeedAutoDoTurnTask(task)) then 
						self:AutoDoTask(true)
					-- end
				else
					self.not_guide_wait_accept_main_task = false
				end
			end
			--登陆不自动任务
			self.taskModel.first_receive = true  
			--记录一下之前是否没有主线，是的话，接取了新的主线之后就要自动做主线
			self.taskModel.last_notMain = self.taskModel.notMain
		end
		func()
	end
	if not self.taskModel:IsWaitProto() then
		self.delay_id = GlobalTimerQuest:AddDelayQuest(delay_fun, 0.2)
	end
	-- GlobalEventSystem:Fire(EventName.SET_REINCARNATION_ICON)
end

--延时做任务，让流程不那么急，但是接任务和完成任务要取消掉，避免延时出问题
function TaskController:Clear30000Timer()
	if self.delay_time_id then
		GlobalTimerQuest:CancelQuest(self.delay_time_id)
		self.delay_time_id = nil
	end
	if self.delay_id then
		GlobalTimerQuest:CancelQuest(self.delay_id)
		self.delay_id = nil
	end
	if self.break_timer_id then
		GlobalTimerQuest:CancelQuest(self.break_timer_id)
		self.break_timer_id = nil
	end
end

function TaskController:handler30001()
	if self.timer_id then
		GlobalTimerQuest:CancelQuest(self.timer_id)
		self.timer_id = nil
	end
	if self.event_id then
		GlobalEventSystem:UnBind(self.event_id)
		self.event_id = nil
	end

	local a_taskId = self:ReadFmt("i")
	local len = self:ReadFmt("h")
	local ttable={}
	local obj = nil
	for index = 1, len do
		obj = {
			type = self:ReadFmt("h"),
			isFinish = self:ReadFmt("h"),
			id = self:ReadFmt("i"),
			name = self:ReadFmt("s"),
			count = self:ReadFmt("i"),
			nowCount = self:ReadFmt("i"),
			sceneId = self:ReadFmt("i"),
			sceneName = self:ReadFmt("c"),
			scene_x = self:ReadFmt("h"),
			scene_y =self:ReadFmt("h"),
			need_find_way = self:ReadFmt("c"),
			additionalProperty = self:ReadFmt("s"),
			stage = self:ReadFmt("c"),
		}
		ttable[index] = obj
	end
	local cur_stage = self:ReadFmt("c")
	local target_num = self:ReadFmt("i")
	local cur_num = self:ReadFmt("i")

	local isComplete=false
	local recData=self.taskModel._receivedTaskList
	local need_req_task_list = true 
	for key, var in ipairs(recData) do
		local taskVO=var		
		if taskVO.id == a_taskId  then
			local type = ttable[1] and ttable[1].type
			if type == TaskTipType.TYPE0 
				or (type == TaskTipType.TYPE1 and (taskVO.type == TaskType.BOUNTY_LINE or taskVO.type == TaskType.GUILD_LINE or taskVO.type == TaskType.MAIN_LINE)) --支线不算完成，让玩家手动点击
				or type == TaskTipType.TYPE2 
				or type == TaskTipType.TYPE9
				or type == TaskTipType.TYPE16
				or type == TaskTipType.TYPE18  then --杀怪或者采集
				isComplete = cur_num==target_num   --数量达到就是完成
				print('Ych:TaskController.lua[844] data', isComplete)
			end

			--支线进度引导触发
			if taskVO.id == 3150001 and cur_num == target_num then
				 GlobalEventSystem:Fire(EventName.TEST_HELP_STEP,HelpType.EXTENSION_LINE_TASK_FINISH)
			end

			--如果是社团的送新任务，则判读是否是都完成了
			if taskVO.type == TaskType.GUILD_LINE and not isComplete and type == TaskTipType.TYPE7 then
				local is_complete = true
				for i,v in ipairs(ttable) do
					if v.isFinish == 0 then
						is_complete = false
						break
					end
				end
				
				isComplete = is_complete
				print('Ych:TaskController.lua[861] data', isComplete)
			end

			--未完成的话就别请求新的任务列表
			if not isComplete then
				need_req_task_list = false
			end
			taskVO.taskTips=ttable
			taskVO.cur_num = cur_num
			taskVO.target_num = target_num
			taskVO.cur_stage = cur_stage

			-- self.taskModel:Fire(TaskEvent.TASK_LIST_INIT, false)
			-- self.taskModel:Fire(TaskEvent.REFRESH_TASK_DATA, taskVO.id)

			for i,v in ipairs(ttable) do
				if v.type == TaskTipType.TYPE9 then --要结束采集,(以结束对话来结束)
					GlobalEventSystem:Fire(EventName.CANCEL_NEXT_COLLECT)
				end
			end
			--处理副本任务偶然的bug
			if need_req_task_list and TaskModel:getInstance().need_task then
				self:request30000()
				need_req_task_list = false
			end


			print('Ych:TaskController.lua[888] data', isComplete)
			if isComplete==true then
				--重置状态
				self.taskModel:ResetFlag()
				if need_req_task_list and not TaskModel:getInstance().need_task then
					self:request30000()
					need_req_task_list = false
				end

				if taskVO.type == TaskType.BOUNTY_LINE then
					GlobalEventSystem:Fire(EventName.OPEN_TASK_CIRCLE_TIPS, TaskType.BOUNTY_LINE)	
				elseif taskVO.type == TaskType.GUILD_LINE then
					print('Ych:TaskController.lua[887] data', cur_num, target_num, cur_stage)
					PrintTable(taskVO)					
					if not ((type == TaskTipType.TYPE18 or type == TaskTipType.TYPE16) and cur_num == 0) then
						GlobalEventSystem:Fire(EventName.OPEN_TASK_CIRCLE_TIPS, TaskType.GUILD_LINE)	
					end

				end
				local is_turn_task_and_need_auto = false
				-- 更新的是转职任务，则弹出任务窗口
				if taskVO.type == TaskType.TRUN_LINE then 
					is_turn_task_and_need_auto = self.taskModel:NeedAutoDoTurnTask(taskVO)
				-- 	if SceneManager.Instance:IsMainCityorYieldScene() and not is_turn_task_and_need_auto then -- 转职界面涉及到副本，副本内不要弹出界面
				-- 		local turn = ReincarnationModel:getInstance():GetCurTurn()
				-- 		ReincarnationModel:getInstance():Fire(ReincarnationModel.OPEN_REIN_MAIN_TASK_VIEW, true, turn)
				-- 	end
				end

				--自动寻路
				local _play_action = function()
					if taskVO.type ~= TaskType.LIMIT_LINE 	-- 限时任务不自动做
						and (taskVO.type ~= TaskType.TRUN_LINE or taskVO.type == TaskType.TRUN_LINE and is_turn_task_and_need_auto -- 非需自动的转职任务不自动做
						) then 
						GlobalEventSystem:Fire(SceneEventType.SHOW_TASK, tonumber(taskVO.tipParam[3]))
					end
					
					if self.timer_id then
						GlobalTimerQuest:CancelQuest(self.timer_id)
						self.timer_id = nil
					end
				end

				if isComplete == true and taskVO.need_find_way == 1 and taskVO.tipParam[2] and taskVO.tipParam[3] then

				elseif taskVO.tipParam[1] and (taskVO.tipParam[1] == TaskTipType.TYPE7 or taskVO.tipParam[1] == TaskTipType.TYPE8
					or taskVO.tipParam[1] == TaskTipType.TYPE9) then  --不需要寻路完成的对话任务

					if SceneManager:getInstance():IsSceneStart() then
					    local delay_call = function ()
					    	_play_action()
					    end
					    if not self.timer_id then
							self.timer_id = GlobalTimerQuest:AddDelayQuest(delay_call, 0.1)
					    end
					else
						local function complete_fun()
							_play_action()
							if self.event_id then
								GlobalEventSystem:UnBind(self.event_id)
								self.event_id = nil
							end
						end
						if not self.event_id then
							self.event_id = GlobalEventSystem:Bind(EventName.SCENE_LOAD_VIEW_COMPLETE, complete_fun)
						end
					end
				end
			end

		end
	end

	self:DoTaskNotify()
end

function TaskController:DoTaskNotify( )
	--分时刷新
	local function callback()
		self.taskModel:Fire(TaskEvent.TASK_LIST_INIT)
	end
	local is_limit = false
	if RoleManager.Instance.mainRoleInfo.level > 70 then
		is_limit = true
	end
	if is_limit then
		TimeManager.GetInstance():StartTime("TaskController_UpdateTaskProgress", 0.6, callback)
	else
		callback()
	end
end

function TaskController:request30005(id)
	self:SendFmtToGame(30005,"i", id)
end

function TaskController:handler30005()
	local code = self:ReadFmt("i")
	if code > 0 then
		self:request30000()
	end
end

function TaskController:handler30017( )
	local len = UserMsgAdapter.ReadFmt("h")	
	local temp_list = {}
	for i=1,len do
		local id = UserMsgAdapter.ReadFmt("i")
		temp_list[id] = id
	end
	self.taskModel:SetFinishTaskList(temp_list)
	if ServerTimeController.Instance and ServerTimeController.Instance.open_init_eveny_can_fire then--是否可以发送任务完成列表协议
		ServerTimeController.Instance.open_init_eveny_can_fire = false
		GlobalEventSystem:Fire(EventName.OPEN_DAY_INIT)
	end
	BaseDungeonModel:getInstance():Fire(BaseDungeonModel.ON_FINISHED_TASK_DATA_RECEIVED)
end

function TaskController:request30018(id)
	self:SendFmtToGame(30018,"i", id)
end

function TaskController:handler30018( )
	local code = self:ReadFmt("i")
	if code == 3000008 then
		-- if self.taskModel.opening_circle_buy_tip then
		-- 	self.taskModel.wait_circle_buy_tip_close = true
		-- end
		self:request30000()
	else
		ErrorCodeShow(code)
	end
end

function TaskController:handler30019( )
	local code = self:ReadFmt("i")
	local task_type = self:ReadFmt("c")
	local reward_progress = self:ReadFmt("c")
	if code == 1 then
		local info = DeepCopy(TaskModel:getInstance():GetCircleTaskInfo(task_type))
		if info then
			info.reward_progress = reward_progress
			self.taskModel:SetCircleTaskInfo( info )
			--改需求了，直接关界面
			-- GlobalEventSystem:Fire(EventName.REFRESH_TASK_CIRCLE_TIPS)
			-- self:DoTaskNotify()
		else
			DialogueModel:getInstance():Fire(DialogueModel.REQUEST_CCMD_EVENT, 30010, task_type)
		end
		GlobalEventSystem:Fire(EventName.CLOSE_TASK_CIRCLE_TIPS)
	else
		ErrorCodeShow(code)
	end
end

--任务寻路
--2020年2月19日调整修改--force_use_shoe:点击任务栏飞鞋按钮时强制使用飞鞋
function TaskController:findElement(param, use_shoe, force_use_shoe)
	local use_shoe = false
	local level = RoleManager.Instance.mainRoleInfo.level
	if level >= Config.ConfigTaskEffect.GuideLevel then
		if VipModel:getInstance():CanFreeUseShoe() then
			use_shoe = true
		else
			local is_auto_use_shoe = lua_settingM:GetAutoFlyShoeSet()
			if force_use_shoe or is_auto_use_shoe then
				local num = GoodsModel:getInstance():GetTypeGoodsNum(AutoFightManager.FlyGoodsID)
				use_shoe = num > 0
			end
		end
	end
	
	if self.can_move_timer_id then 
		TimerQuest.CancelQuest(GlobalTimerQuest, self.can_move_timer_id)
		self.can_move_timer_id = false 
	end

	if self.fly_timer_id then 
		TimerQuest.CancelQuest(GlobalTimerQuest, self.fly_timer_id)
		self.fly_timer_id = false 
	end

	local array=Split(param,",")
	if Config.ConfigTaskEffect.NeedClickTaskType[tonumber(array[1])] then
		--点击判断是否已经完成任务，是的话发协议完成任务
		local task = TaskModel:getInstance():GetTaskById(tonumber(array[4]))
		if self.taskModel:IsNeedClickTask(task) then
			local tip = self.taskModel:GetExtendSpecialTip(task)
			if tip and tip.isFinish==1 then
				GlobalEventSystem:Fire(TaskEventType.SEND_TASK_FINISH, task.id)
				return
			end
		end
	end

	-- if array and #array > 0 and self.taskModel:NeedFindWayTask(tonumber(array[1])) then 
	-- 	local main_role = Scene.Instance:GetMainRole()
	-- 	if main_role and main_role:CanMove() then 
	-- 		print("Saber:TaskController [start:814] ------------------------------------------")
	-- 	else
	-- 		local timer_func = function ()
	-- 			local main_role = Scene.Instance:GetMainRole()
	-- 			if main_role and main_role:CanMove() then 
	-- 				if self.can_move_timer_id then 
	-- 					TimerQuest.CancelQuest(GlobalTimerQuest, self.can_move_timer_id)
	-- 					self.can_move_timer_id = false
	-- 				end
	-- 				self:findElement(param,use_shoe)
	-- 				local task = self.taskModel:GetTaskById(tonumber(array[4]))
	-- 				if self.taskModel:IsAutoDoTask(task) then
	-- 					GlobalEventSystem:Fire(EventName.STARTAUTOFIGHT,false,true)
	-- 				end
	-- 				return
	-- 			end
	-- 		end
	-- 		self.can_move_timer_id = TimerQuest.AddPeriodQuest(GlobalTimerQuest, timer_func, 0.01, -1)
	-- 		return
	-- 	end
	-- end


	if Scene.Instance:HasDropPick() and AutoFightManager:getInstance():GetAutoFightState()
		and not use_shoe then
		Scene.Instance.need_task_after_pick = true
		return
	end

	local params={}
	if #array>0 then
		self.taskModel.need_check_monster = false
		local findVo = FindVo.New()
		findVo.type = -1
		local type=tonumber(array[1])
		findVo.sceneId = tonumber(array[2])
		local sceneId=tonumber(array[2])
		local npcId=0
		if type == TaskTipType.TYPE0 or type == TaskTipType.TYPE7 or type == TaskTipType.TYPE8 or type == TaskTipType.TYPE9 or type == TaskTipType.TYPE35 or type == TaskTipType.TYPE38 then	--NPC
			if tonumber(array[3]) == 0 then --自言自语
					GlobalEventSystem:Fire(SceneEventType.SHOW_TASK, tonumber(array[3]))
				return
			else
				findVo.type = FindVo.NPC
				findVo.id = tonumber(array[3])

				local scene_info = SceneManager.Instance:GetSceneInfo(findVo.sceneId)
				print("---------find npc-------:", findVo.id, findVo.sceneId, scene_info)
				if scene_info == nil then
					print("tanar: TaskController [949] npc  scene_info is nil")
					return
				end

				--用小飞鞋，查找数据库获得npc坐标， 如果不需要用则不查数据库
				if use_shoe or findVo.sceneId ~= SceneManager.Instance:GetSceneId() then
					local item = ConfigItemMgr.Instance:GetSceneItem(findVo.sceneId)
					if item and item.Npcs then
						local npc = item.Npcs[findVo.id]
						if npc then
							findVo.x = npc.x/ SceneObj.LogicRealRatio.x
							findVo.y = npc.y/ SceneObj.LogicRealRatio.y
						end
					end
				else
					local npc = SceneManager.Instance:GetNpcVo(findVo.id)   --npc寻路，只有npc和主角在同一场景才有位置值
					print("---------npc-is nil ?------:", npc)
					if npc then
						findVo.x = npc.logic_x
						findVo.y = npc.logic_y
					else
						print("找不到npc", findVo.id)
					end
				end
			end
		elseif type == TaskTipType.TYPE1 or type == TaskTipType.TYPE18 then	--怪物/采集/收集任务


			findVo.type = FindVo.MONSTER
			findVo.id = tonumber(array[3])
			local task_id = tonumber(array[4])
			findVo.need_check_monster = true
			if #array == 6 or #array == 7 then
				findVo.x=tonumber(array[5]) / SceneObj.LogicRealRatio.x
				findVo.y=tonumber(array[6]) / SceneObj.LogicRealRatio.y
			end

			if TaskModel:getInstance().now_task_id then
				--(注意，一般采集任务不会进这里，因为采集物没有配置random_pos，会走到FindVo.MONSTER)
				local random_logic_pos, random_real_pos, ignore_rush = TaskModel:getInstance():GetTaskMonsterRandomPos(findVo.id, sceneId)
				if random_logic_pos then  --随机一堆怪物，解决玩家分流问题
					--没有飞鞋的时候，打怪任务要走冲刺逻辑
					if not ignore_rush and not use_shoe and type == TaskTipType.TYPE1 then
						local monster = Scene.Instance:FindNearestMonster(findVo.id, false, false)
						if monster then
							Scene.Instance:MainRoleAttackMonster(monster)
							GlobalEventSystem:Fire(EventName.STARTAUTOFIGHT)
							return
						else
							if findVo.sceneId == SceneManager.Instance:GetSceneId() then
								GlobalEventSystem:Fire(EventName.STOPAUTOFIGHT)
								Scene.Instance:MainRoleRushToPos(random_real_pos)
								return
							end
						end
					end
					local function point_call_back(  )
						self.taskModel.task_cache_pos = nil
						--打怪任务
						if type == TaskTipType.TYPE1 then
							GlobalEventSystem:Fire(EventName.STARTAUTOFIGHT)
						--采集任务
						elseif type == TaskTipType.TYPE18 then
							self.try_collect_left_num = 6--采集物未创建的话,每隔一段时间尝试一下,6次就够了
							local try_to_collect = nil--必须这么写
							try_to_collect = function (  )
								local monster = Scene.Instance:FindNearestMonster(findVo.id, false, true) 
								if monster then
									local main_role = Scene.Instance.main_role
									if main_role then
										if self.task_collect_start_real_pos == nil then
											self.task_collect_start_real_pos = co.TableXY(main_role:GetRealPos())
										else
											self.task_collect_start_real_pos.x = main_role.real_pos.x
											self.task_collect_start_real_pos.y = main_role.real_pos.y
										end
										if self.task_collect_end_real_pos == nil then
											self.task_collect_end_real_pos = co.TableXY(monster:GetRealPos())
										else
											self.task_collect_end_real_pos.x = monster.real_pos.x
											self.task_collect_end_real_pos.y = monster.real_pos.y
										end
										main_role:SetDirection(self.task_collect_start_real_pos, self.task_collect_end_real_pos, true	, true)
									end
									EventSystem.Fire(GlobalEventSystem,EventName.OPEN_COLLECT_VIEW, monster.id, monster:GetVo().type_id, monster:GetVo().pick_time)
								else
									self.try_collect_left_num = self.try_collect_left_num - 1
									--此时采集物可能还未创建,所以延迟一段时间再尝试
									if not self.delay_collect_id and self.try_collect_left_num >= 0 then
										self.delay_collect_id = GlobalTimerQuest:AddPeriodQuest(try_to_collect, 0.5, 1)
									end
								end
							end
							try_to_collect()

						end
					end

					findVo.find_range = 0
					-- findVo.find_range = 1
					-- if type == TaskTipType.TYPE1 then
					-- 	findVo.find_range = 3
					-- end
					findVo.x = random_logic_pos.x 
					findVo.y = random_logic_pos.y
					findVo.type = FindVo.POINT
					findVo.call_back = point_call_back
				end
			end
		elseif type == TaskTipType.TYPE6 then --收集任务配置的是物品id，直接打怪就行了
			local function call_back(  )
				GlobalEventSystem:Fire(EventName.STARTAUTOFIGHT)
			end
			findVo.type = FindVo.POINT
			local task_id = tonumber(array[4])
			if task_id and Config.ConfigWorldMon.CollectTask[task_id] then
				local collect_task_id = self.taskModel:GetCollectTaskId()
				if collect_task_id and collect_task_id == task_id then
					findVo.x = self.collect_task_pos.x
					findVo.y = self.collect_task_pos.y
					self.taskModel:ClearCollectTaskId()
				else
					local data = Config.ConfigWorldMon.CollectTask[task_id]
					local index = math.random(1,#data.way_point)
					local pos = data.way_point[index]
					findVo.x = pos.x / SceneObj.LogicRealRatio.x
					findVo.y = pos.y / SceneObj.LogicRealRatio.y

					self.taskModel:SetCollectTaskId(task_id)
					self.collect_task_pos = {x = findVo.x,y = findVo.y}
				end
			else
				findVo.x=tonumber(array[5]) / SceneObj.LogicRealRatio.x
				findVo.y=tonumber(array[6]) / SceneObj.LogicRealRatio.y
			end
			findVo.call_back = call_back
		elseif type == TaskTipType.TYPE16 then --探索场景
			findVo.type = FindVo.Explore
			findVo.sceneId = tonumber(sceneId)
			local x = tonumber(array[3])
			local y = tonumber(array[4])
			findVo.x = x / SceneObj.LogicRealRatio.x
			findVo.y = y / SceneObj.LogicRealRatio.y
			findVo.time = tonumber(array[5])
			findVo.call_back = function ()
				GlobalEventSystem:Fire(TaskEventType.TASK_QUEST)
			end
		elseif type == TaskTipType.TYPE2 or type == TaskTipType.TYPE37 or type == TaskTipType.TYPE29 then --通关副本
			local task_id = tonumber(array[4])
			if task_id and task_id == BossModel.FAKE_MONEY_BOSS_TASK_ID then
				GlobalEventSystem:Fire(EventName.OPEN_BOSS_VIEW,Config.ConfigBoss.ModuleId.Money)
				return
			end
			local config = Config.Dungeoncfg[tonumber(array[3])]
			if config and config.type == BaseDungeonModel.DUN_TYPE.PersonBoss then
				--专属幻魔
				local boss_id = false
				for k,v in pairs(Config.Personalbossinfo) do
					if v.dun_id == tonumber(array[3]) then
						boss_id = v.boss_id
					end
				end
				GlobalEventSystem:Fire(EventName.OPEN_BOSS_VIEW,Config.ConfigBoss.ModuleId.Person,boss_id)
				return
			end
			local task = TaskModel:getInstance():GetTaskById(task_id)
			if task then
				local open_ui_task = Config.ConfigTaskEffect.OpenUITask[task_id]
				if task.type == TaskType.EXTENSION_LINE or open_ui_task then
					--支线特殊处理
					local is_open_view = tonumber(array[2])==0
					if is_open_view or open_ui_task then
						--打开副本界面 根据副本id
						local cfg = Config.Dungeoncfg[tonumber(array[3])]
						if cfg then
							if tonumber(cfg.type) == BaseDungeonModel.DUN_TYPE.PersonBoss then
								OpenFun.Open(460,1)
							else
								local dungeon_type = tonumber(cfg.type)
								if BaseDungeonModel.DungeonSingleType[dungeon_type] then
									if dungeon_type == BaseDungeonModel.DUN_TYPE.MATERIAL then
										local open_key = cfg.id - 900 --没有字段区分是哪一个进阶副本，先写死id
										if open_key and open_key >= 101 and open_key <= 108 then
											OpenFun.Open(610, open_key)
										else
											OpenFun.Open(610, dungeon_type)
										end
									else
										OpenFun.Open(610, dungeon_type)
									end
								else
									OpenFun.Open(215, BaseDungeonModel.DungeonTeamType[dungeon_type])
								end
							end
							return
						end
					else
						--直接进入副本
						setTimeout(
							function()
								local config = Config.Dungeoncfg[tonumber(array[3])]
								if config and config.enter_type == 1 then
									local main_role = Scene.Instance.main_role
									if main_role then
										local enter_dir_angle = main_role:GetDirectionAngle()
										RoleManager:getInstance():SetEnterDirAngle(enter_dir_angle)
									end
								end
								BaseDungeonModel:getInstance():Fire(BaseDungeonModel.REQUEST_CCMD_EVENT, 61001, tonumber(array[3])) end,0.3)
						return
					end
				else

					local dun_id = tonumber(array[3])
					local time = 0.3
					if dun_id == GuideModel.CHANGE_GOD_SCENE_ID then
						time = 1
					end
					local function on_delay_enter_dungeon()
						local config = Config.Dungeoncfg[tonumber(array[3])]
						if config and config.enter_type == 1 then
							local main_role = Scene.Instance.main_role
							if main_role then
								local enter_dir_angle = main_role:GetDirectionAngle()
								RoleManager:getInstance():SetEnterDirAngle(enter_dir_angle)
							end
						end
						BaseDungeonModel:getInstance():Fire(BaseDungeonModel.REQUEST_CCMD_EVENT, 61001, dun_id) 
					end

					--主线任务无缝加载，距离太远的话要校正一下坐标，先走到策划配置的点再进入副本
					local temp_limit_cfg = Config.ConfigChangeSceneEffect.DungeonLimit[dun_id]
					local need_reset_pos = false
					if temp_limit_cfg then
						local target_pos = temp_limit_cfg.enter_pos
						local cur_scene_id = SceneManager:getInstance():GetSceneId()
						local dun_scene_id = Config.Dungeoncfg[dun_id].scene_id
						if dun_scene_id == cur_scene_id then
							--已经在副本场景里了，则自动战斗
							GlobalEventSystem:Fire(EventName.STARTAUTOFIGHT,false,true)
							return
						else
							--走小飞鞋寻路
							findVo.type = FindVo.POINT
							findVo.dunSceneId = dun_scene_id
							findVo.sceneId = tonumber(temp_limit_cfg.enter_scene_id)
							local x = tonumber(target_pos.x)
							local y = tonumber(target_pos.y)
							findVo.x = x / SceneObj.LogicRealRatio.x
							findVo.y = y / SceneObj.LogicRealRatio.y
							local range = temp_limit_cfg.work_min_distance/100
							range = range > 1 and range or 0
							findVo.range = range
							findVo.call_back = on_delay_enter_dungeon
						end
					else
						--正常情况是这里进入副本
						setTimeout(on_delay_enter_dungeon, time)
						--自动做的任务， 打完回来要继续
						TaskModel:getInstance():SetNeedTaskFlag(true)
						return
					end
				end
			end
		-- elseif type == TaskTipType.TYPE25 then --五转 点亮星格
		-- 	GlobalEventSystem:Fire(EventName.OPEN_REINCARNATION_VIEW)
		-- 	return
		elseif type == TaskTipType.TYPE51 then --解锁地狱摩托
			OpenFun.Open(114, 0)
			return
		elseif type == TaskTipType.TYPE100 then --击杀BOSS
			GlobalEventSystem:Fire(EventName.OPEN_BOSS_VIEW, tonumber(array[3]))
			return
		elseif type == TaskTipType.TYPE101 then --强化装备
			OpenFun.Open(152, 1)
			return
		elseif type == TaskTipType.TYPE102 then --完成某类型副本
			if tonumber(array[3]) == BaseDungeonModel.DUN_TYPE.PersonBoss then
				OpenFun.Open(460,1)
			elseif BaseDungeonModel.DungeonTeamType[tonumber(array[3])] then
				DunManyModel:getInstance():Fire(DunManyModel.OPEN_DUN_MANY_HALL_VIEW,tonumber(array[3]))
			else
				BaseDungeonModel:GetInstance():Fire(BaseDungeonModel.OPEN_HALL_VIEW,tonumber(array[3]))
			end
			return
		elseif type == TaskTipType.TYPE103 then --单次副本获得x经验
			BaseDungeonModel:getInstance():OpenViewByDunType(tonumber(array[3]))
			return
		elseif type == TaskTipType.TYPE104 then --添加好友
			GlobalEventSystem:Fire(EventName.OPEN_SOCIALITY_VIEW)
			setTimeout(function ()
		  		GlobalEventSystem:Fire(EventName.OPEN_SOCIALITY_VIEW, 2)
		  	end,0.15)
			return
		elseif type == TaskTipType.TYPE105 then --加入社团
			OpenFun.Open(400, 0)
			-- GlobalEventSystem:Fire(EventName.OPEN_GUILD_APPLY_VIEW)
			return
		elseif type == TaskTipType.TYPE106 then --社团装备回收
			if RoleManager.Instance.mainRoleInfo.level >= Config.ConfigOpenLv.EquipSwallow then
				GlobalEventSystem:Fire(EventName.OPEN_PET_SWALLOW_VIEW)
			else
				Message.show("熔炼功能" ..  Config.ConfigOpenLv.EquipSwallow .."级开启哦")
			end
			return
		elseif type == TaskTipType.TYPE107 then --完成社团活动
			if RoleManager.Instance.mainRoleInfo.guild_id>0 then
				local contentId = tonumber(array[3])
				OpenFun.Open(402, contentId)
			else
				Message.show("请先加入一个社团")
			end
			return
		elseif type == TaskTipType.TYPE108 then --捐献一件装备到社团仓库
			-- if RoleManager.Instance.mainRoleInfo.guild_id>0 then
			-- 	if GuildModel:getInstance():GetGuildBuildLvInfo(GuildModel.GUILD_DEPOT) == 0 then
		 --  			Message.show("暂时未开启此建筑")
		 --  		else
		 --  			GlobalEventSystem:Fire(EventName.OPEN_GUILD_MAIN_VIEW, 3)		  		
		 --  		end
			-- else
			-- 	Message.show("请先加入一个社团")
			-- end
			return
		elseif type == TaskTipType.TYPE109 then --在市场上购买1个商品
			GlobalEventSystem:Fire(EventName.OPEN_MARKET_VIEW, 1)
			return
		elseif type == TaskTipType.TYPE110 then --在市场上架1个物品
			GlobalEventSystem:Fire(EventName.OPEN_MARKET_VIEW, 3)
			return
		elseif type == TaskTipType.TYPE23 then --合成物品
			--合成按钮跳转
			local type_id = tonumber(array[3])
			ComposeModel.Instance:TryComposeJump(type_id)
			return
		elseif type == TaskTipType.TYPE24 then --活跃度
			GlobalEventSystem:Fire(ActivityIconManager.SHOW_LEAD_EFFECT,157)
			return
		elseif type == TaskTipType.TYPE26 then --吞噬
			if RoleManager.Instance.mainRoleInfo.level >= Config.ConfigOpenLv.EquipSwallow then
				GlobalEventSystem:Fire(EventName.OPEN_PET_SWALLOW_VIEW)
			else
				Message.show("熔炼功能" ..  Config.ConfigOpenLv.EquipSwallow .."级开启哦")
			end
			return
		elseif type == TaskTipType.TYPE27 then --击杀首领
			local kill_type = tonumber(array[2])
			local monster_id = tonumber(array[3])
			if monster_id and kill_type then
				local boss_type = TaskModel.TYPE27_KILL_TYPE[kill_type]
				GlobalEventSystem:Fire(EventName.OPEN_BOSS_VIEW, boss_type, monster_id)
			end
			return
		elseif type == TaskTipType.TYPE28 then --钓鱼之路
			GlobalEventSystem:Fire(EventName.OPEN_SKILL_VIEW,4,1,true)
			return
		elseif type == TaskTipType.TYPE111 then --击杀首领
			local dun_id = tonumber(array[3])
			if dun_id then
				local config = Config.Dungeoncfg[dun_id]
				if config then
					if config.type == 20 then --"宝石副本"
						OpenFun.Open(610,37)
					elseif config.type == 21 then  -- "神格副本"
						OpenFun.Open(610,23)
					elseif config.type == 5 then  -- "装备副本"
						OpenFun.Open(610,32)
					end
				end
			end
			return
		elseif type == TaskTipType.TYPE36 then --装备附能
			OpenFun.Open(152,5)
			return
		elseif type == TaskTipType.TYPE39 then --装备升星
			OpenFun.Open(152,2)
			return
		elseif type == TaskTipType.TYPE31 then --竞技场次数
			OpenFun.Open(280,0)
			return
		elseif type == TaskTipType.TYPE40 then --商城购买
			local shop_key_id = tonumber(array[2])
			local temp_cfg = Config.Shop[shop_key_id]
			local show_open_effect = true--针对一些特别的显示特效不显示tip
			if show_open_effect then
				GlobalEventSystem:Fire(EventName.OPEN_SHOP_VIEW, temp_cfg.shop_type, temp_cfg.sub_type, temp_cfg.goods_id, nil,true)
			else
				GlobalEventSystem:Fire(EventName.OPEN_SHOP_VIEW, temp_cfg.shop_type, temp_cfg.sub_type, temp_cfg.goods_id, true)
			end
			return
		elseif type == TaskTipType.TYPE34 then --进入某类副本
			local dungeon_type = tonumber(array[3])
			if BaseDungeonModel.DungeonSingleType[dungeon_type] then
				OpenFun.Open(610, dungeon_type)
			else
				OpenFun.Open(215, BaseDungeonModel.DungeonTeamType[dungeon_type])
			end
			return
		elseif type == TaskTipType.TYPE41 or type == TaskTipType.TYPE42 then --好友送礼/好友亲密度
			OpenFun.Open(140, 1)
			return
		elseif type == TaskTipType.TYPE43 then --进阶系统升级
			OpenFun.Open(146,tonumber(array[3]))
			return
		elseif type == TaskTipType.TYPE56 then --进阶目标（进阶到一定阶数）
			OpenFun.Open(146,tonumber(array[3]))
			return
		elseif type == TaskTipType.TYPE44 then --升品之路
			OpenFun.Open(414, 0)
			return
		elseif type == TaskTipType.TYPE45 then --唤神升级
			OpenFun.Open(173, 1)
			return
		elseif type == TaskTipType.TYPE46 then --星辰升级
			OpenFun.Open(148,1)
			return
		elseif type == TaskTipType.TYPE47 then --宠物升级
			OpenFun.Open(163,1)
			return
		elseif type == TaskTipType.TYPE48 then --晒娃
			OpenFun.Open(165,1)
			return
		elseif type == TaskTipType.TYPE49 then --装备圣物
			OpenFun.Open(139,2)
			return
		elseif type == TaskTipType.TYPE50 then --圣物寻宝
			OpenFun.Open(139,7)
			return
		elseif type == TaskTipType.TYPE52 then --转职目标
			GlobalEventSystem:Fire(EventName.OPEN_NEW_MAIN_ROLE_VIEW, NewMainRoleModel.TabId.REIN)
			return
		elseif type == TaskTipType.TYPE53 then --龙神抽奖
			OpenFun.Open(170,1)
			return
		elseif type == TaskTipType.TYPE54 then --装备套装
			local dai_num = tonumber(array[3])
			local color = tonumber(array[2])
			EquipCollectModel:getInstance():Fire(EquipCollectConst.OPEN_EC_MAIN_VIEW,true, EquipCollectConst.TAB_ID.COLLECT, dai_num, color, color)
			return
		elseif type == TaskTipType.TYPE55 then --战魂强化
			OpenFun.Open(143,5)
			return
		elseif type == TaskTipType.TYPE57 then --完成预期任务
			self:AutoDoTask(true, true)--直接做主线
			return
		elseif type == TaskTipType.TYPE58 then --宝宝同心值
			OpenFun.Open(165,0)
			return			
		elseif type == TaskTipType.TYPE59 then --战力
			--这里不做任何处理，放到item点击处
			return				
		elseif type == TaskTipType.TYPE60 then --任意主动技能升级次数
			OpenFun.Open(210,1)
			return		
		elseif type == TaskTipType.TYPE61 then --指定商店购买技能书		
			local temp_cfg = Config.Shop[10317]	--指定第一本技能书的商店配置
			local career = RoleManager.Instance.mainRoleInfo.career
			local goods_table = 
			{
				[1] = 210101,
				[2] = 210201,
				[3] = 210301,
				[4] = 210401,
			}
			GlobalEventSystem:Fire(EventName.OPEN_SHOP_VIEW, temp_cfg.shop_type, temp_cfg.sub_type, goods_table[career], nil, true)
			return
		elseif type == TaskTipType.TYPE62 then --任意商店技能书购买
			GlobalEventSystem:Fire(EventName.SHOW_MAIN_GET_SKILL_TASK_TIPS_VIEW, true)
			return
		end

		--跨服主城场景id校正
		if findVo.sceneId and (findVo.sceneId == KfWorldConst.BFCitySceneId or findVo.sceneId == KfWorldConst.KFCitySceneId) then
			if KfWorldModel:GetInstance():IsKFCityOpen() then
				findVo.sceneId = KfWorldConst.KFCitySceneId
			else
				findVo.sceneId = KfWorldConst.BFCitySceneId
			end
		end

		local function on_find_vo_func()
			Scene.Instance:ResetUserManulState()	--到了执行寻路回调这里，就可以重置寻路缓存状态了
			local cur_scene_id = SceneManager.Instance:GetSceneId()
			if findVo.dunSceneId and findVo.dunSceneId == cur_scene_id then
				--进入镜像副本之后，就不要再切场景了
				GlobalEventSystem:Fire(EventName.STARTAUTOFIGHT,false,true)
			elseif (findVo.sceneId == cur_scene_id) or SceneManager:getInstance():IsMappingToSameScene(cur_scene_id, findVo.sceneId) then
				--已经是目标场景了，开始寻路，这里要兼容一下主城跟跨服主城
				GlobalEventSystem:Fire(EventName.FIND, findVo)
			else
				--如果不在同场景， 先切场景
				TaskModel:getInstance():SetNeedTaskFlag(true)
				GlobalEventSystem:Fire(SceneEventType.REQUEST_CHANGE_SCENE, findVo.sceneId, nil, SceneTransType.GateAny, findVo.x, findVo.y)
			end
		end

		if use_shoe then  --使用小飞鞋
			TaskModel:getInstance():SetChangeSceneType(false, false)
			if findVo.sceneId ~= SceneManager.Instance:GetSceneId() then
				TaskModel:getInstance():SetNeedTaskFlag(true)
			end

			local end_pos = GameMath.GetPosByCeterPoint(findVo.x * SceneObj.LogicRealRatio.x,findVo.y * SceneObj.LogicRealRatio.y, 100)
			local fly_shoe_scene_id = SceneManager.Instance:GetSceneId()
            local call_back = function (  )
				if findVo.sceneId == fly_shoe_scene_id then
					on_find_vo_func()
				else
					self.fly_timer_id = setTimeout(on_find_vo_func,0.5)
				end
            end
            GlobalEventSystem:Fire(EventName.USE_FLY_SHOE, findVo.sceneId, end_pos.x,end_pos.y, call_back)
		else
			TaskModel:getInstance():SetChangeSceneType(SceneTransType.GateAny, findVo)
			if findVo.sceneId ~= SceneManager.Instance:GetSceneId() then
				TaskModel:getInstance():SetNeedTaskFlag(true)
			end
			GlobalEventSystem:Fire(EventName.FIND, findVo, change_scene_type)
		end
	end
end

-----------------界面相关-----------------
function TaskController:OpenTaskView(index,task_id,parent_index,sub_index)
	if self.TaskNewBaseView == nil then
		self.TaskNewBaseView = TaskNewBaseView.New()
	end
	self.TaskNewBaseView:Open(index, task_id,parent_index,sub_index)
end

function TaskController:CheckNewMainLineTip( )
	local level = RoleManager.Instance.mainRoleInfo.level
	if level < Config.ConfigTaskEffect.NewMainLineTipLvMin or Config.ConfigTaskEffect.NewMainLineTipLvMax < level then
		return
	end
	local cur_task = self.taskModel:GetMainTask()

	if not self.mark_main_line_list then
		self.mark_main_line_list = {[0] = true}
	end
	if cur_task then
		if not self.mark_main_line_list[cur_task.id] then
			--新任务，标记起来
			self.mark_main_line_list[cur_task.id] = true
			if self.next_need_new_main_tip or (not self.first_call_new_tip) then
				self.taskModel.tip_new_main_line = cur_task.id
				GuideController.Instance:TriggerHelper(GuideModel.TASK_TRIGGER_TYPE, 9993150002)
				self.taskModel:Fire(TaskEvent.SHOW_NEW_MAIN_LINE_TIP)
			end
		end
	end
	--上一次是无主线，下一次才需要，或者第一次调用
	self.next_need_new_main_tip = (not (cur_task and cur_task.id > 0))-- or (not self.first_call_new_tip)
	if not self.first_call_new_tip then
		self.first_call_new_tip = true
	end
end

function TaskController:CheckWaitNewMainLineAccept( )
	--等待断级主线的接取，那次30000协议返回不用自动任务
	if Config.ConfigTaskEffect.GuideLevel < RoleManager.Instance.mainRoleInfo.level then
		local cur_task = self.taskModel:GetMainTask()
		local b = (not (cur_task and cur_task.id > 0 and cur_task.id ~= Config.ConfigTaskEffect.DefaultTaskId))		

		--如果当前卡主线了，等级达到一定程度，如果当前有跑环任务，就去跑环
		if b == true and self.main_line_break_wait == false and RoleManager.Instance.mainRoleInfo.level >= Config.ConfigTaskEffect.WhenBreakMainLineGotoDoDailyTaskLevel then
			self.taskModel:JustDoDailyCircleTask()
		end		
		self.main_line_break_wait = b
	end
end