def joust_info(self, user):
''' 获取大乱斗的基本信息 '''
_redis_key = SET_JOUST_CID_SCORE
_is_open = self.check_time_status()
if _is_open == JOUST_HAD_END_ERROR:
_redis_key = SET_JOUST_LAST_CID_SCORE
_score = yield self.get_char_score(user.cid, _redis_key)
_rank = yield self.get_char_rank(user.cid, _redis_key)
_joust_data, _status = yield self.get_joust_data(
user.cid, _score, _rank)
_left_count = JOUST_FREE_COUNT + _joust_data[2] - _joust_data[1]
#_left_buy_count = 0
#_vip_conf = get_vip_conf( user.vip_level )
#if _vip_conf:
# _left_buy_count = _vip_conf['JoustCount'] - _joust_data[2]
# if _left_buy_count < 0:
# _left_buy_count = 0
_details = yield self.get_joust_details(_joust_data[3])
_next_timestamp = 0
if not _status:
_next_timestamp = get_reward_timestamp(JOUST_HOUR_END)
elif 1 == _status:
_next_timestamp = get_reward_timestamp(JOUST_HOUR_START)
elif 2 == _status:
_next_timestamp = get_joust_reward_timestamp(1, JOUST_HOUR_START)
defer.returnValue((_rank, _score, _left_count, JOUST_FREE_COUNT,
_joust_data[4], _details, _status, _next_timestamp))
def arena_info(self, user):
'''
@summary: 获取竞技场信息
'''
total_rank = get_total_robot_rank()
cur_rank = yield self.get_char_rank( user.cid )
arena_data = [cur_rank, get_reward_timestamp(hours=ARENA_RANK_REWARD_HOUR), []]
enemy_rank = []
if cur_rank == 0:
# 全是机器人
enemy_rank = sorted(random.sample(range(total_rank-300, total_rank), 7))
for _rank in enemy_rank:
_detail = yield self.get_rank_detail( _rank )
if _detail:
arena_data[2].append( _detail )
# 玩家第一次进入竞技场的时候，统一没有排名 没有排名奖励
fellow_ids = yield user.fellow_mgr.get_camp_fellow_id()
arena_data[2].append( [user.cid, user.level, user.nick_name, 0, 0, 0, fellow_ids, user.lead_id] )
defer.returnValue( arena_data )
elif cur_rank >= 3000:
after_have = total_rank - cur_rank
if after_have <= 300:
enemy_rank = sorted(random.sample(range(cur_rank-300, cur_rank-1), 7))
enemy_rank.append( cur_rank )
else:
enemy_rank = self.random_enemy_rank( cur_rank, 300 )
elif cur_rank >= 1000:
enemy_rank = self.random_enemy_rank( cur_rank, 200 )
elif cur_rank >= 500:
enemy_rank = self.random_enemy_rank( cur_rank, 100 )
elif cur_rank >= 300:
enemy_rank = self.random_enemy_rank( cur_rank, 50 )
elif cur_rank >= 200:
enemy_rank = self.random_enemy_rank( cur_rank, 30 )
elif cur_rank >= 100:
enemy_rank = self.random_enemy_rank( cur_rank, 10 )
elif cur_rank > 5:
enemy_rank = self.random_enemy_rank( cur_rank, 5 )
else:
enemy_rank = range(1, 9)#self.random_enemy_rank( cur_rank, cur_rank, cur_rank, 7-cur_rank )
for _rank in enemy_rank:
# 一定保证返回当前玩家的信息, 防止排行榜异常
if _rank == cur_rank:
_gold , _prestige = self.get_rank_award( _rank )
fellow_ids = yield user.fellow_mgr.get_camp_fellow_id()
arena_data[2].append( [user.cid, user.level, user.nick_name, _rank, _gold, _prestige, fellow_ids, user.lead_id] )
else:
_detail = yield self.get_rank_detail( _rank )
if _detail:
arena_data[2].append( _detail )
defer.returnValue( arena_data )
def load_all_alliance(self):
try:
all_alliance_streams = yield redis.hgetall(HASH_ALLIANCE_INFO)
for stream in all_alliance_streams.itervalues():
_a = yield Alliance.load(stream)
if not _a:
continue
self.add_alliance(_a)
_remain = get_reward_timestamp(23, 59, 59) - int(time())
reactor.callLater(_remain, self.sync_alliance_rank)
except Exception as e:
reactor.callLater(1, self.load_all_alliance)
print 'WARNING. Redis connection fail, callLater 1 second. e:', e
def load_all_alliance( self ):
try:
all_alliance_streams = yield redis.hgetall( HASH_ALLIANCE_INFO )
for stream in all_alliance_streams.itervalues():
_a = yield Alliance.load( stream )
if not _a:
continue
self.add_alliance( _a )
_remain = get_reward_timestamp(23, 59, 59) - int(time())
reactor.callLater(_remain, self.sync_alliance_rank)
except Exception as e:
reactor.callLater(1, self.load_all_alliance)
print 'WARNING. Redis connection fail, callLater 1 second. e:', e
def daily_reward(self):
'''
@summary: 每日22:00-22:15发放奖励, 且更新幸运排名
'''
try:
# 发奖励
yield self.reward_to_award_center()
# 更新幸运排名, 并发放钻石
yield self.update_lucky_ranklist()
except Exception as e:
log.error('Exception e: {0}.'.format( e ))
# for test
DAILY_AWARD_INTERVAL = get_reward_timestamp(hours=ARENA_RANK_REWARD_HOUR) - int(time())
log.debug('Next 22:00 after {0} seconds will reward again.'.format( DAILY_AWARD_INTERVAL ))
reactor.callLater( DAILY_AWARD_INTERVAL, g_ArenaMgr.daily_reward )
def sync_alliance_rank(self):
_alliances = []
for _a in Server.__alliances:
_member_cids = _a.members
_total_might = 0
for _cid in _member_cids:
_m = yield g_UserMgr.get_offline_user(_cid)
if not _m:
continue
_total_might += _m.might
_a.set_might(_total_might)
bisect.insort_right(_alliances, _a)
Server.__alliances = _alliances
_remain = get_reward_timestamp(23, 59, 59) - int(time())
reactor.callLater(_remain, self.sync_alliance_rank)
def sync_alliance_rank(self):
_alliances = []
for _a in Server.__alliances:
_member_cids = _a.members
_total_might = 0
for _cid in _member_cids:
_m = yield g_UserMgr.get_offline_user(_cid)
if not _m:
continue
_total_might += _m.might
_a.set_might(_total_might)
bisect.insort_right( _alliances, _a )
Server.__alliances = _alliances
_remain = get_reward_timestamp(23, 59, 59) - int(time())
reactor.callLater(_remain, self.sync_alliance_rank)
def limit_item_info(self, member):
''' 仙盟商店中珍宝的兑换信息 '''
_data = yield redis.hget(HASH_ALLIANCE_LIMIT_ITEM, self.__id)
if _data:
_data = loads( _data )
# 判断是否是12点需要更新
_reset_timestamp = get_reset_timestamp(12)
if _data[0] <= _reset_timestamp:
random_item_ids = yield self.random_limit_item( self.__level )
if not random_item_ids:
log.error('Not found limit item conf. alliance_id: {0}, level: {1}.'.format( self.__id, self.__level ))
defer.returnValue( NOT_FOUND_CONF )
_data = [int(time()), self.__level, [[_s_id, []] for _s_id in random_item_ids]]
yield redis.hset(HASH_ALLIANCE_LIMIT_ITEM, self.__id, dumps(_data))
else:
random_item_ids = yield self.random_limit_item( self.__level )
if not random_item_ids:
log.error('Not found limit item conf. alliance_id: {0}, level: {1}.'.format( self.__id, self.__level ))
defer.returnValue( NOT_FOUND_CONF )
_data = [int(time()), self.__level, [[_s_id, []] for _s_id in random_item_ids]]
yield redis.hset(HASH_ALLIANCE_LIMIT_ITEM, self.__id, dumps(_data))
limit_items = [] # 珍宝的详细信息
limit_conf = get_shop_limit_conf( _data[1] )
for _idx, _detail in enumerate(_data[2]):
_item = limit_conf.get( _detail[0], None )
if _item:
_left_count = _item['BuyMax'] - len(_detail[1])
_left_count = 0 if _left_count < 0 else _left_count
# 是否已兑换的标志位
_status = 0 if member.cid in _detail[1] else 1
limit_items.append( (_idx, _item['ItemType'], _item['ItemID'], _item['ItemNum'], _left_count, _item['Cost'], _status) )
# 距离下一次刷新还需要的秒数
need_seconds = get_reward_timestamp(hours=12) - int(time())
defer.returnValue( (need_seconds, limit_items, self.__level, self.__exp) )
defer.returnValue( CHAR_PRESTIGE_NOT_ENOUGH )
# 扣声望值
user.consume_prestige( need_prestige, WAY_ARENA_EXCHANGE )
# 向背包中新增道具
model = ITEM_MODELs.get( conf['ItemType'], None )
if not model:
log.error('Can not find model. item type: {0}.'.format( conf['ItemType'] ))
defer.returnValue( ITEM_TYPE_ERROR )
res_err, add_items = yield model( user, ItemID=conf['ItemID'], ItemNum=exchange_count*conf['ItemNum'], AddType=WAY_ARENA_EXCHANGE, CapacityFlag=False )
if res_err:
defer.returnValue( res_err )
# 更新已兑换记录
if conf['MaxExchangeCount'] > 0:
old_excharge[2] += exchange_count
if conf['DailyExchangeCount'] > 0:
old_excharge[3] += exchange_count
yield redis.hset(HASH_ARENA_EXCHANGE, user.cid, dumps(data))
defer.returnValue( (user.base_att.prestige, old_excharge[2], old_excharge[3], add_items) )
try:
g_ArenaMgr
except NameError:
g_ArenaMgr = ArenaMgr()
DAILY_AWARD_INTERVAL = get_reward_timestamp(hours=ARENA_RANK_REWARD_HOUR) - int(time())
reactor.callLater( DAILY_AWARD_INTERVAL, g_ArenaMgr.daily_reward )