yzyCli/u3d/Lua/game/dialogue/DialogueController.lua

--[[
	@description:对话模块
]]

require("game.dialogue.DialogueModel")
require("game.dialogue.DialogueViewNew")
require("game.dialogue.DialogueEvent")
require("game.dialogue.vo.NpcDialogVo")
require("game.dialogue.vo.DialogueNodeVo")
-- require("game.dialogue.vo.DialogueTaskVo")
require("game.dialogue.DialogueTypeConst")
require("game.dialogue.DialogLang")
require("game.dialogue.DialogueTaskBtnItem")	 -- 对话界面的任务item
require("game.dialogue.DialogueChooseMessage")	 -- 对话选项提示


DialogueController=DialogueController or BaseClass(BaseController)
function DialogueController:__init()
	DialogueController.Instance=self
	self.dialogueView = nil
	self.dialogueModel = DialogueModel:getInstance()
	self.taskModel = TaskModel:getInstance()
	self.dialogueModel.autoIntoCopy = 0
	self:registerAllProtocals()
	self:addAllEvents()

end
function DialogueController:__delete()

end
function DialogueController:registerAllProtocals()
	self:RegisterProtocal(12101, "response12101") --获取指定npc关联的任务列表
	self:RegisterProtocal(12102, "response12102") --获取指定任务的对话列表

	self:RegisterProtocal(30003, "response30003") --接受任务
	self:RegisterProtocal(30004, "response30004") --完成任务
	self:RegisterProtocal(30007, "response30007") --任务对话事件
	self:RegisterProtocal(30008, "response30008")--任务探索事件件
	self:RegisterProtocal(30009, "response30009")--触发悬赏任务和社团周任务
	self:RegisterProtocal(30010, "response30010")--悬赏任务和社团周任务进度
	self:RegisterProtocal(30011, "response30011")--请求赏金和社团任务奖励，奖励是规则算出来的，所以不读配置
	self:RegisterProtocal(30012, "response30012")--上一个完成的任务id
	self:RegisterProtocal(30015, "response30015")--任务请求完成进度


	--切换活动镜像场景
    local function onSceneLoadViewComplete(  )
		--如果是在副本里面，则等待
		if not self.dialogueModel.is_show_main_task_tips_flag and  not SceneManager:getInstance():IsMirrorScene() and self.dialogueModel.is_delay_show_main_task_tips then
			local task_id = self.dialogueModel.is_delay_show_main_task_tips
			self.taskModel.now_task_id = nil
			GlobalEventSystem:Fire(EventName.STOP_AUTO_DO_TASK) --停止自动任务

			local function ok_callback()
				GlobalEventSystem:Fire(EventName.CLOSE_ALL_VIEW)
				self.taskModel.tip_new_main_line = task_id
				GuideController.Instance:TriggerHelper(GuideModel.TASK_TRIGGER_TYPE, 9993150002)
				self.taskModel:Fire(TaskEvent.SHOW_NEW_MAIN_LINE_TIP)
            end
            local function cancle_callback()
            	local next_task = self.taskModel:GetTaskByType(TaskType.BOUNTY_LINE)
            	if next_task then
            		self.taskModel.now_task_id = next_task.id
            	else
            		self.taskModel.now_task_id = task_id	
            	end
				self.taskModel:SetTaskAutoFlag(true)
				GlobalEventSystem:Fire(EventName.FORCE_TO_DO_TASK)               
            end	    
            
            local str = "任务指引\n\n有新的主线任务，赶紧去看看吧!"
            Alert.show(str, Alert.Type.Two, ok_callback, cancle_callback, "确定", "继续任务")
            self.dialogueModel.is_show_main_task_tips_flag = true
        	self.dialogueModel.is_delay_show_main_task_tips = false
		end

    end
    GlobalEventSystem:Bind(EventName.SCENE_LOAD_VIEW_COMPLETE, onSceneLoadViewComplete)			


    --新手期，跑环任务时升级，触发主线推荐
	local function onChangeLevel(level)		
		if not self.dialogueModel.is_show_main_task_tips_flag and  Config.ConfigTaskEffect.NewMainLineTipLvMin <= level and RoleManager.Instance.mainRoleInfo.level <= level then
			local cur_task = self.taskModel:GetCurTask()
			if cur_task and cur_task.type == TaskType.BOUNTY_LINE then				
				local cur_main_task = self.taskModel:GetMainTask()
				if cur_main_task and level >= cur_main_task.level then
					self.taskModel.now_task_id = false
					GlobalEventSystem:Fire(EventName.STOP_AUTO_DO_TASK) --停止自动任务
					--如果是在副本里面，则等待
					if not SceneManager:getInstance():IsMirrorScene() then
						local function ok_callback()
							if cur_main_task then
								GlobalEventSystem:Fire(EventName.CLOSE_ALL_VIEW)
								self.taskModel.tip_new_main_line = cur_main_task.id
								GuideController.Instance:TriggerHelper(GuideModel.TASK_TRIGGER_TYPE, 9993150002)
								self.taskModel:Fire(TaskEvent.SHOW_NEW_MAIN_LINE_TIP)
							end	                    
		                end
		                local function cancle_callback()
							self.taskModel:SetTaskAutoFlag(true)
							GlobalEventSystem:Fire(EventName.FORCE_TO_DO_TASK)               
		                end	    
      	                
		                local str = "任务指引\n\n有新的主线任务，赶紧去看看吧!"
		                Alert.show(str, Alert.Type.Two, ok_callback, cancle_callback, "确定", "继续任务")
		                self.dialogueModel.is_show_main_task_tips_flag = true
		            else
		            	self.dialogueModel.is_delay_show_main_task_tips = cur_main_task.id
					end	  
				end
			end
		end
	end
	RoleManager.Instance.mainRoleInfo:Bind(EventName.CHANGE_LEVEL, onChangeLevel)        
end

function DialogueController:showDialogue(npcDialogVo)
	if self.dialogueView == nil then
		self.dialogueView = DialogueViewNew.New()
	end

	if self:IsShowCircleView(npcDialogVo) then
		local cfg1 = self.taskModel:GetTaskAcceptNpcConfig(TaskType.BOUNTY_LINE)
		local cfg2 = self.taskModel:GetTaskAcceptNpcConfig(TaskType.GUILD_LINE)
		--判断是否可领取奖励
		local task_type = false
		if npcDialogVo.npc_id == cfg1.npc_id then
			task_type = TaskType.BOUNTY_LINE
		elseif npcDialogVo.npc_id == cfg2.npc_id then
			task_type = TaskType.GUILD_LINE
		end
		GlobalEventSystem:Fire(EventName.OPEN_TASK_CIRCLE_TIPS, task_type, nil, npcDialogVo)
		return
	end

	if npcDialogVo and npcDialogVo.dialogList then
		self.dialogueView:Open(npcDialogVo)
	else
		if self.dialogueView:HasOpen() == true then 
			self.dialogueView:Close()
		end
	end
end

function DialogueController:CloseDialoueView()
	if self.dialogueView and self.dialogueView:HasOpen() == true then
		self.dialogueView:Close()
	end
end

function DialogueController:addAllEvents()
	local function onRequestHandler(...)
		local args_list = {...}
		if args_list[1] == 30009 then
			self:SendFmtToGame(args_list[1], "c", args_list[2])
		elseif args_list[1] == 30010 or args_list[1] == 30019 then
			self:SendFmtToGame(args_list[1], "c", args_list[2])
		elseif args_list[1] == 30015 then
			self:SendFmtToGame(args_list[1], "cli", args_list[2], args_list[3], args_list[4])
		elseif args_list[1] == 30011 then
			self:SendFmtToGame(args_list[1], "i", args_list[2])
		else
			self:SendFmtToGame(args_list[1])
		end
	end
	self.dialogueModel:Bind(DialogueModel.REQUEST_CCMD_EVENT,onRequestHandler)

	local function taskFun(npcId, taskId, state)
		self:request12102(npcId, taskId, state)
	end
	self:Bind(DialogueModel.SELECT_TASK, taskFun )

	local function answer_fun(dialogueVo, dialogueNodeVo, selected,double)
		self:clickAnswerHandler(dialogueVo, dialogueNodeVo, selected,double)
	end
	self:Bind(DialogueModel.CLICK_ANSWER,  answer_fun)

	local function showTask1(id)
		local level = RoleManager.Instance.mainRoleInfo.level
		-- if id == GuildModel.FEAST_NPC then
		-- 	--社团宴席npc， 请求是否可以采集
		-- 	GuildModel:getInstance():Fire(GuildModel.REQUEST_CCMD_EVENT, 40219)
		-- else
		if GetModuleIsOpen(500) and (id == EscortConst.START_NPC or id == EscortConst.KF_START_NPC) then --护送领取npc
			GlobalEventSystem:Fire(EscortConst.OPEN_ESCORT_VIEW, true)
		elseif GetModuleIsOpen(500) and (id == EscortConst.END_NPC or id == EscortConst.KF_END_NPC) and EscortModel:getInstance():IsEscortState( ) then --护送结算npc
			EscortModel:getInstance():Fire(EscortConst.REQUEST_SCMD_EVENT, 50003, 2)
		else
			self.dialogueModel.changeSceneClose=false
			self.dialogueModel.isAuto = false   --发事件过来的要重置一下auto状态
			self:request12101(id)
		end
	end
	self:Bind(SceneEventType.SHOW_TASK, showTask1 )
	
	local function acceptTask1(id)
		self.dialogueModel.changeSceneClose=false
		self:acceptTask(id)
	end
	self:Bind(TaskEventType.SEND_TASK_ACCEPT,  acceptTask1 )

	local function finishTask1(id, arr)
		self.dialogueModel.changeSceneClose=false
		self:finishTask(id, arr)
	end
	self:Bind(TaskEventType.SEND_TASK_FINISH,  finishTask1 )

	local function taskQuest()
		self:request30008()
	end
	self:Bind(TaskEventType.TASK_QUEST, taskQuest)

	-- 超级强硬的关闭对话框
	local function OutCloseDialog()
		self:CloseDialoueView()
		self.dialogueModel.changeSceneClose=true
		self.taskModel.last_circle_tip_type = false

		--清理剧情软对话
		self.dialogueModel:CancelTaskTalkTimer()
	end
	GlobalEventSystem:Bind(SceneEventType.SCENE_CHANGED, OutCloseDialog)

	local close_fun = function ()
		self:CloseDialoueView()
	end
	GlobalEventSystem:Bind(SceneEventType.CLOSE_DIALOGUE_VIEW, close_fun)

	local game_start = function()		
		setTimeout(function()
			if not self.preload_dialogue_view then
				local playerLv = RoleManager:getInstance():GetMainRoleVo().level
				if playerLv <= 120 then
					self.preload_dialogue_view = true 
					if self.dialogueView == nil then
						self.dialogueView = DialogueViewNew.New()
					end
					self.dialogueView:Open()
					self.dialogueView:Hide()
				end
			end
 		end,1.6)
	end
	GlobalEventSystem:Bind(EventName.GAME_START,game_start)


	local function on_choose_message( choose_type, choose_value )
		if not self.choose_message then
			self.choose_message = DialogueChooseMessage.New()
		end
		if self.choose_message:HasOpen() then
			self.choose_message:SetData(choose_type, choose_value)
		else
			self.choose_message:Open(choose_type, choose_value)
		end
	end
	GlobalEventSystem:Bind(DialogueModel.CHOOSE_MESSAGE_EVENT, on_choose_message)


	local function playerLevelUp()
		local task_id = TaskModel:getInstance().need_accept
		if task_id and task_id~=0 then
			--先判断等级
			local cfg = ConfigItemMgr.Instance:GetTaskData(task_id)
			if cfg then
				if RoleManager.Instance.mainRoleInfo.level >= cfg.level then
					self:acceptTask(task_id)
					TaskModel:getInstance().need_accept = nil
				end
			end
		end
	end
	RoleManager.Instance.mainRoleInfo:Bind(EventName.CHANGE_LEVEL,playerLevelUp)
end

function DialogueController:request12101(id)
	self.taskModel.scmd12101Send = true
	self:SendFmtToGame(12101, "i", id)
end

function DialogueController:response12101()
	if not self.taskModel.scmd12101Send then
		return
	end
	self.taskModel.scmd12101Send = false
	local scmd12101 = SCMD12101.New(true)
	-- print("Saber:DialogueController [start:178] scmd12101 ------------------------------------------")
	-- PrintTable(scmd12101)
	scmd12101.task_id = 0
	self.dialogueModel.npcDialogVo = scmd12101
	local dialogid = self.dialogueModel:GetDialogueId(scmd12101.npc_id)
	local task = TaskModel:getInstance():GetTaskById(self.taskModel.now_task_id)
	if task and task.task_kind==TaskKind.DUN_KIND and task.content_id~=0 and task.acceptType==0 then
		--副本类型的任务，如果已经接过就做一个假任务对话
		if task.type==TaskType.GUILD_LINE or task.type==TaskType.BOUNTY_LINE then
			--赏金和社团任务要判断是否已经进行了任务对话  副本失败后，taskTips列表就只有副本步骤了
			self:showNpcTalk(dialogid,#scmd12101.task_list)
			return
		else
			--主线或者支线，就做一个假任务对话
			for k,v in pairs(task.taskTips) do
				if v.type==TaskTipType.TYPE2 and v.isFinish==0
					and scmd12101.npc_id==task.start_npc then
					local scmd12102 = SCMD12102.New()
					scmd12102.npc_id = task.start_npc
					scmd12102.task_id = task.id
					scmd12102.talk_id = task.start_talk
					self.dialogueModel.npcDialogVo = scmd12102
					self.dialogueModel.npcDialogVo.dialogList = ConfigItemMgr.Instance:GetTalkItem(self.dialogueModel.npcDialogVo.talk_id)
					self.dialogueModel.npcDialogVo.task_list = {}
					self:showDialogue(self.dialogueModel.npcDialogVo)
					return
				end
			end
		end
	end
	self:showNpcTalk(dialogid,#scmd12101.task_list)

	--如果没有任务，则播放声音
	if #scmd12101.task_list == 0 then
		SoundModel:getInstance():PlayNpcSound(scmd12101.npc_id)
	end
end

--[[
	 * 显示对话
	 * @param npcId NPCID
	 * @param taskId 任务ID
	 * @param state 任务状态
	 *
]]
function DialogueController:request12102(npcId, taskId, state)
	self:SendFmtToGame(12102, "ii", npcId, taskId)
	self.dialogueModel.isAuto = false
end

function DialogueController:response12102()
	if self.dialogueModel.changeSceneClose==true then
		-- 过滤掉延时的返回
		return
	end
	local scmd12102 = SCMD12102.New(true)
	-- print("Saber:DialogueController [start:261] scmd12102 ------------------------------------------")
	-- PrintTable(scmd12102)
	self.dialogueModel.npcDialogVo = scmd12102
	-- print("response12102:",self.dialogueModel.npcDialogVo.npc_id,self.dialogueModel.npcDialogVo.task_id,self.dialogueModel.npcDialogVo.talk_id)
	self.dialogueModel.npcDialogVo.dialogList = ConfigItemMgr.Instance:GetTalkItem(self.dialogueModel.npcDialogVo.talk_id)
	self.dialogueModel.npcDialogVo.task_list = {}
	--奖励这里获取
	self.dialogueModel.npcDialogVo.award = nil 
	local temp = TaskModel.Instance:GetCanTaskById(self.dialogueModel.npcDialogVo.task_id);
	if temp == nil then
		temp = TaskModel.Instance:GetReceivedTaskById(self.dialogueModel.npcDialogVo.task_id);
		if temp then 
			self.dialogueModel.npcDialogVo.award = temp.award_list
		end
	else
		self.dialogueModel.npcDialogVo.award = temp.award_list
	end
	if self.dialogueModel.npcDialogVo.dialogList and self.dialogueModel.npcDialogVo.dialogList.content then
		for k,v in ipairs(self.dialogueModel.npcDialogVo.dialogList.content) do
			for _,vo in ipairs(v.list) do
				if vo.type==0 and Trim(vo.text)=="" then
					--对话内容为空字符串，直接接受任务或者完成任务
					local data = TaskModel:getInstance():GetTaskById(scmd12102.task_id)
					if data then
						if data.acceptType==0 then
							self:finishTask(scmd12102.task_id)
						elseif data.acceptType==1 then
							-- 如果是转职任务，则记录接受任务时的玩家等级
							if self.taskModel:IsTurnTask(flag) then
								self.taskModel:RecordProcessingTurnTaskLevel()
							end
							self:acceptTask(scmd12102.task_id)
						end
					end
					return
				end
			end
		end
	end
	self:showDialogue(self.dialogueModel.npcDialogVo)
	SoundModel:getInstance():PlayTaskAcceptSound(scmd12102.task_id)
end

-- 接受任务
function DialogueController:acceptTask(id)
	TaskController.Instance:Clear30000Timer()
	id = tonumber(id)
	local task = TaskModel:getInstance():GetTaskById(id)
	if task and task.task_kind==TaskKind.DUN_KIND and task.content_id~=0 then
		--副本类型的任务，如果已经接过就直接进入副本(特殊处理，副本失败是要重新接任务的)
		-- GlobalEventSystem:Fire(EventName.STOP_AUTO_DO_TASK)
		local need_go_dun = true
		if task.type==TaskType.GUILD_LINE or task.type==TaskType.BOUNTY_LINE then
			self.taskModel.last_circle_tip_type = false--接任务的时候重置一下任务类型
			if self.dialogueModel.npcDialogVo and self.dialogueModel.npcDialogVo.npc_id then
				self:talkToNPC(self.dialogueModel.npcDialogVo.npc_id, task.id)
				--30007发送后会推送30001， 但是进度未完成，不会自动任务，这里手动请求30000
				TaskController.Instance:request30000()
				need_go_dun = false
			end
		else
			if task.acceptType==1 then
				TaskModel:getInstance().wait_30003 = true
				self:SendFmtToGame(30003, "i", id)
				-- 转职任务需要记录接受任务时的等级，判断断级
			end
		end
		if need_go_dun then
			BaseDungeonModel:getInstance():Fire(BaseDungeonModel.REQUEST_CCMD_EVENT, 61001, task.content_id)
		end
		TaskModel:getInstance():SetNeedTaskFlag(true)
	else
		if task and (task.type==TaskType.GUILD_LINE or task.type==TaskType.BOUNTY_LINE) then
			self:talkToNPC(self.dialogueModel.npcDialogVo.npc_id, task.id)
			self.dialogueModel.isAuto = true
			--30007发送后会推送30001， 但是进度未完成，不会自动任务，这里手动请求30000
			TaskController.Instance:request30000()
		else
			TaskModel:getInstance().wait_30003 = true
			self:SendFmtToGame(30003, "i", id)
			self.dialogueModel.isAuto = true
		end
	end
end

function DialogueController:response30003()
	TaskModel:getInstance().wait_30003 = false
	local flag, msg = self:ReadFmt("ii")
	if flag==0 then
		-- if msg ~= TaskLang.TASK_STR81 then
		-- 	Message.show(Language.substitute(TaskLang.TASK_STR82, msg));
		-- end
		ErrorCodeShow(msg)
	else
		print('Ych:DialogueController.lua[436] data', TaskController.Instance.auto_accept_main_id , flag)
		if TaskController.Instance.auto_accept_main_id == flag then
			--当前这次不要主动做主线，所以自动接完任务也不要主动切换当前任务
			TaskController.Instance.auto_accept_main_id = nil
		else
			if self.taskModel:IsTurnTask(flag) then -- 转职任务需要特殊处理，接取到任务时需要判断是否时断级接取
				self.taskModel.now_task_id = not self.taskModel:IsNewTurnTaskInLimitLv() and flag or self.taskModel.now_task_id
			else
				self.taskModel.now_task_id = flag
			end
		end
		self.dialogueModel:CheckTaskTalkEvent(flag)
		-- Message.show("成功接受任务")
		-------接受任务mainui表现
		local data = {
			type = SceneSpecialTipType.task,
			isAccept = true,
		}
		CommonController.Instance:Fire(EventName.OPEN_SCENESPECIALTIPVIEW,data)

		SoundModel:getInstance():PlayTaskSound(flag)
	end
	-- print("30003============:", self.dialogueModel.isAuto, self.dialogueModel.npcDialogVo, flag, msg)
	-- if self.dialogueModel.isAuto == true and self.dialogueModel.npcDialogVo ~= nil then
	-- 	-- print("接受了任务后，这里又打开了对话==", self.dialogueModel.npcDialogVo.npc_id)
	-- 	self:request12101(self.dialogueModel.npcDialogVo.npc_id)
	-- end

	TaskController.Instance:HandleTask()
end
--double: 0是默认 1是双倍
function DialogueController:finishTask(id, arr,double)
	TaskController.Instance:Clear30000Timer()
	self.dialogueModel.isAuto = true
	TaskModel:getInstance().wait_30004 = true
	arr = arr or {}
	double = double or 0
	local len = #arr
	self:WriteBegin(30004)
	self:WriteFMT("i", id)
	self:WriteFMT("c", double)
	self:WriteFMT("h", len)
	for i = 1, len do
		self:WriteFMT("i", arr[i])
	end
	self:SendToGame()

	-- self:Fire(EventName.TASK_CHANGE, id, 2)
end

function DialogueController:response30004()
	TaskModel:getInstance().wait_30004 = false
	local flag, code = self:ReadFmt("ii")
	local len = self:ReadFmt("h")
	local goods_list = {}
	local goods_list_2 = {}
	for i = 1, len do
		local obj = {
			style = self:ReadFmt("c"),
			typeId = self:ReadFmt("i"),
			count = self:ReadFmt("i"),
		}
		table.insert(goods_list, obj)
		-------------------------
		if obj.style == 5 then
			local have = false
			local goods_id = Config.ConfigNotNormalGoods[obj.style].goods_id
			for k,v in pairs(goods_list_2) do
				have = have or (v == goods_id)
			end
			if not have then
				goods_list_2[#goods_list_2+1] = goods_id
			end
		end
	end

	if flag == 0 then
		ErrorCodeShow(code)
	else
		-------完成任务mainui表现
		local data = {
			type = SceneSpecialTipType.task,
			isAccept = false,
		}
		CommonController.Instance:Fire(EventName.OPEN_SCENESPECIALTIPVIEW,data)

		--添加任务完成标识
		self.taskModel:AddFinishTask( flag )
		
		--如果是触发引导的任务， 就停止自动任务
		-- if Config.ConfigHelper.Task[flag] and not Config.ConfigHelper.NotStopList[flag] then
		-- 	GlobalEventSystem:Fire(EventName.STOP_AUTO_DO_TASK)
		-- end

		--如果是主线
		if TaskModel:getInstance():IsMainTask(flag) then
			TaskModel:getInstance().last_finish_task_id = flag
		end
		-- 如果是转职任务，则记录完成任务时的玩家等级
		if self.taskModel:IsTurnTask(flag) then
			self.taskModel:RecordProcessingTurnTaskLevel()
		end
		--在副本里面出来
		-- if Config.ConfigHelper.NeedDelayExecute[flag] then
		-- 	GuideModel:getInstance():SetNeedDelayExecuteGuide(true)
		-- end
		print("完成任务， id====：", flag)
		if flag == self.taskModel.tip_new_main_line then
			--清掉继续主线提示
			self.taskModel.tip_new_main_line = false
		end
		-------------------------
		if Config.ConfigTaskEffect.GuideLevel < RoleManager.Instance.mainRoleInfo.level then
			if TaskModel:getInstance():IsCircleTask(flag) then--（非主线）只有跑环类会做完一个任务，自动衔接下一个同类任务的
				--起一个计时器，1s内收到30000协议并主动接主线任务的时候，不会停止自动任务
				TaskModel:getInstance().sign_mask_not_guide_wait_accept_main_task = true
				local function delay( )
					TaskModel:getInstance().sign_mask_not_guide_wait_accept_main_task = nil
				end
				setTimeout(delay,1)
			end
		end
		-------------------------

		local taskVo = TaskModel:getInstance():GetTaskById(flag)
		GlobalEventSystem:Fire(TaskEventType.TASK_SUCCESS, flag)
		self.taskModel.last_task_id_cache = flag
		self.taskModel.now_task_id = nil 
		--如果是支线或者限时， 就不处理，避免中断其他任务
		-- if taskVo and taskVo.type~=TaskType.EXTENSION_LINE and taskVo.type~=TaskType.LIMIT_LINE then
			if taskVo then
				self.taskModel.last_task_type_cache = taskVo.type
			end
		-- end

		if taskVo and taskVo.type == TaskType.EXTENSION_LINE then
			--支线任务完成增加表现效果
			lua_soundM:PlayEffect(self, "extension_line_success", false, LuaSoundManager.SOUND_TYPE.ROLE)
		else
			SoundModel:getInstance():PlayTaskSound(flag)
			SoundModel:getInstance():PlayTaskCompleteSound(flag)
		end

		if taskVo and taskVo.type == TaskType.BOUNTY_LINE then
			--日常任务飘经验获得
			MainUIModel:getInstance():PlayGoodsFlyList(goods_list_2)

			self.dialogueModel.is_delay_show_main_task_tips = false
			self.dialogueModel.is_show_main_task_tips_flag = false
			--完成经验跑环时，会提示要不要做主线
			if Config.ConfigTaskEffect.NewMainLineTipLvMin <= RoleManager.Instance.mainRoleInfo.level and RoleManager.Instance.mainRoleInfo.level <= Config.ConfigTaskEffect.NewMainLineTipLvMax then
				local cur_main_task = self.taskModel:GetMainTask()
				if cur_main_task and RoleManager.Instance.mainRoleInfo.level >= cur_main_task.level then
					self.taskModel.now_task_id = nil
					GlobalEventSystem:Fire(EventName.STOP_AUTO_DO_TASK) --停止自动任务
					--如果是在副本里面，则等待
					if not SceneManager:getInstance():IsMirrorScene() then
						local function ok_callback()
							if cur_main_task then
								GlobalEventSystem:Fire(EventName.CLOSE_ALL_VIEW)
								self.taskModel.tip_new_main_line = cur_main_task.id
								GuideController.Instance:TriggerHelper(GuideModel.TASK_TRIGGER_TYPE, 9993150002)
								self.taskModel:Fire(TaskEvent.SHOW_NEW_MAIN_LINE_TIP)
							end	                    
		                end
		                local function cancle_callback()
							self.taskModel:SetTaskAutoFlag(true)
							GlobalEventSystem:Fire(EventName.FORCE_TO_DO_TASK)               
		                end	    
      	                
		                local str = "任务指引\n\n有新的主线任务，赶紧去看看吧!"
		                Alert.show(str, Alert.Type.Two, ok_callback, cancle_callback, "确定", "继续任务")
		                self.dialogueModel.is_show_main_task_tips_flag = true
		            else
		            	self.dialogueModel.is_delay_show_main_task_tips = cur_main_task.id
					end	                
				end
			end
		end
	
		--判断是否配置了自动接下个任务
		if taskVo and taskVo.next~=0 then
			if taskVo.type ~= TaskType.EXTENSION_LINE then --支线不需要自动触发下一个
				--先判断等级
				local cfg = ConfigItemMgr.Instance:GetTaskData(taskVo.next)
				if cfg then
					if RoleManager.Instance.mainRoleInfo.level >= cfg.level then
						self:acceptTask(taskVo.next)
					else
						-- if Config.ConfigTaskEffect.GuideLevel < RoleManager.Instance.mainRoleInfo.level then
						-- 	if TaskModel:getInstance():IsMainTask(flag) then
						-- 		--如果是非新手期，而且是完成主线，那就不用记录了，30000返回的时候主线就会被自动接掉
						-- 		return
						-- 	end
						-- end
						--升级了就触发
						TaskModel:getInstance().need_accept = taskVo.next
					end
				end
			end
		end
	end
end

--[[
 * 任务对话事件
 * @param npcId NPCID
 * @param taskId 任务ID
 *
 ]]
function DialogueController:talkToNPC(npcId, taskId)
	self:SendFmtToGame(30007, "ii", taskId, npcId)
	self.dialogueModel.isAuto=true;
end

function DialogueController:response30007()

end

--任务探索事件
function DialogueController:request30008()
	self:SendFmtToGame(30008)
end

function DialogueController:response30008()
	
end

function DialogueController:response30009()
	local code = self:ReadFmt("i")
	if code==1 then
		--Message.show("成功接受任务")
		-------接受任务mainui表现
		local data = {
			type = SceneSpecialTipType.task,
			isAccept = true,
		}
		TaskModel.getInstance():Fire(TaskEvent.SHOW_SCROLL_TO_ITEM, 1)	--领取任务后，置顶任务栏
		CommonController.Instance:Fire(EventName.OPEN_SCENESPECIALTIPVIEW,data)
	else
		ErrorCodeShow(code)
	end
end

function DialogueController:response30010()
	local info = {}
	info.task_type = self:ReadFmt("c")
	info.cur_progress = self:ReadFmt("c")
	info.total_progress = self:ReadFmt("c")
	info.reward_progress = self:ReadFmt("c")
	TaskModel:getInstance():SetCircleTaskInfo(info)
end

function DialogueController:response30011(  )
	local info = {}
	info.task_id = self:ReadFmt("i")
	local basedata=ConfigItemMgr.Instance:GetTaskData(info.task_id)
	--奖励
	local len0 = UserMsgAdapter.ReadFmt("h") or 0
	info.reward = info.reward or {}
	local vo0 = nil
	for i = 1,len0 do
	    vo0 = {
	   	 	UserMsgAdapter.ReadFmt("c") or 0,
		    UserMsgAdapter.ReadFmt("i") or 0,
		    UserMsgAdapter.ReadFmt("l") or 0
	    }
	 	table.insert(info.reward,vo0)
	end

	--额外奖励
	info.extra_reward = info.extra_reward or {}
	local len1 = UserMsgAdapter.ReadFmt("h") or 0
	local vo1 = nil
	for i = 1,len1 do
	    vo1 = {
	    	UserMsgAdapter.ReadFmt("c") or 0,
		    UserMsgAdapter.ReadFmt("i") or 0,
		    UserMsgAdapter.ReadFmt("l") or 0
	    }
	 	table.insert(info.extra_reward,vo1)
	end
	
	self.taskModel.circle_cache_reward = info

	GlobalEventSystem:Fire(EventName.UPDATE_TASK_BOUNTY_REWARD, info)
	-------------------------
	TaskModel:getInstance():Fire(TaskEvent.TASK_LIST_INIT)
end

function DialogueController:response30012()
	local task_id = self:ReadFmt("i")
	TaskModel:getInstance().last_finish_task_id = task_id

	GlobalEventSystem:Fire(EventName.REFRESH_CALL_STAR_MODEL)

	GlobalEventSystem:Fire(EventName.TASK_DATA_INIT)
end

function DialogueController:response30015()
	local code = self:ReadFmt("i")
	ErrorCodeShow(code)
end

--选择npc功能对话框
function DialogueController:showNpcFunctionSelectTalk(talkid,taskCount)
	local dialogid = talkid
	local npcDialogVo = self.dialogueModel.npcDialogVo
	npcDialogVo.dialogId = dialogid
	npcDialogVo.dialogList = ConfigItemMgr.Instance:GetTalkItem(dialogid)
	if npcDialogVo.dialogList==nil then
		-- print("~~选择npc功能对话框~~~对话id is nil, 显示默认对话:",dialogid)
		npcDialogVo.dialogList=DialogueModel.DEFAULT_TALK
		if npcDialogVo.dialogList.content[1] then 
			npcDialogVo.dialogList.content[1].id = npcDialogVo.npc_id
		end
	end
	-- 跳过空对话
	-- print("---------showNpcFunctionSelectTalk--------:", self.dialogueModel.isAuto, taskCount)
	if self.dialogueModel.isAuto == true and taskCount==0 then
		self.dialogueModel.isAuto = false
		return
	end
	self:showDialogue(npcDialogVo)
end

function DialogueController:showNpcTalk(talkid,taskCount)
	local dialogid = talkid
	local npcDialogVo = self.dialogueModel.npcDialogVo --12101
	local is_default_talk = false
	--[[
		同个npc下面可能同时会有主线和支线任务，12101协议任务数据可能会有2条，
		这样客户端就不知道应该选择哪个任务来触发相关操作， 所以在开始任务前，客户端先记下当前任务id，
		这里判断12101协议里面的任务数据是不是存在当前客户端保存的当前任务id，存在的话就把非当前任务的数据删掉
	]]
	-- 2019年11月6日修改：增加多任务过滤筛选出第一个要处理的任务 
	-- 17：45分，天气晴，飒爽的秋风带来了冬季的寒意，窗外的阳光似乎没有了温度，而我心中只记得策划大佬突然又要改需求了(╯‵□′)╯︵┻━┻

	-- if self.taskModel.now_task_id and self.dialogueModel.npcDialogVo and #self.dialogueModel.npcDialogVo.task_list > 1 then 
	if self.dialogueModel.mult_select_task_id and self.dialogueModel.npcDialogVo and #self.dialogueModel.npcDialogVo.task_list > 1 then 
		local find = false
		for i,v in ipairs(self.dialogueModel.npcDialogVo.task_list) do
			if v.task_id == self.dialogueModel.mult_select_task_id then 
				find = true 
				break
			end
		end
		if find then 
			local delete_index={}
			for i,v in ipairs(self.dialogueModel.npcDialogVo.task_list) do
				if v.task_id ~= self.taskModel.now_task_id then 
					table.insert(delete_index,i)
				end	
			end
			local del_num=0
			for i,v in ipairs(delete_index) do
				local index = v - del_num
				table.remove(self.dialogueModel.npcDialogVo.task_list, index)
				del_num = del_num + 1
			end
		-- else
		-- 	-- 对多任务进行排序，然后根据排好的顺序只选择第一个任务
		-- 	self.dialogueModel:SortMultTaskList(self.dialogueModel.npcDialogVo.task_list)
		-- 	for k = #self.dialogueModel.npcDialogVo.task_list , 1 do 
		-- 		if k > 1 then
		-- 			table.remove(self.dialogueModel.npcDialogVo.task_list, k)
		-- 		end
		-- 	end
		end
		taskCount = 1
	end
	-- 每次走完多任务的判断都要保证多任务选择的任务id置空
	self.dialogueModel:SetMultSelectTaskID(nil)
	-- dialogid是目标npc默认的对话内容，如果为空则显示通用默认npc的对话，一般是npcid为0或者空的时候会出现
	npcDialogVo.dialogId = dialogid
	npcDialogVo.dialogList = ConfigItemMgr.Instance:GetTalkItem(dialogid)
	if npcDialogVo.dialogList==nil then
		print("~~~~~db里面找不到该对话id, 显示默认对话:",dialogid)
		npcDialogVo.dialogList=DialogueModel.DEFAULT_TALK
		is_default_talk = true
		if npcDialogVo.dialogList.content[1] then 
			npcDialogVo.dialogList.content[1].id = npcDialogVo.npc_id
		end
	end

	-- 跳过空对话
	if self.dialogueModel.isAuto == true and taskCount==0 then
		self.dialogueModel.isAuto = false
		return
	end
	-- 判断是否是可选任务，是则不请求12102协议获取对话内容(仅需在只有一条任务数据的时候判断)
	local is_optional_task = false
	if taskCount == 1 and npcDialogVo.task_list and npcDialogVo.task_list[1] and npcDialogVo.task_list[1].task_id then
		local task_vo = TaskModel:getInstance():GetTaskById(npcDialogVo.task_list[1].task_id) or {}
		if task_vo.tipType then
			is_optional_task = is_optional_task or task_vo.tipType == TaskTipType.TYPE35
			local is_target_npc = task_vo.tipParam and task_vo.tipParam[3] == npcDialogVo.npc_id
			if is_optional_task and is_target_npc then
				npcDialogVo.task_id = npcDialogVo.task_list[1].task_id
			end
		end
	end
	--(task_state  0:无 1:有可接任务 2:有未完成的任务 3:有可提交的任务 4:有任务对话)
	local is_cur_select = npcDialogVo and npcDialogVo.task_list and npcDialogVo.task_list[1] and 
				((TaskModel:getInstance().now_task_id or 0) == 0 or TaskModel:getInstance().now_task_id == npcDialogVo.task_list[1].task_id)
	if is_cur_select and npcDialogVo.dialogList.total_content == 1 and npcDialogVo.dialogList.content[1].total_list == 1
		and taskCount == 1 and npcDialogVo.task_list[1].task_state~=2 and not is_optional_task then
		self:request12102(npcDialogVo.npc_id, npcDialogVo.task_list[1].task_id, npcDialogVo.task_list[1].task_state)
	else
		if npcDialogVo.npc_id == 0 and is_default_talk then --当npc_id 是0 ，而且是默认对话的时候，对话框就不显示出来了
			return
		end

		if self.dialogueModel.isAuto == false then
			self:showDialogue(npcDialogVo)
		elseif #npcDialogVo.task_list > 0 then
			-- self.model:SortMultTaskList(npcDialogVo.task_list)
			local isShow=false
			for _, taskNodeVo in pairs(npcDialogVo.task_list) do
				if taskNodeVo.task_state ~= 2 then
					isShow=true
					break
				end
			end
			if isShow==true and npcDialogVo.dialogId and npcDialogVo.dialogId ~= 0 then
				self:showDialogue(npcDialogVo)
			end
		end
	end
	self.dialogueModel.isAuto=false
end

--[[
 * 点击NPC对话框确定按钮
 * @param e
 *
 ]]
function DialogueController:clickAnswerHandler(dialogueVo, dialogueNodeVo, selected,double)
	selected = selected or false
	local typeId = 0
	--任务的操作
	self.dialogueModel.andTriggerTask = nil 
	if dialogueNodeVo.type == DialogueTypeConst.FINISH_AND_TRIGGER then 
		self.dialogueModel.andTriggerTask = dialogueNodeVo
		self:finishTask(dialogueVo.task_id,false,double);
	elseif dialogueNodeVo.type == DialogueTypeConst.TRIGGER then 
		self:acceptTask(dialogueVo.task_id);
	elseif dialogueNodeVo.type == DialogueTypeConst.FINISH then
		self:finishTask(dialogueVo.task_id,false,double);
	elseif dialogueNodeVo.type == DialogueTypeConst.TRIGGER_AND_FINISH then
	elseif dialogueNodeVo.type == DialogueTypeConst.TALK_EVENT then
		self:talkToNPC(dialogueVo.npcId, dialogueVo.task_id)
	end
end

-- 是否是显示跑环界面
function DialogueController:IsShowCircleView( npcDialogVo )
	-------------------------
	local cfg1 = self.taskModel:GetTaskAcceptNpcConfig(TaskType.BOUNTY_LINE)
	local cfg2 = self.taskModel:GetTaskAcceptNpcConfig(TaskType.GUILD_LINE)
	if not (npcDialogVo.npc_id == cfg1.npc_id or npcDialogVo.npc_id == cfg2.npc_id) then
		--当前不是跑环npc
		return false
	end
	-------------------------
	--判断是否可领取奖励
	local task_type = false
	if npcDialogVo.npc_id == cfg1.npc_id then
		task_type = TaskType.BOUNTY_LINE
	elseif npcDialogVo.npc_id == cfg2.npc_id then
		task_type = TaskType.GUILD_LINE
	end
	local reward_data = self.taskModel:CanCircleReward(task_type)
	if reward_data then
		return true
	end
	-------------------------
	if npcDialogVo.task_id == 0 then
		--身上没任务，首次接任务用对话框
		return false
	end
	local task = TaskModel:getInstance():GetTaskById(npcDialogVo.task_id)
	if not task then return false end
	local is_circle_line = task.type==TaskType.GUILD_LINE or task.type==TaskType.BOUNTY_LINE
	if is_circle_line then
		if task.tipType == TaskTipType.TYPE35 and self.taskModel.last_circle_tip_type == task.tipType then
			--多选任务,而且上一次跑环tip显示的是多选类，那就显示普通对话
			return false
		end
		if task.acceptType==0 and self.taskModel:IsTaskProgressFinish(task) then
			--任务已完成等结束
			return false
		end
		if task.taskTips and task.taskTips[1] and task.taskTips[1].isFinish == 0 then
			--第一步改成弹界面
			return true
		end
	end
	return false
end