local ipairs = ipairs
  local table = table
  local math = math
  local next = next
  local string = string
  local redisproxy = redisproxy
  local MsgPack = MsgPack
  local getRandomName = getRandomName
  local mcast_util = mcast_util
  local string_format = string.format
  local tonumber = tonumber
  local require = require
  local table_insert = table.insert
  local tconcat = table.concat
  local table_unpack = table.unpack
  

  local AdvCommon = require "adv.AdvCommon"
  

  local _M = {}
  

  -- 无尽模式是否开放
  local function isOpenEndless(role)
  	if role.advOverTime ~= 0 and skynet.timex() >= role.advOverTime then
  		return false
  	end
  	return true
  end
  -- 冒险内的操作是否可以继续
  local function isCanContinue(role)
  	local adv = role:getAdvData()
  	if not adv:isRunning() then return false end
  	if adv:isEndless() then
  		if not isOpenEndless(role) then return false end
  	end
  	return true
  end
  

  local function checkFormat(role, format, checkAdvTeam)

  	local advHang = role:getProperty("advHang")
  	local hadHero = {}
  	for chapterId, info in pairs(advHang) do
  		if info.format then
  			for _, heroId in pairs(info.format.heros) do
  				hadHero[heroId] = true
  			end
  		end
  	end
  

  	if checkAdvTeam then

  		for _, heroId in pairs(role:getProperty("advTeam").heros or {}) do
  			hadHero[heroId] = true
  		end
  	end
  
  	if not format.leader then return end

  	if format.leader2 == format.leader then return end

  	local hadLeader = false

  	local hadLeader2 = false
  	local heroCount = 0

  	for slot, heroId in pairs(format.heros) do
  		if not role.heros[heroId] or hadHero[heroId] then
  			return
  		end
  		if heroId == format.leader then
  			hadLeader = true
  		end

  		if heroId == format.leader2 then
  			hadLeader2 = true
  		end
  		heroCount = heroCount + 1
  	end
  	if not hadLeader2 and heroCount >= 2 then
  		return

  	end
  	if not hadLeader then return end
  	return true
  end
  

  --开始一个新的关卡

  function _M.startAdvRpc( agent, data )
  	local role = agent.role
  	local msg = MsgPack.unpack(data)

  	local chapterId = msg.chapterId --关卡id
  	local layer = msg.layer or 1	--选择层数
  	local format = msg.format 		--编队

  	local supportIdx = msg.supportIdx --选择的支援效果

  	if not role:isFuncUnlock(FuncUnlock.Adv) then return end
  	

  	--上一个关卡结束才可以开始新的关卡

  	if role:getAdvData():isRunning() then return 8 end

  	local chapterData = csvdb["adv_chapterCsv"][chapterId]

  	if not chapterData or layer < 1 then return  1 end

  	local advPass = role:getProperty("advPass")

  
  	if AdvCommon.isEndless(chapterId) then -- 无尽模式判断
  

  		if chapterId ~= role.advElChapter then return end -- 不是当前进行的章节
  		if not isOpenEndless(role) then return end

  		if role.dailyData:getProperty("advElC") >= role:getAdvElLimit() then return 2 end -- 是否有体力

  		if not role:isFuncOpen(FuncOpenType.AdvEndless) then return 11 end -- 无尽模式 才可以玩儿无尽模式
  
  		local advElM = role:getProperty("advElM")  --最高通关的层数

  
  		if layer == 1 then
  			if not role:advChapterIsOpen(chapterId, layer) then return 13 end

  		else
  			local relayData = role:getAdvData():isHaveRelay(layer, chapterId) 
  			if not relayData then return end  -- 不是中继层
  			if advElM < relayData.unlockfloor then return end --未解锁

  		end 

  	else   -- 普通模式判断

  		if role.dailyData:getProperty("advC") >= role:getAdvHangLimit() then return 2 end -- 是否有体力

  		if layer > chapterData.limitlevel  then return 4 end
  		-- 关卡开放判断
  		if not role:advChapterIsOpen(chapterId, layer) then return 5 end

  		-- 普通模式没有中继 只能从1 开始 中继开放判断
  		if layer ~= 1 then return 6 end

  	end

  	
  	if not checkFormat(role, format) then return 7 end

  	local advTeam = role:getProperty("advTeam")
  	table.clear(advTeam)
  
  	advTeam.heros = {}

  	for slot, heroId in pairs(format.heros) do

  		advTeam.heros[slot] = heroId
  	end

  	advTeam.leader = format.leader

  	advTeam.leader2 = format.leader2

  	role:updateProperty({field = "advTeam", value = advTeam})

  	if AdvCommon.isEndless(chapterId) then
  		role.dailyData:updateProperty({field = "advElC", delta = 1})
  	else
  		role.dailyData:updateProperty({field = "advC", delta = 1})
  	end

  	local support = {}  -- 支援效果
  	if AdvCommon.isEndless(chapterId) then
  		-- 选择的支援效果
  		local advSup = role:getProperty("advSup")
  		if supportIdx then
  			if advSup[supportIdx] then
  				table.insert(support, advSup[supportIdx])
  			end
  			role:advRandomSupportEffect() -- 选完就重新随机
  		end
  		-- 增加 默认增加的支援效果
  		local active = role:getAdvActiveSupportEffect()
  		for aId, _ in pairs(active) do
  			local curData = csvdb["adv_supportCsv"][aId]
  			if curData.type == 2 then
  				table.insert(support, aId)
  			end
  		end
  	end
  
  	role:getAdvData():initByChapter(chapterId, layer, false, false, layer ~= 1, true, support)

  	role:checkTaskEnter("AdvStart", {id = chapterId})

  	role:checkTaskEnter("AdvStartSelf", {id = chapterId})

  	role:getAdvData():popBackEvents() -- 清一下事件

  	role:getAdvData():log({desc = "start", int1 = supportIdx})
  

  	SendPacket(actionCodes.Adv_startAdvRpc, '')
  	return true
  end
  

  
  function _M.startHangRpc(agent, data)

  	local role = agent.role
  	local msg = MsgPack.unpack(data)

  	local chapterId = msg.chapterId --关卡id
  	local format = msg.format --编队
  
  	local chapterData = csvdb["adv_chapterCsv"][chapterId]
  	if not chapterData then return end
  
  	local advHang = role:getProperty("advHang")
  	if advHang[chapterId] then return end --正在挂机
  

  	if role:getAdvData():isRunning() and role:getAdvData().chapterId == chapterId then return end
  

  	local advPass = role:getProperty("advPass")

  	if AdvCommon.isEndless(chapterId) or advPass[chapterId] ~= chapterData.limitlevel then return end -- 没有全通关

  
  	if role.dailyData:getProperty("advC") >= role:getAdvHangLimit() then return end -- 是否有体力
  

  	if not checkFormat(role, format, role:getAdvData():isRunning()) then return end --编队是否正确

  
  	local battleV = 0
  	for _, heroId in pairs(format.heros) do
  		local hero = role.heros[heroId]
  		battleV = battleV + hero:getProperty("battleV")
  	end
  	if battleV < chapterData.idleValue then return end -- 战斗力是否满足
  
  	local info = {}
  	info.format = {}
  	info.format.leader = format.leader

  	info.format.leader2 = format.leader2

  	info.format.heros  = {}
  	for slot, heroId in pairs(format.heros) do
  		info.format.heros[slot] = heroId
  	end
  	info.time = skynet.timex() + chapterData.idleTime --挂机时间
  

  	-- 没有在战斗  用team来挂机了  把team清掉

  	if not role:getAdvData():isRunning() then
  		role:updateProperty({field = "advTeam", value = {}})
  	end

  	role:changeUpdates({{type = "advHang", field = chapterId, value = info}})
  
  	role.dailyData:updateProperty({field = "advC", delta = 1})

  	role:checkTaskEnter("AdvStart", {id = chapterId})

  	role:log("adv_action", {desc = "startHang", int1 = chapterId})
  

  	SendPacket(actionCodes.Adv_startHangRpc, '')
  	return true
  end
  

  function _M.quickHangRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  
  	local chapterId = msg.chapterId --关卡id
  	
  	local advHang = role:getProperty("advHang")
  	local info = advHang[chapterId]
  	if not info then return end 
  
  	local chapterData = csvdb["adv_chapterCsv"][chapterId]
  	if not chapterData then return end
  	
  	local reward, isFull
  	if skynet.timex() >= info.time then return end  -- 已经完成了
  
  	local cost = math.ceil((info.time - skynet.timex()) / chapterData.idleTime * chapterData.accelerate)
  
  	if not role:checkItemEnough({[ItemId.Diamond] = cost}) then return end

  	role:costItems({[ItemId.Diamond] = cost}, {log = {desc = "quickHang", int1 = chapterId}})

  	info.time = 0
  	role:changeUpdates({{type = "advHang", field = chapterId, value = info}})
  

  	role:log("adv_action", {desc = "quickHang", int1 = chapterId})
  

  	SendPacket(actionCodes.Adv_quickHangRpc, '')
  	return true
  end
  

  function _M.endHangRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  
  	local chapterId = msg.chapterId --关卡id
  	local cancel = msg.cancel  --是否是取消
  	
  	local advHang = role:getProperty("advHang")
  	local info = advHang[chapterId]
  	if not info then return end 
  
  	local chapterData = csvdb["adv_chapterCsv"][chapterId]
  	if not chapterData then return end
  	
  	local reward, isFull
  	if skynet.timex() >= info.time then

  		reward = role:award(chapterData.idleReward, {log = {desc = "advHang", int1 = chapterId}})

  	else
  		if cancel then
  			if role.dailyData:getProperty("advC") <= 0 then 
  				isFull = true
  			else
  				role.dailyData:updateProperty({field = "advC", delta = -1})
  			end
  		else

  			return
  		end
  	end

  	
  	role:changeUpdates({{type = "advHang", field = chapterId, value = nil}})
  

  	role:log("adv_action", {desc = "endHang", int1 = chapterId, short1 = cancel and 1 or 0})
  

  	SendPacket(actionCodes.Adv_endHangRpc, MsgPack.pack({reward = reward, isFull = isFull}))
  	return true
  end
  
  function _M.buyAdvCountRpc(agent , data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	
  	local count = msg.count --购买次数

  	local isEl = msg.isEl -- 是否是无尽模式
  	local cost
  	if isEl then

  		if math.illegalNum(count, 1, globalCsv.adv_endless_daily_buy_count - role.dailyData:getProperty("advElBC")) then return end

  		cost = {[ItemId.Diamond] = count * globalCsv.adv_endless_daily_buy_cost}
  	else

  		if math.illegalNum(count, 1, globalCsv.adv_daily_buy_count - role.dailyData:getProperty("advBC")) then return end

  		cost = {[ItemId.Diamond] = count * globalCsv.adv_daily_buy_cost}
  	end
  	
  	

  	if not role:checkItemEnough(cost) then return end

  	role:costItems(cost, {log = {desc = "buyAdvCount", short1 = isEl and 1 or 0, int1 = count}})

  	if isEl then
  		role.dailyData:updateProperty({field = "advElC", delta = -count})
  		role.dailyData:updateProperty({field = "advElBC", delta = count})
  	else
  		role.dailyData:updateProperty({field = "advC", delta = -count})
  		role.dailyData:updateProperty({field = "advBC", delta = count})
  	end

  	role:log("adv_action", {desc = "buyAdvCount", short1 = isEl and 1 or 0, int1 = count})

  	
  	SendPacket(actionCodes.Adv_buyAdvCountRpc, '')

  	return true
  end
  

  function _M.finishTaskRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  

  	if not isCanContinue(role) then return end

  	local adv = role:getAdvData()
  	local taskId = msg.taskId  -- -1 则是主线任务
  	local status, reward
  	if taskId == -1 then
  		status, reward = adv:finishMTask()
  	else
  		status, reward = adv:finishTask(taskId)

  		adv:checkAchievement(adv.AchievType.TaskLayer, 1, taskId)
  		adv:updateAchievement()

  	end

  	adv:updateTask()

  	if not status then return end

  	role:checkTaskEnter("AdvOverTask", {id = taskId})

  
  	adv:log({desc = "finishTask", int1 = taskId})
  

  	SendPacket(actionCodes.Adv_finishTaskRpc, MsgPack.pack({reward = reward}))
  	return true
  end
  

  -- 点击地块（解锁）(触发事件)
  function _M.clickBlockRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  

  	if not isCanContinue(role) then return end

  	local adv = role:getAdvData()

  	if adv:isWaitChooseArtifact() then return end

  
  	adv:log({desc = "clickBlock", int1 = msg.roomId, int2 = msg.blockId})
  

  	local status, errorCode = adv:clickBlock(msg.roomId, msg.blockId, msg)
  	if not status then return errorCode end

  	SendPacket(actionCodes.Adv_clickBlockRpc, MsgPack.pack({events = adv:popBackEvents()}))
  	return true
  end
  
  --use item 使用背包道具
  function _M.useItemRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  

  	local itemId = msg.itemId -- 道具Id
  	local count = msg.count or 1 --数量
  	local target = msg.target -- {roomId = 1, blockId = 1} 选择的目标
  
  	local itemData = csvdb["adv_itemCsv"][itemId] 
  	if not itemData then return end
  

  	if not isCanContinue(role) then return end

  	local adv = role:getAdvData()

  	if adv:isWaitChooseArtifact() then return end

  	--重置数量 
  	if itemData["function"] == 0 or itemData["function"] == 2 then count = 1 end
  	if not adv:cost({[itemId] = count}, {}, true) then return true end
  

  	--消耗
  	if itemData["function"] == 0 or itemData["function"] == 1 then 

  		adv:cost({[itemId] = count}, {log = {desc = "useItem", int1 = itemId, int2 = count}})

  		adv:backUse({[itemId] = count})

  	end
  

  	adv:checkAchievement(adv.AchievType.UseItem, count, itemId)

  	adv:log({desc = "useItem", int1 = itemId, int2 = count})

  
  	for i = 1, count do
  		adv:doActive(itemData.effect, target) -- target
  	end
  	

  	adv:afterRound()
  	adv:saveDB()
  

  	SendPacket(actionCodes.Adv_useItemRpc, MsgPack.pack({events = adv:popBackEvents()}))
  	return true
  end
  

  --使用营养技能

  function _M.usePotionRpc(agent, data)

  	local role = agent.role
  	local msg = MsgPack.unpack(data)

  	local potionId = msg.potionId -- 营养剂Id
  	local target = msg.target -- {roomId = 1, blockId = 1} 选择的目标
  	local potionLv = role.dinerData:getProperty("dishTree"):getv(potionId, 0)
  	if potionLv == 0 then return 1 end
  
  	local potionSet = csvdb["adv_potionCsv"][potionId]
  	if not potionSet then return 2 end
  
  	local potionData = potionSet[potionLv]
  	if not potionData then return 3 end
  
  	local potionBag = role:getProperty("potionBag")
  	local own = potionBag[potionId] or 0
  	if own <= 0 then return 4 end

  
  	if not isCanContinue(role) then return end

  	local adv = role:getAdvData()

  	if adv:isWaitChooseArtifact() then return end
  

  	adv:log({desc = "usePotion", int1 = potionId})
  

  	local status = adv:doActive(potionData.effect, target) -- target

  	if not status then return end

  
  	potionBag[potionId] = own - 1
  	role:updateProperty({field = "potionBag", value = potionBag})

  	adv:pushBackEvent(AdvBackEventType.Potion, {id = potionId})

  	adv:afterRound()
  	adv:saveDB()
  	role:checkTaskEnter("AdvUsePotion")
  

  	SendPacket(actionCodes.Adv_usePotionRpc, MsgPack.pack({events = adv:popBackEvents()}))

  	return true
  end

  -- 选择神器
  function _M.chooseArtifactRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)

  	if not isCanContinue(role) then return end
  
  	local adv = role:getAdvData()

  	if not msg.idx then return end
  	if not adv:isWaitChooseArtifact() then return end
  	local status = adv:chooseArtifact(msg.idx)
  	if not status then return end
  	adv:saveDB()

  	SendPacket(actionCodes.Adv_chooseArtifactRpc, '')
  	return true
  end
  
  -- 穿戴神器
  function _M.wearArtifactRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local slot = msg.slot
  	local id = msg.id
  

  	if not isCanContinue(role) then return end
  

  	local adv = role:getAdvData()
  

  	if math.illegalNum(slot, 1, 5) then return 1 end

  	if adv:isWaitChooseArtifact() then return 2 end

  
  	local status = adv:wearArtifact(slot, id)

  	if not status then return 3 end

  	adv:saveDB()
  
  	SendPacket(actionCodes.Adv_wearArtifactRpc, '')
  	return true
  end
  
  -- 升级神器
  function _M.upArtifactRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local id = msg.id
  

  	if not isCanContinue(role) then return end
  

  	local adv = role:getAdvData()

  	if adv:isWaitChooseArtifact() then return 1 end

  	local curLevel = adv:isHaveArtifact(id)

  	if not curLevel then return 2 end
  	if not role:isArtifactOpen(id, adv:isEndless(), curLevel + 1) then return 3 end
  	local cost = csvdb["adv_artifactCsv"][id][curLevel].exp:toNumMap()
  	if not adv:cost(cost, {}, true) then return 4 end

  
  	local status = adv:artifactLevelUp(id)

  	if not status then return 5 end

  	adv:cost(cost, {log = {desc = "upArtifact", int1 = id}})

  	adv:backCost(cost)

  	if status == 1 then -- 现在穿着呢。更新下
  		adv:saveDB()
  	end
  	SendPacket(actionCodes.Adv_upArtifactRpc, '')
  	return true
  end
  

  --退出
  function _M.exitAdvRpc(agent, data)
  	local role = agent.role
  	-- local msg = MsgPack.unpack(data)

  	if not isCanContinue(role) then return end
  

  	local adv = role:getAdvData()

  	adv:log({desc = "exit"})

  	local status = adv:exit() -- target {roomId = 1, blockId = 1} 选择的目标
  	SendPacket(actionCodes.Adv_exitAdvRpc, MsgPack.pack({events = adv:popBackEvents()}))
  	return true
  end 
  

  --开始战斗
  function _M.startBattleRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  
  	-- 校验一下信息
  	local roomId = msg.roomId
  	local blockId = msg.blockId
  	local monsterId = msg.monsterId
  	local enemyId = msg.enemyId
  	if not enemyId then return end

  	if not isCanContinue(role) then return end

  
  	local adv = role:getAdvData()

  	if adv:isWaitChooseArtifact() then return end

  	local enemy = adv.battle:getEnemyById(enemyId)
  
  	if enemy.monsterId ~= monsterId or enemy.roomId ~= roomId or enemy.blockId ~= blockId or enemy.lock or enemy.isDead then return end
  
  	local key = tostring(math.random())
  	adv.__battleCache = {
  		enemyId = enemyId,
  		key = key
  	}
  	SendPacket(actionCodes.Adv_startBattleRpc, MsgPack.pack({key = key}))
  	return true
  end
  
  -- 结束战斗
  function _M.endBattleRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local roomId = msg.roomId
  	local blockId = msg.blockId
  	local monsterId = msg.monsterId
  	local enemyId = msg.enemyId
  	local key =  msg.key
  	local player = msg.player

  	local bySkill = msg.bySkill --死于 技能

  
  	if not player or not player.hp or not player.sp or not enemyId or not key then return end

  	if not isCanContinue(role) then return end
  	

  	local adv = role:getAdvData()

  	if adv:isWaitChooseArtifact() then return end

  	-- 校验
  	if not adv.__battleCache then return end
  	if adv.__battleCache.enemyId ~= enemyId then return end
  	local enemy = adv.battle:getEnemyById(enemyId)
  	if enemy.monsterId ~= monsterId or enemy.roomId ~= roomId or enemy.blockId ~= blockId then return end
  	adv.__battleCache = nil
  

  	adv:log({desc = "endBattle"})

  	local status = adv:clickBlock(roomId, blockId, {player = player, bySkill = bySkill})

  	if not status then return end
  	SendPacket(actionCodes.Adv_endBattleRpc, MsgPack.pack({events = adv:popBackEvents()}))
  	return true
  end
  

  -- function _M.workshopRpc(agent, data)
  -- 	local role = agent.role
  -- 	local msg = MsgPack.unpack(data)
  
  -- 	local id = msg.id 
  -- 	local count = msg.count or 1
  -- 	local mergeData = csvdb["adv_mergeCsv"][id]
  -- 	if not mergeData then return 1 end
  
  -- 	if not role:isFuncOpen(FuncOpenType.AdvWS) or role:getFuncLv(FuncOpenType.AdvWS) < mergeData.unlock then return 2 end
  
  -- 	local advWs = role.dailyData:getProperty("advWs")
  -- 	if math.illegalNum(count, 1, mergeData.limit - (advWs[id] or 0)) then return 3 end
  
  -- 	local cost = mergeData.formula:toNumMap()
  -- 	for k, v in pairs(cost) do
  -- 		cost[k] = v * count
  -- 	end
  -- 	if not role:checkItemEnough(cost) then return 4 end
  
  -- 	role:costItems(cost)
  -- 	advWs[id] = (advWs[id] or 0) + count
  -- 	role.dailyData:updateProperty({field = "advWs", value = advWs})
  -- 	local reward = role:award({[id] = count})
  -- 	SendPacket(actionCodes.Adv_workshopRpc, MsgPack.pack({reward = reward}))
  -- 	return true
  -- end

  function _M.wheelSurfRpc(agent, data)
  	local role = agent.role

  	-- if not role:isFuncOpen(FuncOpenType.AdvWheelSurf) then return end -- 默认解锁

  	local msg = MsgPack.unpack(data)

  	local ptype = msg.ptype  -- 池子类型 1, 2
  	local ctype = msg.ctype  -- 抽取次数  1 1次，2 10次

  	local countPool = {
  		[1] = 1,
  		[2] = 10
  	}
  	local count = countPool[ctype]

  	if not count then return 1 end

  	if ptype == 2 and not role:isFuncOpen(FuncOpenType.AdvEndless) then

  		return 2

  	end

  	local drawTypeData = csvdb["adv_wheelsurfCsv"][ptype]

  	if not drawTypeData then return 3 end

  	local drawData = drawTypeData[role:getAdvWheelSurfLv(ptype)]

  	if not drawData then return 4 end

  	local costs = drawData.cost:toNumMap()

  	for id, count_ in pairs(costs) do

  		costs[id] = count_ * count

  	end
  

  	if not role:checkItemEnough(costs) then return 5 end

  	role:costItems(costs, {log = {desc = "advWheelSurf", int1 = ptype}})

  	role:addAdvLvExp(costs[ItemId.OldCoin] or 0)

  	local advDrawB = role:getProperty("advDrawB")
  	advDrawB[ptype] = (advDrawB[ptype] or 0) + count
  	role:updateProperty({field = "advDrawB", value = advDrawB})

  	-- 随机池子
  	local pool = drawData.weight:randWeight()
  	local reward = {}
  	local backReward = {}
  	for i = 1, count do
  		local gift = drawData["pool" .. pool]:randWeight(true)
  		reward[gift[1]] = (reward[gift[1]] or 0) + gift[2]
  		table.insert(backReward, gift)
  	end

  	role:award(reward, {log = {desc = "advWheelSurf", int1 = ptype}})
  

  	role:checkTaskEnter("AdvDraw", {count = count, ptype = ptype})

  	role:log("adv_action", {desc = "advWheelSurf", int1 = ptype, int2 = count})
  

  	SendPacket(actionCodes.Adv_wheelSurfRpc, MsgPack.pack({reward = backReward}))

  	return true
  end

  function _M.repayWheelSurfRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  
  	local ptype = msg.ptype
  
  	if ptype == 2 and not role:isFuncOpen(FuncOpenType.AdvEndless) then
  		return
  	end
  
  	local drawTypeData = csvdb["adv_wheelsurfCsv"][ptype]
  	if not drawTypeData then return end
  	local drawData = drawTypeData[role:getAdvWheelSurfLv(ptype)]
  	if not drawData then return end
  
  	local advDrawB = role:getProperty("advDrawB")
  	if (advDrawB[ptype] or 0) < globalCsv.adv_draw_back_cond then
  		return
  	end
  	advDrawB[ptype] = advDrawB[ptype] - globalCsv.adv_draw_back_cond
  	role:updateProperty({field = "advDrawB", value = advDrawB})
  	local gift = drawData["pool3"]:randWeight(true)
  	local reward = {[gift[1]] = gift[2]}

  	reward = role:award(reward, {log = {desc = "advRepayWheelSurf", int1 = ptype}})
  	role:log("adv_action", {desc = "advRepayWheelSurf", int1 = ptype})

  
  	SendPacket(actionCodes.Adv_repayWheelSurfRpc, MsgPack.pack({reward = reward}))
  	return true
  end

  function _M.finishAchievRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)

  	local ctype = msg.ctype or 2 -- 领取类型 1 成就  2 pt累计奖励

  	local chapterId = msg.chapterId --章节id
  	local taskId = msg.taskId  -- 领取id
  
  	local adv = role:getAdvData()

  	local status, reward

  	if ctype == 1 then
  		status, reward = adv:finishAchievement(chapterId, taskId)
  	elseif ctype == 2 then

  		status, reward = adv:getAchievementReward(chapterId, taskId)

  	end

  	if not status then return end
  	adv:updateAchievement()

  	role:log("adv_action", {desc = "finishAchiev", short1 = ctype, int1 = chapterId, int2 = taskId})