local ipairs = ipairs
  local table = table
  local math = math
  local string = string
  local redisproxy = redisproxy
  local MsgPack = MsgPack
  local string_format = string.format
  local tonumber = tonumber
  local table_insert = table.insert
  local table_unpack = table.unpack
  local table_find = table.find
  local table_nums = table.nums
  local math_random = math.randomInt
  
  
  local _M = {}
  
  
  function _M.sudokuRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local id = msg.id
  
  	local sudoku = role:getProperty("sudoku")
  	local phase = sudoku[-1] or 1
  	local curData = (csvdb["guide_sudokuCsv"][phase] or {})[id]
  	if phase == -1 or not curData then return 1 end
  
  	sudoku.task = sudoku.task or {}
  	sudoku.task[phase] = sudoku.task[phase] or {}
  
  	if (sudoku.task[phase][id] or 0) < curData.con1 then return 2 end
  
  	sudoku.task[phase][id] = -1

  	local task, tchange = role:award(curData.reward, {log = {desc = "sudoku", int1 = id, int2 = phase}}) -- 任务奖励

  	local reward, rchange = {}

  	local rId = {}
  	for pid, pdata in pairs(csvdb["guide_sudoku_rewardCsv"][phase] or {}) do
  		local pos = pdata.pos:toArray(true, "=")
  		local ok, is = true, false
  		for _, one in pairs(pos) do
  			if one == id then
  				is = true
  			end
  			if sudoku.task[phase][one] ~= -1 then
  				ok = false
  				break
  			end
  		end
  
  		if ok and is then
  			for itemId, count in pairs(pdata.reward:toNumMap()) do
  				reward[itemId] = (reward[itemId] or 0) + count
  			end
  			table.insert(rId, pid)
  		end
  	end
  
  	if not next(reward) then
  		reward = nil
  	else

  		reward, rchange = role:award(reward, {log = {desc = "sudokuR", int1 = id, int2 = phase}})

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

  	role:log("activity", {
  		activity_id = id, -- 活动ID（或活动指定任务的ID）
  		activity_type = 0, -- 活动类型，见活动类型枚举表

  		activity_reward = reward or {}, -- 活动奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}

  	})

  	role:mylog("act_action", {desc = "sudoku", int1 = id, int2 = phase})

  	SendPacket(actionCodes.Activity_sudokuRpc, MsgPack.pack({task = role:packReward(task, tchange), reward = role:packReward(reward, rchange), rId = rId}))

  	return true
  end
  
  function _M.sudokuRewardRpc(agent, data)
  	local role = agent.role
  
  
  	local sudoku = role:getProperty("sudoku")
  	local phase = sudoku[-1] or 1
  
  	local curData = csvdb["guide_sudokuCsv"][phase]
  	if not curData then return end
  	if not globalCsv.guide_sudoku_reward[phase] then return end
  
  	local curTask = (sudoku.task or {})[phase] or {}
  
  	for id, _ in pairs(curData) do
  		if curTask[id] ~= -1 then
  			return
  		end
  	end
  

  	local reward, change = role:award(globalCsv.guide_sudoku_reward[phase], {log = {desc = "sudokuRP", int1 = phase}})

  
  	sudoku[-1] = phase + 1
  	sudoku.task[phase] = nil
  	if not csvdb["guide_sudokuCsv"][sudoku[-1]] then
  		sudoku[-1] = -1
  		sudoku.task = nil
  	end
  	role:updateProperty({field = "sudoku", value = sudoku})
  

  	role:log("activity", {
  		activity_id = 10000 + phase, -- 活动ID（或活动指定任务的ID）
  		activity_type = 0, -- 活动类型，见活动类型枚举表

  		activity_reward = reward, -- 活动奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}

  	})
  

  	SendPacket(actionCodes.Activity_sudokuRewardRpc, MsgPack.pack(role:packReward(reward, change)))

  	return true
  end
  
  
  function _M.signRpc(agent, data)
  	local role = agent.role
  

  	local serverT = skynet.timex() - RESET_TIME * 3600

  	local tm = os.date("*t", serverT)
  
  	local curDay = tm.day
  	
  	local yearMonth = tm.year * 100 + tm.month
  	local monthData = csvdb["daily_signInCsv"][yearMonth]
  	if not monthData or not monthData[curDay] then
  		return 1
  	end
  
  	local signs = role:getProperty("sign")
  	if signs[curDay] == yearMonth then  -- 未重置的还可以签到正常（本月已经签到）
  		return 2
  	end
  	signs[curDay] = yearMonth

      -- 记录玩家签到天数
      role.activity:incrProperty("signInDay", 1)

  	-- 达到一定等级，签到会有额外奖励
  	local reward = role:getBnousDaily()
  	local change
  	local award = monthData[curDay].item:toNumMap() or {}
  	for k, v in pairs(award) do
  		reward[k] = (reward[k] or 0) + v
  	end
  	reward, change = role:award(reward, {log = {desc = "sign", int1 = yearMonth, int2 = curDay}})

  	role:changeUpdates({{type = "sign", field = curDay, value = yearMonth}})

  	role:checkTaskEnter("SignIn")

  	if monthData[curDay].daily_sign_email ~= "" then
  		local emails = monthData[curDay].daily_sign_email:toArray(true,"=")
  		for _, emailId in pairs(emails) do

  			--redisproxy:insertEmail({roleId = role:getProperty("id"), emailId = emailId})
  			role:sendMail(emailId)

  		end
  	end
  

  	SendPacket(actionCodes.Activity_signRpc, MsgPack.pack(role:packReward(reward, change)))

  	return true
  end
  
  

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

  	if not role.activity:isOpen("Sign") then return 1 end

  
  	local curData = role.activity:getActData("Sign")

  	local reward, change = {}

  	for day, csvData in ipairs(csvdb["new_signInCsv"]) do

  		if day <= (curData[0] or 0) then
  			if not curData[day] then
  				curData[day] = -1
  				-- 奖励
  				for itemId, count in pairs(csvData.reward:toNumMap()) do
  					reward[itemId] = (reward[itemId] or 0) + count
  				end
  			end
  		else
  			break
  		end
  	end
  	if next(reward) then

  		role.activity:updateActData("Sign", curData)

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

  	end

  
  	role:log("activity", {
  		activity_id = curData[0], -- 活动ID（或活动指定任务的ID）
  		activity_type = role.activity.ActivityType.Sign, -- 活动类型，见活动类型枚举表

  		activity_reward = reward, -- 活动奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}

  	})
  

  	SendPacket(actionCodes.Activity_actSignRpc, MsgPack.pack(role:packReward(reward, change)))

  	return true
  end
  

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

  	local dayIndex = msg.day

  	local actGoodsFlag = role.storeData:getProperty("actGoodsFlag")
  	local index = GetActGoodsIndex("paySignIn")

  	local ts = actGoodsFlag[index] or 0
  	if ts == 0 then return 1 end

  	local open, actId = role.activity:isOpen("PaySignIn")
  	if not open then return 2 end

  	--local diffDay = diffFromTs(ts) + 1

  
  	local curData = role.activity:getActData("PaySignIn")

  	if not curData then return 3 end

  	local reward, change = {}
  	for day, csvData in ipairs(csvdb["pay_signInCsv"]) do

  		if day <= (curData[0] or 0) and day == dayIndex then

  			if not curData[day] then
  				curData[day] = 1
  				-- 奖励
  				for itemId, count in pairs(csvData.reward:toNumMap()) do
  					reward[itemId] = (reward[itemId] or 0) + count
  				end
  			end

  		--else
  		--	break

  		end
  	end
  	if next(reward) then
  		role.activity:updateActData("PaySignIn", curData)
  		reward, change = role:award(reward, {log = {desc = "actPaySign"}})
  	end
  
  	role:log("activity", {

  		activity_id = actId, -- 活动ID（或活动指定任务的ID）

  		activity_type = role.activity.ActivityType.PaySignIn, -- 活动类型，见活动类型枚举表
  		activity_reward = reward, -- 活动奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}
  	})
  
  	SendPacket(actionCodes.Activity_actPaySignRpc, MsgPack.pack(role:packReward(reward, change)))
  	return true
  end

  function _M.actCalendaTaskRpc(agent, data)

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

  	local calTask = role:getProperty("calTask") or {}

  	local record = calTask["r"] or {}
  	local flag = record[taskId] or 0
  	if flag == 1 then return 1 end
  	local open, actId = role.activity:isOpen("CalendaTask")
  	local actData = csvdb["activity_ctrlCsv"][actId]
  	if not open then return 2 end
  	if not actData then return 3 end
  

  	local taskList = csvdb["activity_taskCsv"][actData.condition]
  	if not taskList then return 4 end
  	local taskCfg = taskList[taskId]
  	if not taskCfg then return 5 end
  	if taskCfg.key ~= actData.condition then return 6 end

  	if (calTask[taskId] or 0) < taskCfg.condition1 then return 7 end

  
  	record[taskId] = 1
  	calTask["r"] = record
  

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

  	local reward, change = role:award(taskCfg.reward, {log = {desc = "calendaTask"}})

  
  	role:log("activity", {
  		activity_id = taskId, -- 活动ID（或活动指定任务的ID）
  		activity_type = role.activity.ActivityType.CalendaTask, -- 活动类型，见活动类型枚举表
  		activity_reward = reward, -- 活动奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}
  	})
  

  	role:checkTaskEnter("FinishSpeTask", {taskId = taskId, actId = actId})
  

  	SendPacket(actionCodes.Activity_actCalendaTaskRpc, MsgPack.pack(role:packReward(reward, change)))

  	return true

  end
  

  function _M.actBattleCommandTaskRpc(agent, data)

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

  	local calTask = role:getProperty("bcTask") or {}

  	local record = calTask["r"] or {}
  	local flag = record[taskId] or 0
  	if flag == 1 then return 1 end

  	local open, actId = role.activity:isOpen("BattleCommandTask")

  	local actData = csvdb["activity_ctrlCsv"][actId]
  	if not open then return 2 end
  	if not actData then return 3 end
  
  	local taskList = csvdb["activity_taskCsv"][actData.condition]
  	if not taskList then return 4 end
  	local taskCfg = taskList[taskId]
  	if not taskCfg then return 5 end
  	if taskCfg.key ~= actData.condition then return 6 end
  
  	if (calTask[taskId] or 0) < taskCfg.condition1 then return 7 end
  

  	local open, actId = role.activity:isOpen("BattleCommand")
  	local actData = csvdb["activity_ctrlCsv"][actId]
  	if not open then return 2 end
  	if not actData then return 3 end
  
  

  	record[taskId] = 1
  	calTask["r"] = record
  

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

  	local reward, change = role:award(taskCfg.reward, {log = {desc = "battleCommandTask"}})

  
  	role:log("activity", {
  		activity_id = taskId, -- 活动ID（或活动指定任务的ID）

  		activity_type = role.activity.ActivityType.BattleCommandTask, -- 活动类型，见活动类型枚举表

  		activity_reward = reward, -- 活动奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}
  	})

  	role:mylog("act_action", {desc="bcTask", int1=taskId, int2=taskCfg.resetType})

  
  	role:checkTaskEnter("FinishSpeTask", {taskId = taskId, actId = actId})
  

  	SendPacket(actionCodes.Activity_actBattleCommandTaskRpc, MsgPack.pack(role:packReward(reward, change)))

  
  	return true
  end
  

  function _M.actNewUserTaskRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local taskId = msg.id
  	local calTask = role:getProperty("nbTask") or {}
  	local record = calTask["r"] or {}
  	local flag = record[taskId] or 0
  	if flag == 1 then return 1 end
  	local open, actId = role.activity:isOpen("NewUserTask")
  	local actData = csvdb["activity_ctrlCsv"][actId]
  	if not open then return 2 end
  	if not actData then return 3 end
  
  	local taskList = csvdb["activity_taskCsv"][actData.condition]
  	if not taskList then return 4 end
  	local taskCfg = taskList[taskId]
  	if not taskCfg then return 5 end
  	if taskCfg.key ~= actData.condition then return 6 end
  
  	if (calTask[taskId] or 0) < taskCfg.condition1 then return 7 end
  
  	record[taskId] = 1
  	calTask["r"] = record
  
  	role:updateProperty({field = "nbTask", value = calTask})
  
  	local reward, change = role:award(taskCfg.reward, {log = {desc = "newUserTask"}})
  
  	role:log("activity", {
  		activity_id = taskId, -- 活动ID（或活动指定任务的ID）
  		activity_type = role.activity.ActivityType.NewUserTask, -- 活动类型，见活动类型枚举表
  		activity_reward = reward, -- 活动奖励，json格式记录,{'itemid1':123,'itemid2':456,………...}
  	})
  
  	role:checkTaskEnter("FinishSpeTask", {taskId = taskId, actId = actId})
  
  	SendPacket(actionCodes.Activity_actNewUserTaskRpc, MsgPack.pack(role:packReward(reward, change)))
  
  	return true
  end
  

  function _M.exchangeRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local actid = msg.actid
  	local id = msg.id

  	local count = msg.count
  	if not role.activity:isOpenById(actid, "Exchange") then return 1 end

  
  	local exchangeCfg = csvdb["activity_exchangeCsv"][actid]
  	if not exchangeCfg then return 2 end
  	if not exchangeCfg[id] then return 3 end
  	local curData = role.activity:getActData("Exchange") or {}
  	local exchangeData = curData[actid] or {}
  	local curCount = exchangeData[id] or 0
  	local actCfg = exchangeCfg[id]

  	local limitArr = actCfg.limit:toArray(true, "=")

  	if curCount + count > limitArr[2] then return 4 end

  
  	local costs = actCfg.goods:toNumMap()

  	for k,v in pairs(costs) do
  		costs[k] = v * count
  	end

  	if not role:checkItemEnough(costs) then return 5 end
  	role:costItems(costs, {log = {desc = "actExchange", int1 = actid, int2 = id}})
  

  	curCount = curCount + count

  	exchangeData[id] = curCount
  	curData[actid] = exchangeData
  	role.activity:updateActData("Exchange", curData)
  

  	local award = actCfg.award:toNumMap()
  	for k,v in pairs(award) do
  		award[k] = v * count
  	end
  
  	local reward, change = role:award(award, {log = {desc = "actExchange", int1 = actid, int2 = id}})

  
  
  	SendPacket(actionCodes.Activity_exchangeRpc, MsgPack.pack(role:packReward(reward, change)))
  	return true
  end
  

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

  	local count = msg.count
  
  	if count > 10 then return end
  

  	if not role.activity:isOpenById(actid, "Gachakon") then return 1 end

  	local actCtrlData = csvdb["activity_ctrlCsv"][actid]
  	if not actCtrlData then return 2 end
  	local cost = actCtrlData.condition2:toNumMap()
  

  	local actCfg = csvdb["activity_capsuleToysCsv"][actid]

  	if not actCfg then return 3 end
  

  	local gachakonInfo = role.activity:getActData("Gachakon") or {}

  	local award = {}
  	local remain = 0

  	local showAward = {}

  	for i = 1, count do

  		local tmpCfg = clone(actCfg)
  		remain = 0

  		for id, cfg in pairs(tmpCfg) do
  			local num = gachakonInfo[id] or 0

  			num = cfg.amount >= num and cfg.amount - num or 0
  			cfg.weight = cfg.weight * num

  			if cfg.weight > 0 then

  				remain = remain + num

  			end

  			--print("num ".. num, id, cfg.weight, cfg.amount)

  		end

  		if remain == 0 then

  			break
  		end
  		local id = math.randWeight(tmpCfg, "weight")

  		if not id then return 4 end

  		gachakonInfo[id] = (gachakonInfo[id] or 0) + 1
  		local curAward = tmpCfg[id].award:toNumMap()

  		table.insert(showAward, curAward)

  		for k, v in pairs(curAward) do
  			award[k] = (award[k] or 0) + v

  		end

  	end

  	for k, v in pairs(cost) do
  		cost[k] = v * count
  	end
  
  	if not role:checkItemEnough(cost) then return 5 end

  
  	role:costItems(cost, {log = {desc = "actGachakon", int1 = actid, int2 = count}})

  	local reward, change = role:award(award, {log = {desc = "actGachakon", int1 = actid, int2 = count}})

  	--print("-----------", remain, count)
  	if remain <= 1 then

  		gachakonInfo = {}

  	end

  	role.activity:updateActData("Gachakon", gachakonInfo)
  

  	SendPacket(actionCodes.Activity_gachakonRpc, MsgPack.pack(showAward))

  	return true
  end
  

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

  	if not role.activity:isOpenById(actid, "HangDrop") then return 1 end

  	local actCtrlData = csvdb["activity_ctrlCsv"][actid]
  	if not actCtrlData then return end

  
  	local actCfg = csvdb["activity_putCsv"][actid]
  	if not actCfg then return 2 end
  
  	local award, period = "", 0
  	for i = 1, #actCfg do
  		local cfg = actCfg[i]
  		if not cfg then
  			break
  		end
  		if cfg.condition ~= "" then
  			local arr = cfg.condition:toArray(true, "=")
  			local type = arr[1]
  			if type == 1 then
  				local actId = arr[2]
  				local carbonId = arr[3]

  				if not role.activity:isOpenById(actId, "ChallengeLevel") then return 3 end

  				local clInfo = role.activity:getActData("ChallengeLevel") or {}
  				if not clInfo[carbonId] then
  					break
  				end
  			end
  		end
  		award = cfg.reward
  		period = cfg.period * 60
  	end
  	local actData = role.activity:getActData("HangDrop") or 0
  	local timeNow = skynet.timex()
  	if period == 0 or award == "" then
  		return 4
  	end
  	local num = math.floor((timeNow - actData)/ period)

  	num = num > actCtrlData.condition and actCtrlData.condition or num

  	if num == 0 then
  		return 5
  	end
  	local reward, change = {}, nil
  	for id, value in pairs(award:toNumMap()) do
  		reward[id] = value * num
  	end
  
  	reward, change  = role:award(reward, {log = {desc = "actHangDrop", int1 = actid, int2 = num}})
  

  	if num < 8 then
  		actData = actData + num * period
  	else
  		actData = timeNow
  	end
  
  	role.activity:updateActData("HangDrop", actData)

  
  	SendPacket(actionCodes.Activity_hangDropRpc, MsgPack.pack(role:packReward(reward, change)))
  
  	return true
  end
  

  local function getStarCount(cfg, data)
  	local count = 0
  	for i = 0, #(cfg.sweep_condition:toTableArray(true)) do
  		if (1 << i & data) > 0 then
  			count = count + 1
  		end
  	end
  
  	return count
  end
  
  function _M.startBattleRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local actid = msg.actid
  	local id = msg.id
  	local count = msg.count

  	if not role.activity:isOpenById(actid, "ChallengeLevel") then return 1 end

  
  	local actCfg = csvdb["activity_battleCsv"][actid]
  	if not actCfg then return 2 end
  
  	local battleCfg = actCfg[id]
  	if not battleCfg then return 3 end
  
  	local actData = role.activity:getActData("ChallengeLevel") or {}
  
  	local preArr = battleCfg.prepose:toArray(true, "=")
  	for _, v in ipairs(preArr) do
  		local battleInfo = actData[v]
  		if not battleInfo then
  			return 4
  		end
  		local star = battleInfo["star"] or 0
  		if star <= 0 then
  			return 4
  		end
  	end
  	-- check cost
  	local changeFlag = false
  	local ticket = actData["ticket"]

  	local num = 0	-- cost num

  	if battleCfg.type ~= "" then

  		role.activity:getBattleTicket(actid)

  		num = battleCfg.type:toArray(true, "=")[3]

  		if count and count > 0 then

  			if battleCfg.rank ~= 0 then
                  local bi = actData[id]
                  if not bi then return 8 end
                  local star = bi["star"] or 0
                  local maxP = bi["maxP"] or 0
                  -- 世界boss
                  if battleCfg.worldBoss_award ~= 0 then
                      if maxP < 1 then
                          return 9
                      end
                  else
                      if star < 1 then
                          return 9
                      end
                  end

  			end

              num = num * count

          else
              num = 0

  		end
  		if ticket < num then
  			return 6
  		end

  		changeFlag = true
  	end

  	-- 解锁活动剧情
  	role:checkStoryStatus(false, 5, id)

  
  	if not count then
  		role.__actBattleCache = {
  			key = tostring(math.random()),
  			actid = actid,
  			id = id,

  			format = msg.format,

  		}
  		SendPacket(actionCodes.Activity_startBattleRpc, MsgPack.pack({key = role.__actBattleCache.key}))
  	else
  		if count <= 0 then
  			return
  		end

  		local bi = actData[id]

  		local star = bi["star"] or 0

  		local award = battleCfg.item_clear:toNumMap()

  
  		if battleCfg.rank ~= 0 then
              if getStarCount(battleCfg, star) == 3 then
                  local aw = battleCfg.perfect_reward:toNumMap()
                  for k, v in pairs(aw) do
                      award[k] = (award[k] or 0) + v
                  end
              end
          end

  		for k, v in pairs(award) do
  			award[k] = v * count
  		end
  		local reward, change  = role:award(award, {log = {desc = "actBattle", int1 = actid, int2 = count or 0}})

          changeFlag = true
          actData["ticket"] = ticket - num

  		if battleCfg.rank ~= 0 then
              if battleCfg.worldBoss_award ~= 0 and (bi["maxP"] or 0) > 0 then
                  bi["bossP"] = (bi["bossP"] or 0) + bi["maxP"] * count
              end
  
              bi["sum"] = bi["sum"] + bi["top"] * count
              actData[id] = bi
  
              local rankVal = 0
              if battleCfg.rank == 1 then
                  rankVal = bi["sum"]
              elseif battleCfg.rank == 2 then
                  rankVal = bi["top"]
              end
              role:updateRankCommon(RANK_TYPE.ActBattleBoss, rankVal)

  		end

          role.activity:updateActData("ChallengeLevel", actData)

  		SendPacket(actionCodes.Activity_startBattleRpc, MsgPack.pack(role:packReward(reward, change)))
  
          return true

  	end

  	--if changeFlag then
  	--	role.activity:updateActData("ChallengeLevel", actData)
  	--end

  
  	return true
  end
  
  function _M.endBattleRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local actid = msg.actid
  	local id = msg.id
  	local key = msg.key
  	local isWin = msg.isWin
  	local heros = msg.heros
  	local support = msg.support

  	if not role.activity:isOpenById(actid, "ChallengeLevel") then
  		SendPacket(actionCodes.Activity_endBattleRpc, MsgPack.pack({}))
  		return true
  	end

  
  	if not role.__actBattleCache then return 2 end
  	
  	if role.__actBattleCache.id ~= id or role.__actBattleCache.key ~= key and role.__actBattleCache.actid ~= actid then 
  		SendPacket(actionCodes.Activity_endBattleRpc, MsgPack.pack({errorCode = 1}))
  	end
  

  	-- 防作弊
  	if not role:checkBattleCheat("act_battle", {
  		id = id,
  		isWin = isWin,
  		info = msg.info,
  		format = role.__actBattleCache.format
  	}) then

  		SendPacket(actionCodes.Activity_endBattleRpc, MsgPack.pack({errorCode = 1}))

  		return true
  	end
  	role.__actBattleCache = nil
  

  	local actCfg = csvdb["activity_battleCsv"][actid]
  	if not actCfg then return 3 end
  
  	local battleCfg = actCfg[id]
  	if not battleCfg then return 4 end
  
  	local actData = role.activity:getActData("ChallengeLevel") or {}
  

  	-- 总输出
  	local dmg = 0
  	for k, v in pairs(msg.info.damage) do
  		if k % 100 == 2 then
  			dmg = dmg + v
  		end
  	end
  

  	local reward, change = {}, nil
  
  	local battleInfo = actData[id] or {}
  	local curStar = 0
   	if isWin then
   		local herosInfo = msg.heros
  
   		local check = {}
   		-- 1 通关
  		check[1] = function(_)
  			return true
  		end
  		-- 2 阵亡人数 <= N
  		check[2] = function(_, cond)
  			return msg.info.dead and msg.info.dead <= cond
  		end
  		-- 3 全员存活
  		check[3] = function(_)
  			return msg.info.dead and msg.info.dead == 0
  		end
  		-- 4 指定种族 >= N
  		check[4] = function(_, cond)
  			local count = 0
  			for _, one in pairs(herosInfo) do
  				local heroData = csvdb["unitCsv"][one.type]
  				if heroData.camp == cond then
  					count = count + 1
  				end
  			end
  			return count >= cond
  		end
  		-- 5 指定职业 >= N
  		check[5] = function(_, cond)
  			local count = 0
  			for _, one in pairs(herosInfo) do
  				local heroData = csvdb["unitCsv"][one.type]
  				if heroData.job == cond then
  					count = count + 1
  				end
  			end
  			return count >= cond
  		end
  		-- 6 含有指定角色 
  		check[6] = function(_, cond)
  			for _, one in pairs(herosInfo) do
  				if one.type == cond then
  					return true
  				end
  			end
  			return false
  		end
  		-- 7 通关耗时 <= X 秒  msg.info.atime
  		check[7] = function(_, cond)
  			return msg.info.atime and msg.info.atime <= cond
  		end