local _M = {}
  local redisproxy = redisproxy
  function _M.clientRequest(agent, data)
  	local msg = MsgPack.unpack(data)
  	local role = agent.role
  	local action = _M[msg.cmd]
  	local bin = MsgPack.pack({ cmd = "指令失败" })
  	if not action then
  		SendPacket(actionCodes.Gm_receiveResponse, bin)
  		return true
  	end
  	local ret = action(role, msg)
  	bin = MsgPack.pack({ cmd = ret })
  	SendPacket(actionCodes.Gm_receiveResponse, bin)
  	return true
  end
  

  function _M.testhotfix(role, pms)

  	return csvdb["itemCsv"][1]["name"] .. " -=- " .. globalCsv["codeVersion"] .. " -=- " .. role:getItemCount(123) .. " -=- " .. table.pack(next(role.heros))[2]:getBattleValue()

  end

  function _M.ignoreout(role, pms)
  	pms = pms or {}
  	local status = tonum(pms.pm1, 1)

  	if status == 1 then  -- 忽视
  		role:updateProperty({field = "ignoreMt", value = 1})
  	else  -- 解除
  		role:updateProperty({field = "ignoreMt", value = 0})
  	end

  	role:mylog("gm_action", {desc = "ignoreout", key1 = pms.sender})

  	return "指令生效"
  end
  
  function _M.ban(role, pms)
  	local now = skynet.timex()
  	local time = tonum(pms.pm1, 1)
  	local ctype = tonum(pms.pm2, 0)
  

  	role:setBan(time, ctype)

  	role:mylog("gm_action", {desc = "ban", int1 = time, int2 = ctype, key1 = pms.sender})

  	return "封杀成功"

  end
  

  function _M.unban(role, pms)
  	role:setBan(0, 0)

  	role:setProperty("cheatCount", 0) -- 清除作弊次数

  	role:mylog("gm_action", {desc = "unban", key1 = pms.sender})
  

  	return "解封杀成功"
  end
  
  function _M.gmmsg(role, pms)
  	role:sendGmMsg(pms.pm1, true)

  	role:mylog("gm_action", {desc = "gmmsg", text1 = pms.pm1, key1 = pms.sender})

  	return "指令成功"
  end
  

  
  function _M.reset_rank(role, pms)
  	role:resetRank()
  	role:mylog("gm_action", {desc = "reset_rank",  key1 = pms.sender})
  	return "封杀成功"
  end
  

  function _M.silent(role, pms)
  	local pm1 = tonum(pms.pm1)
  	if pm1 < 1 then
  		role:updateProperty({field = "silent", value = 0})
  		return "解禁言成功"
  	end
  	role:updateProperty({field = "silent", value = specTime({hour = 0}, skynet.timex()) + pm1 * 86400})

  
  	role:mylog("gm_action", {desc = "silent", int1 = pms.pm1, key1 = pms.sender})

  	return "禁言成功"
  end
  

  function _M.pvp_cross_head(role, pms)
  	role:awardExpireItem(tonum(pms.expire), pms.reward, {log = {desc = "pvpCHead"}})
  	return "成功"
  end
  

  local helpDes = {{"描述", "指令", "参数1", "参数2"	,"参数3"}}
  
  table.insert(helpDes, {"获得角色"	, "hero", "角色类型"})

  function _M.hero(role, pms)
  	local heroType = tonum(pms.pm1)

  	if not role:addHero({type = heroType, log = {desc = "gm"}}) then

  		return "失败"
  	end

  
  	role:mylog("gm_action", {desc = "hero", int1 = heroType, key1 = pms.sender})

  	return "成功"
  end
  

  table.insert(helpDes, {"角色升级"	, "herol", "角色类型", "增加等级"})
  function _M.herol(role, pms)
  	local heroType = tonum(pms.pm1)
  	local addLevel = tonum(pms.pm2)

  	local hero = role:isHaveHero(heroType)
  
  	local MaxLv = 200
  
  	if not hero then
  		return "不存在的英雄类型"
  	end
  	if hero:getProperty("breakL") >= #csvdb["unit_breakCsv"] and hero:getProperty("level") >= MaxLv then
  		return "等级已满"

  	end

  	local nextLevel = math.min(addLevel + hero:getProperty("level"), MaxLv)

  	for i = 0, #csvdb["unit_breakCsv"] do

  		local upLimit = csvdb["unit_breakCsv"][i].levelLimit
  		local lowLimit = csvdb["unit_breakCsv"][i - 1] and csvdb["unit_breakCsv"][i - 1].levelLimit or 0
  		if upLimit > nextLevel and lowLimit <= nextLevel then
  			local addbl = i - hero:getProperty("breakL")
  			if addbl > 0 then
  				hero:updateProperty({field = "breakL", delta = addbl})
  			end
  		end

  	end

  	addLevel = math.min(hero:getMaxLevel() - hero:getProperty("level"), addLevel)

  	hero:updateProperty({field = "level", delta = addLevel})
  	role:checkTaskEnter("HeroLevelUp", {level = hero:getProperty("level")})

  	role:mylog("gm_action", {desc = "herol", int1 = heroType, int2 = addLevel, key1 = pms.sender})
  

  	return "成功"
  end
  

  
  table.insert(helpDes, {"全部角色升级"	, "herola", "增加等级"})
  function _M.herola(role, pms)
  	local addLevel = tonum(pms.pm1)
  	for _, hero in pairs(role.heros) do
  		_M.herol(role, {pm1 = hero:getProperty("type"), pm2 = addLevel})
  	end

  	role:mylog("gm_action", {desc = "herola", int1 = addLevel, key1 = pms.sender})
  

  	return "成功"
  end
  
  

  table.insert(helpDes, {"获得装备"	, "equip", "装备类型"	, "装备等级", "装备个数"})

  function _M.equip(role, pms)
  	local typ = tonum(pms.pm1)
  	local level = tonum(pms.pm2)
  	local count = tonum(pms.pm3)

  	role:addEquip(typ, level, count, {log = {desc = "gm"}})

  	role:mylog("gm_action", {desc = "equip", int1 = typ, int2 = level, long1 = count, key1 = pms.sender})

  	return "成功"
  end
  

  table.insert(helpDes, {"获得零件"	, "rune", "零件类型", "零件id"})

  function _M.rune(role, pms)
  	local typ = tonum(pms.pm1)
  	local id = tonum(pms.pm2)

  	local result = role:addRune({type = typ,id = id, log = {desc = "gm"}})

  	role:mylog("gm_action", {desc = "rune", int1 = typ, int2 = id, key1 = pms.sender})

  	return result
  end
  

  table.insert(helpDes, {"通关挂机副本", "fb", "挂卡id"})

  function _M.fb(role, pms) -- 直接通关
  	local carbonId = tonum(pms.pm1)
  	if not csvdb["idle_battleCsv"][carbonId] then return "不存在的carbon" end

  	local addPre 
  	addPre = function(carbonId)
  		local carbonData = csvdb["idle_battleCsv"][carbonId]
  		for _, pre in ipairs(carbonData.prepose:toArray(true, "=")) do

  			role:hangFinish(pre)

  			role:checkTaskEnter("HangPass", {id = pre})

  			addPre(pre)
  		end
  	end

  	role:hangFinish(carbonId)

  	addPre(carbonId)

  	role:mylog("gm_action", {desc = "fb", int1 = carbonId, key1 = pms.sender})
  

  	role:checkTaskEnter("HangPass", {id = carbonId})

  	return "成功"
  end
  

  table.insert(helpDes, {"抵达挂机副本", "fbc", "副本id"})

  function _M.fbc(role, pms) -- 直接通关
  	local carbonId = tonum(pms.pm1)
  	if not csvdb["idle_battleCsv"][carbonId] then return "不存在的carbon" end
  	local passCarbon = {}
  	local addPre 
  	addPre = function(carbonId)
  		local carbonData = csvdb["idle_battleCsv"][carbonId]
  		for _, pre in ipairs(carbonData.prepose:toArray(true, "=")) do

  			role:hangFinish(pre)

  			role:checkTaskEnter("HangPass", {id = pre})

  			addPre(pre)
  		end
  	end

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

  	addPre(carbonId)

  	
  	role:mylog("gm_action", {desc = "fbc", int1 = carbonId, key1 = pms.sender})

  	return "成功"
  end
  

  -- table.insert(helpDes, {"好感度", "love", "角色类型", "好感度等级", "好感度经验"})
  -- function _M.love(role, pms)
  -- 	local heroType = tonum(pms.pm1)
  -- 	local level = tonum(pms.pm2)
  -- 	local exp = tonum(pms.pm3)
  -- 	local curPlus = csvdb["unit_love_plusCsv"][heroType]
  -- 	if not curPlus then return "参数错误" end
  -- 	level = math.max(math.min(curPlus.limit, level), 0)
  -- 	local curEffect = csvdb["unit_love_effectCsv"][level]
  -- 	exp = math.max(math.min(curEffect.loveValue, exp) , 0)
  -- 	for _, hero in pairs(role.heros) do
  -- 		if hero:getProperty("type") == heroType then
  -- 			hero:updateProperty({field = "loveL", value = level})
  -- 			hero:updateProperty({field = "loveExp", value = exp})
  -- 			if role:getProperty("loveStatus"):getv(heroType, 0) < level then
  -- 				role:changeUpdates({{type = "loveStatus", field = heroType, value = level}}) -- 总的
  -- 			end
  -- 			role:checkTaskEnter("LoveBreak", {heroType = heroType, loveL = level})
  -- 		end
  -- 	end
  -- 	return "成功"
  -- end

  table.insert(helpDes, {"玩家经验", "exp", "经验"})

  function _M.exp(role, pms)
  	local exp =  tonum(pms.pm1)
  	exp = math.floor(math.max(exp, 0))

  	role:addPlayExp(exp, {log = {desc = "gm"}})
  

  	role:mylog("gm_action", {desc = "exp", int1 = exp, key1 = pms.sender})
  

  	return "成功"
  end
  

  table.insert(helpDes, {"获得物品", "get", "物品ID", "个数"})
  table.insert(helpDes, {"获得所有物品", "get", "ALL"})
  table.insert(helpDes, {"获得所有装备", "get", "EQUIP"})
  table.insert(helpDes, {"获得所有零件", "get", "RUNE"})
  table.insert(helpDes, {"获得所有碎片", "get", "FRAG"})
  table.insert(helpDes, {"获得所有食物", "get", "FOOD"})
  table.insert(helpDes, {"获得所有角色", "get", "HERO"})

  table.insert(helpDes, {"获得满级满觉醒角色,满级满精进铭文", "get", "MAXHERO"})

  function _M.get(role, pms)

  	if pms.pm1 == "ALL" then

  		local reward = {}
  		for id, data in pairs(csvdb["gm_getallCsv"]) do
  			if csvdb["itemCsv"][id] then
  				reward[id] = data.number

  			end
  		end

  		role:award(reward, {log = {desc = "gm"}})

  	elseif pms.pm1 == "EQUIP" then
  		for itemId = 7000 , 8000 do
  			if csvdb["itemCsv"][itemId] then

  				role:award({[itemId] = 100}, {log = {desc = "gm"}})

  			end
  		end

  	elseif pms.pm1 == "RUNE" then

  		for itemId = 10000 , 20000 do

  			if csvdb["itemCsv"][itemId] then

  				role:award({[itemId] = 1}, {log = {desc = "gm"}})

  			end
  		end
  	elseif pms.pm1 == "FRAG" then
  		for itemId = 100 , 400 do
  			if csvdb["itemCsv"][itemId] then

  				role:award({[itemId] = 100}, {log = {desc = "gm"}})

  			end
  		end

  	elseif pms.pm1 == "FOOD" then
  		for itemId = 4000 , 5000 do
  			if csvdb["itemCsv"][itemId] then

  				role:award({[itemId] = 100}, {log = {desc = "gm"}})

  			end
  		end

  	elseif pms.pm1 == "HERO" then
  		for itemId = 400 , 700 do
  			if csvdb["itemCsv"][itemId] then

  				role:award({[itemId] = 1}, {log = {desc = "gm"}})

  			end
  		end

  	elseif pms.pm1 == "MAXHERO" then
  		-- 给英雄
  		for itemId = 400 , 700 do
  			if csvdb["itemCsv"][itemId] then
  				role:award({[itemId] = 1}, {log = {desc = "gm"}})
  			end
  		end
  		-- 升满级
  		for _, hero in ipairs(role.heros) do
  			hero:updateProperty({field = "level", value = 140})
  			hero:updateProperty({field = "wakeL", value = #csvdb["unit_wakeCsv"]})
  		end
  
  		-- 添加铭文
  		for itemId = 10000 , 20000 do
  			if csvdb["itemCsv"][itemId] then
  				role:award({[itemId] = 1}, {log = {desc = "gm"}})
  			end
  		end
  		for _, rune in ipairs(role.runeBag) do
  			local typ = rune:getProperty("type")
  			local id = rune:getProperty("id")
  
  			local runeSet = csvdb["runeCsv"][typ]
  			if not runeSet then break end
  			local runeData = runeSet[id]
  			if not runeData then break end
  
  			rune:updateProperty({field = "level",value = runeData.lvLimit})
  		end

  	else
  		local itemId = tonum(pms.pm1)
  		if not csvdb["itemCsv"][itemId] then
  			return "物品不存在"
  		end

  		local count = tonum(pms.pm2, 1)

  		role:award({[itemId] = count}, {log = {desc = "gm"}})

  		role:mylog("gm_action", {desc = "get", int1 = itemId, int2 = count, key1 = pms.sender})

  	end

  	return "成功"
  end
  

  table.insert(helpDes, {"冒险清除"	, "advc"})

  function _M.advc(role, pms)

  	local advTeam = role:getProperty("advTeam")
  	advTeam.player = nil
  
  	local reward = role:getProperty("advItems"):toNumMap()
  	for itemId, count in pairs(reward) do
  		reward[itemId] = math.ceil(count * globalCsv.adv_fail_reward_ratio / 100) -- 奖励相当于失败
  	end

  	role:award(reward, {log = {desc = "gm"}})

  
  	role:updateProperties({
  		advInfo = {}, 
  		advTeam = advTeam,
  		advItems = "",
  		advAFGet = {},
  		advAFWear = {},
  	}, notNotify)
  	role.advData = nil

  
  	role:mylog("gm_action", {desc = "advc", key1 = pms.sender})
  

  	return "成功"
  end
  

  table.insert(helpDes, {"冒险次数恢复", "advf"})

  function _M.advf(role, pms)

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

  	role.dailyData:updateProperty({field = "advElC", value = 0})

  	role:mylog("gm_action", {desc = "advf", key1 = pms.sender})
  

  	return "成功"
  end
  

  table.insert(helpDes, {"冒险通关", "adv", "章节id", "层数"})

  function _M.adv(role, pms)
  	local chapterId = tonum(pms.pm1)
  	local layer = tonum(pms.pm2)
  

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

  	if not advCsv then return "不存在的章节" end

  	if math.floor(chapterId / 100) ~= 2 then

  		layer = math.min(layer, advCsv.limitlevel)

  	end

  	local advPass = role:getProperty("advPass")

  	if (advPass[chapterId] or 0) < layer then
  		advPass[chapterId] = layer

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

  	role:mylog("gm_action", {desc = "adv", int1 = chapterId, int2 = layer, key1 = pms.sender})

  
  	return "成功"
  end
  

  table.insert(helpDes, {"冒险到达指定层", "advt", "章节id", "层数", "地图id(选)"})

  function _M.advt(role, pms)
  	local chapterId = tonum(pms.pm1)
  	local layer = tonum(pms.pm2)

  	local mapId = tonum(pms.pm3)

  	local advCsv = csvdb["adv_chapterCsv"][chapterId]
  	if not advCsv then return "不存在的章节" end

  	local status = _M.adv(role, {pm1 = chapterId, pm2 = layer - 1})
  	if status ~= "成功" then return status end
  

  	local advData = role:getAdvData()

  	if advData:isRunning() then
  		advData:forceOver()

  	end

  	advData:initByChapter({
  		chapterId = chapterId, 
  		level = layer, 
  		isEnter = true,
  		debugMapId = mapId,
  	})

  	role:mylog("gm_action", {desc = "advt", int1 = chapterId, int2 = layer, key1 = pms.sender})

  	return "成功"
  end
  

  table.insert(helpDes, {"冒险队等级增加", "advl", "经验"})

  function _M.advl(role, pms)

  	local exp = tonum(pms.pm1)
  	role:addAdvLvExp(math.max(0, exp))

  	role:mylog("gm_action", {desc = "advl", int1 = exp, key1 = pms.sender})
  

  	return "成功"
  end
  

  -- table.insert(helpDes, {"冒险内等级增加", "advcl", "经验值"})
  -- function _M.advcl(role, pms)
  -- 	local exp = tonum(pms.pm1)
  -- 	local advData = role:getAdvData()

  -- 	if not advData.chapterId then
  -- 		return "先随便开启一关"
  -- 	end
  -- 	advData.battle.player:addExp(exp)
  -- 	advData:saveDB()
  -- 	role:mylog("gm_action", {desc = "advcl", int1 = exp, key1 = pms.sender})

  -- 	return "成功"
  -- end

  table.insert(helpDes, {"挂机清除"	, "idlec"})

  function _M.idlec(role, pms)

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

  	role:mylog("gm_action", {desc = "idlec", key1 = pms.sender})

  	role.advData = nil
  	return "成功"
  end
  

  table.insert(helpDes, {"冒险内可使用道具", "advit", "ALL"})
  table.insert(helpDes, {"冒险内消耗道具", "advit", "itemId", "count"})

  function _M.advit(role, pms)

  	local reward = {}

  	if pms.pm1 == "ALL" then
  		for k, v in pairs(csvdb["adv_itemCsv"]) do
  			if csvdb["itemCsv"][k] and v.effect ~= 0 then
  				reward[k] = 1
  			end

  		end

  		for k , v in pairs(csvdb["adv_artifactCsv"]) do

  			if v[1].unlock == 0 then

  				reward[k] = 1
  			end
  		end
  	else
  		local itemId = tonum(pms.pm1)
  		local count = tonum(pms.pm2)
  		reward[itemId] = count

  
  		role:mylog("gm_action", {desc = "advit", int1 = itemId, int2 = count, key1 = pms.sender})

  	end

  	local adv = role:getAdvData()

  	adv:award(reward, {log = {desc = "gm"}})

  	return "成功"
  end
  
  

  table.insert(helpDes, {"爬塔到指定层", "tower", "层数"})

  function _M.tower(role, pms)

  	local level = tonum(pms.pm1, 1)

  	if not csvdb["tower_battleCsv"][level] then return  "不存在" end
  	role:updateProperty({field = "towerInfo", value = {c = globalCsv.tower_count_limit, l = level}})

  	role:mylog("gm_action", {desc = "tower", int1 = level, key1 = pms.sender})
  

  	return "成功"
  end
  

  table.insert(helpDes, {"发送邮件", "email", "id", "奖励"})
  function _M.email(role, pms)
  	local id = tonum(pms.pm1, 0)
  	local reward = pms.pm2
  	redisproxy:insertEmail({
  		roleId = role:getProperty("id"), 
  		emailId = id,
  		createtime = skynet.timex(),
  		title = id == 0 and "来自GM的邮件！" or nil, 
  		stitle = id == 0 and "GM测试" or nil, 
  		content = id == 0 and "测试内容测试内容！！！\n\t 巴拉巴拉！" or nil, 
  		attachments = id == 0 and reward or nil,
  		rewardPms = id ~= 0 and reward or nil,
  	})

  	role:mylog("gm_action", {desc = "email", int1 = id, key1 = pms.sender})
  

  	return "成功"
  end

  table.insert(helpDes, {"引导", "guide", "skip/reset"})
  function _M.guide(role, pms)
  	local cmd = pms.pm1 or "un"
  	if cmd == "SKIP" then
  		role:updateProperty({field = "newerGuide", value = "9999=1"})
  		local str = ""
  		for _, set in pairs(csvdb["guide_mainCsv"]) do
  			str = str:setv(set[1].major * 1000,1)
  			for _,data in ipairs(set) do
  				if data["break"] ~= 0 then
  					str = str:setv(data.major * 1000 + data.minor,1)
  				end
  			end
  		end

  		for _, data in pairs(csvdb["guide_unlockCsv"]) do
  			if data.type == 0 or data.type == 3 then
  				str = str:setv(data.id,1)
  			end
  		end

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

  		role:mylog("gm_action", {desc = "sguide", key1 = pms.sender})
  

  	elseif cmd == "RESET" then
  		local id = tonum(pms.pm2, 0)
  		if id == 0 then
  			role:updateProperties({
  				newerGuide = "1=1",
  				funcGuide = "",
  			}, notNotify)
  		elseif id == 1 then
  			role:updateProperty({field = "newerGuide", value = "1=1"})
  		elseif id == 2 then
  			role:updateProperty({field = "funcGuide", value = ""})
  		end

  		role:mylog("gm_action", {desc = "cguide", int1 = id, key1 = pms.sender})
  

  	end

  	return "成功"

  end
  

  table.insert(helpDes, {"挑战关卡次数", "actbattle"})
  function _M.actbattle(role, pms)
  	if not role.activity:isOpen("ChallengeLevel") then return end
  	local actData = role.activity:getActData("ChallengeLevel")
  	actData["ticket"] = 100
  	role.activity:updateActData("ChallengeLevel", actData)
  
  	return "成功"
  end
  

  table.insert(helpDes, {"清空背包", "clearbag"})
  function _M.clearbag(role, pms)
  	-- 装备
  	role:updateProperty({field="equips", value = {}})
  	-- 道具
  	local items = role:getProperty("items"):toNumMap()
  	for k, v in pairs(items) do
  		role:addItem({itemId = k, count = -v, log = {desc = "gm"}})
  	end
  
  	-- 铭文
  	local uids = {}
  	for uid, _ in pairs(role.runeBag) do
  		table.insert(uids, uid)
  	end
  	role:delRunes(uids, {log = {desc = "gm"}})
  
  	return "成功"
  end
  

  function _M.helpRpc(agent, data)
  	SendPacket(actionCodes.Gm_helpRpc, MsgPack.pack({help = helpDes}))
  	return true
  end
  

  function _M.test(role, pms)
  	local id = tonum(pms.pm1, 0)

  	local actid = nil
  	if id > 100 then
  		actid = tonum(pms.pm2, 0)
  	end

  	--local hero = require ("actions.HeroAction")
  	--hero.unlockPoolRpc({role = role}, MsgPack.pack({type = id}))

  	--role:sendMail(13, nil, "1=2", {111})

  	local file = io.open("draw_hero_"..id..".csv", "a")
  	for i=1, 10000 do
  		local heroIds = _M.drawHero(role, id, actid)
  		for k, v in ipairs(heroIds) do
  			print((i - 1)* 10 + k, v)
  			file:write(v.."\n")
  		end
  	end
  	io.close(file)

  	return "成功"
  end
  

  -- 充值回调
  function _M.ayncPurchase(role, params)

  	return role:handlePurchase(params) or ""

  end

  -- 获取订单号
  function _M.getPurchaseOrder(role, params)
  	return role:getPurchaseOrderByPlatform(params) or ""
  end
  
  

  function _M.cz(role, pms)
  	local id = tonum(pms.pm1)
  	local csvData = csvdb["shop_rechargeCsv"][id]
  	if not csvData then
  		return "充值id错误, 查看shop_recharge.csv"
  	end
  	role:recharge({
  		id = id,
  		transactionId = "GM",
  		order = "GM",
  		pay_time = skynet.timex(),
  	})
  	role:mylog("gm_action", {desc = "recharge", int1 = id, key1 = pms.sender})
  	return "指令成功"
  end
  

  function _M.drawHero(role, t, act)
  	local btype = t	-- 1 2 3 4 5	卡池类型  4新手卡池 5心愿卡池
  	local subType = 1-- 定向卡池需要传 子类型
  	local drawType = 2 -- 1 单抽 2 十连
  	if btype ~= 1 then
  		subType = 1
  	end
  
  	local actid = act
  	-- 另开活动卡池
  	if actid then
  		--if not role.activity:isOpenById(actid, "ActHeroPool") then return end
  		local cfg = csvdb["activity_ctrlCsv"][actid]
  		if not cfg then return end
  
  		btype = cfg.condition
  	end
  
  	local buildTypeData = csvdb["build_typeCsv"][btype]
  	if not buildTypeData then return 2 end
  
  	local drawCount = {1, 10} -- 抽取次数
  	if not drawCount[drawType] then return 3 end
  
  	local draw_floor_back_counts = globalCsv.draw_floor_back_counts[btype]
  	local floorHeroCount = role:getProperty("floorHero")[btype] or 0
  
  	-- 抽取的池子
  	local poolMap = buildTypeData["pool"]:toNumMap()
  	local poolId = poolMap[subType]
  	if not poolId then return 5 end
  	
  	--TODO 活动覆盖
  	local actPoolId = role.activity:getActivityPool(btype, subType)
  	if actPoolId ~= 0 then
  		poolId = actPoolId
  	end
  
  	local unitPool = csvdb["build_unitCsv"][poolId]
  	if not unitPool then return 7 end
  
  	-- 开始抽
  	local resultPool = {}
  	local function fillDrawPool(isFloorBack)
  		local condition = {"rare"}
  		local values = {}
  
  
  		for idx, field in ipairs(condition) do
  			if not values[idx] then
  				local lpool = {}
  				local curIdx = 1
  				while unitPool[field .. "_" .. curIdx] do
  					lpool[curIdx] = {unitPool[field .. "_" .. curIdx]}
  					curIdx = curIdx + 1
  				end
  
  				if next(lpool) then
  					values[idx] =  math.randWeight(lpool, 1)
  				end
  			end
  		end
  
  		local weight = 0
  		local up_pool = nil
  		local rand_v = math.randomInt(1, 100)
  		if values[1] == HeroQuality.SR then
  			weight = unitPool["up_sr_weight"]
  			up_pool = unitPool["up_sr_id"]
  		elseif values[1] == HeroQuality.SSR then
  			weight = unitPool["up_ssr_weight"]
  			up_pool = unitPool["up_ssr_id"]
  		end
  		--print(poolId, rand_v, weight, up_pool, values[1])
  		if rand_v < weight and up_pool then
  			up_pool = up_pool:toArray(true, "=")
  			if btype == 5 then -- 爱心卡池，使用玩家设置的备选池子
  				up_pool = role:getProperty("wishPool")
  				up_pool[1] = 606
  				up_pool[2] = 607
  				up_pool[3] = 608
  			end
  			for k, v in ipairs(up_pool) do
  				resultPool[v] = {1}
  			end
  		else
  			for itemId, oneData in pairs(isFloorBack and csvdb["build_floorCsv"] or csvdb["build_poolCsv"]) do
  				local pool_str = "pool_" .. poolId
  				if oneData[pool_str] and oneData[pool_str] ~= "" then
  					local itemData = csvdb["itemCsv"][itemId]
  					while itemData do
  						if itemData.type ~= ItemType.Hero then break end
  						local heroData = csvdb["unitCsv"][itemData.id - ItemStartId.Hero]
  						if not heroData then break end
  						local ok = true
  						-- 保底是全随机，不用比较类型
  						if not isFloorBack then
  							for idx, field in ipairs(condition) do
  								if heroData[field] ~= values[idx] then ok = false break end
  							end
  						end
  						if not ok then break end
  						if oneData[pool_str] > 0 then
  							resultPool[itemId] = {oneData[pool_str]}  -- itemId, count, 概率
  						end
  						break
  					end
  				end
  			end
  		end
  	end
  
  	local guideHero = nil
  	if role:getProperty("newerGuide") == "8=1" then
  		guideHero = globalCsv.newdraw_hero_item_id or 503
  	end
  
  	local ssrCount = 0
  	local reward = {}
  	local logReward = {}
  	local result = {}
  	for i = 1, drawCount[drawType] do
  		floorHeroCount = floorHeroCount + 1
  		local isFloorBack = draw_floor_back_counts and floorHeroCount >= draw_floor_back_counts
  		resultPool = {}
  		fillDrawPool(isFloorBack)
  		if not next(resultPool) then
  			skynet.error("random pool error, poolId:" .. poolId, isFloorBack)
  			return 8
  		end
  
  		local itemId = math.randWeight(resultPool, 1)
  		if guideHero then
  			itemId = guideHero
  		end
  
  		local itemData = csvdb["itemCsv"][itemId]
  		if itemData.quality == HeroQuality.SSR then
  			ssrCount = ssrCount + 1
  			if not guideHero then
  				-- 广播获得ssr英雄
  				local ntf = {heroId = itemData.id - ItemStartId.Hero, nick = role:getProperty("name")}
  				--mcast_util.pub_world(actionCodes.Role_broadGetSSR, MsgPack.pack(ntf))
  			end
  		end
  
  		if btype == 4 and role:getProperty("newerDraw") == 0 then		-- 新手卡池
  			if itemData.quality == HeroQuality.SSR then
  				floorHeroCount = 0
  			end
  		else
  			if itemData.quality >= HeroQuality.SR then
  				floorHeroCount = 0
  			end
  		end
  
  		if role:isHaveHero(itemData.id - ItemStartId.Hero) then
  			local fragId = itemData.id - ItemStartId.Hero
  			local heroData = csvdb["unitCsv"][fragId]
  			local count = globalCsv.draw_unit_tofragment[heroData.rare]
  			role:award({[fragId] = count}, {log = {desc = "drawHero", int1 = btype, int2 = poolId}})
  			logReward[fragId] = (logReward[fragId] or 0) + count
  			table.insert(reward, {id = fragId, count = count, from = itemId, fcount = 1})
  		else
  			role:award({[itemId] = 1}, {log = {desc = "drawHero", int1 = btype, int2 = poolId}})
  			logReward[itemId] = (logReward[itemId] or 0) + 1
  			table.insert(reward, {id = itemId, count = 1})
  		end
  	end
  
  	if draw_floor_back_counts then
  		local floorHero = role:getProperty("floorHero")
  		floorHero[btype] = floorHeroCount
  		role:setProperty("floorHero", floorHero)
  	end
  
  	if btype == 4 then
  		local newCount = role:getProperty("newerDraw")
  		role:updateProperty({field="newerDraw", value = newCount + drawCount[drawType]})
  	end
  
  	--SendPacket(actionCodes.Hero_drawHeroRpc, MsgPack.pack({reward = reward})) -- 这个 reward 是数组
  	for k, v in pairs(reward) do
  		local hero = v
  		if hero["from"] then
  			result[#result+1] = hero["from"]
  		else
  			result[#result+1] = hero["id"]
  		end
  	end
  
  	local feedbackId = buildTypeData["can_feedback"] or 0
  	if feedbackId ~= 0 then
  		-- 达到一定次数，给响应奖励
  		local oldVal = role:getProperty("repayHero") or 0
  		if actid then
  			local actData = role.activity:getActData("ActHeroPool")
  			oldVal = actData[btype] or 0
  		end
  		local newVal = oldVal + drawCount[drawType]
  		local drawCardReward, val = role:getDrawCardExtraReward(feedbackId, oldVal, newVal)
  		-- 空字符穿代表直接给英雄  走以前repayHeroRpc
  		if drawCardReward == "" then
  			local repayHeroMaxCount = role:getProperty("repayMaxC") or 0
  			repayHeroMaxCount = repayHeroMaxCount + 1
  
  			role:updateProperty({field = "repayMaxC", value = repayHeroMaxCount})
  			local even = repayHeroMaxCount % 2
  			local id = 0
  			if even == 1 then
  				id = math.randWeight(csvdb["build_giftCsv"], "pool_"..feedbackId)
  			else
  				local giftHeroSet = {}
  				for gid, cfg in pairs(csvdb["build_giftCsv"]) do
  					if cfg["pool_"..feedbackId] ~= 0 and not role:isHaveHero(gid - ItemStartId.Hero) then
  						giftHeroSet[gid] = {1}
  					end
  				end
  				if next(giftHeroSet) then
  					id = math.randWeight(giftHeroSet, 1)
  				end
  			end
  			if id == 0 then
  				id = math.randWeight(csvdb["build_giftCsv"], "pool_"..feedbackId)
  			end
  
  			local r,change = {}
  			local itemData = csvdb["itemCsv"][id]
  			--if itemData.type == ItemType.Hero and role:isHaveHero(itemData.id - ItemStartId.Hero) then
  			--	local fragId = itemData.id - ItemStartId.Hero
  			--	local heroData = csvdb["unitCsv"][fragId]
  			--	local count = globalCsv.draw_unit_tofragment[heroData.rare]
  			--	r, change = role:award({[fragId] = count}, {log = {desc = "drawHeroExtraReward"}})
  			--	--r = {id = fragId, count = count, from = id, fcount = 1}
  			--else
  			r, change = role:award({[id] = 1}, {log = {desc = "drawHeroExtraReward"}})
  			--end
  			SendPacket(actionCodes.Hero_drawHeroExtraRewardNtf, MsgPack.pack(role:packReward(r, change)))
  		elseif drawCardReward and drawCardReward ~= "" then
  			local r,change = {}
  			r, change = role:award(drawCardReward, {log = {desc = "drawHeroExtraReward", int1 = oldVal, int2 = newVal}})
  			SendPacket(actionCodes.Hero_drawHeroExtraRewardNtf, MsgPack.pack(role:packReward(r, change)))
  		end
  		if not actid then
  			role:updateProperty({field = "repayHero", value = val})
  		else
  			local actData = role.activity:getActData("ActHeroPool")
  			actData[btype] = val
  			role.activity:updateActData("ActHeroPool", actData)
  		end
  	end
  	return result
  end