def _calc_union_season_battle_post(self, pre_proxy, data, req, timer):
union = data.union.get(True)
rankings = {}
#获得己方联盟的排名
if union.is_belong_to_union():
own_ranking = pre_proxy.get_ranking("unionseason", "score",
union.union_id)
own_season = pre_proxy.get_result("unionseason", union.union_id)
rankings[own_ranking] = own_season
results = pre_proxy.get_rank_result("unionseason", "score",
req.start_index - 1,
req.end_index - 1)
for i, season in enumerate(results):
rankings[i] = season
#查询联盟信息
proxy = DataProxy()
for index in rankings:
proxy.search("unionunion", rankings[index].union_id)
defer = proxy.execute()
defer.addCallback(self._calc_union_season_battle_result, rankings,
data, req, timer)
return defer
def _calc_accept_friend(self, data, req, timer):
proxy = DataProxy()
proxy.search("user", req.friend_id)
defer = proxy.execute()
defer.addCallback(self._calc_accept_friend_info, data, req, timer)
return defer
def _calc_result(self, pre_proxy):
self.user = pre_proxy.get_result("user", self.user_id)
self.battle_score = pre_proxy.get_result("battle_score", self.user_id)
self.union = pre_proxy.get_result("union", self.user_id)
self.technologys = pre_proxy.get_all_result("technology")
#过滤 team
teams_id = self.battle_score.get_powerful_teams_id()
self.teams = []
teams = pre_proxy.get_all_result("team")
for team in teams:
if team.id in teams_id:
self.teams.append(team)
#查询 heroes
heroes_id = []
for team in self.teams:
heroes_id.extend(team.get_heroes())
proxy = DataProxy()
for hero_id in heroes_id:
proxy.search("hero", hero_id)
defer = proxy.execute()
defer.addCallback(self._calc_detail_result)
return defer
def load_from_cache(self, id):
"""从 cache 中载入联盟数据
Args:
id[int]: 联盟 id
"""
self.id = id
proxy = DataProxy()
proxy.search("unionunion", id)
proxy.search_by_index("unionmember", "union_id", id)
proxy.search_by_index("unionapplication", "union_id", id)
proxy.search_by_index("unionaid", "union_id", id)
proxy.search("unionseason", id)
proxy.search_by_index("unionbattle", "union_id", id)
proxy.search_by_index("unionbattle_node", "union_id", id)
proxy.search_by_index("unionbattle_record", "union_id", id)
proxy.search_by_index("uniondonatebox", "union_id", id)
proxy.search_by_index("uniondonaterecord", "union_id", id)
proxy.search_by_index("unionboss", "union_id", id)
defer = proxy.execute()
defer.addCallback(self._post_load)
return defer
def _calc_season_result(self, pre_proxy, req, union_min, union_max,
indiv_min, indiv_max, timer):
seasons = []
users = []
for i, union_info in enumerate(
pre_proxy.get_rank_result("unionseason", "score", union_min,
union_max)):
seasons.append(union_info)
for i, indiv_info in enumerate(
pre_proxy.get_rank_result("union", "season_score", indiv_min,
indiv_max)):
users.append(indiv_info)
#查询联盟信息
proxy = DataProxy()
for union_info in seasons:
proxy.search("unionunion", union_info.union_id)
proxy.search_by_index("unionmember", "union_id",
union_info.union_id)
for indiv_info in users:
proxy.search("user", indiv_info.user_id)
defer = proxy.execute()
defer.addCallback(self._calc_season_ranking_result, req, seasons,
users, timer)
return defer
def _set_pvp_rival_guard(self, proxy, rival_user_id, rival):
"""
"""
guards = proxy.get_all_result("guard")
rival_guard = None
for guard in guards:
if guard.user_id == rival_user_id:
#一个玩家目前只对应一个guard
rival_guard = guard
break
#if rival_guard is None:
# rival.clear() #该玩家不存在或没有guard信息
rival.set_pvp_enemy_guard(rival_guard)
if rival_guard == None:
rival.rival_id = rival_user_id
rival.is_rob = True
cache_proxy = DataProxy()
#查询 user, technology, hero, resource, defense 表
cache_proxy.search("user", rival.rival_id)
cache_proxy.search("union", rival.rival_id)
cache_proxy.search_by_index("technology", "user_id", rival.rival_id)
heroes_id = rival.get_heroes_id()
for hero_id in heroes_id:
if hero_id != 0:
cache_proxy.search("hero", hero_id)
if rival.is_rob:
cache_proxy.search("resource", rival.rival_id)
cache_proxy.search("defense", rival.defense_id)
defer = cache_proxy.execute()
return defer
def _calc_query_melee_ranking(self, proxy, user_id, scores_range, req,
timer):
cache_proxy = DataProxy()
self_arena = proxy.get_result("melee", user_id)
self_ranking = proxy.get_ranking("melee", "score", user_id) + 1
cache_proxy.search("user", user_id)
all_arenas = {}
all_arenas_rank = {}
player_rankings = {}
for range in scores_range:
arena_list = proxy.get_rank_score_result("melee", "score",
range[0], range[1], 0,
MELEE_COUNT)
#按照积分先排序
arena_list.sort(lambda x, y: cmp(ArenaInfo.get_real_score(
x.score), ArenaInfo.get_real_score(y.score)),
reverse=True)
arena_rank = 1
for arena in arena_list:
all_arenas[arena.user_id] = arena
all_arenas_rank[arena.user_id] = arena_rank
arena_rank = arena_rank + 1
cache_proxy.search("user", arena.user_id)
defer = cache_proxy.execute()
defer.addCallback(self._query_melee_ranking_succeed, user_id,
self_arena, self_ranking, all_arenas,
all_arenas_rank, req, timer)
return defer
def _calc_chat_friend(self, data, req, timer):
logger.notice("TEXT = %s" % req.content)
proxy = DataProxy()
proxy.search("user", req.friend_id)
defer = proxy.execute()
defer.addCallback(self._calc_chat_friend_info, data, req, timer)
return defer
def match(self, data, city_id):
"""进行匹配
"""
proxy = DataProxy()
proxy.search("unitcity", city_id)
defer = proxy.execute()
defer.addCallback(self._calc_result, city_id)
return defer
def _calc_approve(self, data, req, timer):
"""审批
"""
#判断目标用户是否存在
proxy = DataProxy()
proxy.search("user", req.target_user_id)
defer = proxy.execute()
defer.addCallback(self._calc_approve_query, data, req, timer)
return defer
def _collect(self, pre_proxy):
"""收集信息
"""
proxy = DataProxy()
for union in pre_proxy.get_all_result("unionunion"):
proxy.search("unionseason", union.id)
defer = proxy.execute()
defer.addCallback(self._calc_result)
return defer
def match(self):
"""进行匹配
"""
proxy = DataProxy()
for user_id in self.ids:
proxy.search("user", user_id)
defer = proxy.execute()
defer.addCallback(self._calc_result)
return defer
def _calc_result(self, pre_proxy):
self.members = {}
for member in pre_proxy.get_all_result("unionmember"):
if member.is_join_battle:
self.members[member.user_id] = member
proxy = DataProxy()
for user_id in self.members:
proxy.search("user", user_id)
defer = proxy.execute()
defer.addCallback(self._calc_detail_result)
return defer
def patch(self, union_id):
proxy = DataProxy()
proxy.search("unionseason", union_id)
proxy.search_by_index("unionbattle", "union_id", union_id)
proxy.execute(asyn=False)
season = proxy.get_result("unionseason", union_id)
for battle in proxy.get_all_result("unionbattle"):
if battle.index == season.current_battle_index:
return battle.stage
raise Exception("union data error")
def match(self):
"""查询玩家信息、战力信息
"""
#self.user_id = user_id
proxy = DataProxy()
for user_id in self.ids:
proxy.search("user", user_id)
proxy.search("battle_score", user_id)
defer = proxy.execute()
defer.addCallback(self._calc_result)
return defer
def _update_last_user_level_rank(proxy):
results = proxy.get_rank_result("battle_score", "score", 0, 49)
if len(results) == 0:
MissionPool.update_last_user_level(0)
return 0
last_user_id = results[len(results) - 1].user_id
proxy = DataProxy()
proxy.search("user", last_user_id)
defer = proxy.execute()
defer.addCallback(_update_last_user_level_result, last_user_id)
return defer
def _filter_pvp_rival(self, proxy):
"""筛选出合适的对手
筛选掉不合法的对手（比如重复的对手）
"""
exit_rivals = []
for rival in self._pvp_players:
candidate = []
guard_list = proxy.get_rank_score_result("guard", "score",
rival.score_min, rival.score_max, rival.offset, rival.count)
for guard in guard_list:
if guard.user_id not in self._invalid:
logger.debug("Candidate[user id=%d]" % guard.user_id)
candidate.append(guard)
#如果可选对手为空，退化为 PVE
if len(candidate) == 0:
logger.warning("Bad luck for no candidate[id=%d][%d-%d][%d,%d]" %
(rival.id, rival.score_min, rival.score_max,
rival.offset, rival.count))
exit_rivals.append(rival)
continue
#随机选择
random.seed()
rival_guard = random.sample(candidate, 1)[0]
rival.set_pvp_enemy_guard(rival_guard)
self._invalid.append(rival.rival_id) #不能匹配到重复的敌人
logger.debug("Add invalid user[user id=%d]" % rival.rival_id)
#退化成 PVE 对手
for rival in exit_rivals:
self._pvp_convert_to_pve(rival)
cache_proxy = DataProxy()
#查询 user, technology, hero, resource, defense 表
for rival in self._pvp_players:
cache_proxy.search("user", rival.rival_id)
cache_proxy.search("union", rival.rival_id)
cache_proxy.search_by_index("technology", "user_id", rival.rival_id)
heroes_id = rival.get_heroes_id()
for hero_id in heroes_id:
if hero_id != 0:
cache_proxy.search("hero", hero_id)
if rival.is_rob:
cache_proxy.search("resource", rival.rival_id)
cache_proxy.search("defense", rival.defense_id)
defer = cache_proxy.execute()
return defer
def load_from_cache(self, id):
"""从 cache 中载入城池数据
Args:
id[int]: 城池 id
"""
self.id = id
proxy = DataProxy()
proxy.search("unitcity", id)
proxy.search_by_index("unitposition", "city_id", id)
defer = proxy.execute()
defer.addCallback(self._post_load)
return defer
def _calc_be_invited(self, data, req, timer):
"""
"""
inviter_id = utils.decode(req.invite_code, utils.INVITE_CODE_KEY)
if inviter_id == "":
inviter_id = 0
else:
inviter_id = long(inviter_id)
cache_proxy = DataProxy()
#查询玩家所在房间人数
cache_proxy.search("user", inviter_id)
defer = cache_proxy.execute()
defer.addCallback(self._check_inviter_id, data, inviter_id, req, timer)
return defer
def _query_activity_hero_ranking(self, user_id, req, timer):
if req.start_index < 1 or req.start_index > req.end_index:
raise Exception("Ranking req error")
proxy = DataProxy()
proxy.search("draw", user_id) #先查玩家自己的draw
proxy.search_ranking("draw", "activity_scores", user_id) #先查玩家自己的排名
proxy.search_by_rank("draw", "activity_scores", req.start_index - 1,
req.end_index - 1)
defer = proxy.execute()
defer.addCallback(self._calc_query_activity_hero_ranking, user_id, req,
timer)
defer.addErrback(self._query_activity_hero_ranking_failed, req, timer)
return defer
def _query_player_powerful_team_heroes(self, proxy, technology_basic_ids,
req, timer, teams_id):
teams = proxy.get_all_result("team")
proxy = DataProxy()
for team in teams:
for hero_id in team.get_heroes():
if hero_id == 0:
continue
else:
proxy.search("hero", hero_id)
defer = proxy.execute()
defer.addCallback(self._query_ranking_player_powerful_teams_succeed,
technology_basic_ids, req, timer, teams)
return defer
def _query_worldboss_ranking(self, user_id, req, timer):
if req.start_index < 1 or req.start_index > req.end_index:
raise Exception("Ranking req error")
proxy = DataProxy()
proxy.search("worldboss", user_id) #先查玩家自己的worldboss
proxy.search_ranking("worldboss", "merit", user_id) #先查玩家自己的排名
proxy.search_by_rank("worldboss", "merit", req.start_index - 1,
req.end_index - 1)
defer = proxy.execute()
defer.addCallback(self._calc_query_worldboss_ranking, user_id, req,
timer)
defer.addErrback(self._query_worldboss_ranking_failed, req, timer)
return defer
def match_specify(self, data, plunder, rival_user_id, country):
"""
"""
rival_id = plunder.generate_specify_rival_id()
rival = data.rival_list.get(rival_id)
self.players[rival.id] = rival
self._pvp_players.append(rival)
cache_proxy = DataProxy()
cache_proxy.search("guard", rival_user_id)
defer = cache_proxy.execute()
defer.addCallback(self._set_pvp_rival_guard, rival_user_id, rival)
defer.addCallback(self._calc_pvp_rival_info, country)
return defer
def _select_players_info(self, proxy, data, melee, players_rank):
"""查询玩家的主公信息、阵容和战斗科技
"""
users_id = []
users_arena = {}
users_arena_ranking = {}
for rank in players_rank:
if rank > self.users_count: #超过本房间人数则跳过
continue
results = proxy.get_rank_result("melee", "score",
self.rank_base + rank - 1,
self.rank_base + rank - 1)
if len(results) == 0:
continue
#匹配到玩家自己，舍弃
if results[0].user_id == data.user.get(True).id:
continue
#匹配到积分为0的玩家，舍弃
if MeleeInfo.get_real_score(results[0].score) == 0:
continue
#如果乱斗场阵容不足9个，舍弃
if len(utils.split_to_int(results[0].heroes_basic_id)) != 9:
logger.warning("melee heroes_id not correct.[user_id=%d]" %
results[0].user_id)
continue
#assert len(results) == 1
user_id = results[0].user_id
users_id.append(user_id)
users_arena[user_id] = results[0]
users_arena_ranking[user_id] = rank
cache_proxy = DataProxy()
for user_id in users_id:
cache_proxy.search("user", user_id) #查询主公信息
cache_proxy.search("guard", user_id) #查阵容
cache_proxy.search_by_index("technology", "user_id",
user_id) #查战斗科技
defer = cache_proxy.execute()
defer.addCallback(self._select_teams, data, melee, users_id,
users_arena, users_arena_ranking)
return defer
def _calc_query_activity_hero_ranking(self, proxy, user_id, req, timer):
self_score = proxy.get_result("draw", user_id).activity_scores
self_ranking = proxy.get_ranking("draw", "activity_scores",
user_id) + 1
results = proxy.get_rank_result("draw", "activity_scores",
req.start_index - 1, req.end_index - 1)
proxy = DataProxy()
players = {}
players_ranking = {}
for i, value in enumerate(results):
players[value.user_id] = value
players_ranking[value.user_id] = i
proxy.search("user", value.user_id)
proxy.search("user", user_id) #再查一下玩家自己
#players的积分排名，需要保证积分相同时，后达到积分的人排名在后面
for (k, v) in players.items():
k_draw_last_time = v.last_gold_draw_time
k_score = v.activity_scores
k_ranking = players_ranking[k]
for (k1, v1) in players.items():
if k == k1:
continue
k1_draw_last_time = v1.last_gold_draw_time
k1_score = v1.activity_scores
k1_ranking = players_ranking[k1]
if (k_score == k1_score
and k_draw_last_time < k1_draw_last_time
and k_ranking > k1_ranking):
#互换排名
players_ranking[k] = k1_ranking
players_ranking[k1] = k_ranking
k_ranking = k1_ranking
if user_id in players_ranking:
self_ranking = players_ranking[user_id] + 1
defer = proxy.execute()
defer.addCallback(self._query_activity_hero_ranking_succeed, user_id,
req, self_ranking, self_score, players,
players_ranking, timer)
return defer
def _query_anneal_hard_mode_ranking(self, user_id, req, timer):
if req.start_index < 1 or req.start_index > req.end_index:
raise Exception("Ranking req error")
proxy = DataProxy()
proxy.search("anneal", user_id) #先查玩家自己的anneal
proxy.search_ranking("anneal", "hard_floor", user_id) #先查玩家自己的排名
proxy.search_by_rank("anneal", "hard_floor", req.start_index - 1,
req.end_index - 1)
defer = proxy.execute()
defer.addCallback(self._calc_query_anneal_hard_mode_ranking, user_id,
req, timer)
defer.addErrback(self._query_anneal_hard_mode_ranking_failed, req,
timer)
return defer
def _query_kill_enemy_ranking(self, user_id, req, timer):
if req.start_index < 1 or req.start_index > req.end_index:
raise Exception("Ranking req error")
proxy = DataProxy()
proxy.search("trainer", user_id) #先查玩家自己的battle
proxy.search_ranking("trainer", "kills", user_id) #先查玩家自己的排名
proxy.search_by_rank("trainer", "kills", req.start_index - 1,
req.end_index - 1)
defer = proxy.execute()
defer.addCallback(self._calc_query_kill_enemy_ranking, user_id, req,
timer)
defer.addErrback(self._query_kill_enemy_ranking_failed, user_id, req,
timer)
return defer
def _query_users(self, proxy, min_score, max_score, count, users):
"""
"""
results = proxy.get_rank_score_result(
"arena", "score", min_score, max_score, 0, count)
cache_proxy = DataProxy()
arena_rankings = {}
arenas = {}
for i,value in enumerate(results):
arena_rankings[value.user_id] = i + 1 #排名
arenas[value.user_id] = value
cache_proxy.search("user", value.user_id)
defer = cache_proxy.execute()
defer.addCallback(self._get_users, min_score, max_score,
arenas, arena_rankings, users)
return defer
def _calc_union_season_battle(self, data, req, timer):
if req.start_index < 1 or req.start_index > req.end_index:
raise Exception("Ranking req error")
union = data.union.get(True)
proxy = DataProxy()
if union.is_belong_to_union():
proxy.search_ranking("unionseason", "score", union.union_id)
proxy.search("unionseason", union.union_id)
proxy.search_by_rank("unionseason", "score", req.start_index - 1,
req.end_index - 1)
defer = proxy.execute()
defer.addCallback(self._calc_union_season_battle_post, data, req,
timer)
defer.addCallback(self._query_succeed, req, timer)
return defer
def load_from_cache(self, id):
"""从 cache 中载入基础数据
Args:
id[int]:
"""
self.id = id
proxy = DataProxy()
proxy.search("basicinit", self.id)
proxy.search_by_index("basicactivity", "basic_id", self.id)
proxy.search_by_index("basicactivitystep", "basic_id", self.id)
proxy.search_by_index("basicactivityheroreward", "basic_id", self.id)
proxy.search_by_index("basicworldboss", "basic_id", self.id)
defer = proxy.execute()
defer.addCallback(self._post_load)
return defer
