def world_ranklist(p, req):
if hasattr(p, "uid"):
log.debug('uid:{0}'.format(p.uid))
uid = p.uid
else: # used to test
log.error('client has not found uid.')
defer.returnValue((CONNECTION_LOSE, None))
user = g_UserMgr.getUserByUid(uid)
if not user:
defer.returnValue((CONNECTION_LOSE, None))
data = list()
other_data = list()
weight_data = yield redis.zrange(SET_RANK_PVP_WEIGHT, 0, 10, True)
for _rank, (_uid, _weight) in enumerate(weight_data):
_machine_code = yield redis.hget(HASH_UID_MACHINE_CODE, _uid)
other_data.append((_rank + 1, _uid, _machine_code, _weight))
self_rank = yield redis.zrank(SET_RANK_PVP_WEIGHT, uid)
self_rank = 0 if self_rank is None else int(self_rank) + 1
self_machine_code = yield redis.hget(HASH_UID_MACHINE_CODE, uid)
self_weight = yield redis.zscore(SET_RANK_PVP_WEIGHT, uid)
self_weight = 0 if self_weight is None else abs(self_weight)
data = (other_data, (self_rank, uid, self_machine_code, self_weight))
defer.returnValue((NO_ERROR, data))
def get_char_rank(self, cid):
''' rank: 0-没有排名
'''
_rank = yield redis.zscore( SET_ARENA_CID_RANK, cid )
_rank = int(_rank) if _rank else 0
defer.returnValue( _rank )
def world_ranklist(p, req):
if hasattr(p, "uid"):
log.debug('uid:{0}'.format(p.uid))
uid = p.uid
else: # used to test
log.error('client has not found uid.')
defer.returnValue((CONNECTION_LOSE, None))
user = g_UserMgr.getUserByUid(uid)
if not user:
defer.returnValue((CONNECTION_LOSE, None))
data = list()
other_data = list()
weight_data = yield redis.zrange(SET_RANK_PVP_WEIGHT, 0, 10, True)
for _rank, (_uid, _weight) in enumerate(weight_data):
_machine_code = yield redis.hget(HASH_UID_MACHINE_CODE, _uid)
other_data.append((_rank+1, _uid, _machine_code, _weight))
self_rank = yield redis.zrank(SET_RANK_PVP_WEIGHT, uid)
self_rank = 0 if self_rank is None else int(self_rank) + 1
self_machine_code = yield redis.hget(HASH_UID_MACHINE_CODE, uid)
self_weight = yield redis.zscore(SET_RANK_PVP_WEIGHT, uid)
self_weight = 0 if self_weight is None else abs(self_weight)
data = (other_data, (self_rank, uid, self_machine_code, self_weight))
defer.returnValue((NO_ERROR, data))
def get_name_info(self, nick_name):
_score = yield redis.zscore( SET_LIMIT_FELLOW_NAME_SCORE, nick_name )
_score = int(_score) if _score else 0
# 第一名返回rank=0, 没有rank为None
_rank = yield redis.zrevrank( SET_LIMIT_FELLOW_NAME_SCORE, nick_name )
_rank = int(_rank) + 1 if _rank >= 0 else 0
defer.returnValue( (_rank, _score) )
def get_name_info(self, nick_name):
_score = yield redis.zscore(SET_LIMIT_FELLOW_NAME_SCORE, nick_name)
_score = int(_score) if _score else 0
# 第一名返回rank=0, 没有rank为None
_rank = yield redis.zrevrank(SET_LIMIT_FELLOW_NAME_SCORE, nick_name)
_rank = int(_rank) + 1 if _rank >= 0 else 0
defer.returnValue((_rank, _score))
def get_char_score(self, cid, redis_key=SET_JOUST_CID_SCORE):
''' 获取玩家的积分 '''
_score = yield redis.zscore(redis_key, cid)
if _score is None:
_score = JOUST_BASIC_SCORE
yield redis.zadd(redis_key, cid, -JOUST_BASIC_SCORE)
else:
_score = -int(_score)
defer.returnValue(_score)
def overPVP(self):
''' 战斗结算 '''
for _uid in self.__users.iterkeys():
yield redis.zadd(SET_RANK_ROOM_EAT%self.__id, _uid, -self.__eat_num.get(_uid, 0))
yield redis.zadd(SET_RANK_ROOM_EATED%self.__id, _uid, -self.__be_eated_num.get(_uid, 0))
_user_mgr = g_UserMgr.getUserByUid(_uid)
_user_mgr.attrib.paly_num += 1
_volume = yield redis.zscore(SET_RANK_ROOM_VOLUME%self.__id, _uid)
_weight = int(_volume) * 10 if _volume else 0
if _user_mgr.attrib.max_weight < _weight:
_user_mgr.attrib.max_weight = _weight
yield redis.zadd(SET_RANK_PVP_WEIGHT, _uid, -_weight)
yield redis.hset(HASH_PVP_ROOM_USER_NUM, self.__id, self.count)
def getRoomRanklist(self, room_id, self_uid):
other_data = list()
_volume_data = yield redis.zrange(SET_RANK_ROOM_VOLUME%room_id, 0, 5, True)
_volume_data = _volume_data if _volume_data else list()
for _rank, (_uid, _volume) in enumerate(_volume_data):
_machine_code = yield redis.hget(HASH_UID_MACHINE_CODE, _uid)
_eat_num = yield redis.zscore(SET_RANK_ROOM_EAT%room_id, _uid)
_eat_num = abs(int(_eat_num)) if _eat_num else 0
_be_eated_num = yield redis.hget(SET_RANK_ROOM_EATED%room_id, _uid)
_be_eated_num = abs(int(_be_eated_num)) if _be_eated_num else 0
other_data.append((_rank+1, _uid, _machine_code, abs(_volume)*10, _eat_num, _be_eated_num))
_self_rank = yield redis.zrank(SET_RANK_ROOM_VOLUME%room_id, self_uid)
_self_rank = 0 if _self_rank is None else int(_self_rank) + 1
_self_volume = yield redis.zscore(SET_RANK_ROOM_VOLUME%room_id, self_uid)
_self_weight = abs(_self_volume)*10 if _self_volume else 0
_self_machine_code = yield redis.hget(HASH_UID_MACHINE_CODE, self_uid)
_self_eat_num = yield redis.zscore(SET_RANK_ROOM_EAT%room_id, self_uid)
_self_eat_num = abs(int(_self_eat_num)) if _self_eat_num else 0
_self_be_eated_num = yield redis.hget(SET_RANK_ROOM_EATED%room_id, self_uid)
_self_be_eated_num = abs(int(_self_be_eated_num)) if _self_be_eated_num else 0
self_data = (_self_rank, self_uid, _self_machine_code, _self_weight, _self_eat_num, _self_be_eated_num)
defer.returnValue((other_data, self_data))
def randcard(self, rand_type):
''' 免费抽卡、钻石抽卡 '''
_status, _data = yield self.status()
if _status < 0:
defer.returnValue( LIMIT_FELLOW_NO_ERROR )
_need_time = self.left_free_timestamp( _data[3], LIMIT_FELLOW_FREE_TIME )
_last_time = _data[3]
# 检查抽卡条件是否满足
_score = yield redis.zscore( SET_LIMIT_FELLOW_NAME_SCORE, self.user.nick_name )
_score = int(_score) if _score else 0
_cost_flag = True # 扣钻石的标识位
if rand_type == RANDCARD_TYPE_FREE:
if _need_time > 0:
defer.returnValue( LIMIT_FELLOW_FREE_ERROR )
else:
_last_time = int(time())
_cost_flag = False
_need_time = LIMIT_FELLOW_FREE_TIME
else:
# 某积分的整数倍时免费钻石抽卡
if not _score or _score%RAND_COST_FREE_SCORE != 0:
if self.user.credits < LIMIT_FELLOW_RAND_COST:
defer.returnValue( CHAR_CREDIT_NOT_ENOUGH )
else:
_cost_flag = False
# 卡池升级
res_err, shrine_data = self.update_shrine(_data[1], _data[2])
if res_err:
defer.returnValue( res_err )
#log.info('For Test. shrine_data: {0}, redis_data: {1}.'.format( shrine_data, _data ))
# 获取抽卡池并抽卡
card_conf = self.get_randcard_frompool(_data[1], shrine_data[3]-_data[2])
if not card_conf:
defer.returnValue( NOT_FOUND_CONF )
# 更新免费时间或扣钻石
yield redis.hset( HASH_LIMIT_FELLOW_SHRINE, self.cid, dumps([_data[0], shrine_data[0], shrine_data[1], _last_time]) )
if _cost_flag:
yield self.user.consume_credits( LIMIT_FELLOW_RAND_COST, WAY_LIMIT_FELLOW_RANDCARD )
_score += RANDCARD_ONCE_SCORE
yield redis.zadd( SET_LIMIT_FELLOW_NAME_SCORE, self.user.nick_name, _score )
# 新增fellow
try:
# args: fellow_id, is_major, camp_id, on_troop
new_fellow = []
fellow_id = card_conf['ItemId']
res_err, attrib = yield self.user.fellow_mgr.create_table_data( fellow_id, 0, 0, 0 )
if not res_err:
new_fellow = [attrib.attrib_id, fellow_id]
conf = get_fellow_by_fid( fellow_id )
if conf and conf['Quality'] == QUALITY_PURPLE:
syslogger(LOG_FELLOW_GET, self.cid, self.user.level, self.user.vip_level, self.user.alliance_id, \
attrib.attrib_id, fellow_id, conf['QualityLevel'], conf['Star'], RANDCARD_TYPE_CREDITS, '')
message = [RORATE_MESSAGE_ACHIEVE, [ACHIEVE_TYPE_LIMIT_FELLOW, [self.user.nick_name, fellow_id]]]
gw_broadcast('sync_broadcast', [message])
except Exception as e:
log.warn('Create fellow fail! e:', e)
defer.returnValue(res_err)
_rank = yield redis.zrevrank( SET_LIMIT_FELLOW_NAME_SCORE, self.user.nick_name )
_rank = int(_rank) + 1 if _rank >= 0 else 0
_ranklist = yield self.ranklist()
defer.returnValue( [self.user.credits, _rank, _score, _need_time, shrine_data[2], _ranklist, new_fellow] )
def login(p, req):
res = [UNKNOWN_ERROR, [None, int(time()), config.httport, [0, 0], -1] ]
log.warn('Login args: {0}.'.format( req ))
if len(req) == 6:
login_type, platform_id, accountname, session_key, version, sid = req
else:
login_type, accountname, session_key, version, sid = req
platform_id = TIPCAT_CID
#当服务器没有开启，且该账号不在AdminUser集合内，提示玩家服务器未开放
if not gm.opened:
_is_admin_user = yield redis.sismember( SET_GM_USER, accountname )
if not _is_admin_user:
res[0] = SERVER_IS_CLOSED
defer.returnValue( res )
# 检查客户端版本号 低于当前版本不能登录/注册
_ver_status = check_client_version(version)
if _ver_status:
res[0] = _ver_status
defer.returnValue( res )
accountname = accountname.strip()
session_key = session_key.strip()
if len(accountname) == 0:
log.error('Invalid account!')
res[0] = UNKNOWN_CHAR
defer.returnValue( res )
elif len(session_key) == 0:
log.error('Invalid session key!')
res[0] = SESSION_NOT_VALID
defer.returnValue( res )
#try:
# res_sk = yield login_check(int(platform_id), accountname, session_key)
# log.debug('Result of login check:', res_sk)
# if not res_sk[0]:
# res[0] = SESSION_NOT_VALID
# log.error('Invalid session_key. accountname: {0}, session_key: {1}.'.format( accountname, session_key ))
# defer.returnValue( res )
#except Exception as e:
# log.error('exception. e: {0}, accountname: {1}, session_key: {2}.'.format( e, accountname, session_key ))
# res[0] = SESSION_NOT_VALID
# defer.returnValue( res )
p.account = accountname
p.session_key = session_key
cid = yield redis.hget(DICT_ACCOUNT_REGISTERED, '%s%s'%(accountname,sid))
if not cid:
res[0] = LOGIN_NO_CHARACTER
defer.returnValue( res )
else:
cid = int( cid )
# 检查该玩家是否被封号
_status = yield check_character_forbidden( cid )
if _status:
res[0] = CHAR_IN_FORBIDDEN
defer.returnValue( res )
try:
result, char_data, version_conf = yield protocol_manager.gs_call("gs_login", (cid, version))
if result:
log.error('user login gameserver error. cid: {0}.'.format( cid ))
res[0] = result
defer.returnValue( res )
except Exception as e:
log.error('error. e: {0}.'.format( e ))
defer.returnValue( res )
char_data['cid'] = cid
char_data['id'] = cid
char_data['session'] = p.session_key
char_data['sid'] = config.server_id
end_cd_time = yield redis.hget(HASH_SCENE_COOLDOWN_TIME, cid)
char_data['end_cd_time'] = int( end_cd_time or 0 )
# 竞技场排名 0-没有排名
_char_rank = yield redis.zscore( SET_ARENA_CID_RANK, cid )
_char_rank = int(_char_rank) if _char_rank else 0
try:
alli_res, alliance_info = yield alli_call('alli_login', (cid, char_data['nick_name'], char_data['level'], char_data['vip_level'], char_data['might'], _char_rank, char_data['lead_id']))
if alliance_info[0] > 0:
gs_send('gs_alliance_info', (cid, alliance_info))
except:
alli_res = 1
log.exception()
alliance_info = 0, '', 0
if alli_res:
log.error('user login allianceserver error. cid: {0}.'.format( cid ))
try:
result = yield ms_call('ms_login', (cid, char_data['nick_name'], char_data['lead_id'], \
char_data['vip_level'], char_data['level'], char_data['might'], alliance_info))
if result:
log.error('user login messageserver error. cid: {0}, result: {1}.'.format( cid, result ))
except Exception as e:
log.error('Login messageserver error. e: {0}.'.format( e ))
# 获取天神领取的状态
end_timestamp = yield redis.hget(HASH_RESCUE_ER_LANG_GOD, cid)
end_timestamp = end_timestamp if end_timestamp else 0
# 检查账号是否有重复登录, char_data已从gameserver重新获取
_user_logined = g_UserMgr.getUserLogined(cid, p, session_key, info=char_data)
if _user_logined:
log.warn('user id({0}) have logined.'.format( cid ))
res = NO_ERROR, (_user_logined.info, int(time()), config.httport, version_conf, end_timestamp)
defer.returnValue( res )
g_UserMgr.loginUser(p, cid, session_key, accountname, char_data)
res = result, (char_data, int(time()), config.httport, version_conf, end_timestamp)
defer.returnValue( res )
def login(p, req):
res = [UNKNOWN_ERROR, [None, int(time()), config.httport, [0, 0], -1]]
log.warn('Login args: {0}.'.format(req))
if len(req) == 6:
login_type, platform_id, accountname, session_key, version, sid = req
else:
login_type, accountname, session_key, version, sid = req
platform_id = TIPCAT_CID
#当服务器没有开启，且该账号不在AdminUser集合内，提示玩家服务器未开放
if not gm.opened:
_is_admin_user = yield redis.sismember(SET_GM_USER, accountname)
if not _is_admin_user:
res[0] = SERVER_IS_CLOSED
defer.returnValue(res)
# 检查客户端版本号 低于当前版本不能登录/注册
_ver_status = check_client_version(version)
if _ver_status:
res[0] = _ver_status
defer.returnValue(res)
accountname = accountname.strip()
session_key = session_key.strip()
if len(accountname) == 0:
log.error('Invalid account!')
res[0] = UNKNOWN_CHAR
defer.returnValue(res)
elif len(session_key) == 0:
log.error('Invalid session key!')
res[0] = SESSION_NOT_VALID
defer.returnValue(res)
#try:
# res_sk = yield login_check(int(platform_id), accountname, session_key)
# log.debug('Result of login check:', res_sk)
# if not res_sk[0]:
# res[0] = SESSION_NOT_VALID
# log.error('Invalid session_key. accountname: {0}, session_key: {1}.'.format( accountname, session_key ))
# defer.returnValue( res )
#except Exception as e:
# log.error('exception. e: {0}, accountname: {1}, session_key: {2}.'.format( e, accountname, session_key ))
# res[0] = SESSION_NOT_VALID
# defer.returnValue( res )
p.account = accountname
p.session_key = session_key
cid = yield redis.hget(DICT_ACCOUNT_REGISTERED,
'%s%s' % (accountname, sid))
if not cid:
res[0] = LOGIN_NO_CHARACTER
defer.returnValue(res)
else:
cid = int(cid)
# 检查该玩家是否被封号
_status = yield check_character_forbidden(cid)
if _status:
res[0] = CHAR_IN_FORBIDDEN
defer.returnValue(res)
try:
result, char_data, version_conf = yield protocol_manager.gs_call(
"gs_login", (cid, version))
if result:
log.error('user login gameserver error. cid: {0}.'.format(cid))
res[0] = result
defer.returnValue(res)
except Exception as e:
log.error('error. e: {0}.'.format(e))
defer.returnValue(res)
char_data['cid'] = cid
char_data['id'] = cid
char_data['session'] = p.session_key
char_data['sid'] = config.server_id
end_cd_time = yield redis.hget(HASH_SCENE_COOLDOWN_TIME, cid)
char_data['end_cd_time'] = int(end_cd_time or 0)
# 竞技场排名 0-没有排名
_char_rank = yield redis.zscore(SET_ARENA_CID_RANK, cid)
_char_rank = int(_char_rank) if _char_rank else 0
try:
alli_res, alliance_info = yield alli_call(
'alli_login', (cid, char_data['nick_name'], char_data['level'],
char_data['vip_level'], char_data['might'],
_char_rank, char_data['lead_id']))
if alliance_info[0] > 0:
gs_send('gs_alliance_info', (cid, alliance_info))
except:
alli_res = 1
log.exception()
alliance_info = 0, '', 0
if alli_res:
log.error('user login allianceserver error. cid: {0}.'.format(cid))
try:
result = yield ms_call('ms_login', (cid, char_data['nick_name'], char_data['lead_id'], \
char_data['vip_level'], char_data['level'], char_data['might'], alliance_info))
if result:
log.error('user login messageserver error. cid: {0}, result: {1}.'.
format(cid, result))
except Exception as e:
log.error('Login messageserver error. e: {0}.'.format(e))
# 获取天神领取的状态
end_timestamp = yield redis.hget(HASH_RESCUE_ER_LANG_GOD, cid)
end_timestamp = end_timestamp if end_timestamp else 0
# 检查账号是否有重复登录, char_data已从gameserver重新获取
_user_logined = g_UserMgr.getUserLogined(cid,
p,
session_key,
info=char_data)
if _user_logined:
log.warn('user id({0}) have logined.'.format(cid))
res = NO_ERROR, (_user_logined.info, int(time()), config.httport,
version_conf, end_timestamp)
defer.returnValue(res)
g_UserMgr.loginUser(p, cid, session_key, accountname, char_data)
res = result, (char_data, int(time()), config.httport, version_conf,
end_timestamp)
defer.returnValue(res)
def randcard(self, rand_type):
''' 免费抽卡、钻石抽卡 '''
_status, _data = yield self.status()
if _status < 0:
defer.returnValue(LIMIT_FELLOW_NO_ERROR)
_need_time = self.left_free_timestamp(_data[3], LIMIT_FELLOW_FREE_TIME)
_last_time = _data[3]
# 检查抽卡条件是否满足
_score = yield redis.zscore(SET_LIMIT_FELLOW_NAME_SCORE,
self.user.nick_name)
_score = int(_score) if _score else 0
_cost_flag = True # 扣钻石的标识位
if rand_type == RANDCARD_TYPE_FREE:
if _need_time > 0:
defer.returnValue(LIMIT_FELLOW_FREE_ERROR)
else:
_last_time = int(time())
_cost_flag = False
_need_time = LIMIT_FELLOW_FREE_TIME
else:
# 某积分的整数倍时免费钻石抽卡
if not _score or _score % RAND_COST_FREE_SCORE != 0:
if self.user.credits < LIMIT_FELLOW_RAND_COST:
defer.returnValue(CHAR_CREDIT_NOT_ENOUGH)
else:
_cost_flag = False
# 卡池升级
res_err, shrine_data = self.update_shrine(_data[1], _data[2])
if res_err:
defer.returnValue(res_err)
#log.info('For Test. shrine_data: {0}, redis_data: {1}.'.format( shrine_data, _data ))
# 获取抽卡池并抽卡
card_conf = self.get_randcard_frompool(_data[1],
shrine_data[3] - _data[2])
if not card_conf:
defer.returnValue(NOT_FOUND_CONF)
# 更新免费时间或扣钻石
yield redis.hset(
HASH_LIMIT_FELLOW_SHRINE, self.cid,
dumps([_data[0], shrine_data[0], shrine_data[1], _last_time]))
if _cost_flag:
yield self.user.consume_credits(LIMIT_FELLOW_RAND_COST,
WAY_LIMIT_FELLOW_RANDCARD)
_score += RANDCARD_ONCE_SCORE
yield redis.zadd(SET_LIMIT_FELLOW_NAME_SCORE, self.user.nick_name,
_score)
# 新增fellow
try:
# args: fellow_id, is_major, camp_id, on_troop
new_fellow = []
fellow_id = card_conf['ItemId']
res_err, attrib = yield self.user.fellow_mgr.create_table_data(
fellow_id, 0, 0, 0)
if not res_err:
new_fellow = [attrib.attrib_id, fellow_id]
conf = get_fellow_by_fid(fellow_id)
if conf and conf['Quality'] == QUALITY_PURPLE:
syslogger(LOG_FELLOW_GET, self.cid, self.user.level, self.user.vip_level, self.user.alliance_id, \
attrib.attrib_id, fellow_id, conf['QualityLevel'], conf['Star'], RANDCARD_TYPE_CREDITS, '')
message = [
RORATE_MESSAGE_ACHIEVE,
[
ACHIEVE_TYPE_LIMIT_FELLOW,
[self.user.nick_name, fellow_id]
]
]
gw_broadcast('sync_broadcast', [message])
except Exception as e:
log.warn('Create fellow fail! e:', e)
defer.returnValue(res_err)
_rank = yield redis.zrevrank(SET_LIMIT_FELLOW_NAME_SCORE,
self.user.nick_name)
_rank = int(_rank) + 1 if _rank >= 0 else 0
_ranklist = yield self.ranklist()
defer.returnValue([
self.user.credits, _rank, _score, _need_time, shrine_data[2],
_ranklist, new_fellow
])