diff --git a/src/actions/CapsuleAction.lua b/src/actions/CapsuleAction.lua
index d43d125..90c1848 100644
--- a/src/actions/CapsuleAction.lua
+++ b/src/actions/CapsuleAction.lua
@@ -96,11 +96,11 @@ function _M.drawRpc(agent, data)
     local full = msg.full -- 0=单次，1=十连抽 2=全收
     local cares = msg.cares
 
-    local ret, reward, change
+    local ret, reward, change, capsule
     if typ == 1 then
-        ret, reward = skynet.call(agent.capsule_serv, "lua", "draw_capsule", roleId, capsuleId, full, cares)
+        ret, reward, capsule = skynet.call(agent.capsule_serv, "lua", "draw_capsule", roleId, capsuleId, full, cares)
     else
-        ret, reward = role:drawCapsule(capsuleId, full, cares)
+        ret, reward, capsule= role:drawCapsule(capsuleId, full, cares)
     end
     if ret < 4 then
         return ret
@@ -110,9 +110,9 @@ function _M.drawRpc(agent, data)
         SendPacket(actionCodes.Capsule_drawRpc, MsgPack.pack(reward))
     end
 
-    reward, change = role:award(reward, {log = {desc = "CapsuleReward", int1 = capsuleId, int2 = roleId}})
+    reward, change = role:award(reward, {log = {desc = "CapsuleReward", int1 = tonumber(capsuleId), int2 = roleId}})
     dump(reward)
-    SendPacket(actionCodes.Capsule_drawRpc, MsgPack.pack(role:packReward(reward, change)))
+    SendPacket(actionCodes.Capsule_drawRpc, MsgPack.pack({reward = reward, change= change, capsule = capsule}))
     return true
 end
 
diff --git a/src/agent.lua b/src/agent.lua
index fdf53b6..23a4571 100644
--- a/src/agent.lua
+++ b/src/agent.lua
@@ -283,6 +283,8 @@ function CMD.close()
 	mcast_util.usub_union()
 	local role = agentInfo.role
 	if not role then return end
+
+	skynet.call(agent.capsule_serv, "lua", "exit", role:getProperty("id"))
 	role:log("onLogout", {logtime = skynet.timex()-role:getProperty("ltime")})
 	role:mylog("logout", {int1 = skynet.timex()-role:getProperty("ltime")})
 	role:onOfflineEvent()
diff --git a/src/models/Capsule.lua b/src/models/Capsule.lua
index 3cc51b4..7c5c1d6 100644
--- a/src/models/Capsule.lua
+++ b/src/models/Capsule.lua
@@ -6,15 +6,18 @@ function Capsule:ctor(properties)
     Capsule.super.ctor(self, properties)
 end
 
-RewardTYpe = {
-    GOODS = 0,
+RewardType = {
+    GOODS = 1,
+    SPECIAL = 2,
+    INCENTIVE = 3,
+}
+
+SpecialType = {
     TOP = 1,
     CORE = 2,
     LAST = 3,
     JOKER = 4,
     KING = 5,
-    GOOD = 6,
-    INCENTIVE = 7,
 }
 
 CapsuleType = {
@@ -22,10 +25,22 @@ CapsuleType = {
     PUBLIC = 1,
 }
 
+--[[
+--通知数据结构
+{
+[roleId] = {
+    [good_id1] = {
+    },
+    [good_id2] = {
+    },
+}
+}
+]]--
+
 Capsule.schema = {
     id = {"number", 0}, --扭蛋机key，配置读取
     room = {"number", 0}, --房间号, 配置读取
-    name = {"string", 0},
+    name = {"string"},
     typ = {"number", 1}, -- 1=共享，2=独享
     coin = {"number", 0}, --货币代号
     register = {"table", {}}, --人数 {["id"]=0}, 0 围观， 1 已报名
@@ -35,8 +50,8 @@ Capsule.schema = {
     goods = {"table", {}}, --奖励池
     specials = {"table", {}}, --特殊赏
     incentive = {"table", {}}, --激励奖
-    specialsFlag= {"table", {}}, --特殊赏是否已经领取
-    resetInfo = {"table", {}},
+    incentiveRecord = {"table", {}}, --激励奖记录
+    specialsRecord= {"table", {}}, --特殊赏领取记录
     resetTimes = {"number", 0}, --每日一次手动重置的机会
     hideTime = {"number", 0} , --隐藏时间
     drawEndTime = {"number", 0}, --抽完时间
@@ -100,8 +115,7 @@ function Capsule:getResetFields()
         goods = {},
         specials = {},
         incentive = {},
-        specialsFlag= {},
-        resetInfo = {},
+        specialsRecord= {},
         resetTimes = 0,
     }
 end
@@ -123,7 +137,7 @@ function Capsule:init()
             end
         end
     end
-    for _, v in ipairs(goods) do
+    for _, v in pairs(goods) do
         v.weight = (v.weight or 0) * v.amount
     end
 
@@ -237,7 +251,7 @@ end
 function Capsule:getGoodsAmount()
     local goods = self:getProperty("goods") or {}
     local amount = 0
-    for _, v in ipairs(goods) do
+    for _, v in pairs(goods) do
         amount = amount + v.amount
     end
     return amount
@@ -253,74 +267,89 @@ function Capsule:getSpecialByType(typ)
     return nil
 end
 
-function Capsule:getTop(record)
-    local specialsFlag = self:getProperty("specialsFlag") or {}
-    if specialsFlag[RewardTYpe.TOP] then return nil end
-
-    local specials = self:getProperty("specials") or {}
-    local spKey, special = self:getSpecialByType(RewardTYpe.TOP)
+function Capsule:checkSpecialFlag(typ)
+    local spKey, special = self:getSpecialByType(typ)
     if not special then return nil end
 
-    local np = special["np"]
-    if #record >= special["np"] then
-        local topRecord = {}
-        local count = np
-        for _, v in ipairs(record) do
-            if count <= 0 then break end
+    if special["amount"] <= 0 then return nil end
+    return spKey, special
+end
 
-            local tmpCount = 0
-            if count >= v.amount then
-                count = count - v.amount
-                tmpCount = v.amount
-            else
-                tmpCount = count
-                count = 0
-            end
+local function getSpecialRoleNotify(rewardRecord, count, award, spKey, typ, now)
+    local rewardByRole = {}
+    while(count > 0 and next(rewardRecord)) do
+        local roleId = math.randWeight(rewardRecord, "amount")
+        if roleId then
+            local tmp = rewardRecord[roleId]
+            tmp["amount"] = tmp["amount"] - 1
+
+            if tmp["amount"] <= 0 then rewardRecord[roleId] = nil end
 
-            if not topRecord[v.role_id]then
-                topRecord[v.role_id]  = {amount = v.amount }
+            tmp = rewardByRole[roleId]
+            if not tmp  then
+                tmp[spKey] = {good_id = spKey, typ = RewardType.SPECIAL, award = award, amount = 1, quality = typ, create_time= now}
             else
-                topRecord[v.role_id] = {amount = (topRecord[v.rol_id]["amount"] or 0) + tmpCount}
+                if not tmp[spKey] then
+                    tmp[spKey] = {good_id = spKey, typ = RewardType.SPECIAL, award = award, amount = 1, quality = typ, create_time= now}
+                else
+                    tmp[spKey].amount = tmp[spKey].amount + 1
+                end
             end
-        end
+            rewardByRole[roleId] = tmp
 
-        count = special["amount"]
-        local topRoleIds = {}
-        while(count > 0 and next(topRecord)) do
-            local roleId = math.randWeight(topRecord, "amount")
-            if roleId then
-                table.insert(topRoleIds, roleId)
-                local tmpTopRecord = topRecord[roleId]
-                tmpTopRecord["amount"] = tmpTopRecord["amount"] - 1
+            count = count - 1
+        end
+    end
+    return rewardByRole, count
+end
 
-                if tmpTopRecord["amount"] <= 0 then topRecord[roleId] = nil end
+function Capsule:getTop(record)
+    local spKey, special = self:checkSpecialFlag(SpecialType.TOP)
+    if not special then return nil end
+    local specials = self:getProperty("specials") or {}
+    local specialsRecord = self:getProperty("specialsRecord") or {}
 
-                count = count - 1
-            end
+    if #record < special["np"] then return  nil end
+    local topRecord = {}
+    local count = special["np"]
+    for _, v in ipairs(record) do
+        if count <= 0 then break end
 
+        local tmpCount = 0
+        if count >= v.amount then
+            count = count - v.amount
+            tmpCount = v.amount
+        else
+            tmpCount = count
+            count = 0
         end
 
-        special["amount"] = count
-        specials[spKey] = special
-        specialsFlag[RewardTYpe.TOP] = topRoleIds
-        self:setProperty("specialsFlag", specialsFlag)
-        self:setProperty("specials", specials)
-        return {role_ids = topRoleIds, award = sspecial["award"]}
+        if not topRecord[v.roleId]then
+            topRecord[v.roleId]  = {amount = v.amount }
+        else
+            topRecord[v.roleId] = {amount = (topRecord[v.roleId]["amount"] or 0) + tmpCount}
+        end
     end
 
-    return nil
+    local rewardByRole, count = getSpecialRoleNotify(topRecord, special["amount"], special["award"], spKey, SpecialType.TOP)
+
+    special["amount"] = count
+    specials[spKey] = special
+    specialsRecord[SpecialType.TOP] = rewardByRole
+    self:setProperties({specialsRecord = specialsRecord, specials = specials})
+    return rewardByRole
+
 end
 
 --TODO
 function Capsule:getCore(record)
-    if self:getGoodsAmount() > 0 then return nil end
-
-    local specialsFlag = self:getProperty("specialsFlag") or {}
-    if specialsFlag[RewardTYpe.CORE] then return nil end
+    local spKey, special = self:checkSpecialFlag(SpecialType.CORE)
+    if not special then return nil end
 
     local specials = self:getProperty("specials") or {}
-    local spKey, special = self:getSpecialByType(RewardTYpe.CORE)
-    if not special then return nil end
+    local specialsRecord = self:getProperty("specialsRecord") or {}
+
+    if self:getGoodsAmount() > 0 then return nil end
 
     local np = special["np"]
     if np > #record then return nil end
@@ -341,54 +370,38 @@ function Capsule:getCore(record)
                 count = 0
             end
 
-            if not roleRecord[v.role_id]then
-                roleRecord[v.role_id]  = {amount = v.amount }
+            if not roleRecord[v.roleId]then
+                roleRecord[v.roleId]  = {amount = v.amount }
             else
-                roleRecord[v.role_id] = {amount = (roleRecord[v.rol_id]["amount"] or 0) + tmpCount}
+                roleRecord[v.roleId] = {amount = (roleRecord[v.rol_id]["amount"] or 0) + tmpCount}
             end
         end
 
     end
 
-    count = special["amount"]
-    local roleIds = {}
-    while(count > 0 and next(roleRecord)) do
-        local roleId = math.randWeight(roleRecord, "amount")
-        if roleId then
-            table.insert(roleIds, roleId)
-            local tmpLastRecord = roleRecord[roleId]
-            tmpLastRecord["amount"] = tmpLastRecord["amount"] - 1
-
-            if tmpLastRecord["amount"] <= 0 then roleRecord[roleId] = nil end
+    local rewardByRole, count = getSpecialRoleNotify(roleRecord, special["amount"], special["award"], SpecialType.CORE)
 
-            count = count - 1
-        end
-    end
     special["amount"] = count
     specials[spKey] = special
-    specialsFlag[RewardTYpe.CORE] = roleIds
-    self:setProperty("specialsFlag", specialsFlag)
-    self:setProperty("specials", specials)
-    return {role_ids = roleIds, award = special["award"]}
+    specialsRecord[SpecialType.CORE] = rewardByRole
+    self:setProperties({specialsRecord = specialsRecord, specials = specials})
+    return rewardByRole
 end
 
 function Capsule:getLast(record)
-    if self:getGoodsAmount() > 0 then return nil end
-
-    local specialsFlag = self:getProperty("specialsFlag") or {}
-    if specialsFlag[RewardTYpe.LAST] then return nil end
+    local spKey, special = self:checkSpecialFlag(SpecialType.LAST)
+    if not special then return nil end
 
     local specials = self:getProperty("specials") or {}
-    local spKey, special = self:getSpecialByType(RewardTYpe.LAST)
-    if not special then return nil end
+    local specialsRecord = self:getProperty("specialsRecord") or {}
 
-    if not next(record)  then return nil end
-    table.sort(record, function(a, b) return a.create_time > b.create_time end)
+    if self:getGoodsAmount() > 0 then return nil end
 
+    table.sort(record, function(a, b) return a.create_time > b.create_time end)
 
     local np = special["np"]
     local count = np
-    local lastRecord = {}
+    local roleRecord = {}
     for _, v in ipairs(record) do
         if count <= 0 then break end
 
@@ -401,174 +414,130 @@ function Capsule:getLast(record)
             count = 0
         end
 
-        if not lastRecord[v.role_id]then
-            lastRecord[v.role_id]  = {amount = v.amount }
+        if not roleRecord[v.roleId]then
+            roleRecord[v.roleId]  = {amount = v.amount }
         else
-            lastRecord[v.role_id] = {amount = (lastRecord[v.rol_id]["amount"] or 0) + tmpCount}
+            roleRecord[v.roleId] = {amount = (roleRecord[v.rol_id]["amount"] or 0) + tmpCount}
         end
     end
 
-    count = special["amount"]
-    local lastRoleIds = {}
-    while(count > 0 and next(lastRecord)) do
-        local roleId = math.randWeight(lastRecord, "amount")
-        if roleId then
-            table.insert(lastRoleIds, roleId)
-            local tmpLastRecord = lastRecord[roleId]
-            tmpLastRecord["amount"] = tmpLastRecord["amount"] - 1
+    local rewardByRole, count = getSpecialRoleNotify(roleRecord, special["amount"], special["award"], SpecialType.LAST)
 
-            if tmpLastRecord["amount"] <= 0 then lastRecord[roleId] = nil end
-
-            count = count - 1
-        end
-    end
     special["amount"] = count
     specials[spKey] = special
-    specialsFlag[RewardTYpe.LAST] = lastRoleIds
-    self:setProperty("specialsFlag", specialsFlag)
-    self:setProperty("specials", specials)
-    return {role_ids = lastRoleIds, award = special["award"]}
+    specialsRecord[SpecialType.LAST] = rewardByRole
+    self:setProperties({specialsRecord = specialsRecord, specials = specials})
+    return rewardByRole
 end
 
 function Capsule:getJoker(record)
-    if self:getGoodsAmount() > 0 then return nil end
-    local specialsFlag = self:getProperty("specialsFlag") or {}
-    if specialsFlag[RewardTYpe.JOKER] then return nil end
+    local spKey, special = self:checkSpecialFlag(SpecialType.JOKER)
+    if not special then return nil end
 
     local specials = self:getProperty("specials") or {}
-    local spKey, special = self:getSpecialByType(RewardTYpe.JOKER)
-    if not special then return nil end
+    local specialsRecord = self:getProperty("specialsRecord") or {}
+
+    if self:getGoodsAmount() > 0 then return nil end
 
     local roleRecord = {}
     for _, v in ipairs(record) do
-        if not roleRecord[v.role_id]then
-            roleRecord[v.role_id]  = {amount = v.amount }
+        if not roleRecord[v.roleId]then
+            roleRecord[v.roleId]  = {amount = v.amount }
         else
-            roleRecord[v.role_id] = {amount = (roleRecord[v.rol_id]["amount"] or 0) + v.amount}
+            roleRecord[v.roleId] = {amount = (roleRecord[v.rol_id]["amount"] or 0) + v.amount}
         end
     end
 
-    local count = special["amount"]
-    local roleIds = {}
-    while(count > 0 and next(roleRecord)) do
-        local roleId = math.randWeight(roleRecord, "amount")
-        if roleId then
-            table.insert(roleIds, roleId)
-            local tmpRoleRecord = roleRecord[roleId]
-            tmpRoleRecord["amount"] = tmpRoleRecord["amount"] - 1
-
-            if tmpRoleRecord["amount"] <= 0 then roleRecord[roleId] = nil end
+    local rewardByRole, count = getSpecialRoleNotify(roleRecord, special["amount"], special["award"], SpecialType.JOKER)
 
-            count = count - 1
-        end
-    end
     special["amount"] = count
     specials[spKey] = special
-    specialsFlag[RewardTYpe.JOKER] = roleIds
-    self:setProperty("specialsFlag", specialsFlag)
-    self:setProperty("specials", specials)
-    return {role_ids = roleIds, award = special["award"]}
+    specialsRecord[SpecialType.JOKER] = rewardByRole
+    self:setProperties({specialsRecord = specialsRecord, specials = specials})
+    return rewardByRole
 end
 
 function Capsule:getKing(record)
-    if self:getGoodsAmount() > 0 then return nil end
-    local specialsFlag = self:getProperty("specialsFlag") or {}
-    if specialsFlag[RewardTYpe.JOKER] then return nil end
+    local spKey, special = self:checkSpecialFlag(SpecialType.KING)
+    if not special then return nil end
 
     local specials = self:getProperty("specials") or {}
-    local spKey, special = self:getSpecialByType(RewardTYpe.KING)
-    if not special then return nil end
+    local specialsRecord = self:getProperty("specialsRecord") or {}
 
+    if self:getGoodsAmount() > 0 then return nil end
 
     local roleRecord = {}
     for _, v in ipairs(record) do
-        if not roleRecord[v.role_id]then
-            roleRecord[v.role_id]  = {amount = v.amount }
+        if not roleRecord[v.roleId]then
+            roleRecord[v.roleId]  = {amount = v.amount }
         else
-            roleRecord[v.role_id] = {amount = (roleRecord[v.rol_id]["amount"] or 0) + v.amount}
+            roleRecord[v.roleId] = {amount = (roleRecord[v.rol_id]["amount"] or 0) + v.amount}
         end
     end
 
-    local count = special["amount"]
-    local roleIds = {}
-    while(count > 0 and next(roleRecord)) do
-        local roleId = math.randWeight(roleRecord, "amount")
-        if roleId then
-            table.insert(roleIds, roleId)
-            local tmpRoleRecord = roleRecord[roleId]
-            tmpRoleRecord["amount"] = tmpRoleRecord["amount"] - 1
+    local rewardByRole, count = getSpecialRoleNotify(roleRecord, special["amount"], special["award"], SpecialType.KING)
+    special["amount"] = count
+    specials[spKey] = special
+    specialsRecord[SpecialType.KING] = rewardByRole
+    self:setProperties({specialsRecord = specialsRecord, specials = specials})
+    return rewardByRole
+end
 
-            if tmpRoleRecord["amount"] <= 0 then roleRecord[roleId] = nil end
+local rewardToNtyFunc = function(notify, tmpReward)
+    for key, val in pairs(tmpReward or {}) do
+        if not notify[key] then
+            notify[key] = val
+        else
+            for k, v in pairs(val) do
+                if not notify[key][k] then
+                    notify[key][k] = v
+                else
+                    notify[key][k] = notify[key][k].amount + v.amount
+                end
+            end
 
-            count = count - 1
         end
     end
-    special["amount"] = count
-    specials[spKey] = special
-    specialsFlag[RewardTYpe.KING] = roleIds
-    self:setProperty("specialsFlag", specialsFlag)
-    self:setProperty("specials", specials)
-    return {role_ids = roleIds, award = special["award"]}
 end
 
-
-function Capsule:checkSpecialReward()
+function Capsule:checkSpecialReward( now)
     local specials = self:getProperty("specials") or {}
     if not next(specials) then return nil end
     local record =  self:getProperty("record") or {}
+
     if not next(record) then return nil end
     table.sort(record, function(a, b) return a.create_time < b.create_time  end )
-    local notify =  {}
 
-    local topReward = self:getTop(record)
-    if topReward then
-        for _, roleId in ipairs(topReward.role_ids) do
-            rpcRole(roleId, "paySpecialReward", RewardTYpe.TOP, topReward.award)
-            table.insert(notify, {role_id = roleId, typ = RewardTYpe.TOP,  award = topReward.award, amount = 1,  create_time= skynet.timex()})
-        end
-    end
+
+    local notify = self:getTop(record) or {}
 
     local coreReward = self:getCore(record)
-    if coreReward then
-        for _, roleId in ipairs(topReward.role_ids) do
-            rpcRole(roleId, "paySpecialReward", RewardTYpe.CORE, coreReward.award)
-            table.insert(notify, {role_id = roleId, typ = RewardTYpe.CORE,  award = topReward.award, amount = 1,  create_time= skynet.timex()})
-        end
-    end
+    rewardToNtyFunc(notify, coreReward)
+
     local lastReward = self:getLast(record)
-    if lastReward then
-        for _, roleId in ipairs(lastReward.role_ids) do
-            rpcRole(roleId, "paySpecialReward", RewardTYpe.LAST, lastReward.award)
-            table.insert(notify, {role_id = roleId, typ = RewardTYpe.LAST,  award = topReward.award, amount = 1,  create_time= skynet.timex()})
-        end
-    end
+    rewardToNtyFunc(notify, lastReward)
+
     local jokerReward = self:getJoker(record)
-    if jokerReward then
-        for _, roleId in ipairs(jokerReward.role_ids) do
-            rpcRole(roleId, "paySpecialReward", RewardTYpe.JOKER, jokerReward.award)
-            table.insert(notify, {role_id = roleId, typ = RewardTYpe.JOKER,  award = topReward.award, amount = 1,  create_time= skynet.timex()})
-        end
-    end
+    rewardToNtyFunc(notify, jokerReward)
+
     local kingReward = self:getKing(record)
-    if kingReward then
-        for _, roleId in ipairs(kingReward.role_ids) do
-            rpcRole(roleId, "paySpecialReward", RewardTYpe.KING, kingReward.award)
-            table.insert(notify, {role_id = roleId, typ = RewardTYpe.KING,  award = topReward.award, amount = 1,  create_time= skynet.timex()})
-        end
-    end
+    rewardToNtyFunc(notify, kingReward)
 
+    --广播出去TODO
+    --rpcRole(roleId, "paySpecialReward", RewardTYpe.JOKER, jokerReward.award)
     return notify
 end
 
-function Capsule:checkIncentive(roleId)
+function Capsule:checkIncentive(roleId, now)
     local goods = self:getProperty("goods") or {}
-    local record = self:getProperty("record") or {}
     local recordByRole = self:getProperty("recordByRole") or {}
     local roleRecord = recordByRole[roleId] or {}
+    local incentiveRecord = self:getProperty("incentiveRecord") or {}
+    local incentiveByRole = incentiveRecord[roleId] or {}
     local incentive = self:getProperty("incentive")
 
 
-    local reward
+    local notify = {}
     -- 最后一抽 TODO
     if incentive["last"] then
         local last = true
@@ -578,7 +547,9 @@ function Capsule:checkIncentive(roleId)
                 break
             end
         end
-        reward = incentive["last"]["award"]
+        if last then
+             notify["last"] = {good_id = "last", typ = RewardType.INCENTIVE, award = incentive["last"]["award"], amount = 1, quality = 1, create_time= now}
+        end
     end
 
     --次数
@@ -592,9 +563,7 @@ function Capsule:checkIncentive(roleId)
 
         local count = math.floor(amount / incentive["amount"]["np"])
         local tmpCount = count * incentive["amount"]["np"]
-        for i=1, count do
-            reward = reward.. " " .. incentive["amount"]["award"]
-        end
+        notify["amount"] = {good_id = "amount", typ = RewardType.INCENTIVE, award = incentive["amount"]["award"], amount = count, quality = 2, create_time= now}
 
         --填充v.calculated 字段，标识已经用于每x抽的计算中。
         for _, v in pairs(roleRecord) do
@@ -618,21 +587,15 @@ function Capsule:checkIncentive(roleId)
     if incentive["probabilities"] then
         local probabilities = math.randomInt(1, 100)
         if probabilities <= incentive["probabilities"]["np"] then
-            reward = reward .. " " .. incentive["probabilities"]["award"]
+            notify["probabilities"] = {good_id = "probabilities", typ = RewardType.INCENTIVE, award = incentive["probabilities"]["award"], amount = 1, quality = 3, create_time= now}
+
         end
     end
-    if reward and reward ~= "" then
-        local tmpReward, notify = {}, {}
-        for k, v in pairs(reward:toNumMap()) do
-            tmpReward[k] = (tmpReward[k] or 0) + v
-        end
+    table.insert(incentiveByRole, notify)
+    incentiveRecord[roleId] = incentiveByRole
+    self:setProperty("incentiveRecord", incentiveRecord)
 
-        notify = {role_id = roleId, typ = RewardTYpe.incentive,  award = reward, amount = 1,  create_time= skynet.timex()}
-        table.insert(record, notify)
-        self:setProperty("record", record)
-        return tmpReward,notify
-    end
-    return nil, nil
+    return notify
 end
 
 function Capsule:drawByCount(roleId, count)
@@ -641,61 +604,74 @@ function Capsule:drawByCount(roleId, count)
     local goods = self:getProperty("goods") or {}
     local record = self:getProperty("record") or {}
     local recordByRole = self:getProperty("recordByRole") or {}
+    local roleRecord = recordByRole[roleId] or {}
 
     local id = self:getProperty("id")
     local room = self:getProperty("room")
     local ichibankuji = csvdb["ichibankuji_mainCsv"][id][room]
     local goods_id = ichibankuji["goods_id"]
+    local now = skynet.timex()
 
     --奖励， 通知信息
-    local reward, notify= {}, {}
+    local  notify= {}
+    notify[roleId] = {}
+
     while (goods and next(goods) and count > 0) do
         local good_id = math.randWeight(goods, "weight")
         if good_id then
             local good = goods[good_id] or {}
-            if good.amount > 0 then
+            if good and good.amount > 0 then
                 good.amount = good.amount - 1
-                for k, v in pairs(good.award:toNumMap()) do
-                    reward[k] = (reward[k] or 0) + v
-                end
 
                 --插入记录
-                local tmpNotify = {role_id = roleId, good_id = good_id, typ = RewardTYpe.GOODS, award = good.award, amount = 1, quality = good.quality, create_time= skynet.timex()}
-
+                local tmpNotify = {good_id = good_id, typ = RewardType.GOODS, award = good.award, amount = 1, quality = good.quality, create_time= now}
                 table.insert(record, tmpNotify)
-                table.insert(notify, tmpNotify)
 
-                --记录角色的抽奖记录
-                local tmp = recordByRole[roleId]
-                if not tmp then
-                    recordByRole[roleId] = {good_id=notify}
+                --作为奖励记录+通知
+                if not notify[roleId][good_id] then
+                    notify[roleId][good_id] = tmpNotify
                 else
-                    if not tmp[good_id] then
-                        tmp[good_id] = notify
-                    else
-                        tmp[good_id].amount = tmp[good_id].amount + 1
-                    end
+                    notify[roleId][good_id].amount = notify[roleId][good_id].amount + 1
                 end
 
-                good.weight = good.weight - csvdb["ichibankuji_goodsCsv"][goods_id].weight
+                --记录角色的抽奖记录 计算激励奖需要用到
+                if not roleRecord[good_id] then
+                    roleRecord[good_id] = tmpNotify
+                else
+                    roleRecord[good_id].amount = roleRecord[good_id].amount + 1
+                end
+
+                good.weight = good.weight - csvdb["ichibankuji_goodsCsv"][goods_id][good.id].weight
                 count = count - 1
             end
         end
 
     end
+    recordByRole[roleId] = roleRecord
+    self:setProperties({recordByRole = recordByRole, record = record, goods = goods})
 
-    self:setProperty("recordByRole", recordByRole)
-    self:setProperty("record", record)
-    self:setProperty("goods", goods)
-    local incentiveReward, tmpNotify = self:checkIncentive(roleId)
-    for k, v in pairs(incentiveReward or {}) do
-        reward[k] = (reward[k] or 0) + v
+    local tmpNotify = self:checkIncentive(roleId, now)
+    for k, v in pairs(tmpNotify) do
+        if not notify[roleId][k] then
+            notify[roleId][k] = v
+        else
+            notify[roleId][k].amount = notify[roleId][k].amount + v.amount
+        end
     end
-    if tmpNotify then table.insert(notify, tmpNotify) end
 
-    local speciNotify = self:checkSpecialReward(roleId)
-    if speciNotify and next(speciNotify) then table.insert(notify, speciNotify) end
+    local speciNotify = self:checkSpecialReward(now)
+    rewardToNtyFunc(notify, speciNotify)
 
+    local reward = {}
+    for key, val in pairs(notify) do
+        if key == roleId then
+            for _, v in pairs(val) do
+                for id, count in pairs(v.award:toNumMap()) do
+                    reward[id] = (reward[id] or 0) + count
+                end
+            end
+        end
+    end
     return reward, notify
 end
 
@@ -703,55 +679,67 @@ function Capsule:drawAll(roleId)
     local goods = self:getProperty("goods") or {}
     local record = self:getProperty("record") or {}
     local recordByRole = self:getProperty("recordByRole") or {}
+    local roleRecord = recordByRole[roleId] or {}
+    local now = skynet.timex()
 
-    local reward, notify = {}, {}
+    local notify = {}
+    notify[roleId] = {}
     for good_id, good in pairs(goods) do
-
         if good.amount > 0 then
-            notify = {role_id = roleId, good_id = good_id, typ = RewardTYpe.GOODS, award = good.award, amount = good.amount, quality = good.quality, create_time = skynet.timex()}
+            --插入记录
+            local tmpNotify = {role_id = roleId, good_id = good_id, typ = RewardType.GOODS, award = good.award, amount = good.amount, quality = good.quality, create_time = now}
             table.insert(record, notify)
 
-            --记录角色的抽奖记录
-            local tmp = recordByRole[roleId]
-            if not tmp then
-                recordByRole[roleId] = {good_id=notify}
+            --作为奖励记录+通知
+            if not notify[roleId][good_id] then
+                notify[roleId][good_id] = tmpNotify
             else
-                if not tmp[good_id] then
-                    tmp[good_id] = notify
-                else
-                    tmp[good_id].amount = tmp[good_id].amount + good.amount
-                end
+                notify[roleId][good_id].amount = notify[roleId][good_id].amount + good.award
             end
-        end
 
-        while(good.amount > 0) do
-            for k, v in pairs(good.award:toNumMap()) do
-                reward[k] = (reward[k] or 0) + v
+            --记录角色的抽奖记录
+            if not roleRecord[good_id] then
+                roleRecord[good_id] = notify
+            else
+                roleRecord[good_id].amount = roleRecord[good_id].amount + good.amount
             end
-            good.amount = good.amount - 1
+
+            good.amount = 0
         end
 
     end
+    recordByRole[roleId] = roleRecord
+    self:setProperties({recordByRole = recordByRole, record = record, goods = goods})
 
-    local incentiveReward, tmpNotify = self:checkIncentive(roleId)
-    for k, v in pairs(incentiveReward or {}) do
-        reward[k] = (reward[k] or 0) + v
+    local tmpNotify = self:checkIncentive(roleId, now)
+    for k, v in pairs(tmpNotify) do
+        if not notify[roleId][k] then
+            notify[roleId][k] = v
+        else
+            notify[roleId][k].amount = notify[roleId][k].amount + v.amount
+        end
     end
-    if tmpNotify then table.insert(notify, tmpNotify) end
 
-    local speciNotify = self:checkSpecialReward(roleId)
-    if speciNotify and next(speciNotify) then table.insert(notify, speciNotify) end
+    local speciNotify = self:checkSpecialReward(now)
+    rewardToNtyFunc(notify, speciNotify)
 
-    self:setProperty("recordByRole", recordByRole)
-    self:setProperty("record", record)
-    self:setProperty("goods", goods)
+    local reward = {}
+    for key, val in pairs(notify) do
+        if key == roleId then
+            for _, v in pairs(val) do
+                for id, count in pairs(v.award:toNumMap()) do
+                    reward[id] = (reward[id] or 0) + count
+                end
+            end
+        end
+    end
     return reward, notify
 end
 
 --@param
 --[[
 @roleId
-@typ 1=全收 0=单次
+@typ 0=独享，1=公开
 @cares 关注{k=v}
 ]]--
 
@@ -793,7 +781,7 @@ function Capsule:data(roleId)
         goods = self:getProperty("goods"),
         specials = self:getProperty("specials"),
         incentive = self:getProperty("incentive"),
-        specialsFlag= self:getProperty("specialsFlag"),
+        specialsRecord= self:getProperty("specialsRecord"),
     }
 end
 
diff --git a/src/services/capsuled.lua b/src/services/capsuled.lua
index f7a56d3..e1395fc 100644
--- a/src/services/capsuled.lua
+++ b/src/services/capsuled.lua
@@ -3,7 +3,7 @@ require "shared.init"
 require "GlobalVar"
 require "RedisKeys"
 require "skynet.manager"
-local skynet = require "skynet"
+skynet = require "skynet"
 csvdb = require "shared.csvdata"
 redisproxy = require "shared.redisproxy"
 datacenter = require "skynet.datacenter"
@@ -56,7 +56,6 @@ end
 
 
 local function add(roleId, capsuleId)
-    print(type(capsuleId))
     local capsule = capsules[capsuleId] or {}
     if next(capsule) then
         capsule:join(roleId)
@@ -86,7 +85,7 @@ function CMD.start()
     local now = skynet.timex()
     local res = redisproxy:smembers(CAPSULE_INFO) or {}
     for _, key in pairs(res) do
-        local capsule = require("models.Capsule").new({ key = CAPSULE_PUBLIC:format(tonumber(key))})
+        local capsule = require("models.Capsule").new({ key = CAPSULE_PUBLIC:format(key)})
         capsule:load()
         if capsule:isShow() then
             if capsule:refreshing(now) then
@@ -95,7 +94,7 @@ function CMD.start()
             end
             capsules[key] = capsule
         else
-            redisproxy:del(CAPSULE_PUBLIC:format(tonumber(key)))
+            redisproxy:del(CAPSULE_PUBLIC:format(key))
             redisproxy:srem(CAPSULE_INFO, key)
         end
     end
@@ -103,9 +102,9 @@ function CMD.start()
     for _, data in pairs(csvdb["ichibankuji_mainCsv"]) do
         for _, val in ipairs(data) do
             if val.type == 1 then
-                local key = string.format("%d%d", val.id, val.room)
+                local key = val.id..val.room
                 if not capsules[key] then
-                    local capsule = require("models.Capsule").new({ key = CAPSULE_PUBLIC:format(tonumber(key)), id= val.id, room = val.room, typ = 1, name=val.name})
+                    local capsule = require("models.Capsule").new({ key = CAPSULE_PUBLIC:format(key), id= val.id, room = val.room, typ = 1, name=val.name})
                     capsule:init()
                     capsule:create()
                     capsules[key] = capsule
@@ -138,10 +137,19 @@ end
 
 
 function CMD.exit(roleId, capsuleId)
-    local capsule = capsules[capsuleId] or {}
-    if next(capsule) then
-        capsule:exit(roleId)
-        broadCastCapsule(roleId, capsuleId, {changeType = NotifyChangeType.EXIT, roleId = roleId})
+    if capsuleId then
+        local capsule = capsules[capsuleId] or {}
+        if next(capsule) then
+            capsule:exit(roleId)
+            broadCastCapsule(roleId, capsuleId, {changeType = NotifyChangeType.EXIT, roleId = roleId})
+        end
+    else
+        for _, capsule in pairs(capsules) do
+            if next(capsule) then
+                capsule:exit(roleId)
+                broadCastCapsule(roleId, capsuleId, {changeType = NotifyChangeType.EXIT, roleId = roleId})
+            end
+        end
     end
 end
 
@@ -152,7 +160,7 @@ function CMD.draw_capsule(roleId, capsuleId, full, cares)
         --if ret > 4 then
         --    broadCastCapsule(roleId, capsuleId, {changeType = NotifyChangeType.DRAW, roleId = roleId, notify = notify})
         --end
-        return ret, reward
+        return ret, reward, capsule:data(roleId)
     end
     return nil
 end
--
libgit2 0.21.2