def rank(self):
_rank = yield redis.zrank(RANK_WORLDBOSS_DAMAGE, self._cid)
if not _rank:
yield redis.zadd(RANK_WORLDBOSS_DAMAGE, self._cid, -self._damage_total)
_rank = yield redis.zrank(RANK_WORLDBOSS_DAMAGE, self._cid)
defer.returnValue(_rank)
def rank(self):
_rank = yield redis.zrank(RANK_WORLDBOSS_DAMAGE, self._cid)
if not _rank:
yield redis.zadd(RANK_WORLDBOSS_DAMAGE, self._cid,
-self._damage_total)
_rank = yield redis.zrank(RANK_WORLDBOSS_DAMAGE, self._cid)
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 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, redis_key=SET_JOUST_CID_SCORE):
'''
@return : rank=0时表示玩家没有排名.
'''
_rank = yield redis.zrank(redis_key, cid)
_rank = 0 if _rank is None else int(_rank) + 1
defer.returnValue(_rank)
def ranklist(self):
''' 获取天外天的排行榜 '''
yield self.load()
# get myself rank and layer
_my_rank = yield redis.zrank(SET_CLIMBING_CID_LAYER, self.cid)
_my_rank = 0 if _my_rank is None else int(_my_rank)+1
_ranklist = [self.climbing.max_layer, _my_rank, []]
_cid_layers = yield redis.zrange(SET_CLIMBING_CID_LAYER, 0, 9, withscores=True)
for _idx, _data in enumerate(_cid_layers):
#log.error('For Test. _idx: {0}, _cid_layers: {1}.'.format( _idx+1, _data ))
if int(_data[1]) >= 0:
continue
_detail = yield load_climbing_user_data(_data[0])
if not _detail:
log.error('Unknown user. cid: {0}.'.format( _data[0] ))
continue
_detail.extend( [-int(_data[1]), _idx+1] )
_ranklist[2].append( _detail )
defer.returnValue( _ranklist )
def ranklist(self):
''' 剧情副本的排行榜 '''
yield self._load()
# get myself rank and star
_my_rank = yield redis.zrank(SET_SCENE_CID_STAR, self.cid)
_my_rank = 0 if _my_rank is None else int(_my_rank)+1
_ranklist = [self.total_star, _my_rank, []]
_cid_stars = yield redis.zrange(SET_SCENE_CID_STAR, 0, 9, withscores=True)
#log.error('For Test. _cid_stars: {0}.'.format( _cid_stars ))
for _idx, _data in enumerate(_cid_stars):
if int(_data[1]) >= 0:
continue
_detail = yield load_scene_user_data(_data[0])
if not _detail:
log.error('Unknown user. cid: {0}.'.format( _data[0] ))
continue
_detail.extend( [-int(_data[1]), _idx+1] )
_ranklist[2].append( _detail )
defer.returnValue( _ranklist )
def newUser(self, uid):
if not self.__users:
# common foodball and spineball
self.__foodball = get_all_foodball()
self.__spineball = get_all_spineball()
foodball_conf = self.__foodball.values()
spineball_conf = self.__spineball.values()
self.__end_time = int((time() + PVP_SECONDS)*1000)
#reactor.callLater(PVP_SECONDS, self._broadcastFoodball)
else:
foodball_conf = self.__foodball.values()
spineball_conf = self.__spineball.values()
self.__eat_num.setdefault(uid, 0)
self.__be_eated_num.setdefault(uid, 0)
userball_obj = Userball(uid)
self.__users[uid] = userball_obj
all_userball = userball_obj.initBall(self.count)
for _ub in self.__users.itervalues():
if _ub.uid == uid:
continue
all_userball.extend(_ub.getAllBall())
yield redis.zadd(SET_RANK_ROOM_VOLUME%self.__id, uid, -INIT_USERBALL_VOLUME)
rank = yield redis.zrank(SET_RANK_ROOM_VOLUME%self.__id, uid)
rank = 0 if rank is None else int(rank) + 1
data = {'userball': all_userball, \
'foodball': foodball_conf, \
'spineball': spineball_conf, \
'end_time': self.__end_time, \
'total': self.count,
'rank': rank, \
'room_id': self.__id,
}
defer.returnValue(data)
def ranklist(self):
''' 剧情副本的排行榜 '''
yield self._load()
# get myself rank and star
_my_rank = yield redis.zrank(SET_SCENE_CID_STAR, self.cid)
_my_rank = 0 if _my_rank is None else int(_my_rank) + 1
_ranklist = [self.total_star, _my_rank, []]
_cid_stars = yield redis.zrange(SET_SCENE_CID_STAR,
0,
9,
withscores=True)
#log.error('For Test. _cid_stars: {0}.'.format( _cid_stars ))
for _idx, _data in enumerate(_cid_stars):
if int(_data[1]) >= 0:
continue
_detail = yield load_scene_user_data(_data[0])
if not _detail:
log.error('Unknown user. cid: {0}.'.format(_data[0]))
continue
_detail.extend([-int(_data[1]), _idx + 1])
_ranklist[2].append(_detail)
defer.returnValue(_ranklist)
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 ranklist(self):
''' 获取天外天的排行榜 '''
yield self.load()
# get myself rank and layer
_my_rank = yield redis.zrank(SET_CLIMBING_CID_LAYER, self.cid)
_my_rank = 0 if _my_rank is None else int(_my_rank) + 1
_ranklist = [self.climbing.max_layer, _my_rank, []]
_cid_layers = yield redis.zrange(SET_CLIMBING_CID_LAYER,
0,
9,
withscores=True)
for _idx, _data in enumerate(_cid_layers):
#log.error('For Test. _idx: {0}, _cid_layers: {1}.'.format( _idx+1, _data ))
if int(_data[1]) >= 0:
continue
_detail = yield load_climbing_user_data(_data[0])
if not _detail:
log.error('Unknown user. cid: {0}.'.format(_data[0]))
continue
_detail.extend([-int(_data[1]), _idx + 1])
_ranklist[2].append(_detail)
defer.returnValue(_ranklist)
def syncUserball(self, character, ball_info, status):
uid = character.attrib_id
if not (ball_info and isinstance(ball_info[0], list)):
log.error("args error. uid:{0}, ball_info:{1}.".format(uid, ball_info))
defer.returnValue((ARGS_ERROR, None))
if uid not in self.__users:
log.error("user not in room error. uid:{0}, room_id:{1}.".format(uid, self.__id))
defer.returnValue((PVPROOM_LOSE, None))
_hide_fb_ids = list()
userball_obj = self.__users[uid]
if userball_obj.isDead:
log.warn("room uids:{0}, __eat_num:{1}, __be_eated_num:{2}, uid:{3}, isDead:{4}, status:{5}.".format(self.__users.keys(), self.__eat_num, self.__be_eated_num, uid, userball_obj.isDead, status))
if status:
userball_obj.revive()
else:
log.error("user is dead. uid:{0}, isDead:{1}, status:{2}.".format(uid, userball_obj.isDead, status))
defer.returnValue((USER_IS_DEAD, None))
_hide_ub_ids, _delta_volume, ball_info = userball_obj.checkHideBall(ball_info)
#_delta_br = int(FOODBALL_RADIUS * MULTIPLE_ENLARGE_FOODBALL * 0.01)
_max_hide = 1
for _bid, _bx, _by, _bz in self.__foodball.itervalues():
for _, ball_id, ball_x, ball_y, ball_z, ball_r, ball_v, ball_s, pow_r in ball_info:
# 和食物球 其它玩家球比较半径大小 计算直线距离
# 玩家球 分裂后的半径也会比食物球大吗？
_distance = pow(ball_x-_bx, 2) + pow(ball_y-_by, 2) + pow(ball_z-_bz, 2)
if _distance < pow_r:
log.warn('--------------- eated foodball uid:{0}, pow_r:{1}, _distance:{2}, source:{3}, target:{4}, _delta_volume:{5}.'.format(uid, pow_r, _distance, (ball_id, ball_x, ball_y, ball_z, ball_r), (_bid, _bx, _by, _bz), _delta_volume))
# 自身体积增长
_delta_volume[ball_id] = _delta_volume.setdefault(ball_id, ball_v) + INIT_FOODBALL_VOLUME
_hide_fb_ids.append(_bid)
if len(_hide_fb_ids) > 2:
break
for _bid in _hide_fb_ids:
self.__hide_foodball_ids[_bid] = 0
if _bid in self.__foodball:
del self.__foodball[_bid]
# uid and ballid
for _ub in self.__users.itervalues():
if _ub.isDead:
log.error('----------------- user is dead. room_id:{0}, uid:{1}, isDead:{2}'.format(self.__id, _ub.uid, _ub.isDead))
if _ub.uid == uid or _ub.isDead:
continue
_all_ball = _ub.getAllBall()
for _uid, _bid, _bx, _by, _bz, _br, _bv, _bs in iter(_all_ball):
_be_eated_user = g_UserMgr.getUserByUid(_uid)
for _, ball_id, ball_x, ball_y, ball_z, ball_r, ball_v, ball_s, pow_r in ball_info:
if MULTIPLE_HIDE_USERBALL*_bv > ball_v:
continue
_distance = pow(ball_x-_bx, 2) + pow(ball_y-_by, 2) + pow(ball_z-_bz, 2)
if _distance < pow_r:
log.warn('---------------- eated userball uid:{0}, pow_r:{1}, _distance:{2}, source:{3}, target:{4}.'.format(uid, pow_r, _distance, (_uid, _bid, _bx, _by, _bz, _br), (ball_id, ball_x, ball_y, ball_z, ball_r)))
# 记录吞噬/被吞噬 玩家球的个数
character.eat_num += 1
self.__eat_num[uid] += 1
if _be_eated_user and _be_eated_user.attrib:
_be_eated_user.attrib.be_eated_num += 1
self.__be_eated_num[_uid] = self.__be_eated_num.setdefault(_uid, 0) + 1
# 自身体积增长
_delta_volume[ball_id] = _delta_volume.setdefault(ball_id, ball_v) + _bv
_ub.setHideBall(_bid)
_hide_ub_ids.append((_uid, _bid))
yield redis.zincrby(SET_RANK_ROOM_VOLUME%self.__id, _uid, _bv)
data = list()
_delta_ub_data = list()
_delta_ub_volume = 0
for _, ball_id, ball_x, ball_y, ball_z, ball_r, ball_v, ball_s, pow_r in ball_info:
ball_v = _delta_volume[ball_id] if ball_id in _delta_volume else ball_v
_delta_ub_data.append((uid, ball_id, ball_x, ball_y, ball_z, ball_r, ball_v, ball_s))
_delta_ub_volume += ball_v
# 更新自己的球体积排行榜
yield redis.zadd(SET_RANK_ROOM_VOLUME%self.__id, uid, -_delta_ub_volume)
# 更新自己的球体积信息
userball_obj.updateVolume(_delta_volume)
if (_hide_ub_ids or _hide_fb_ids or _delta_ub_data):
data = [_hide_ub_ids, _hide_fb_ids, _delta_ub_data]
#TODO broadcast
uids = self.__users.keys()
uids.remove(uid)
if uids:
send2client(uids, 'broadcastUserball', data)
if _hide_ub_ids or _hide_fb_ids:
log.error("-------------- final hide info. room_id:{0}, uid:{1}, _hide_ub_ids:{2}, _hide_fb_ids:{3}".format(self.__id, uid, _hide_ub_ids, _hide_fb_ids))
_rank = yield redis.zrank(SET_RANK_ROOM_VOLUME%self.__id, uid)
_rank = 0 if _rank is None else int(_rank) + 1
_total = len(self.__users)
data.append((_rank, _total))
defer.returnValue((NO_ERROR, data))