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 advHang = role:getProperty("advHang")
  	if advHang[chapterId] then return 9 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 not role:advChapterIsOpen(chapterId) then return 13 end

  		if layer ~= 1 then

  			local relayData = role:getAdvData():isHaveRelay(layer, chapterId) 

  			if not relayData then return 14 end  -- 不是中继层
  			if advElM < relayData.unlockfloor then return 15 end --未解锁

  		end 

  	else   -- 普通模式判断

  		if not role:checkAdvCount(chapterData.limitlevel) then return 2 end -- 是否有体力

  		if layer >= chapterData.limitlevel  then return 4 end

  		-- 关卡开放判断

  		if not role:advChapterIsOpen(chapterId) then return 5 end
  
  		if layer ~= 1 then
  			local relayData = role:getAdvData():isHaveRelay(layer, chapterId) 
  			if not relayData then return 6 end  -- 不是中继层
  			if (advPass[chapterId] or 0) < relayData.floor then return 21 end
  		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:changeAdvCount(chapterData.limitlevel)

  	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 = chapterId, 
  		level = layer, 
  		isRelay = layer ~= 1, 
  		isEnter = true, 
  		support = 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 1 end
  	if chapterData.idleReward == "" then return 2 end --没有奖励 没有挂机

  
  	local advHang = role:getProperty("advHang")

  	if advHang[chapterId] then return 3 end --正在挂机

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

  	if AdvCommon.isEndless(chapterId) then return 5 end -- 无尽没有代理

  	local advRelay = role:getProperty("advRelay") 

  	if not next(advRelay[chapterId] or {}) then return 6 end -- 没有开放

  	if not role:checkAdvCount(chapterData.limitlevel) then return 7 end -- 是否有体力

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

  	local player = {}
  	local attrs = role:getTeamBattleInfo(format).heros
  	for attrName, _ in pairs(AdvAttsEnum) do
  		for _, hero in pairs(attrs) do
  			player[attrName] = (player[attrName] or 0) + hero[attrName]
  		end
  		player[attrName] = player[attrName] * (globalCsv.adv_battle_attr_ratio[attrName] or 1)

  	end

  
  	local battleV = 1 * player["hp"]
  		+ 2 * player["atk"]
  		+ 1.25 * player["def"]
  		+ 0.226 * player["hit"]
  		+ 0.26 * player["miss"]
  

  	if battleV < chapterData.idleValue then return 9 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:changeAdvCount(chapterData.limitlevel)

  	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 = "advQuickHang", int1 = chapterId}})

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

  	role:log("adv_action", {desc = "advQuickHang", 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, change

  	if skynet.timex() >= info.time then

  		-- 英雄加成
  		local idleUnit = chapterData.idleUnit:toNumMap()
  		local upUnit = 0

  		for slot, heroId in pairs((info.format or {}).heros or {}) do
  			local hero = role.heros[heroId]
  			if hero then
  				if idleUnit[hero:getProperty("type")] then
  					upUnit = upUnit + idleUnit[hero:getProperty("type")]
  				end

  			end
  		end
  		-- 中继加成
  		local advPass = role:getProperty("advPass")
  		local maxCampsite = nil
  		local campsiteCsv = csvdb["adv_chapter_campsiteCsv"][chapterId]
  		for _, campsite in ipairs(campsiteCsv) do
  			if campsite.floor <= advPass[chapterId] then
  				maxCampsite = campsite

  			else
  				break

  			end
  		end
  
  		if not maxCampsite then return end
  
  		local idleReward = chapterData.idleReward:toNumMap()
  		for itemId, count in pairs(idleReward) do

  			idleReward[itemId] = math.floor(count * (maxCampsite.idleValue + upUnit) / 100)

  		end

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

  	else
  		if cancel then

  			role:changeAdvCount(-chapterData.limitlevel)
  			-- if role:getProperty("advC") <= 0 then 
  			-- 	isFull = true
  			-- else
  			-- 	role:updateProperty({field = "advC", delta = -chapterData.limitlevel})
  			-- 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, change = change, 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:changeAdvCount(-count * globalCsv.adv_daily_buy_num)

  		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, change

  	if taskId == -1 then

  		status, reward, change = 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(role:packReward(reward, change)))

  	return true
  end
  

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

  	local function returnFail(status)
  		SendPacket(actionCodes.Adv_clickBlockRpc, MsgPack.pack({events = {}}))
  		return true or status -- 调试使用 status
  	end
  
  	if not isCanContinue(role) then
  		return returnFail()
  	end

  	local adv = role:getAdvData()

  	if adv:isWaitChooseArtifact() then return returnFail() 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 returnFail(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
  

  	if itemId == 5020 then
  		role:finishGuide(53)
  	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")
  

  	role:finishGuide(61)
  

  	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 1 end

  
  	local adv = role:getAdvData()

  	if not msg.idx then return 2 end
  	if not adv:isWaitChooseArtifact() then return 3 end

  	local status = adv:chooseArtifact(msg.idx)

  	if not status then return 4 end

  	adv:saveDB()

  
  	role:finishGuide(54)

  	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()
  

  	role:finishGuide(55)
  

  	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()

  	else
  		adv:updateAchievement()

  	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

  	if not role:checkOverGuide(57) then
  		role:saveGuide(57,1,true)
  	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
  

  	-- 打完野猪怪
  	role:finishGuide(52)
  	-- 调理剂使用引导(生命药剂)
  	if not role:checkOverGuide(61) then
  		local potionBag = role:getProperty("potionBag")
  		local own = potionBag[10] or 0
  		if own > 0 then
  			-- 造假
  			player.hp = player.hp * 0.8
  			role:saveGuide(61,1,true)
  		end
  	end
  

  	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)