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 httpc = require("http.httpc")
  
  local WAVE_HERO_NUMS = 150

  local WAVE_RUNE_NUMS = 150

  
  local function validName(name)
  	name = string.upper(name)
  	local exist = redisproxy:exists(string_format("user:%s", name))
  	if exist then return "existed" end
  

  	local SERV = string_format(".named%d", math.random(1, 5))

  	local legal = skynet.call(SERV, "lua", "check", name)
  	return legal and "ok" or "illegal"
  end
  
  -- 随机玩家名
  local function randomRoleName()
  	-- 过滤已经存在的名字
  	local name
  	repeat
  		name = getRandomName()
  	until validName(name) == "ok"
  	return name
  end
  
  local function setRoleName(uid, roleId)
  	local result
  	local name
  	local dbName
  	repeat
  		name = randomRoleName()
  		dbName = string.upper(name)
  		result = redisproxy:setnx(string_format("user:%s", dbName), roleId)
  	until result == 1
  	redisproxy:set(string_format("uid:%s", uid), dbName)
  	return name
  end
  
  local _M = {}
  function _M.loginRpc( agent, data )
  	local msg = MsgPack.unpack(data)
  	local response = {}

  	if msg.codeVersion ~= globalCsv.codeVersion then
  		response.result = "UPDATE_TIP"
  		SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
  		return true
  	end

  
  	-- 1.
  	local roleId = redisproxy:get(string_format("user:%s", string.upper(msg.name)))
  	if not roleId then
  		response.result = "NOT_EXIST"
  		SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
  		return true
  	end
  
  	roleId = tonumber(roleId)
  
  	--维护不能登录
  	local maintain = tonumber(redisproxy:hget("autoincrement_set", "maintain"))
  	if maintain and maintain > 0 then

  		if tonumber(redisproxy:hget(string_format("role:%d", roleId), "ignoreMt")) ~= 1 then

  			response.result = "MAINTAIN_TIP"
  			SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
  			return true
  		end
  	end
  
  	local now = skynet.timex()
  	local role = agent.role
  	-- 2
  	if not role then
  		local roleKey = string_format("role:%d", roleId)
  		if not redisproxy:exists(roleKey) then
  			response.result = "DB_ERROR"
  			SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
  			return true
  		end
  		-- 2a
  		role = require("models.Role").new({key = roleKey})
  		role:load()
  		role:loadAll()

  		role:startActionUcode()

  	else
  		role:reloadWhenLogin()
  	end

  
  	role.sysVersion = msg.sysVersion
  	role.ip = agent.ip:toArray(false, ":")[1]
  	role.clientVersion = msg.clientVersion
  	role.network = msg.network
  
  	if msg.subId then
  		role:setProperty("sid", msg.subId)
  	end
  
  	if msg.deviceMode then
  		local deviceMode = tostring(msg.deviceMode)
  		if role:getProperty("dmode") ~= deviceMode then
  			role:setProperty("dmode", deviceMode)
  		end
  	end
  	if msg.device then
  		local device = tostring(msg.device)
  		if role:getProperty("device") ~= device then
  			role:setProperty("device", device)
  		end
  	end

  	if msg.token then
  		role._pushToken = msg.token
  	end

  	if not msg.isGMlogin then
  		local banTime = role:getProperty("banTime")
  		if banTime > now then
  			response.result = "BAN_TIP"
  			response.banTime = banTime
  			response.banType = role:getProperty("banType")
  			response.roleId = roleId
  			SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
  			return true
  		end
  		if banTime ~= 0 then
  			-- 清除封号状态
  			role:setBan(0)
  		end
  	end

  	if msg.deviceMode then
  		local deviceMode = tostring(msg.deviceMode)

  		if role:getProperty("dmode") ~= deviceMode then
  			role:setProperty("dmode", deviceMode)

  		end
  	end
  	if msg.device then
  		local device = tostring(msg.device)

  		if role:getProperty("device") ~= device then
  			role:setProperty("device", device)

  		end
  	end
  	

  	SERV_OPEN = redisproxy:hget("autoincrement_set", "server_start")

  	role:changeStructVersion() -- 数据结构 版本更新

  	role:advEndlessSeasonCheck(true) -- 冒险赛季更新检查

  	-- 跨天登陆事件

  	local resetMode = role:updateTimeReset(now)

  	if not resetMode or not resetMode["CrossDay"] then -- 没有跨天
  		role.activity:checkActivityStatus(now, false, false)

  		role:log("onLogin")

  	end

  	role:checkTaskEnter("Login", {})

  	redisproxy:zadd(FRIEND_RECOMMEND, now, roleId)

  	for _, name in ipairs({"dailyData", "dinerData", "activity", "storeData"}) do

  		response[name] = role[name]:data()

  		--print("["..name.."]")
  		--dump(response[name])

  	end
  

  	response.role = role:data()
  	response.result = "SUCCESS"
  	response.serverTime = now

  	--response.openTime = getServerOpenTs()

  	local modules = {}
  
  	local heroIds = {}
  	for heroId, _ in pairs(role.heros) do
  		table.insert(heroIds, heroId)
  	end
  	local heroWave = math.ceil(#heroIds / WAVE_HERO_NUMS)

  	if #heroIds <= 50 then

  		heroWave = 0
  		table_insert(modules, "heros")
  	end
  

  	local runeIds = {}
  	for id ,_ in pairs(role.runeBag) do
  		table.insert(runeIds, id)
  	end 
  	local runeWave = math.ceil(#runeIds / WAVE_RUNE_NUMS)
  	if #runeIds <= 50 then
  		runeWave = 0
  		table_insert(modules, "runeBag")
  	end
  

  	for _, name in ipairs(modules) do
  		response[name] = {}
  		for id, unit in pairs(role[name]) do
  			response[name][id] = unit:data()
  		end
  	end
  

  	response.wave = 1 + heroWave + runeWave + 1

  
  	SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(response))
  

  	local curWave = 1 
  
  	local runeIndex = 1
  	for index = curWave + 1, curWave + runeWave do
  		local runeResponse = {runeBag = {}}
  		for i = runeIndex, runeIndex + WAVE_RUNE_NUMS do
  			local runeId = runeIds[i]
  			if not runeId then
  				break
  			end
  			local rune = role.runeBag[runeId]
  			table.insert(runeResponse.runeBag, rune:data())
  			runeIndex = runeIndex + 1
  		end
  		runeResponse.runeWave = index
  		SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(runeResponse))

  	end

  	curWave = curWave + runeWave

  	local heroIndex = 1

  	for index = curWave + 1, curWave + heroWave do

  		local heroResponse = {heros = {}}
  		for i = heroIndex, heroIndex + WAVE_HERO_NUMS do
  			local heroId = heroIds[i]
  			if not heroId then
  				break
  			end
  			local hero = role.heros[heroId]
  			table_insert(heroResponse.heros, hero:data())
  			heroIndex = heroIndex + 1
  		end
  		heroResponse.heroWave = index
  		SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(heroResponse))
  	end

  	curWave = curWave + heroWave

  	-- 注册全服广播

  	if not role._channelIdx then
  		local channel = math.randomInt(1, 1)
  		role._channelIdx = channel
  	end
  	if not mcast_util.channel_world() then
  		local w_channel = datacenter.get( ("MC_W_CHANNEL" .. role._channelIdx) )
  		if w_channel then
  			mcast_util.sub_world(w_channel)
  		end

  	end

  
  	-- 发下缓存的世界消息
  	local worldChatResponse = {worldChats = {}}

  	-- local ok, msgs = pcall(skynet.call, '.globald', "lua", "getWorldMsg", role._channelIdx)
  	local ok, msgs = true, {}

  	if not ok then 
  		msgs = {} 
  	end
  	worldChatResponse.worldChats = msgs

  	local redret = redisproxy:pipelining(function(red)
  		red:lrange(CHAT_OFFLINE:format(roleId), 0, -1)
  		red:del(CHAT_OFFLINE:format(roleId))
  	end)
  	worldChatResponse.p2pChats = redret[1]

  	worldChatResponse.chatWave = curWave + 1
  	curWave = curWave + 1
  
  	SendPacket(actionCodes.Role_loginRpc, MsgPack.pack(worldChatResponse))
  

  	datacenter.set("agent", roleId, {
  		serv = skynet.self(),
  		fd = agent.client_fd,
  		gate_serv = agent.gate_serv,
  	})
  	agent.role = role
  
  	start_agent_timer()

  
  
  	-- 玩家登陆做的一些操作

  	role:updateHangTeamInfo()

  	role:savePvpCTeam()

  	role:savePvpHTeam()

  	local hangPass = role:getProperty("hangPass")

  	role:mylog("login", {key1 = agent.ip:toArray(false, ":")[1], int1 = hangPass[1] or 0})

  	if msg.newdevice then
  		role:mylog("newdevice", {key1 = agent.ip:toArray(false, ":")[1]})
  	end

  	return true
  end
  
  function _M.createRpc(agent, data)
  	local msg = MsgPack.unpack(data)
  	local response = {}
  
  	-- 再次检查uid
  	local uid = tostring(msg.uid)
  	local user = redisproxy:get(string_format("uid:%s", uid))
  	if user then
  		response.result = "SUCCESS"
  		response.roleName = user
  		SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
  		return true
  	end

  	local stopcreate = tonumber(redisproxy:hget("autoincrement_set", "stopcreate"))
  	if stopcreate and stopcreate > 0 then
  		response.result = "STOP_CREATE"
  		SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
  		return true
  	end
  

  
  	local roleId = getNextRoleId()
  	if not roleId then
  		response.result = "DB_FULL"
  		SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
  		return true
  	end
  	local roleName = setRoleName(msg.uid, roleId)

  	local newRole = require("models.Role").new({
  		key = string_format("role:%d", roleId),
  		id = roleId,
  		uid = tostring(msg.uid),

  		sid = msg.subId or 0,

  		name = roleName,
  		uname = msg.uname or "",

  		device = tostring(msg.device),

  		dmode = msg.deviceMode and tostring(msg.deviceMode) or nil

  	})
  
  	if newRole:create() then
  		--更新USER表
  		response.result = "SUCCESS"
  		response.roleId = roleId
  		response.roleName = string.upper(roleName)
  	else
  		response.result = "DB_ERROR"
  		SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))
  		return true
  	end

  	newRole:startActionUcode()

  	newRole.sysVersion = msg.sysVersion
  	newRole.ip = agent.ip:toArray(false, ":")[1]
  	newRole.clientVersion = msg.clientVersion
  	newRole.network = msg.network
  

  	newRole:award(globalCsv.birthItem, {log = {desc = "birth"}, notNotify = true})

  	-- 欢迎邮件

  	redisproxy:insertEmail({roleId = roleId, emailId = 1})

  	if msg.newuser then
  		newRole:log("onCreateAccount")
  	end
  	newRole:log("onCreateRole")

  	newRole:mylog("create", {key1 = agent.ip:toArray(false, ":")[1]})

  	if msg.newdevice then
  		newRole:mylog("newdevice", {key1 = agent.ip:toArray(false, ":")[1]})
  	end

  
  	SendPacket(actionCodes.Role_createRpc, MsgPack.pack(response))

  
  	-- cb付费返利
  	skynet.timeout(0, function()
  		local cbbackd = cluster.query("center", "cbbackd")
  		local uid = newRole:getProperty("uid")
  		local start = uid:find("_")
  		if start then
  			uid = uid:sub(start + 1)
  		end
  		if cbbackd then
  			local status, back = pcall(cluster.call, "center", cbbackd, "getCbBack", {uid = uid, id = roleId})
  			if status then

  				if back and next(back) and back.reward and next(back.reward) then

  					local reward = ""

  					for itemId, count in pairs(back.reward) do

  						reward = reward:setv(itemId, count)
  					end

  					if back.reward[70] then
  						redisproxy:insertEmail({roleId = roleId, emailId = MailId.CBBackAward2, contentPms = {back.money}, createtime = skynet.timex(), attachments = reward})
  					else
  						redisproxy:insertEmail({roleId = roleId, emailId = MailId.CBBackAward, contentPms = {back.money}, createtime = skynet.timex(), attachments = reward})
  					end

  					newRole:mylog("cbback", {key1 = uid, int2 = roleId})
  				end
  			else
  				skynet.error("[ERROR] cbbackd cant call center uid: " .. uid .. " roleId:" .. roleId)
  			end
  		else
  			skynet.error("[ERROR] cbbackd cant call center uid: " .. uid .. " roleId:" .. roleId)
  		end
  	end)
  	

  	return true
  end
  

  function _M.changeNameRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  	local msg = MsgPack.unpack(data)
  
  	local newName = msg.name
  	local oldName = role:getProperty("name")
  
  	if not newName or type(newName) ~= "string" then return end
  	if newName == oldName then return end
  	-- 检查name是否合法
  	local checked = validName(newName)
  	if checked ~= "ok" then
  		--[[
  			"existed" 已经存在
  			"illegal" 包含非法字符
  		]]
  		local errCodes = {
  			["existed"] = 1,
  			["illegal"] = 2
  		}
  		SendPacket(actionCodes.Role_changeNameRpc, MsgPack.pack({result = errCodes[checked]}))
  		return true
  	end
  
  	if not roleId then 
  		SendPacket(actionCodes.Role_changeNameRpc, MsgPack.pack({result = 3}))
  		return true
  	end

  	local dbName = string.upper(newName)
  	local result = redisproxy:setnx(string_format("user:%s", dbName), roleId)

  	if result == 0 then
  		SendPacket(actionCodes.Role_changeNameRpc, MsgPack.pack({result = 1}))
  		return true
  	end
  	redisproxy:pipelining(function (red)

  		red:del(string_format("user:%s", string.upper(oldName)))
  		red:set(string_format("uid:%s", role:getProperty("uid")), dbName)

  	end)
  
  	role:updateProperties({
  		["name"] = newName,
  	})

  
  	role:changeCrossServerPvpSelfInfo("name")

  	SendPacket(actionCodes.Role_changeNameRpc, MsgPack.pack({result = 0}))
  	return true
  end
  

  function _M.getRandomNameRpc()
  	local name = randomRoleName()
  	SendPacket(actionCodes.Role_getRandomNameRpc, MsgPack.pack({name = name}))
  	return true
  end
  

  function _M.changeIntroRpc(agent, data)
  	local role = agent.role
  	local roleId = role:getProperty("id")
  	local msg = MsgPack.unpack(data)
  	local content = msg.content
  	if not content or type(content) ~= "string" then return end
  

  	local SERV = string_format(".chated%d", math.random(1, 5))

  	local legal, mod = skynet.call(SERV, "lua", "check", content)
  	if not legal then
  		content = mod or ""
  	end
  

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

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

  function _M.syncTimeRpc(agent, data)
  	SendPacket(actionCodes.Role_syncTimeRpc, MsgPack.pack({nowTime = skynet.timex()}))
  	return true
  end
  

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

  	local backs = msg.backs
  	if not backs then return end
  
  	local reward = {}

  	local fragCount = 0

  	for itemId, count in pairs(backs) do
  		if math.illegalNum(count, 1, role:getItemCount(itemId)) then return end
  		local itemData = csvdb["itemCsv"][itemId]
  		if itemData.sell_effect == "" then return end

  		if itemData.type == ItemType.HeroFragment or itemData.type == ItemType.HeroFCommon then
  			fragCount = fragCount + count
  		end

  		local sellEffect = itemData.sell_effect:toArray(true, "=")
  		reward[sellEffect[1]] = (reward[sellEffect[1]] or 0) + sellEffect[2] * count

  
  		role:log("carriage_decals", {
  			item_id = itemId, --道具id
  			item_type = itemData.type, --道具类型，具体见枚举表中道具类型枚举表
  			item_level = 0, --道具等级
  			item_number = count, --道具变化数量的绝对值
  			carriage_decals_rwdid = sellEffect[1], --拆解获得物资ID
  			carriage_decals_rwdnum = sellEffect[2] * count, --拆解获得物资数量
  		})

  	end	
  	

  	role:costItems(backs, {log = {desc = "saleItem"}})

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

  	role:checkTaskEnter("DecoFrag", {count = fragCount})

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

  	return true
  end
  
  function _M.openItemRpc(agent, data)
  	local role = agent.role
  	local msg = MsgPack.unpack(data)
  	local itemId = msg.itemId
  	local count = msg.count
  	if math.illegalNum(count, 1, role:getItemCount(itemId)) then return end
  	local itemData = csvdb["itemCsv"][itemId]
  	if itemData.use_type ~= 2 then return end
  	local randomData = csvdb["item_randomCsv"][tonumber(itemData.use_effect)]

  	if not randomData or randomData.openTime > 0 then return end

  	local reward = {}
  	for _i = 1, count do
  		for i = 1, 10 do
  			local num = randomData["num" .. i] 
  			local gift = randomData["gift" .. i]
  			if num and gift and num > 0 and gift ~= "" then
  				local pool = {}
  				for _, temp in ipairs(gift:toArray()) do
  					table.insert(pool, temp:toArray(true, "="))
  				end
  				local needCount = math.min(#pool, num)
  				for j = 1, needCount do
  					local idx = math.randWeight(pool, 3)
  					reward[pool[idx][1]] = (reward[pool[idx][1]] or 0) + pool[idx][2]
  					table.remove(pool, idx)
  				end

  			end
  		end
  	end

  	reward[0] = nil
  

  	role:costItems({[itemId] = count}, {log = {desc = "openItem"}})

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

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

  	return true
  end
  

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

  	local oper = msg.oper  -- 操作 1 - 2

  	local slot = msg.slot  -- 位置 1 - 6

  
  	-- 特权卡时间箱额外栏位

  	-- local privExtraCnt = role.storeData:getTimeBoxSlotExtraCount()
  	-- if oper == 1 then
  	-- 	if math.illegalNum(slot, 1, role:getFuncLv(FuncOpenType.TimeBoxSlot) + privExtraCnt) then return end
  	-- end

  
  	local boxL = role:getProperty("boxL")

  	local reward, change
  	if oper == 1 then -- 构建开始(包括切换构建的id)

  		local itemId = msg.itemId

  		local itemData = csvdb["itemCsv"][itemId]

  		if not itemData then return 1 end
  		if not boxL[slot] then
  			boxL[slot] = {}
  		else
  			local oldId, process, time = boxL[slot].id, boxL[slot].process, boxL[slot].time
  			local unitTime = globalCsv.box_key_time[oldId] * 60

  			local doneCnt = time == 0 and 0 or math.floor((process + skynet.timex() - time) / unitTime)

  			if doneCnt > 0 then

  				reward = role:award({[oldId] = doneCnt}, {log = {desc = "openTimeBox", int1 = slot, int2 = oper}})

  			end
  		end
  		local limit = globalCsv.box_key_max[itemId] or 5
  		if role:getItemCount(itemId) >= limit then return 3 end
  
  		boxL[slot] = {id = itemId, process = 0, time = skynet.timex()}
  		role:pushMsg({type = "box", slot = slot, time = skynet.timex() + globalCsv.box_productLine_time * 3600})
  	elseif oper == 2 then -- 重置运行时间（可以使用加速）

  		local quick = msg.quick

  		if not boxL[slot] then return 4 end
  
  		local itemId, process, time = boxL[slot].id, boxL[slot].process, boxL[slot].time
  		local nowTime = skynet.timex()
  		local stopTime = nowTime
  		local itemData = csvdb["itemCsv"][itemId]
  		local unitTime = globalCsv.box_key_time[itemId] * 60
  		if quick then
  			stopTime = time + globalCsv.box_productLine_time * 3600

  			local cost_pre = globalCsv.box_timeOpen_diamond:toArray(true, "=")

  			local costKey = math.ceil((stopTime - nowTime) / (cost_pre[1] * 60)) * cost_pre[2]
  			if not role:checkItemEnough({[ItemId.Diamond] = costKey}) then return 5 end

  			role:costItems({[ItemId.Diamond] = costKey}, {log = {desc = "openTimeBox", int1 = slot, int2 = oper}})

  		else
  			stopTime = math.min(nowTime,time + globalCsv.box_productLine_time * 3600)

  		end

  		role:pushCancel({type = "box", slot = slot})

  		local doneCnt = math.floor((process + stopTime - time) / unitTime)
  		if doneCnt > 0 then

  			reward = role:award({[itemId] = doneCnt}, {log = {desc = "openTimeBox", int1 = slot, int2 = oper}})

  		end
  		if role:getItemCount(itemId) >= globalCsv.box_key_max[itemId] then
  			nowTime = 0
  		end
  
  		boxL[slot] = {id = itemId, process = (process + stopTime - time) % unitTime, time = nowTime}
  		role:pushMsg({type = "box", slot = slot, time = nowTime + globalCsv.box_productLine_time * 3600})
  	elseif oper == 3 then -- 开箱子
  		local costId = msg.costId
  		local costs = (msg.costs or ""):toNumMap()
  		if not costId or not csvdb["itemCsv"][costId] or not next(costs) then return 6 end
  		
  		local costIdData = csvdb["itemCsv"][costId]
  		local count = 0
  		for itemId, num in pairs(costs) do
  			local itemIdData = csvdb["itemCsv"][itemId]
  			if not itemIdData or not csvdb["item_randomCsv"][itemId] or costIdData.quality ~= itemIdData.quality then return 7 end
  			count = count + num
  		end
  
  		if role:getItemCount(costId) < count then return 8 end

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

  
  		role:costItems({[costId] = count}, {log = {desc = "openTimeBox"}})
  
  		reward = {}
  		for itemId, value in pairs(costs) do
  			local tempReward = {}
  			local randomData = csvdb["item_randomCsv"][itemId]
  			local itemData = csvdb["itemCsv"][itemId]
  			role:costItems({[itemId] = value}, {log = {desc = "openTimeBox"}})
  			for _ = 1, value do
  				for i = 1, 10 do
  					local num = randomData["num" .. i] 
  					local gift = randomData["gift" .. i]
  					if num and gift and num > 0 and gift ~= "" then
  						local pool = {}
  						for _, temp in ipairs(gift:toArray()) do
  							local set = temp:toArray(true, "=")
  							table.insert(pool, set)
  						end
  
  						local needCount = math.min(#pool, num)
  						for j = 1, needCount do
  							local idx = math.randWeight(pool, 3)
  							tempReward[pool[idx][1]] = (tempReward[pool[idx][1]] or 0) + pool[idx][2]
  							table.remove(pool, idx)
  						end
  					end

  				end

  			end

  			tempReward[0] = nil
  			role:checkTaskEnter("OpenBox", {id = itemId, count=value, quality=itemData.quality})
  			role:log("carriage_dismantle", {
  				item_id = itemId, -- 道具id
  				item_type = itemData.type, -- 道具类型，具体见枚举表中道具类型枚举表
  				item_level = 0, -- 道具等级
  				item_number = 1, -- 道具变化数量的绝对值
  				carriage_dismantle_type = 1, -- 拆解方式，时间到期:0，钥匙开启:1
  				carriage_dismantle_time = 0, -- 拆解耗时，填写实际耗时
  				carriage_dismantle_cost = value, -- 拆解花费钥匙数量，未使用填写0
  				carriage_dismantle_rwd = tempReward, -- 拆解获得物资，json格式记录，{'itemid1':2,'itemid2':3,…………..}
  			})
  
  			for id, num in pairs(tempReward) do
  				reward[id] = (reward[id] or 0) + num
  			end

  		end

  		reward, change = role:award(reward, {log = {desc = "openTimeBox", int1 = costId, int2 = oper}})

  	else
  		return
  	end
  

  	role:setProperty("boxL",boxL) --刷新
  	if slot then
  		role:changeUpdates({{type = "boxL", field = slot, value = boxL[slot], isOnlyToC = true}}) -- 通知客户端
  	end

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

  	return true

  end
  

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

  	local itemInfo = msg.itemInfo

  
  	local reward = {}

  	for i = 1, #itemInfo do
  		local pair = itemInfo[i]
  		local id = pair[1]
  		local count = pair[2]
  		local itemData = csvdb["itemCsv"][id]
  		if not itemData or itemData.type ~= ItemType.SpeedBox then return end
  
  		if math.illegalNum(count, 1, role:getItemCount(id)) then return 1 end
  		local useType, hour = table.unpack(itemData.use_effect:toArray(true, "="))
  		local time = hour * 60 * 60
  
  		if useType == 1 then -- 挂机齿轮
  			local hangInfo = role:getProperty("hangInfo")
  			if not hangInfo.expCarbonId then
  				return 2
  			end
  			local carbonData = csvdb["idle_battleCsv"][hangInfo.expCarbonId]
  			reward[ItemId.Gold] = (reward[ItemId.Gold] or 0) + math.floor(time / globalCsv.idle_money_produce_cd) * carbonData.money * count
  		elseif useType == 2 then -- 挂机经验
  			local hangInfo = role:getProperty("hangInfo")
  			if not hangInfo.expCarbonId then
  				return 3
  			end
  			local carbonData = csvdb["idle_battleCsv"][hangInfo.expCarbonId]
  			reward[ItemId.Exp] = (reward[ItemId.Exp] or 0) + math.floor(time / globalCsv.idle_money_produce_cd) * carbonData.exp * count
  		elseif useType == 3 then  -- 食材商人收入
  			local buildType = 6
  			local level = role.dinerData:getProperty("buildL"):getv(buildType, 1)
  			local buildingData = csvdb["diner_buildingCsv"][buildType][level]
  			if not buildingData then
  				return 4
  			end
  			local gfood = role.dinerData:getProperty("gfood")
  			if not next(gfood) then return 5 end
  			for k , v in pairs(gfood) do
  				local itemId = v.id
  				local speed = globalCsv.diner_get_food_speed[csvdb["itemCsv"][itemId].quality] * buildingData.speed / 100

  				reward[itemId] = (reward[itemId] or 0) + math.floor((time / speed) * count)

  			end
  		else
  			return 6

  		end

  
  		role:costItems({[id] = count}, {log = {desc = "speedUpBox"}})

  	end
  

  	local change

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