You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1053 lines
30 KiB
Lua
1053 lines
30 KiB
Lua
local skynet = require "skynet"
|
|
local mysql = require "skynet.db.mysql"
|
|
local cjson = require "cjson"
|
|
local datacenter = require "skynet.datacenter"
|
|
local mqhelper = require "mqhelper"
|
|
local redis = require "skynet.db.redis"
|
|
local mongo = require "skynet.db.mongo"
|
|
local settings = require "settings"
|
|
local utils = require "utils"
|
|
local lordlogic = require "lordlogic"
|
|
local herologic = require "herologic"
|
|
local equipmentlogic= require "equipmentlogic"
|
|
local clublogic = require "clublogic"
|
|
local artifactlogic = require "artifactlogic"
|
|
local dateutils = require "dateutils"
|
|
local keysutils = require "keysutils"
|
|
local yanguanconf = require "yanguanconf"
|
|
local mongohelper = require "mongohelper"
|
|
local skynet_node_name = ...
|
|
|
|
require "functions"
|
|
require "skynet.manager"
|
|
|
|
math.randomseed(tostring(os.time()):reverse():sub(1, 6))
|
|
|
|
local CMD = {}
|
|
local db
|
|
local rediscli
|
|
|
|
local users = {}
|
|
local heros = {}
|
|
local artifacts = {}
|
|
local bags = {}
|
|
local saltpots = {}
|
|
|
|
local allranks = {}
|
|
local userrank = {}
|
|
|
|
local function getServer(uid)
|
|
local user = users[uid]
|
|
local serverid = user.serverid
|
|
return utils.getserver(serverid)
|
|
end
|
|
|
|
local function loadalluser()
|
|
local page = 1
|
|
while true do
|
|
local s = (page - 1) * 100
|
|
local ret = db[settings.user_mongodb_key.cname]:find():sort({ uid = 1 }):skip(s):limit(100)
|
|
if not ret:hasNext() then
|
|
break
|
|
end
|
|
while ret:hasNext() do
|
|
local u = ret:next()
|
|
users[u.uid] = u
|
|
end
|
|
page = page + 1
|
|
end
|
|
end
|
|
|
|
local function loadallhero()
|
|
local page = 1
|
|
while true do
|
|
local s = (page - 1) * 50
|
|
local ret = db[settings.hero_mongodb_key.cname]:find():sort({ uid = 1 }):skip(s):limit(50)
|
|
if not ret:hasNext() then
|
|
break
|
|
end
|
|
while ret:hasNext() do
|
|
local r = ret:next()
|
|
heros[r.uid] = heros[r.uid] or {}
|
|
table.insert(heros[r.uid], r)
|
|
end
|
|
page = page + 1
|
|
end
|
|
end
|
|
|
|
--加载所有鱼灵
|
|
local function loadallartifact()
|
|
local page = 1
|
|
while true do
|
|
local s = (page - 1) * 100
|
|
local ret = db[settings.artifact_mongodb_key.cname]:find():sort({ uid = 1 }):skip(s):limit(100)
|
|
if not ret:hasNext() then
|
|
break
|
|
end
|
|
while ret:hasNext() do
|
|
local art = ret:next()
|
|
art._id = nil
|
|
-- DEBUG("loadallartifact art = ", cjson.encode(art))
|
|
artifacts[art.uid] = artifacts[art.uid] or {}
|
|
table.insert(artifacts[art.uid], art)
|
|
end
|
|
page = page + 1
|
|
end
|
|
end
|
|
|
|
|
|
local function loadallbag()
|
|
local page = 1
|
|
while true do
|
|
local s = (page - 1) * 100
|
|
local ret = db[settings.bag_mongodb_key.cname]:find():sort({ uid = 1 }):skip(s):limit(100)
|
|
if not ret:hasNext() then
|
|
break
|
|
end
|
|
while ret:hasNext() do
|
|
local u = ret:next()
|
|
bags[u.uid] = u
|
|
end
|
|
page = page + 1
|
|
end
|
|
end
|
|
|
|
local pattern = "(%d+)-(%d+)-(%d+) (%d+):(%d+):(%d+)"
|
|
|
|
function CMD.login(uid)
|
|
local u = users[uid]
|
|
if not u then
|
|
local ret = db[settings.user_mongodb_key.cname]:findOne({ uid = uid })
|
|
assert(ret ~= nil, "loaduser from mongo fail uid = "..uid)
|
|
u = ret
|
|
users[ret.uid] = ret
|
|
end
|
|
|
|
local frist_login = false
|
|
if not u.last_login_time or u.last_login_time == "" then
|
|
u.login_day = u.login_day or 0
|
|
u.login_day = u.login_day + 1
|
|
frist_login = true
|
|
else
|
|
local t1 = dateutils.cal_daynum_by_datetime(u.last_login_time, pattern)
|
|
local t2 = dateutils.cal_daynum_by_datetime(dateutils.get_datetime(), pattern)
|
|
if t1 ~= t2 then
|
|
u.login_day = u.login_day or 0
|
|
u.login_day = u.login_day + 1
|
|
frist_login = true
|
|
end
|
|
end
|
|
|
|
u.online_status = 1
|
|
u.last_login_time = dateutils.get_datetime()
|
|
|
|
local account_status = 0
|
|
if u.account_status and u.account_status == 1 then
|
|
if u.freeze_date and u.freeze_date ~= "" then
|
|
if os.time() < dateutils.get_timestamp_by_datetime(u.freeze_date, pattern) then
|
|
account_status = 1
|
|
end
|
|
end
|
|
end
|
|
|
|
local ok = mqhelper.exec("upsert", uid, settings.user_mongodb_key.tname, settings.user_mongodb_key.cname, {["$set"]=u}, {uid=uid})
|
|
return account_status, frist_login
|
|
end
|
|
|
|
|
|
function CMD.loaduser(uid)
|
|
local u = users[uid]
|
|
if not u then
|
|
local ret = db[settings.user_mongodb_key.cname]:findOne({ uid = uid })
|
|
assert(ret ~= nil, "loaduser from mongo fail uid = "..uid)
|
|
u = ret
|
|
users[ret.uid] = ret
|
|
end
|
|
return u
|
|
end
|
|
|
|
function CMD.get_account_status(uid)
|
|
local u = users[uid]
|
|
if not u then
|
|
return 0
|
|
end
|
|
local account_status = 0
|
|
if u.account_status and u.account_status == 1 then
|
|
if u.freeze_date and u.freeze_date ~= "" then
|
|
if os.time() < dateutils.get_timestamp_by_datetime(u.freeze_date, pattern) then
|
|
account_status = 1
|
|
end
|
|
end
|
|
end
|
|
return account_status
|
|
end
|
|
|
|
function CMD.saveuser(uid, param)
|
|
local u = users[uid]
|
|
assert(u ~= nil, "user not found uid = "..uid)
|
|
for k,v in pairs(param) do
|
|
u[k] = v
|
|
end
|
|
return "ok"
|
|
end
|
|
|
|
|
|
function CMD.loadbag(uid)
|
|
local bag = bags[uid]
|
|
if not bag then
|
|
local ret = db[settings.bag_mongodb_key.cname]:findOne({ uid = uid })
|
|
if ret then
|
|
bags[ret.uid] = ret
|
|
bag = ret
|
|
end
|
|
end
|
|
return bag
|
|
end
|
|
|
|
--获取鱼灵
|
|
function CMD.loadartifact(uid)
|
|
local temps = artifacts[uid]
|
|
if not temps then
|
|
local ret = db[settings.artifact_mongodb_key.cname]:find({ uid = uid })
|
|
local rets = {}
|
|
while ret:hasNext() do
|
|
local art = ret:next()
|
|
art._id = nil
|
|
|
|
table.insert(rets, art)
|
|
end
|
|
artifacts[uid] = rets
|
|
temps = rets
|
|
end
|
|
return temps
|
|
end
|
|
|
|
function CMD.saveartifact(uid, param)
|
|
local arts = artifacts[uid]
|
|
DEBUG("saveartifact arts = ", cjson.encode(arts))
|
|
local artid = param.artid
|
|
local found = false
|
|
for i,v in ipairs(arts) do
|
|
if v.artid == artid and v.star == param.star then
|
|
found = true
|
|
for k1, v1 in pairs(v) do
|
|
if param[k1] then
|
|
v[k1] = param[k1]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if not found then
|
|
table.insert(arts, param)
|
|
end
|
|
return "ok"
|
|
end
|
|
|
|
function CMD.savebag(uid, param)
|
|
local b = bags[uid]
|
|
for k,v in pairs(param) do
|
|
b[k] = v
|
|
end
|
|
return "ok"
|
|
end
|
|
|
|
|
|
function CMD.loadhero(uid)
|
|
local temps = heros[uid]
|
|
if not temps then
|
|
local ret = db[settings.hero_mongodb_key.cname]:find({ uid = uid })
|
|
local rets = {}
|
|
while ret:hasNext() do
|
|
table.insert(rets, ret:next())
|
|
end
|
|
heros[uid] = rets
|
|
temps = rets
|
|
end
|
|
return temps
|
|
end
|
|
|
|
|
|
function CMD.loaduserlineup(uid)
|
|
local lineup = {}
|
|
lineup.lord = CMD.getuserinfo(uid)
|
|
local t = heros[uid]
|
|
local temps = {}
|
|
for i, v in ipairs(t) do
|
|
if checkint(v.pos) > 0 then
|
|
table.insert(temps, v)
|
|
end
|
|
end
|
|
lineup.heros = temps
|
|
return lineup
|
|
end
|
|
|
|
|
|
function CMD.savehero(uid, param)
|
|
local tmps = heros[uid]
|
|
local id = param.id
|
|
local found = false
|
|
for i,v in ipairs(tmps) do
|
|
if v.id == id then
|
|
found = true
|
|
for k1,v1 in pairs(v) do
|
|
if param[k1] then
|
|
v[k1] = param[k1]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if not found then
|
|
table.insert(tmps, param)
|
|
end
|
|
return "ok"
|
|
end
|
|
|
|
local function loadsaltpot()
|
|
local page = 1
|
|
while true do
|
|
local s = (page - 1) * 100
|
|
local ret = db[settings.saltpot_mongodb_key.cname]:find():sort({ uid = 1 }):skip(s):limit(100)
|
|
if not ret:hasNext() then
|
|
break
|
|
end
|
|
while ret:hasNext() do
|
|
local v = ret:next()
|
|
saltpots[v.uid] = v
|
|
end
|
|
page = page + 1
|
|
end
|
|
end
|
|
|
|
|
|
function CMD.getuserbyid(userid)
|
|
local user = users[userid]
|
|
if not user then
|
|
return nil
|
|
end
|
|
local u = {}
|
|
u.uid = users[userid].uid
|
|
u.avatar = user.avatar
|
|
u.nickname = user.nickname
|
|
u.serverid = user.serverid
|
|
u.max_level = user.max_level
|
|
u.zhanli = CMD.getuserzhanli(userid)
|
|
--TODO:获取俱乐部/勋章墙
|
|
u.lineup = CMD.getlineup(userid)
|
|
return u
|
|
end
|
|
|
|
|
|
function CMD.getmyusers(unionid)
|
|
local myusers = {}
|
|
for i, mu in pairs(users) do
|
|
if mu.unionid == unionid then
|
|
local u = {}
|
|
u.avatar = mu.avatar
|
|
u.nickname = mu.nickname
|
|
u.serverid = mu.serverid
|
|
u.max_level = mu.max_level
|
|
u.default = mu.default
|
|
u.zhanli = CMD.getuserzhanli(checkint(mu.uid))
|
|
table.insert(myusers, u)
|
|
end
|
|
end
|
|
|
|
return myusers
|
|
end
|
|
|
|
local function getequipmentatk(eqps)
|
|
local atk = 0
|
|
for k,v in pairs(eqps) do
|
|
atk = atk + equipmentlogic.getatk(k, v.lv)
|
|
end
|
|
return atk
|
|
end
|
|
|
|
|
|
local function getequipmenthp(eqps)
|
|
local atk = 0
|
|
for k,v in pairs(eqps) do
|
|
atk = atk + equipmentlogic.gethp(k, v.lv)
|
|
end
|
|
return atk
|
|
end
|
|
|
|
local function getequipmentdef(eqps)
|
|
local atk = 0
|
|
for k,v in pairs(eqps) do
|
|
atk = atk + equipmentlogic.getdef(k, v.lv)
|
|
end
|
|
return atk
|
|
end
|
|
|
|
local function getequipmentspeed(eqps)
|
|
local atk = 0
|
|
for k,v in pairs(eqps) do
|
|
atk = atk + equipmentlogic.getspeed(k, v.lv)
|
|
end
|
|
return atk
|
|
end
|
|
|
|
local function calsetattr(hero)
|
|
local eqps = hero.equipment
|
|
local sets = {}
|
|
for k,v in pairs(eqps) do
|
|
local color = equipmentlogic.getcolor(v.lv)
|
|
sets[color] = sets[color] or 0
|
|
sets[color] = sets[color] + 1
|
|
end
|
|
local ext = 0
|
|
for k,v in pairs(sets) do
|
|
local attrs = equipmentlogic.getsetattr(k, v)
|
|
for i,v in ipairs(attrs) do
|
|
ext = ext + v.hp_ratio
|
|
end
|
|
end
|
|
return ext
|
|
end
|
|
|
|
local function getartid(artid, star)
|
|
return math.floor(artid * 1000 + star)
|
|
end
|
|
|
|
local function gethaloattrs(uid)
|
|
local temps = {}
|
|
local myheros = heros[uid] or {}
|
|
for k,v in pairs(myheros) do
|
|
-- DEBUG("gethaloattrs v = ", cjson.encode(v))
|
|
local cfg = herologic.getconf(v.heroid)
|
|
if v.pos > 0 and cfg.color == 3 then
|
|
local club = cfg.club
|
|
temps[club] = temps[club] or 0
|
|
temps[club] = temps[club] + 1
|
|
end
|
|
end
|
|
local function found(temps)
|
|
for k,v in pairs(temps) do
|
|
if v >= 3 then
|
|
return k, v
|
|
end
|
|
end
|
|
end
|
|
local club, num = found(temps)
|
|
if club and num then
|
|
local attrs = herologic.gethaloattrs(club, num)
|
|
return attrs
|
|
end
|
|
end
|
|
|
|
local function gethaloext(tp, uid)
|
|
local attrs = gethaloattrs(uid)
|
|
local ext = 0
|
|
if attrs ~= nil then
|
|
for _, attr in ipairs(attrs) do
|
|
local n = attr[tp] or 0
|
|
ext = ext + n
|
|
end
|
|
end
|
|
return ext
|
|
end
|
|
|
|
|
|
|
|
local function getatk(hero)
|
|
-- DEBUG("getatk hero = ", cjson.encode(hero))
|
|
local born_atk = herologic.getbornatk(hero.heroid)
|
|
local lord_atk = lordlogic.getatk(users[hero.uid].lv)
|
|
local shuijing_atk = 0
|
|
local eqp_atk = getequipmentatk(hero.equipment)
|
|
local yuling_atk = 0
|
|
if hero.yuling then
|
|
yuling_atk = artifactlogic.getattrabs("atk", getartid(hero.yuling.artid, hero.yuling.star))
|
|
end
|
|
local lvup_atk = herologic.getlvupext("atk", hero.heroid) * (hero.lv-1)
|
|
local lord_ext = lordlogic.getlordorderext("atk_ratio", users[hero.uid].stage)
|
|
local shuijing_ext = 0
|
|
local yuling_ext = 0
|
|
local yuling_limit_ext = 0
|
|
if hero.yuling then
|
|
yuling_ext = artifactlogic.getattrabs("atk_ratio", getartid(hero.yuling.artid, hero.yuling.star))
|
|
yuling_limit_ext = artifactlogic.getlimitattrext("atk_ratio", hero.heroid, getartid(hero.yuling.artid, hero.yuling.star))
|
|
end
|
|
local stageup_ext = herologic.getstageupattrext("atk_ratio", hero.stage)
|
|
local starup_ext = herologic.getstarupattrext("atk_ratio", hero.star)
|
|
local club_ext = clublogic.getclubresearchattrnum(hero.work, 0, "atk_ratio", {0,0,0,0,0,0,0,0})
|
|
local skill_ext = herologic.getskillext("atk_ratio", hero.heroid, hero.stage, hero.skill or {})
|
|
local halo_ext = gethaloext("atk_ratio", hero.uid)
|
|
return utils.round((born_atk + lord_atk + shuijing_atk + eqp_atk + yuling_atk + lvup_atk) * (1 + lord_ext) * (1 + shuijing_ext) * (1 + yuling_ext) * (1 + yuling_limit_ext) * (1 + stageup_ext) * (1 + starup_ext) * (1 + club_ext) * (1 + skill_ext) * (1 + halo_ext))
|
|
end
|
|
|
|
|
|
local function gethp(hero)
|
|
local born_hp = herologic.getbornhp(hero.heroid)
|
|
local lord_hp = lordlogic.gethp(users[hero.uid].lv)
|
|
local shuijing_hp = 0
|
|
local eqp_hp = getequipmenthp(hero.equipment)
|
|
local yuling_hp = 0
|
|
if hero.yuling then
|
|
yuling_hp = artifactlogic.getattrabs("hp", getartid(hero.yuling.artid, hero.yuling.star))
|
|
end
|
|
local lvup_hp = herologic.getlvupext("hp", hero.heroid) * (hero.lv-1)
|
|
local lord_ext = lordlogic.getlordorderext("hp_ratio", users[hero.uid].stage)
|
|
local shuijing_ext = 0
|
|
local set_ext = calsetattr(hero)
|
|
local yuling_ext = 0
|
|
local yuling_limit_ext = 0
|
|
if hero.yuling then
|
|
yuling_ext = artifactlogic.getattrext("hp_ratio", getartid(hero.yuling.artid, hero.yuling.star))
|
|
yuling_limit_ext = artifactlogic.getlimitattrext("hp_ratio", hero.heroid, getartid(hero.yuling.artid, hero.yuling.star))
|
|
end
|
|
local stageup_ext = herologic.getstageupattrext("hp_ratio", hero.stage)
|
|
local starup_ext = herologic.getstarupattrext("hp_ratio", hero.star)
|
|
local club_ext = clublogic.getclubresearchattrnum(hero.work, 0, "hp_ratio", {0,0,0,0,0,0,0,0})
|
|
local skill_ext = herologic.getskillext("hp_ratio", hero.heroid, hero.stage, hero.skill or {})
|
|
local halo_ext = gethaloext("hp_ratio", hero.uid)
|
|
return utils.round((born_hp + lord_hp + shuijing_hp + eqp_hp + yuling_hp + lvup_hp) * (1 + lord_ext) * (1 + shuijing_ext) * (1 + set_ext) * (1 + yuling_ext) * (1 + yuling_limit_ext) * (1 + stageup_ext) * (1 + starup_ext) * (1 + club_ext) * (1 + skill_ext) * (1 + halo_ext))
|
|
end
|
|
|
|
local function getdef(hero)
|
|
local born_def = herologic.getborndef(hero.heroid)
|
|
local lord_def = lordlogic.getdef(users[hero.uid].lv)
|
|
local shuijing_def = 0
|
|
local eqp_def = getequipmentdef(hero.equipment)
|
|
local yuling_def = 0
|
|
if hero.yuling then
|
|
yuling_def = artifactlogic.getattrabs("def", getartid(hero.yuling.artid, hero.yuling.star))
|
|
end
|
|
local lvup_def = herologic.getlvupext("def", hero.heroid) * (hero.lv-1)
|
|
local lord_ext = lordlogic.getlordorderext("def_ratio", users[hero.uid].stage)
|
|
local shuijing_ext = 0
|
|
local yuling_ext = 0
|
|
local yuling_limit_ext = 0
|
|
if hero.yuling then
|
|
yuling_ext = artifactlogic.getattrext("def_ratio", getartid(hero.yuling.artid, hero.yuling.star))
|
|
yuling_limit_ext = artifactlogic.getlimitattrext("def_ratio", hero.heroid, getartid(hero.yuling.artid, hero.yuling.star))
|
|
end
|
|
local stageup_ext = herologic.getstageupattrext("def_ratio", hero.stage)
|
|
local starup_ext = herologic.getstarupattrext("def_ratio", hero.star)
|
|
local club_ext = clublogic.getclubresearchattrnum(hero.work, 0, "def_ratio", {0,0,0,0,0,0,0,0})
|
|
local skill_ext = herologic.getskillext("def_ratio", hero.heroid, hero.stage, hero.skill or {})
|
|
return utils.round((born_def + lord_def + shuijing_def + eqp_def + yuling_def + lvup_def) * (1 + lord_ext) * (1 + shuijing_ext) * (1 + yuling_ext) * (1 + yuling_limit_ext) * (1 + stageup_ext) * (1 + starup_ext) * (1 + club_ext) * (1 + skill_ext))
|
|
end
|
|
|
|
|
|
local function getspeed(hero)
|
|
local bornspeed = herologic.getbornspeed(hero.heroid)
|
|
local shuijingspeed = 0
|
|
local yulingspeed = 0
|
|
if hero.yuling then
|
|
yulingspeed = artifactlogic.getattrabs("spd", getartid(hero.yuling.artid, hero.yuling.star))
|
|
end
|
|
local lvupspeed = herologic.getlvupext("spd", hero.heroid) * (hero.lv-1)
|
|
local skillspeed = herologic.getskillext("spd", hero.heroid, hero.stage, hero.skill or {})
|
|
local skillspeed_ext = herologic.getskillext("spd_ratio", hero.heroid, hero.stage, hero.skill or {})
|
|
return utils.round((bornspeed + shuijingspeed + yulingspeed + lvupspeed + skillspeed) * (1 + skillspeed_ext))
|
|
end
|
|
|
|
function CMD.getherozhanli(myhero)
|
|
local r1 = getatk(myhero) * 1
|
|
local r2 = gethp(myhero) * 0.21
|
|
local r3 = getdef(myhero) * 0.74
|
|
local r4 = getspeed(myhero) * 1
|
|
return utils.round(r1 + r2 + r3 + r4)
|
|
end
|
|
|
|
|
|
function CMD.getuserzhanli(uid)
|
|
local zhanli = 0
|
|
local myheros = heros[uid] or {}
|
|
for _, myhero in ipairs(myheros) do
|
|
if myhero.pos > 0 then
|
|
zhanli = zhanli + CMD.getherozhanli(myhero)
|
|
end
|
|
end
|
|
return zhanli
|
|
end
|
|
|
|
-- --获取排行榜
|
|
-- function CMD.getallrank(uid)
|
|
-- local serverid = users[uid].serverid
|
|
-- local myserver = utils.getserver(serverid)
|
|
-- local temp = {}
|
|
-- for userid, u in pairs(users) do
|
|
-- local serverid = users[userid].serverid
|
|
-- local server = utils.getserver(serverid)
|
|
-- if myserver == server then
|
|
-- table.insert(temp, {uid=u.uid, nickname=u.nickname, avatar=u.avatar, zhanli=CMD.getuserzhanli(u.uid), max_level=u.max_level })
|
|
-- end
|
|
-- end
|
|
-- table.sort( temp, function(a, b)
|
|
-- if a.max_level == b.max_level then
|
|
-- return tonumber(a.zhanli) > tonumber(b.zhanli)
|
|
-- end
|
|
-- return a.max_level > b.max_level
|
|
-- end)
|
|
-- local myrank = 0
|
|
-- local ranks = {}
|
|
-- local rank = 0
|
|
-- for i, v in ipairs(temp) do
|
|
-- if i < 100 then
|
|
-- rank = rank + 1
|
|
-- v.rank = rank
|
|
-- table.insert(ranks, v)
|
|
|
|
-- if myrank ~= 0 then
|
|
-- break
|
|
-- end
|
|
-- end
|
|
-- if v.uid == uid then
|
|
-- myrank = i
|
|
-- if #ranks >= 100 then
|
|
-- break
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- return ranks, myrank
|
|
-- end
|
|
|
|
--获取排行榜
|
|
function CMD.getallrank(uid)
|
|
local serverid = users[uid].serverid
|
|
local myserver = utils.getserver(serverid)
|
|
return allranks[myserver] or {}, userrank[uid] or 0
|
|
end
|
|
|
|
-- --获取我的排名
|
|
-- function CMD.getmyrank(uid)
|
|
-- local serverid = users[uid].serverid
|
|
-- local myserver = utils.getserver(serverid)
|
|
-- local temp = {}
|
|
-- for userid, u in pairs(users) do
|
|
-- local serverid = users[userid].serverid
|
|
-- local server = utils.getserver(serverid)
|
|
-- if myserver == server then
|
|
-- table.insert(temp, {uid=u.uid, nickname=u.nickname, avatar=u.avatar, zhanli=CMD.getuserzhanli(u.uid), max_level=u.max_level })
|
|
-- end
|
|
-- end
|
|
-- table.sort( temp, function(a, b)
|
|
-- if a.max_level == b.max_level then
|
|
-- return tonumber(a.zhanli) > tonumber(b.zhanli)
|
|
-- end
|
|
-- return a.max_level > b.max_level
|
|
-- end)
|
|
-- for i, v in ipairs(temp) do
|
|
-- if v.uid == uid then
|
|
-- return i
|
|
-- end
|
|
-- end
|
|
-- return 0
|
|
-- end
|
|
|
|
function CMD.getmyrank(uid)
|
|
return userrank[uid] or 0
|
|
end
|
|
|
|
--定时更新排行榜
|
|
local function updaterank()
|
|
DEBUG("run updaterank")
|
|
local temps = {}
|
|
for userid, u in pairs(users) do
|
|
local serverid = u.serverid
|
|
local server = utils.getserver(serverid)
|
|
|
|
if not temps[server] then
|
|
temps[server] = {}
|
|
end
|
|
table.insert(temps[server], {uid=u.uid, nickname=u.nickname, avatar=u.avatar, zhanli=CMD.getuserzhanli(u.uid), max_level=u.max_level })
|
|
end
|
|
for server, temp in pairs(temps) do
|
|
table.sort( temp, function(a, b)
|
|
if a.max_level == b.max_level then
|
|
return tonumber(a.zhanli) > tonumber(b.zhanli)
|
|
end
|
|
return a.max_level > b.max_level
|
|
end)
|
|
local ranks = {}
|
|
for i, v in ipairs(temp) do
|
|
if i <= 100 then
|
|
v.rank = i
|
|
table.insert(ranks, v)
|
|
end
|
|
if i <= 100 then
|
|
userrank[v.uid] = i
|
|
else
|
|
userrank[v.uid] = 0
|
|
end
|
|
end
|
|
allranks[server] = ranks
|
|
end
|
|
|
|
end
|
|
|
|
--获取盐罐排行榜
|
|
function CMD.getsaltpotrank(uid)
|
|
local serverid = users[uid].serverid
|
|
local myserver = utils.getserver(serverid)
|
|
local temp = {}
|
|
for userid, u in pairs(users) do
|
|
local serverid = users[userid].serverid
|
|
local server = utils.getserver(serverid)
|
|
if myserver == server then
|
|
table.insert(temp, {uid=u.uid, nickname=u.nickname, avatar=u.avatar, zhanli=CMD.getuserzhanli(u.uid), max_level=u.max_level, saltpot = saltpots[u.uid], owner = {uid=users[u.owner].uid, avatar=users[u.owner].avatar,nickname=users[u.owner].nickname}})
|
|
end
|
|
end
|
|
table.sort( temp, function(a, b)
|
|
if a.max_level == b.max_level then
|
|
return tonumber(a.zhanli) > tonumber(b.zhanli)
|
|
end
|
|
return a.max_level > b.max_level
|
|
end)
|
|
local ranks = table.slice(temp, 1, 100)
|
|
return ranks
|
|
end
|
|
|
|
function CMD.getuserinfo(userid)
|
|
local d = {}
|
|
d.uid = users[userid].uid
|
|
d.avatar = users[userid].avatar
|
|
d.nickname = users[userid].nickname
|
|
d.serverid = users[userid].serverid
|
|
d.max_level = users[userid].max_level
|
|
d.zhanli = CMD.getuserzhanli(userid)
|
|
d.online_status = users[userid].online_status
|
|
d.last_logout_time = users[userid].last_logout_time
|
|
return d
|
|
end
|
|
|
|
function CMD.getlineup(userid)
|
|
local lineup = {}
|
|
local myheros = heros[userid] or {}
|
|
for _, myhero in ipairs(myheros) do
|
|
local hero = clone(myhero)
|
|
if hero.pos > 0 then
|
|
hero._id = nil
|
|
table.insert(lineup, hero)
|
|
end
|
|
end
|
|
return lineup
|
|
end
|
|
|
|
function CMD.getuserowner(userid)
|
|
local u = users[userid]
|
|
return checkint(u.owner)
|
|
end
|
|
|
|
|
|
-- --获取推荐好友
|
|
-- function CMD.loadrecomfriends(uid, players)
|
|
-- local myserver = getServer(uid)
|
|
|
|
-- local function checkuser(userid)
|
|
-- if #players <= 0 then
|
|
-- return true
|
|
-- end
|
|
-- for _, uuid in ipairs(players) do
|
|
-- if uuid ~= userid then
|
|
-- return true
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- local friends = {}
|
|
|
|
-- for userid, u in pairs(users) do
|
|
-- local server = getServer(userid)
|
|
-- if myserver == server and u.online_status == 1 and checkuser(userid) and uid ~= userid then
|
|
-- local user = CMD.getuserinfo(userid)
|
|
-- table.insert(friends, user)
|
|
-- end
|
|
-- end
|
|
|
|
-- if #friends <= 6 then
|
|
-- return friends
|
|
-- end
|
|
|
|
-- for i=1,7 do
|
|
-- friends = table.shuffle(friends)
|
|
-- end
|
|
-- local s = math.random(1, #friends - 6)
|
|
-- friends = table.slice(friends, s, 6)
|
|
-- return friends
|
|
-- end
|
|
|
|
--获取推荐好友
|
|
function CMD.loadrecomfriends(uid, players)
|
|
local myserver = getServer(uid)
|
|
|
|
local function checkuser(userid)
|
|
if #players <= 0 then
|
|
return true
|
|
end
|
|
for _, uuid in ipairs(players) do
|
|
if uuid ~= userid then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
local friends = {}
|
|
|
|
local allplayers = allranks[myserver]
|
|
|
|
for i, user in ipairs(allplayers) do
|
|
local userid = user.uid
|
|
local u = users[userid]
|
|
if u.online_status == 1 and checkuser(userid) and uid ~= userid then
|
|
table.insert(friends, user)
|
|
end
|
|
end
|
|
|
|
if #friends <= 6 then
|
|
return friends
|
|
end
|
|
|
|
for i=1,7 do
|
|
friends = table.shuffle(friends)
|
|
end
|
|
local s = math.random(1, #friends - 6)
|
|
friends = table.slice(friends, s, 6)
|
|
return friends
|
|
end
|
|
|
|
function CMD.getuserinfolist(players)
|
|
local result = {}
|
|
for _, userid in ipairs(players) do
|
|
result[userid] = CMD.getuserinfo(userid)
|
|
end
|
|
return result
|
|
end
|
|
|
|
--获取总战力
|
|
function CMD.getzhanlitotal(players)
|
|
local zhanli = 0
|
|
for _, userid in ipairs(players) do
|
|
zhanli = zhanli + CMD.getuserzhanli(userid)
|
|
end
|
|
return zhanli
|
|
end
|
|
|
|
--获取总战力
|
|
function CMD.getalluserzhanli(players)
|
|
local result = {}
|
|
for _, userid in ipairs(players) do
|
|
result[userid] = CMD.getuserzhanli(userid)
|
|
end
|
|
return result
|
|
end
|
|
|
|
function CMD.updateowner(ownerid, userid)
|
|
local u = users[userid]
|
|
u.owner = ownerid
|
|
local ok = mqhelper.exec("upsert", userid, settings.user_mongodb_key.tname, settings.user_mongodb_key.cname, {["$set"]={owner=ownerid}}, {uid=userid})
|
|
return "ok"
|
|
end
|
|
|
|
--获取用户抢占的盐罐
|
|
function CMD.getuserrobsaltpots(userid)
|
|
local pots = {}
|
|
for _,pot in pairs(saltpots) do
|
|
if pot.rob_id == userid then
|
|
table.insert(pots, pot)
|
|
end
|
|
end
|
|
return pots
|
|
end
|
|
|
|
--获取用户家的盐罐
|
|
function CMD.getusersaltpot(userid)
|
|
local mypot = saltpots[userid]
|
|
return mypot
|
|
end
|
|
|
|
|
|
function CMD.getsaltpotlist(players)
|
|
local result = {}
|
|
for _, userid in ipairs(players) do
|
|
result[userid].saltpot = saltpots[userid] or {}
|
|
local owner = users[userid].owner or 0
|
|
if owner > 0 then
|
|
result[userid].owner = {uid=users[owner].uid,avatar=users[owner].avatar,nickname=users[owner].nickname}
|
|
end
|
|
end
|
|
return result
|
|
end
|
|
|
|
|
|
--抢占盐罐
|
|
function CMD.robsaltpot(uid, userid, lineup, time)
|
|
local pot = saltpots[userid]
|
|
pot.rob_id = uid
|
|
pot.rob_time = os.time()
|
|
pot.rob_lineup = lineup
|
|
pot.consume_time = time
|
|
return "ok"
|
|
end
|
|
|
|
local function getrobpot(rob_id, level)
|
|
for i,v in pairs(saltpots) do
|
|
if v.rob_id == rob_id and v.level == level then
|
|
return v.uid
|
|
end
|
|
end
|
|
end
|
|
|
|
--收集盐罐
|
|
function CMD.collectsaltpot(rob_id, level)
|
|
local uid = getrobpot(rob_id, level)
|
|
assert(uid~=nil, "收集盐罐失败")
|
|
local pot = saltpots[uid]
|
|
pot.rob_id = 0
|
|
pot.rob_time = 0
|
|
pot.level = 0
|
|
pot.end_time = 0
|
|
pot.rob_lineup = {}
|
|
pot.consume_time = 0
|
|
return "ok"
|
|
end
|
|
|
|
--制造盐罐奖池
|
|
local function makesaltpotpools()
|
|
local pools = {}
|
|
for k,v in pairs(yanguanconf) do
|
|
for i=1, v.cost * 100 do
|
|
table.insert(pools, checkint(k))
|
|
end
|
|
end
|
|
|
|
for i=1,7 do
|
|
pools = table.shuffle(pools)
|
|
end
|
|
return pools
|
|
end
|
|
|
|
--随机盐罐
|
|
local function randomsaltpot()
|
|
local pools = makesaltpotpools()
|
|
local r = math.random(1, 100)
|
|
if not pools[r] then
|
|
return nil
|
|
end
|
|
local level = pools[r]
|
|
return level
|
|
end
|
|
|
|
--刷新盐罐
|
|
local function refreshsaltpot()
|
|
for _, u in pairs(users) do
|
|
if u.max_level >= 50 then --大于50关后刷新
|
|
local level = randomsaltpot()
|
|
if level then
|
|
if not saltpots[u.uid] then --没有盐罐 则刷新盐罐
|
|
local pot = {
|
|
uid=u.uid,
|
|
serverid=u.serverid,
|
|
level=level,
|
|
rob_id=0,
|
|
rob_time=0,
|
|
rob_lineup={},
|
|
consume_time = 0, --占领收获的时间
|
|
end_time=os.time() + 3*3600,
|
|
refresh_time=os.time(),
|
|
}
|
|
saltpots[u.uid] = pot
|
|
db[settings.saltpot_mongodb_key.cname]:update({uid=u.uid}, pot, true)
|
|
else
|
|
--有盐罐
|
|
local pot = saltpots[u.uid]
|
|
--未被占领
|
|
if pot.rob_id == 0 then
|
|
if os.time() > pot.end_time then
|
|
pot.rob_id = 0
|
|
pot.rob_time = 0
|
|
pot.level = 0
|
|
pot.end_time = 0
|
|
pot.rob_lineup = {}
|
|
db[settings.saltpot_mongodb_key.cname]:update({uid=u.uid}, pot, true)
|
|
end
|
|
else
|
|
--占领了
|
|
local t = checkint(pot.rob_time) + pot.consume_time --占领结束时间
|
|
if os.time() > t then
|
|
pot.rob_id = 0
|
|
pot.rob_time = 0
|
|
pot.level = 0
|
|
pot.end_time = 0
|
|
pot.rob_lineup = {}
|
|
pot.consume_time = 0
|
|
db[settings.saltpot_mongodb_key.cname]:update({uid=u.uid}, pot, true)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
skynet.sleep(60*100)
|
|
end
|
|
|
|
function CMD.send2all(mail)
|
|
skynet.fork(function()
|
|
for userid, user in pairs(users) do
|
|
local id = skynet.call(".id_service", "lua", "genid", "mail")
|
|
mail.id = id
|
|
mail.receiver = userid
|
|
local ok = mongohelper.insert(settings.mail_mongodb_key.tname, settings.mail_mongodb_key.cname, mail)
|
|
skynet.send(".msgd", "lua", "sendmail", userid, mail)
|
|
end
|
|
end)
|
|
return "ok"
|
|
end
|
|
|
|
skynet.start(function()
|
|
skynet.dispatch("lua", function(session, source, cmd, ...)
|
|
skynet.error("usercenterd dispatch", cmd)
|
|
local f = assert(CMD[cmd])
|
|
skynet.ret(skynet.pack(f(...)))
|
|
end)
|
|
|
|
--链接mongo
|
|
local mongoconf = settings.db_cnf[skynet_node_name].mongodb_cnf
|
|
local client = mongo.client(mongoconf)
|
|
|
|
if not client then
|
|
error("usercenterd mongo 数据库连接失败")
|
|
end
|
|
|
|
local tname = settings.mongodb_tb.game
|
|
db = client:getDB(tname)
|
|
if not db then
|
|
error("mongo 连接失败")
|
|
end
|
|
|
|
rediscli = redis.connect(settings.db_cnf.loginserver.redisdb_cnf)
|
|
|
|
if not rediscli then
|
|
error(" rediscli 连接失败")
|
|
end
|
|
|
|
skynet.fork(function()
|
|
while true do
|
|
db = client:getDB(tname)
|
|
rediscli:ping()
|
|
skynet.sleep(1000)
|
|
end
|
|
end)
|
|
|
|
loadalluser()
|
|
loadallhero()
|
|
loadallartifact()
|
|
loadallbag()
|
|
loadsaltpot() --加载盐罐
|
|
|
|
skynet.fork(function()
|
|
while true do
|
|
refreshsaltpot()
|
|
end
|
|
end)
|
|
|
|
skynet.fork(function()
|
|
while true do
|
|
updaterank()
|
|
skynet.sleep(6000)
|
|
end
|
|
end)
|
|
skynet.register('.' .. SERVICE_NAME)
|
|
end)
|