def _calc_start_battle_result(self, union_response, data, req, timer):
res = union_boss_pb2.StartUnionBossBattleRes()
res.status = 0
union_res = internal_union_pb2.InternalSyncBossRes()
union_res.ParseFromString(union_response)
if union_res.status != 0:
raise Exception("Start union boss battle failed")
if union_res.ret != union_pb2.UNION_OK:
res.ret = union_res.ret
return self._start_battle_succeed(data, req, res, timer)
if union_res.boss_status != UserUnionBossInfo.BATTLE:
if union_res.boss_status == UserUnionBossInfo.INACTIVE:
res.ret = union_pb2.UNION_BOSS_INACTIVE
else:
res.ret = union_pb2.UNION_BOSS_KILLED
return self._start_battle_succeed(data, req, res, timer)
boss_id = union_res.boss_id
array_index = req.world_boss_choose_index #选择boss队伍的index
#参战队伍 & 英雄
teams = []
heroes = []
for team_info in req.battle.attack_teams:
team_id = TeamInfo.generate_id(data.id, team_info.index)
team = data.team_list.get(team_id)
if team is None:
continue
teams.append(team)
for hero_id in team.get_heroes():
if hero_id != 0:
hero = data.hero_list.get(hero_id)
heroes.append(hero)
(ret, battle_ret) = union_boss_business.start_battle(data, boss_id,
array_index, teams, heroes, timer.now, req.gold)
if ret != union_pb2.UNION_OK or battle_ret != battle_pb2.BATTLE_OK:
res.ret = ret
res.battle_ret = battle_ret
return self._start_battle_succeed(data, req, res, timer)
node_id = NodeInfo.generate_id(data.id, UserUnionInfo.get_union_boss_node_basic_id())
battle = data.battle_list.get(node_id, True)
resource = data.resource.get(True)
pack.pack_battle_reward_info(battle, res.reward)
pack.pack_resource_info(resource, res.resource)
conscript_list = data.conscript_list.get_all(True)
for conscript in conscript_list:
pack.pack_conscript_info(conscript, res.conscripts.add(), timer.now)
res.ret = union_pb2.UNION_OK
res.battle_ret = battle_pb2.BATTLE_OK
defer = DataBase().commit(data)
defer.addCallback(self._start_battle_succeed, req, res, timer)
return defer
def _pack_pvp_players_response(self, proxy, data, plunder, plunder_matcher, req, timer):
"""构造返回
Returns:
res[protobuf]: 向客户端的返回的响应
"""
res = map_pb2.QueryPlayersRes()
res.status = 0
for id in plunder_matcher.players:
rival = data.rival_list.get(id, True)
player_msg = res.players.add()
pack.pack_plunder_player(rival, player_msg)
#如果已经是仇人了，加上仇恨值
enemy = plunder_business.get_plunder_enemy(data, rival.rival_id)
if enemy is not None:
player_msg.hatred = enemy.hatred
res.attack_num = plunder.attack_num
res.left_reset_num = plunder.get_left_reset_num()
resource = data.resource.get()
resource.update_current_resource(timer.now)
pack.pack_resource_info(resource, res.resource)
defer = DataBase().commit(data)
defer.addCallback(self._query_pvp_players_succeed, req, res, timer)
return defer
def _calc_buy_goods(self, data, req, timer):
union = data.union.get()
if not union.is_belong_to_target_union(req.index):
#玩家不属于联盟
logger.debug("User is not belong to union")
res = wineShop_pb2.BuyGoodsRes()
res.status = 0
res.invalid = True
else:
shop_id = ShopInfo.generate_id(data.id, req.goods.type)
shop = data.shop_list.get(shop_id)
if not shop_business.buy_goods(data, shop, req.goods.id,
timer.now):
raise Exception("Buy Goods failed")
compare.check_item(data, req.item)
res = wineShop_pb2.BuyGoodsRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
res.current_tokens = union.honor
defer = DataBase().commit(data)
defer.addCallback(self._buy_goods_succeed, req, res, timer)
return defer
def _pack_draw_response(self, data, hero_list, item_list,
resource, search_num, next_time, now):
"""封装响应
返回客户端的是抽奖获得的英雄和物品（并未将已经拥有的英雄分解成将魂石）
客户端会自行进行分解
"""
win_hero = []
for (basic_id, num) in hero_list:
soldier_basic_id = HeroInfo.get_default_soldier_basic_id(basic_id)
soldier_id = SoldierInfo.generate_id(data.id, soldier_basic_id)
soldier = data.soldier_list.get(soldier_id, True)
hero = HeroInfo.create(data.id, basic_id, soldier, technology_basic_ids = [])
for i in range(0, num):
win_hero.append(hero)
win_item = []
for (basic_id, num) in item_list:
item = ItemInfo.create(data.id, basic_id, num)
win_item.append(item)
res = wineShop_pb2.WineShopDrawRes()
res.status = 0
for item in win_item:
pack.pack_item_info(item, res.items.add())
for hero in win_hero:
pack.pack_hero_info(hero, res.heroes.add(), now)
pack.pack_resource_info(resource, res.resource)
res.draw.search_num = search_num
res.draw.next_left_time = max(0, next_time - now)
return res
def _finish_sweep_succeed(self, data, anneal, sweep_rewards, items, heroes,
req, timer):
#构造返回
res = anneal_pb2.FinishSweepRes()
res.status = 0
pack.pack_anneal_info(data, anneal, res.anneal, timer.now)
pack.pack_resource_info(data.resource.get(True), res.resource)
for (money, food, reward) in sweep_rewards:
reward_message = res.reward.add()
reward_message.resource.money = money
reward_message.resource.food = food
for (basic_id, num) in reward:
item_message = reward_message.items.add()
item_message.basic_id = basic_id
item_message.num = num
for item in items:
pack.pack_item_info(item, res.items.add())
for hero in heroes:
hero_message = res.heros.add()
hero_message.basic_id = hero[0]
hero_message.level = hero[1]
hero_message.exp = hero[2]
response = res.SerializeToString()
log = log_formater.output(data, "Finish sweep succeed", req, res,
timer.count_ms())
logger.notice(log)
return response
def _calc_reset_hard_attack_num(self, data, req, timer):
res = anneal_pb2.ResetHardAttackNumRes()
res.status = 0
ret = Ret()
if not anneal_business.reset_hard_attack_num(data, req.floor,
timer.now, ret):
if ret.get() == 'GOLD_NOT_ENOUGH':
res.ret = anneal_pb2.ResetHardAttackNumRes.GOLD_NOT_ENOUGH
elif ret.get() == 'VIP_NOT_ENOUGH':
res.ret = anneal_pb2.ResetHardAttackNumRes.VIP_NOT_ENOUGH
return self._reset_hard_attack_num_succeed(data, req, res, timer)
resource = data.resource.get()
resource.update_current_resource(timer.now)
res.ret = anneal_pb2.ResetHardAttackNumRes.OK
pack.pack_resource_info(resource, res.resource)
pack.pack_anneal_info(data, data.anneal.get(True), res.anneal,
timer.now)
defer = DataBase().commit(data)
defer.addCallback(self._reset_hard_attack_num_succeed, req, res, timer)
return defer
def _calc_individual_step_result(self, union_response, data, req, timer):
union_res = internal_union_pb2.InternalQueryUnionBattleRes()
union_res.ParseFromString(union_response)
if union_res.status != 0:
raise Exception("Query union battle res error")
res = union_battle_pb2.AcceptUnionBattleIndividualsRes()
res.status = 0
res.ret = union_res.ret
if res.ret == union_pb2.UNION_OK:
#领取战功阶段奖励
(honor,
items) = union_battle_business.accept_individual_step_award(
data, req.target_step, timer.now)
pack.pack_resource_info(data.resource.get(True), res.resource)
for (item_basic_id, item_num) in items:
item_msg = res.items.add()
item_msg.basic_id = item_basic_id
item_msg.num = item_num
res.honor = honor
defer = DataBase().commit(data)
defer.addCallback(self._accept_individual_step_succeed, req, res,
timer)
return defer
def _calc_buy(self, data, req, timer):
res = transfer_arena_pb2.BuyChallengeTimesRes()
res.status = 0
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
ret = Ret()
if not transfer_business.buy_attack_times(data, timer.now, ret):
if ret.get() == "NO_ENOUGH_GOLD":
res.ret = transfer_arena_pb2.BuyChallengeTimesRes.NO_ENOUGH_GOLD
return self._buy_succeed(data, req, res, timer)
elif ret.get() == "UPPER_LIMIT":
res.ret = transfer_arena_pb2.BuyChallengeTimesRes.UPPER_LIMIT
return self._buy_succeed(data, req, res, timer)
transfer = data.transfer.get()
transfer_records = data.transfer_record_list.get_all(True)
res.ret = transfer_arena_pb2.BuyChallengeTimesRes.OK
res.arena_info.remain_times = transfer.get_remain_times()
res.arena_info.cd_end_time = transfer.get_cd_end_time(timer.now)
for transfer_record in transfer_records:
pack.pack_transfer_record(transfer_record,
res.arena_info.records.add())
resource = data.resource.get(True)
pack.pack_resource_info(resource, res.resource)
defer = DataBase().commit(data)
defer.addCallback(self._buy_succeed, req, res, timer)
return defer
def _pack_refresh_arena_response(self, proxy, data, arena, arena_matcher,
req, timer):
"""构造返回
args:
Returns:
res[protobuf]: 向客户端的返回的响应
"""
res = arena_pb2.QueryArenaInfoRes()
res.status = 0
pack.pack_arena_info(data.user.get(True), arena, res.arena_info,
timer.now, arena_matcher.rank)
#对手信息
rivals_id = arena.generate_arena_rivals_id()
for rival_id in rivals_id:
rival = data.rival_list.get(rival_id, True)
pack.pack_arena_player(rival, res.arena_info.rivals.add())
#系统选定的对战对手
choose_rival_id = arena.get_choose_rival_id()
choose_rival = data.rival_list.get(choose_rival_id, True)
res.arena_info.choosed_user_id = choose_rival.rival_id
resource = data.resource.get(True)
pack.pack_resource_info(resource, res.resource)
defer = DataBase().commit(data)
defer.addCallback(self._refresh_arena_succeed, req, res, timer)
return defer
def _calc_respond_result(self, union_response, data, req, timer):
union_res = internal_union_pb2.InternalRespondUnionAidRes()
union_res.ParseFromString(union_response)
if union_res.status != 0:
raise Exception("Query union aid res error")
res = union_pb2.RespondUnionAidRes()
res.status = 0
res.ret = union_res.ret
if res.ret != union_pb2.UNION_OK:
return self._respond_succeed(data, req, res, timer)
#结束联盟援助
if not union_business.respond_aid(data, req.item.basic_id,
union_res.honor, union_res.exp,
union_res.gold, timer.now):
raise Exception("Respond aid failed")
pack.pack_resource_info(data.resource.get(), res.resource)
res.union_prosperity = union_res.prosperity
compare.check_item(data, req.item)
compare.check_user(data, req.monarch, with_level=True)
#发广播
defer = self._respond_broadcast(data, req, timer)
defer.addCallback(self._calc_respond_result_broadcast, data, req, res,
timer)
return defer
def _calc_score_reward(self, data, req, timer):
res = union_boss_pb2.AcceptUnionBossIndividualsRes()
res.status = 0
union = data.union.get()
resource = data.resource.get()
resource.update_current_resource(timer.now)
if not union_boss_business.is_able_to_accept_score_box(data, req.target_step):
res.ret = union_pb2.UNION_BOSS_SCORE_UNACCEPTABLE
return self._score_reward_succeed(data, req, res, timer)
(items_id, items_num, honor) = \
union_boss_business.get_score_box_reward(data, req.target_step)
item_info = map(None, items_id, items_num)
item_business.gain_item(data, item_info, "score reward", log_formater.SCORE_REWARD)
union.accept_boss_score_box(req.target_step, honor)
res.ret = union_pb2.UNION_OK
pack.pack_resource_info(resource, res.resource)
for item_id, item_num in item_info:
item = res.items.add()
item.basic_id = item_id
item.num = item_num
res.honor = honor
defer = DataBase().commit(data)
defer.addCallback(self._score_reward_succeed, req, res, timer)
return defer
def _calc_finish_battle_result(self, union_response, data, req,
own_soldier_info, enemy_soldier_info, kill_soldier_num, boss, timer):
res = union_boss_pb2.FinishUnionBossBattleRes()
res.status = 0
union_res = internal_union_pb2.InternalSyncBossRes()
union_res.ParseFromString(union_response)
if union_res.status != 0:
raise Exception("finish union boss battle failed")
if union_res.ret != union_pb2.UNION_OK:
res.ret = union_res.ret
return self._finish_battle_succeed(data, req, res, timer)
user = data.user.get(True)
union = data.union.get(True)
res.ret = union_pb2.UNION_OK
res.battle_ret = battle_pb2.BATTLE_OK
pack.pack_unionboss_info(boss, user, union_res.boss_status,
union_res.total_soldier_num, union_res.current_soldier_num,
res.boss, timer.now)
conscript_list = data.conscript_list.get_all(True)
for conscript in conscript_list:
pack.pack_conscript_info(conscript, res.conscripts.add(), timer.now)
resource = data.resource.get(True)
pack.pack_resource_info(resource, res.resource)
defer = DataBase().commit(data)
defer.addCallback(self._finish_battle_succeed, req, res, timer)
return defer
def _calc_reset(self, data, req, timer):
res = dungeon_pb2.QueryExpandDungeonInfoRes()
res.status = 0
dungeon = expand_dungeon_business.get_dungeon_by_id(data, req.id)
if dungeon is None:
res.ret = dungeon_pb2.DUNGEON_NO_DUNGEON
return self._reset_succeed(data, req, res, timer)
ret = expand_dungeon_business.reset_attack_count(
data, dungeon, timer.now)
if ret != dungeon_pb2.DUNGEON_OK:
res.ret = ret
return self._reset_succeed(data, req, res, timer)
resource = data.resource.get()
resource.update_current_resource(timer.now)
user = data.user.get(True)
res.ret = dungeon_pb2.DUNGEON_OK
pack.pack_expand_dungeon_info(dungeon,
user,
res.dungeon_info,
0,
timer.now,
brief=True)
pack.pack_resource_info(resource, res.resource)
defer = DataBase().commit(data)
defer.addCallback(self._reset_succeed, req, res, timer)
return defer
def _check_update_country_result(self, response, data, req, timer):
res = monarch_pb2.UpdateCountryRes()
res.ParseFromString(response)
if res.status != 0:
raise Exception("Check update country result failed")
user = data.user.get()
user.update_country(req.new_country)
resource = data.resource.get()
original_gold = resource.gold
resource.gain_gold(req.reward_gold)
log = log_formater.output_gold(data,
req.reward_gold,
log_formater.CHECK_UPDATE_COUNTRY,
"Gain gold from check update country",
before_gold=original_gold)
logger.notice(log)
resource.update_current_resource(timer.now)
pack.pack_resource_info(resource, res.resource)
defer = DataBase().commit(data)
defer.addCallback(self._update_country_succeed, req, res, timer)
return defer
def pack_resources(user_data, timer):
"""打包资源"""
resource_pack = resource_pb2.ResourceInfo()
resource = user_data.resource.get()
resource.update_current_resource(timer.now)
pack.pack_resource_info(resource, resource_pack)
return resource_pack
def _start_conscript_succeed(self, data, req, timer):
res = conscript_pb2.StartConscriptRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
response = res.SerializeToString()
log = log_formater.output(data, "Start conscript succeed", req, res, timer.count_ms())
logger.notice(log)
return response
def _upgrade_equipment_stone_succeed(self, data, req, timer):
res = hero_pb2.UpgradeStoneRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
response = res.SerializeToString()
log = log_formater.output(data, "Upgrade equipment stone succeed", req, res, timer.count_ms())
logger.notice(log)
return response
def _cancel_research_succeed(self, data, req, timer):
res = technology_pb2.UpgradeTechRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
response = res.SerializeToString()
log = log_formater.output(data, "Cancel research technology succeed",
req, res, timer.count_ms())
logger.notice(log)
return response
def _calc_finish_post(self, patcher, data, req, res, timer):
pack.pack_resource_info(data.resource.get(True), res.resource)
for conscript in data.conscript_list.get_all(True):
pack.pack_conscript_info(conscript, res.conscripts.add(),
timer.now)
defer = DataBase().commit(data)
defer.addCallback(self._finish_succeed, req, res, timer)
return defer
def _pack_use_mail_response(self, resource, rival, now):
res = mail_pb2.UseMailRes()
res.status = 0
if resource is not None:
pack.pack_resource_info(resource, res.resource)
if rival is not None:
pack.pack_rival_info(rival, res.rival)
return res
def _strength_succeed(self, data, req, timer):
res = herostar_pb2.StrengthHeroStarRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
response = res.SerializeToString()
log = log_formater.output(data, "Strength hero star succeed", req, res,
timer.count_ms())
logger.notice(log)
return response
def _buy_buff_succeed(self, data, req, timer):
res = legendcity_pb2.BuyLegendCityBuffRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
response = res.SerializeToString()
log = log_formater.output(data, "Buy legend city buff succeed", req,
res, timer.count_ms())
logger.notice(log)
return response
def _exchange_succeed(self, data, req, timer):
res = resource_pb2.UseGoldRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
response = res.SerializeToString()
log = log_formater.output(data, "Exchange succeed", req, res,
timer.count_ms())
logger.notice(log)
return response
def _cancel_upgrade_succeed(self, data, req, timer):
res = building_pb2.UpgradeBuildingRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
response = res.SerializeToString()
log = log_formater.output(data, "Cancel upgrade building succeed", req,
res, timer.count_ms())
logger.notice(log)
return response
def _update_garrison_hero_succeed(self, data, req, timer):
res = building_pb2.UpdateGarrisonHeroRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
response = res.SerializeToString()
log = log_formater.output(data, "Update garrison hero succeed", req,
res, timer.count_ms())
logger.notice(log)
return response
def _finish_question_succeed(self, data, req, timer):
res = event_pb2.FinishEventQuestionRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
response = res.SerializeToString()
log = log_formater.output(data, "Finish question succeed", req, res,
timer.count_ms())
logger.notice(log)
return response
def _enchant_equipment_max_succeed(self, data, req, timer):
res = hero_pb2.UpdateHeroEquipmentMaxRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
response = res.SerializeToString()
log = log_formater.output(data, "Enchant hero equipment max succeed",
req, res, timer.count_ms())
logger.notice(log)
return response
def _reset_attack_succeed(self, data, req, timer):
res = legendcity_pb2.ResetLegendCityAttackInfoRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
response = res.SerializeToString()
log = log_formater.output(data,
"Reset legend city attack info succeed", req,
res, timer.count_ms())
logger.notice(log)
return response
def _pack_query_response(self, users, data, legendcity, unit_res, req,
timer):
"""打包查询响应
"""
res = legendcity_pb2.QueryLegendCityRes()
res.status = 0
res.ret = unit_res.ret
res.city.city_id = legendcity.city_id
res.city.slogan = unit_res.slogan
res.city.update_slogan_free = unit_res.update_slogan_free
res.city.tax = unit_res.tax
res.city.update_tax_free = unit_res.update_tax_free
res.city.income_by_tax = unit_res.income_by_tax
#计算每个官职需要匹配的对手数目
need_rival_count = {}
for key in data_loader.LegendCityPositionBasicInfo_dict:
info = data_loader.LegendCityPositionBasicInfo_dict[key]
if info.cityId == legendcity.city_id:
need_rival_count[info.level] = info.displayNum
if unit_res.position_level != 0:
#玩家自己的官职，可以少匹配一人，因为会显示玩家自己
need_rival_count[unit_res.position_level] -= 1
for (user_id, is_robot,
position_level) in legendcity.get_rivals_info():
if need_rival_count[position_level] <= 0:
continue
need_rival_count[position_level] -= 1
position = res.city.positions.add()
position.city_id = legendcity.city_id
position.level = position_level
pack.pack_monarch_info(users[user_id], position.user)
res.city.user.position_level = unit_res.position_level
res.city.user.reputation = unit_res.reputation
res.city.user.attack_count_left = legendcity.get_attack_count_left()
res.city.user.attack_reset_num = legendcity.reset_attack_num
for (buff_id, left_time) in legendcity.get_buffs(timer.now):
buff = res.city.user.buffs.add()
buff.city_buff_id = buff_id
buff.left_time = left_time
for record in data.legendcity_record_list.get_all(True):
if record.city_id == req.city_id:
pack.pack_legendcity_record(record, res.city.records.add())
pack.pack_resource_info(data.resource.get(True), res.resource)
defer = DataBase().commit(data)
defer.addCallback(self._query_succeed, req, res, timer)
return defer
def _pack_gather_response(self, resource, new_items, now):
"""打包采集返回
"""
res = exploitation_pb2.GatherRes()
res.status = 0
pack.pack_resource_info(resource, res.resource)
for (basic_id, num) in new_items:
message_item = res.items.add()
message_item.basic_id = basic_id
message_item.num = num
return res
