def match(self, now):
proxy = DataProxy()
proxy.search_by_rank("unionunion", "recent_prosperity",
self.RANK_START, self.RANK_STOP)
defer = proxy.execute()
defer.addCallback(self._calc_result)
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_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 _pre_select_pvp_rival(self, proxy):
"""初步选择对手
在可选区间内，初步随机选择 X 名对手
通常情况下，X > 1，为了避免选择到的对手不合适而需要重新请求
Args:
proxy[DataProxy]
"""
cache_proxy = DataProxy()
exit_rivals = []
least_count = 3 #初步选择3人
for rival in self._pvp_players:
total_count = proxy.get_rank_score_count(
"guard", "score", rival.score_min, rival.score_max)
if total_count <= 0:
#对应的区间范围内无合适的 PVP 对手，退化为 PVE
logger.warning("Invalid rival score range[id=%d][%d-%d]" %
(rival.id, rival.score_min, rival.score_max))
exit_rivals.append(rival)
random.seed()
count = min(least_count, total_count)
offset = random.randint(0, total_count - count)
rival.set_pvp_filter_range(offset, count)
cache_proxy.search_by_rank_score("guard", "score",
rival.score_min, rival.score_max, rival.offset, rival.count)
#退化成 PVE 对手
for rival in exit_rivals:
self._pvp_convert_to_pve(rival)
defer = cache_proxy.execute()
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 update_last_user_level():
"""更新第50名用户的等级"""
proxy = DataProxy()
proxy.search_by_rank("battle_score", "score", 0, 49)
defer = proxy.execute()
defer.addCallback(_update_last_user_level_rank)
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, now):
"""进行推荐
"""
proxy = DataProxy()
proxy.get_all("unionunion", "id")
defer = proxy.execute()
defer.addCallback(self._calc_result, now)
return defer
def match(self):
"""进行匹配
"""
proxy = DataProxy()
proxy.get_all("user", "id")
defer = proxy.execute()
defer.addCallback(self._calc_result)
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 query_specify_user(self, str_list, rival):
"""字符串查询匹配
"""
proxy = DataProxy()
proxy.get_all("user", "id")
defer = proxy.execute()
defer.addCallback(self._calc_query_specify_user_result, str_list)
defer.addCallback(self._query_user_info, rival)
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 _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 _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 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 search(self, unions):
"""查询联盟战争中的玩家信息
"""
self.unions = unions
proxy = DataProxy()
for union_id in self.unions:
proxy.search_by_index("unionmember", "union_id", union_id)
defer = proxy.execute()
defer.addCallback(self._calc_result)
return defer
def get_all(self, name, field_name):
"""获取字段所有值
"""
self.name = name
self.field_name = field_name
proxy = DataProxy()
proxy.get_all_values(self.name, self.field_name)
defer = proxy.execute()
defer.addCallback(self._calc_result)
return defer
def check(self, name, field_name, field_value):
"""检查字段值是否重复
"""
self.name = name
self.field_name = field_name
self.field_value = field_value
proxy = DataProxy()
proxy.is_value_exist(self.name, self.field_name, self.field_value)
defer = proxy.execute()
defer.addCallback(self._calc_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 _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 _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 match(self):
"""匹配
1 筛选所有符合参战条件的联盟
2 优先匹配联盟匹配隐藏积分相同的队伍
# 3 优先匹配联盟成员人数接近的联盟
# 4 优先匹配平均等级接近的联盟
5 尽量不匹配上次的对手
"""
proxy = DataProxy()
proxy.get_all("unionunion", "id")
defer = proxy.execute()
defer.addCallback(self._collect)
return defer
def commit(self, right):
"""确认修改
将自身的数据修改到和 right 一致，并同步到 DB 中
"""
proxy = DataProxy()
for field_name in self.__slots__:
lfield = getattr(self, field_name)
rfield = getattr(right, field_name)
lfield.commit(rfield, proxy)
defer = proxy.execute()
defer.addCallback(self._check_commit)
return defer
def _query_arenas_by_ranking(self, status, arena, count, users):
"""按照排名查询竞技场信息
"""
assert status is True
cache_proxy = DataProxy()
#查询玩家所在房间的前count名
(min_score, max_score) = ArenaInfo.get_index_score_range(arena.index)
cache_proxy.search_by_rank_score(
"arena", "score", min_score, max_score, 0, count)
defer = cache_proxy.execute()
defer.addCallback(self._query_users, min_score, max_score, count, users)
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 match(self):
"""查询玩家信息、战力信息
"""
proxy = DataProxy()
for user_id in self.ids:
proxy.search("user", user_id)
proxy.search("battle_score", user_id)
proxy.search("union", user_id)
defer = proxy.execute()
defer.addCallback(self._calc_result)
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 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 _match_melee(self, status, data, melee):
"""匹配副本对手
"""
assert status is True
x = self.rank
players_rank = []
#根据规则，挑选出要选作对手的玩家排名
if x <= 10:
if x == 1:
players_rank += random.sample(range(2, x + 50), 3)
elif x == 2:
players_rank.append(1)
players_rank += random.sample(range(3, x + 50), 2)
else:
players_rank += random.sample(range(1, x), 1)
players_rank += random.sample(range(x, x + 50), 2)
elif x > 10 and x <= 100:
players_rank += random.sample(
range(int(math.ceil(0.5 * x - 5)), x), 1)
players_rank += random.sample(range(x, x + 100), 2)
elif x > 100 and x <= 1000:
#players_rank += random.sample(range(int(math.ceil(0.5 * x - 10)), int(math.ceil(0.5 * x + 10))), 1)
players_rank += random.sample(
range(int(math.ceil(0.5 * x - 10)), x), 1)
#players_rank += random.sample(range(x-30, x), 1)
players_rank += random.sample(range(x, x + 100), 2)
elif x > 1000:
#players_rank += random.sample(range(int(math.ceil(0.5 * x - 50)), int(math.ceil(0.5 * x + 50))), 1)
players_rank += random.sample(
range(int(math.ceil(0.5 * x - 50)), x), 1)
#players_rank += random.sample(range(int(math.ceil(0.9 * x - 100)), x), 1)
players_rank += random.sample(range(x, x + 100), 2)
assert len(players_rank) == 3
logger.debug("match players by rank[self_rank=%d][match rank=[%d, %d, %d]" %\
(x, players_rank[0], players_rank[1], players_rank[2]))
cache_proxy = DataProxy()
for rank in players_rank:
if rank > self.users_count: #超过本房间人数则跳过
continue
cache_proxy.search_by_rank("melee", "score",
self.rank_base + rank - 1,
self.rank_base + rank - 1)
defer = cache_proxy.execute()
defer.addCallback(self._select_players_info, data, melee, players_rank)
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
