def _calc_update(self, data, req, timer):
"""更新史实城信息
请求 unit 模块
"""
city_id = LegendCityInfo.generate_id(data.id, req.city_id)
legendcity = data.legendcity_list.get(city_id)
unit_req = unit_pb2.UnitUpdateLegendCityReq()
unit_req.user_id = data.id
if req.HasField("slogan"):
unit_req.slogan = req.slogan
if req.HasField("tax"):
unit_req.tax = req.tax
if req.HasField("gold"):
#消耗元宝
unit_req.gold = req.gold
resource = data.resource.get()
original_gold = resource.gold
if not resource.cost_gold(req.gold):
raise Exception("Cost gold failed")
log = log_formater.output_gold(data,
-req.gold,
log_formater.LEGENDCITY_UPDATE,
"Updata legendcity",
before_gold=original_gold)
logger.notice(log)
defer = GlobalObject().remote['unit'].callRemote(
"update_city_info", legendcity.city_id,
unit_req.SerializeToString())
defer.addCallback(self._check_update, data, req, timer)
defer.addCallback(self._update_succeed, data, req, timer)
return defer
def _update_query_info(self, unit_response, data, req, timer):
"""更新史实城信息
"""
unit_res = unit_pb2.UnitQueryLegendCityRes()
unit_res.ParseFromString(unit_response)
if unit_res.status != 0:
raise Exception("Unit res error[res=%s]" % unit_res)
#更新匹配的对手
rivals_info = []
for index in range(0, len(unit_res.rivals_id)):
rivals_info.append(
(unit_res.rivals_id[index], unit_res.rivals_is_robot[index],
unit_res.rivals_position_level[index]))
city_id = LegendCityInfo.generate_id(data.id, req.city_id)
legendcity = data.legendcity_list.get(city_id)
legendcity.change_rivals(unit_res.invalid_rivals_id, rivals_info,
timer.now)
#查询对手当前情况
matcher = UserMatcher()
for (id, is_robot, position) in legendcity.get_rivals_info():
matcher.add_condition(id, is_robot)
defer = matcher.match()
defer.addCallback(self._pack_query_response, data, legendcity,
unit_res, req, timer)
return defer
def _calc_result(self, proxy, rival_id, city_id):
guard = proxy.get_result("guard", rival_id)
user = proxy.get_result("user", rival_id)
legendcity = proxy.get_result(
"legendcity", LegendCityInfo.generate_id(rival_id, city_id))
technology_list = proxy.get_all_result("technology")
hero_list = proxy.get_all_result("hero")
#防守阵容
self.player.set_pvp_enemy_guard(guard)
rival_heroes = []
heroes_id = self.player.get_heroes_id()
for hero_id in heroes_id:
for hero in hero_list:
if hero.id == hero_id:
rival_heroes.append(hero)
break
#战斗科技
tech_basic_ids = []
for technology in technology_list:
if not technology.is_upgrade and technology.is_battle_technology():
tech_basic_ids.append(technology.basic_id)
self.player.set_pvp_enemy_detail(
user, rival_heroes, technology_basic_ids = tech_basic_ids)
#史实城信息
buffs = legendcity.get_buffs(self.now)
self.player.set_legendcity_detail(rival_id, buffs, self.position_level)
return self
def init_legendcity(data, now):
"""初始化史实城
"""
for city_id in data_loader.LegendCityBasicInfo_dict:
node_id = NodeInfo.generate_id(
data.id, data_loader.LegendCityBasicInfo_dict[city_id].nodeId)
legendcity = LegendCityInfo.create(data.id, city_id, node_id, now)
data.legendcity_list.add(legendcity)
return True
def _calc_receive_legendcity_notice(self, data, req, timer):
"""接收到史实城战斗结果通知
添加战斗记录
"""
legendcity = data.legendcity_list.get(
LegendCityInfo.generate_id(data.id, req.city_id))
user = data.user.get(True)
guard = data.guard_list.get(data.id, True)
#传过来的是对手的战斗记录，根据对手的战斗记录，进行赋值
record = legendcity_business.add_battle_record(data, legendcity)
if req.record.result == req.record.WIN:
win = False
else:
win = True
record.set_result(win, False, timer.now)
rival_buffs = utils.join_to_string(
[buff.city_buff_id for buff in req.record.rival.buffs])
record.set_user(user, guard.get_team_score(), req.record.rival.level,
rival_buffs)
user_buffs = utils.join_to_string(
[buff.city_buff_id for buff in req.record.user.buffs])
record.set_rival_detail(req.record.user.user.user_id,
req.record.user.user.name,
req.record.user.user.level,
req.record.user.user.headicon_id,
req.record.user_battle_score,
req.record.user.level, user_buffs)
#防守方需要收到邮件
mail = mail_business.create_legendcity_defense_mail(
data, win, timer.now)
mail.attach_battle_info(win)
mail.attach_enemy_detail(req.record.user.user.name,
req.record.user.user.user_id,
NodeInfo.ENEMY_TYPE_LEGENDCITY)
mail.attach_legendcity_detail(req.record.user.city_id,
req.record.user.level)
self._push_mail(data.id, mail, timer)
#如果是太守发送广播
if req.record.rival.level == 7:
try:
self._receive_broadcast(data, req, timer)
except:
logger.warning("Send receive broadcast failed")
defer = DataBase().commit(data)
defer.addCallback(self._receive_legendcity_notice_succeed, req, timer)
return defer
def _match_user(self, city_id, rival_id):
"""查找真实玩家的信息
"""
#查询 rival 信息
proxy = DataProxy()
proxy.search("user", rival_id)
proxy.search("guard", rival_id)
proxy.search("legendcity", LegendCityInfo.generate_id(rival_id, city_id))
proxy.search_by_index("technology", "user_id", rival_id)
proxy.search_by_index("hero", "user_id", rival_id)
defer = proxy.execute()
defer.addCallback(self._calc_result, rival_id, city_id)
return defer
def _calc_query_rival(self, data, req, timer):
"""请求 unit 模块，核实对手信息
"""
city_id = LegendCityInfo.generate_id(data.id, req.rival.city_id)
legendcity = data.legendcity_list.get(city_id)
unit_req = unit_pb2.UnitCheckLegendCityReq()
unit_req.user_id = data.id
unit_req.rival_id = req.rival.user.user_id
unit_req.rival_position_level = req.rival.level
#查询官职信息
defer = GlobalObject().remote['unit'].callRemote(
"check", legendcity.city_id, unit_req.SerializeToString())
defer.addCallback(self._query_rival_detail, data, req, timer)
defer.addCallback(self._query_rival_succeed, data, req, timer)
return defer
def match(self, data, city_id, rival_id, is_robot, position_level, now):
"""进行匹配
"""
legendcity = data.legendcity_list.get(LegendCityInfo.generate_id(data.id, city_id))
rival = data.rival_list.get(legendcity.node_id)
if rival is None:
logger.debug("Create rival for legendcity[rival_id=%d]" % legendcity.node_id)
rival = RivalInfo.create(legendcity.node_id, data.id)
data.rival_list.add(rival)
self.player = rival
self.now = now
self.position_level = position_level
if is_robot:
return self._match_robot(city_id, rival_id)
else:
return self._match_user(city_id, rival_id)
def _calc_query(self, data, req, timer):
"""查询史实城
"""
user = data.user.get(True)
if not user.allow_pvp:
raise Exception("User pvp locked")
#获取之前匹配的对手信息
city_id = LegendCityInfo.generate_id(data.id, req.city_id)
legendcity = data.legendcity_list.get(city_id)
#用户花费元宝重新匹配对手
if req.HasField("rematch_position_level"):
cost_gold = legendcity.calc_rematch_cost(
req.rematch_position_level)
if cost_gold != req.gold:
raise Exception("Unmatched gold cost[expect=%d][cost=%d]" %
(cost_gold, req.gold))
resource = data.resource.get()
original_gold = resource.gold
if not resource.cost_gold(cost_gold):
raise Exception("Cost gold failed")
log = log_formater.output_gold(data,
-cost_gold,
log_formater.LEGENDCITY_REMATCH,
"Rematch player by gold",
before_gold=original_gold)
logger.notice(log)
unit_req = unit_pb2.UnitQueryLegendCityReq()
unit_req.user_id = data.id
unit_req.rematch_position_level = req.rematch_position_level
for (id, is_robot, position) in legendcity.get_rivals_info():
unit_req.rivals_id.append(id)
unit_req.rivals_position_level.append(position)
#请求 Unit 模块，查询当前的史实城情况
defer = GlobalObject().remote['unit'].callRemote(
"query_city_info", legendcity.city_id,
unit_req.SerializeToString())
defer.addCallback(self._update_query_info, data, req, timer)
return defer
def _calc_buy_buff(self, data, req, timer):
city_id = LegendCityInfo.generate_id(data.id, req.city_id)
legendcity = data.legendcity_list.get(city_id)
if req.HasField("item"):
#消耗物品获得 buff
item_id = ItemInfo.generate_id(data.id, req.item.basic_id)
item = data.item_list.get(item_id)
if not item.use_legendcity_buff_item():
raise Exception("Use legendcity buff item failed")
#检查 buff 和 item 是否匹配
if not legendcity.check_buff_available(req.city_buff_id,
req.item.basic_id):
raise Exception("Check buff available failed")
else:
#消耗元宝获得 buff
need = legendcity.get_buff_gold_cost(req.city_buff_id)
if need != req.gold:
raise Exception("Unmatch gold cost[need=%d][cost=%d]" %
(need, req.gold))
resource = data.resource.get()
original_gold = resource.gold
if not resource.cost_gold(need):
raise Exception("Cost gold failed")
log = log_formater.output_gold(data,
-need,
log_formater.LEGENDCITY_BUY_BUFF,
"Buy buff by gold",
before_gold=original_gold)
logger.notice(log)
if not legendcity.add_buff(req.city_buff_id, timer.now):
raise Exception("Add legendcity buff failed")
if req.HasField("item"):
compare.check_item(data, req.item)
defer = DataBase().commit(data)
defer.addCallback(self._buy_buff_succeed, req, timer)
return defer
def _calc_reset_attack(self, data, req, timer):
"""花费元宝，重置攻击次数
"""
city_id = LegendCityInfo.generate_id(data.id, req.city_id)
legendcity = data.legendcity_list.get(city_id)
if not legendcity.reset_attack_count(req.gold):
raise Exception("Reset attack count failed")
resource = data.resource.get()
original_gold = resource.gold
if not resource.cost_gold(req.gold):
raise Exception("Cost gold failed")
log = log_formater.output_gold(data,
-req.gold,
log_formater.LEGENDCITY_RESET,
"Reset attack in legendcity",
before_gold=original_gold)
logger.notice(log)
defer = DataBase().commit(data)
defer.addCallback(self._reset_attack_succeed, req, timer)
return defer
def _query_rival_detail(self, unit_response, data, req, timer):
"""查询对手现在的详细情况
"""
unit_res = unit_pb2.UnitCheckLegendCityRes()
unit_res.ParseFromString(unit_response)
if unit_res.status != 0:
raise Exception("Unit res error[res=%s]" % unit_res)
#如果对手已经处于不合法的状态，返回原因
if unit_res.ret != legendcity_pb2.OK:
return self._pack_query_rival_invalid_response(unit_res)
city_id = LegendCityInfo.generate_id(data.id, req.rival.city_id)
legendcity = data.legendcity_list.get(city_id, True)
(rival_id, is_robot,
position_level) = legendcity.get_rival_info(req.rival.user.user_id)
#查询对手的详情
matcher = LegendCityRivalMatcher()
defer = matcher.match(data, req.rival.city_id, rival_id, is_robot,
position_level, timer.now)
defer.addCallback(self._check_rival_detail, data, timer)
return defer