def _calc_drum_result(self, union_response, data, item, cost_gold, req,
timer):
union_res = internal_union_pb2.InternalDrumForUnionBattleRes()
union_res.ParseFromString(union_response)
if union_res.status != 0:
raise Exception("Query union battle res error")
res = union_battle_pb2.QueryUnionBattleRes()
res.status = 0
res.ret = union_res.ret
if union_res.ret == union_pb2.UNION_OK:
score = union_res.individual_battle_score_add
union_battle_business.drum(data, item, cost_gold, score, timer.now)
if req.HasField("item"):
compare.check_item(data, req.item)
if union_res.HasField("battle"):
defer = UnionBattlePatcher().patch(res.battle, union_res.battle,
data, timer.now)
defer.addCallback(self._calc_drum_post, data, req, res, timer)
return defer
return self._calc_drum_post(None, data, req, res, timer)
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_use_speed_item(self, data, req, timer):
res = speed_pb2.UseSpeedItemRes()
res.status = 0
building = None
technology = None
if req.HasField("building"):
building_id = BuildingInfo.generate_id(data.id,
req.building.city_basic_id,
req.building.location_index,
req.building.basic_id)
building = data.building_list.get(building_id)
elif req.HasField("tech"):
technology_id = TechnologyInfo.generate_id(data.id,
req.tech.basic_id,
req.tech.type)
technology = data.technology_list.get(technology_id)
item_id = ItemInfo.generate_id(data.id, req.item.basic_id)
item = data.item_list.get(item_id)
use_num = item.num - req.item.num
if not item_business.use_speed_item(item, use_num, building,
technology):
logger.warning("Use speed item failed")
res.return_ret = speed_pb2.UseSpeedItemRes.SPEED_ITEM_ERROR
else:
res.return_ret = 0
compare.check_item(data, req.item)
defer = DataBase().commit(data)
defer.addCallback(self._use_speed_item_succeed, req, res, timer)
return defer
def _calc_choose_card(self, data, req, timer):
"""
"""
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
cost_gold = 0
if req.HasField("cost_gold"):
cost_gold = req.cost_gold
if not pray_business.choose_card(data, req.choose_index, cost_gold):
raise Exception("Choose card failed")
for item in req.item:
compare.check_item(data, item)
pray = data.pray.get()
#if cost_gold != 0:
# log = log_formater.output_gold(data, -cost_gold, log_formater.CHOOSE_CARD,
# "Choose card by gold", choose_index = (pray.get_choose_card_num() + 1))
# logger.notice(log)
if pray.is_need_broadcast():
#祈福最后一次是翻倍的奖励发广播
try:
self._add_pray_broadcast(data.user.get(), pray)
except:
logger.warning("Send pray broadcast failed")
return DataBase().commit(data)
def _calc_finish_mission(self, data, req, timer):
if not mission_business.finish_mission(req.mission.basic_id, data,
timer.now):
raise Exception("mission not finished.")
#验证
if req.HasField("monarch"):
compare.check_user(data, req.monarch, with_level=True)
for item_info in req.items:
compare.check_item(data, item_info)
#删除当前任务
mission_id = MissionInfo.generate_id(data.id, req.mission.basic_id)
data.mission_list.delete(mission_id)
mission_data = data_loader.AllMission_dict[req.mission.basic_id]
mission_name = mission_business.MissionPool().get_mission_name(
req.mission.basic_id)
if mission_data.type == mission_business.MISSION_TYPE_DAILY and \
mission_name != mission_business.MISSION_VITALITY and \
mission_name != mission_business.MISSION_VIP_LEVEL:
#记录次数
trainer = data.trainer.get()
trainer.add_daily_vitality(1)
if mission_data.type >= 11 and mission_data.type <= 17 and \
mission_name != mission_business.DAY7_MISSION_VITALITY:
trainer = data.trainer.get()
trainer.add_day7_vitality(1)
return DataBase().commit(data)
def _calc_buy_legendcity_goods(self, data, req, timer):
"""购买史实城商店中的商品
"""
shop_id = ShopInfo.generate_id(data.id, ShopInfo.GOODS_TYPE_LEGENDCITY,
req.index)
shop = data.shop_list.get(shop_id)
pay = shop.calc_goods_price(req.goods.id)
extra_pay = int(pay * (req.tax / 100.0))
if not shop_business.buy_goods(data, shop, req.goods.id, timer.now,
req.tax):
raise Exception("Buy Goods failed")
compare.check_item(data, req.item)
#请求 Unit 模块，缴税
unit_req = unit_pb2.UnitBuyGoodsReq()
unit_req.user_id = data.id
unit_req.pay = pay
unit_req.extra_pay = extra_pay
unit_req.tax = req.tax
defer = GlobalObject().remote['unit'].callRemote(
"buy_goods", req.index, unit_req.SerializeToString())
defer.addCallback(self._pack_buy_legendcity_goods_response, data, req,
timer)
return defer
def _calc_upgrade_equipment_stone(self, data, req, timer):
"""装备上的宝石升级逻辑
"""
hero_id = HeroInfo.generate_id(data.id, req.hero.basic_id)
hero = data.hero_list.get(hero_id)
if hero is None:
raise Exception("Hero not exist")
if len(req.hero.stone_weapon) != 0:
equipment_type = HeroInfo.EQUIPMENT_TYPE_WEAPON
equipment_stones_id = req.hero.stone_weapon
elif len(req.hero.stone_armor) != 0:
equipment_type = HeroInfo.EQUIPMENT_TYPE_ARMOR
equipment_stones_id = req.hero.stone_armor
elif len(req.hero.stone_treasure) != 0:
equipment_type = HeroInfo.EQUIPMENT_TYPE_TREASURE
equipment_stones_id = req.hero.stone_treasure
else:
raise Exception("Equipment type error")
if not hero_business.upgrade_equipment_stone(data, req.hero.basic_id,
req.item.basic_id, equipment_type, equipment_stones_id, timer.now):
raise Exception("Upgrade equipment stone failed")
#验证
compare.check_hero(data, req.hero, with_equipment_type = equipment_type,
with_equipment_stone = True)
compare.check_item(data, req.item)
return DataBase().commit(data)
def _calc_demount_equipment_stone(self, data, req, timer):
"""装备卸下宝石逻辑
"""
heroes_basic_id = []
equipments_type = []
equipments_stones_id =[]
for hero_info in req.heros:
heroes_basic_id.append(hero_info.basic_id)
if len(hero_info.stone_weapon) != 0:
equipments_type.append(HeroInfo.EQUIPMENT_TYPE_WEAPON)
equipments_stones_id.append(hero_info.stone_weapon)
elif len(hero_info.stone_armor) != 0:
equipments_type.append(HeroInfo.EQUIPMENT_TYPE_ARMOR)
equipments_stones_id.append(hero_info.stone_armor)
elif len(hero_info.stone_treasure) != 0:
equipments_type.append(HeroInfo.EQUIPMENT_TYPE_TREASURE)
equipments_stones_id.append(hero_info.stone_treasure)
else:
raise Exception("Equipment type error")
item_list = []
if not hero_business.demount_equipment_stone(data, heroes_basic_id,
equipments_type, equipments_stones_id, req.item.basic_id, timer.now):
raise Exception("Demount equipment stone failed")
#验证
for i in range(len(req.heros)):
compare.check_hero(data, req.heros[i], with_equipment_type = equipments_type[i],
with_equipment_stone = True)
compare.check_item(data, req.item)
return DataBase().commit(data)
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 _calc_own_finish_result(self, union_response, rival_union_res, win,
own_soldier_info, enemy_soldier_info, data,
skip, heroes, req, timer):
union_res = internal_union_pb2.InternalFinishUnionBattleRes()
union_res.ParseFromString(union_response)
if union_res.status != 0:
raise Exception("Query union battle res error")
score = 0
if union_res.HasField("individual_battle_score_add"):
score = union_res.individual_battle_score_add
#结束战斗
if win:
if not union_battle_business.win_battle(data, enemy_soldier_info,
own_soldier_info, score,
timer.now):
raise Exception("Win battle failed")
else:
if not union_battle_business.lose_battle(data, enemy_soldier_info,
own_soldier_info, score,
timer.now):
raise Exception("Lose battle failed")
#检查请求
if win:
compare.check_user(data, req.monarch, with_level=True)
for info in req.battle.attack_heroes:
compare.check_hero(data, info.hero, with_level=True)
for item_info in req.items:
compare.check_item(data, item_info)
res = union_battle_pb2.FinishUnionBattleRes()
res.status = 0
if union_res.ret != union_pb2.UNION_OK:
res.ret = union_res.ret
else:
res.ret = rival_union_res.ret
if skip:
pack.pack_monarch_info(data.user.get(True), res.monarch)
if win:
res.battle_output.result = battle_pb2.BattleOutputInfo.WIN
else:
res.battle_output.result = battle_pb2.BattleOutputInfo.LOSE
for i, hero in enumerate(heroes):
attack_hero = res.battle_output.attack_heroes.add()
pack.pack_hero_info(hero, attack_hero.hero, timer.now)
attack_hero.soldier_survival = own_soldier_info[i][2]
if union_res.HasField("battle") and rival_union_res.HasField("battle"):
defer = UnionBattlePatcher().patch_by_both_message(
res.battle, union_res.battle, rival_union_res.battle, data,
timer.now)
defer.addCallback(self._calc_finish_post, data, req, res, timer)
return defer
return self._calc_finish_post(None, data, req, res, timer)
def _calc_get_pass_reward(self, data, req, timer):
anneal = data.anneal.get()
if not anneal_business.get_pass_reward(data, anneal, req.mode_type):
raise Exception("Anneal get pass reward failed")
#验证客户端正确性
for item_info in req.items:
compare.check_item(data, item_info)
return DataBase().commit(data)
def _calc_upgrade_star(self, data, req, timer):
"""重现客户端升星计算逻辑，和请求进行比较
"""
res = hero_pb2.UpdateHeroRes()
res.status = 0
hero_id = HeroInfo.generate_id(data.id, req.hero.basic_id)
hero = data.hero_list.get(hero_id)
item_id = ItemInfo.generate_id(data.id, req.item[0].basic_id)
item = data.item_list.get(item_id)
if hero is None or item is None:
raise Exception("Hero or item not exist")
#消耗精魄
soul_num = 0
open_flags = account_business.get_flags()
if "HeroUpStarUseSoul" in open_flags:
soul_num = data_loader.HeroStarLevelBasicInfo_dict[
req.hero.star_level].soul
#使用灵魂石
consume_num = data_loader.HeroStarLevelBasicInfo_dict[
req.hero.star_level].perceptivity
ret = hero_business.star_upgrade(data, hero, item, consume_num,
soul_num, timer.now)
if ret != hero_pb2.HERO_OK:
res.ret = ret
return self._upgrade_star_succeed(data, req, res, timer)
#和请求进行比较
if req.hero.star_level != hero.star:
raise Exception("Unexpect hero star[expect star=%d]" % hero.star)
#验证
compare.check_hero(data, req.hero, with_star=True)
compare.check_item(data, req.item[0])
resource = data.resource.get()
resource.update_current_resource(timer.now)
res.ret = hero_pb2.HERO_OK
pack.pack_resource_info(resource, res.resource)
try:
if hero.is_need_broadcast_star_level():
self._add_upgrade_star_level_broadcast(data.user.get(), hero)
except:
logger.warning("Send upgrade star level broadcast failed")
defer = DataBase().commit(data)
defer.addCallback(self._upgrade_star_succeed, req, res, timer)
return defer
def _calc_buy_goods(self, data, req, timer):
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
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)
defer = DataBase().commit(data)
return defer
def _calc_refresh_goods(self, data, req, types, timer):
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
shops = []
index = 1
if req.HasField("index"):
index = req.index
for type in types:
shop_id = ShopInfo.generate_id(data.id, type, index)
shops.append(data.shop_list.get(shop_id))
is_refresh_with_item = False
refresh_item = None
if req.HasField("item"):
#用刷新代币刷新商铺
is_refresh_with_item = True
item_id = ItemInfo.generate_id(data.id, req.item.basic_id)
refresh_item = data.item_list.get(item_id)
if refresh_item is None:
raise Exception("Item not exist")
free = False
if shops[0].is_able_to_refresh_free(timer.now):
free = True
goods = []
if not shop_business.refresh_goods(data, shops, goods, timer.now,
refresh_item, free):
raise Exception("Refresh goods failed")
if is_refresh_with_item:
compare.check_item(data, req.item)
resource = data.resource.get(True)
#任意选择一个商店的刷新次数
res = self._pack_refresh_goods_response(goods, shops[0], resource, req,
timer.now)
defer = DataBase().commit(data)
defer.addCallback(self._refresh_goods_succeed, types, req, res, timer)
return defer
def _calc_upgrade_equipment(self, data, req, timer):
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
cost_gold = 0
if req.HasField("gold"):
cost_gold = req.gold
if not hero_business.equipment_upgrade(
data, req.hero.basic_id, req.type, cost_gold, timer.now):
raise Exception("Upgrade equipment failed")
#验证
compare.check_hero(data, req.hero, with_equipment_type = req.type)
for item_info in req.items:
compare.check_item(data, item_info)
return DataBase().commit(data)
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_open_chest(self, data, req, timer):
"""打开红包
Args:
"""
chest = data.chest.get()
chest_old = chest_business.open_chest(data, chest, timer.now)
if chest_old is None:
raise Exception("Open chest failed")
for i in range(0, len(req.items)):
compare.check_item(data, req.items[i])
#广播
try:
self._add_chest_broadcast(data, chest_old.gold)
except:
logger.warning("Send open chest broadcast failed")
defer = DataBase().commit(data)
defer.addCallback(self._open_chest_succeed, req, chest_old, timer)
return defer
def _calc_finish_question(self, data, req, timer):
"""结束问答逻辑
"""
node_basic_id = req.node.basic_id
node_id = NodeInfo.generate_id(data.id, node_basic_id)
node = data.node_list.get(node_id)
if not question_business.finish_question_event(
data, node, req.question_id, req.answer, req.correct,
timer.now):
raise Exception("Finish question failed")
#验证
if req.HasField("hero"):
compare.check_hero(data,
req.hero,
with_level=True,
with_soldier=True)
for item_info in req.items:
compare.check_item(data, item_info)
return DataBase().commit(data)
def _calc_awaken(self, data, req, timer):
res = hero_pb2.AwakeningHeroRes()
res.status = 0
temple = None
for building in data.building_list.get_all(True):
if building.is_temple():
temple = building
break
if temple is None or temple.level < int(
float(
data_loader.
OtherBasicInfo_dict['unlock_hero_awakening_level'].value)):
res.return_ret = hero_pb2.AwakeningHeroRes.ERROR_BUILDING
return self._awaken_succeed(data, req, res, timer)
hero = hero_business.get_hero_by_id(data, req.hero.basic_id)
if hero is None:
res.return_ret = hero_pb2.AwakeningHeroRes.ERROR_HERO
return self._awaken_succeed(data, req, res, timer)
ret = hero_business.awaken_hero(data, hero, timer.now)
if ret != hero_pb2.AwakeningHeroRes.SUCCESS:
res.return_ret = ret
return self._awaken_succeed(data, req, res, timer)
try:
compare.check_hero(data, req.hero, with_awaken=True)
for item_info in req.items:
compare.check_item(data, item_info)
except:
res.return_ret = hero_pb2.AwakeningHeroRes.INVALID
return self._awaken_succeed(data, req, res, timer)
res.return_ret = hero_pb2.AwakeningHeroRes.SUCCESS
defer = DataBase().commit(data)
defer.addCallback(self._awaken_succeed, req, res, timer)
return defer
def _calc_enchant_equipment(self, data, req, timer):
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
#精炼后的装备 id
if req.type == HeroInfo.EQUIPMENT_TYPE_WEAPON:
dest_equipment_id = req.hero.equipment_weapon_id
elif req.type == HeroInfo.EQUIPMENT_TYPE_ARMOR:
dest_equipment_id = req.hero.equipment_armor_id
elif req.type == HeroInfo.EQUIPMENT_TYPE_TREASURE:
dest_equipment_id = req.hero.equipment_treasure_id
else:
raise Exception("Invalid input equipment type[type=%d]" % req.type)
#精炼消耗的材料
cost_item = []
for item_info in req.items:
item_id = ItemInfo.generate_id(data.id, item_info.basic_id)
item = data.item_list.get(item_id)
cost_num = item.num - item_info.num
cost_item.append((item.id, cost_num))
#精炼消耗的元宝
cost_gold = 0
if req.HasField("gold"):
cost_gold = req.gold
if not hero_business.equipment_enchant(
data, req.hero.basic_id, req.type, dest_equipment_id,
cost_item, cost_gold, timer.now):
raise Exception("Enchant equipment failed")
#验证
compare.check_hero(data, req.hero, with_equipment_type = req.type)
for item_info in req.items:
compare.check_item(data, item_info)
return DataBase().commit(data)
def _calc_finish_visit(self, data, req, timer):
"""结束探访逻辑
"""
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
node_basic_id = req.node.basic_id
node_id = NodeInfo.generate_id(data.id, node_basic_id)
node = data.node_list.get(node_id)
gold = 0
if req.HasField("gold"):
gold = req.gold
candidate = []
if not visit_business.finish_visit_event(data, node, req.visit_id,
timer.now, gold):
raise Exception("Finish visit failed")
#验证
if req.HasField("hero"):
compare.check_hero(data, req.hero)
if req.HasField("item"):
compare.check_item(data, req.item)
#获得S级武将要播广播
if req.visit_id != 0:
hero_basic_id = data_loader.EventVisitBasicInfo_dict[
req.visit_id].heroBasicId
if hero_basic_id != 0 and hero_business.is_need_broadcast(
hero_basic_id):
try:
self._add_get_hero_broadcast(data.user.get(),
hero_basic_id)
except:
logger.warning("Send get hero broadcast failed")
return DataBase().commit(data)
def _calc_buy_attack_num(self, data, req, timer):
"""
"""
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
anneal = data.anneal.get()
anneal.update_current_attack_num(timer.now)
item = None
if req.HasField("item"):
item_id = ItemInfo.generate_id(data.id, req.item.basic_id)
item = data.item_list.get(item_id)
need_gold, original_gold = anneal_business.buy_attack_num(
data, anneal, item, timer.now)
if need_gold < 0:
raise Exception("Buy attack num failed")
#记录次数
#trainer = data.trainer.get()
#trainer.add_daily_buy_attack_num(1)
if req.HasField("item"):
compare.check_item(data, req.item)
if need_gold > 0:
log = log_formater.output_gold(
data,
-need_gold,
log_formater.BUY_ATTACK_NUM,
"Buy attack num by gold",
before_gold=original_gold,
attack_num=anneal.get_attack_num_of_buy())
logger.notice(log)
return DataBase().commit(data)
def _calc_get_melee_win_num_reward(self, data, req, timer):
user = data.user.get()
melee = data.melee.get()
if not melee.is_able_to_unlock(user):
raise Exception("melee is not unlock[user_level=%d]" % user.level)
if not melee_business.get_melee_win_num_reward(data, melee, timer.now):
raise Exception("melee get win num reward failed")
#验证客户端正确性
for item_info in req.items:
compare.check_item(data, item_info)
melee_matcher = MeleeMatcher()
if melee.need_query_rank():
defer = melee_matcher.query_ranking(data, melee)
else:
defer = Deferred()
defer.callback(True)
defer.addCallback(self._pack_get_melee_win_num_reward_response,
data, melee, melee_matcher, req, timer)
return defer
def _calc_get_arena_win_num_reward(self, data, req, timer):
user = data.user.get()
if not user.allow_pvp_arena:
raise Exception("Arena is not unlock[user_level=%d]" % user.level)
arena = data.arena.get()
if not arena_business.get_arena_win_num_reward(data, arena, timer.now):
raise Exception("Arena get win num reward failed")
#验证客户端正确性
for item_info in req.items:
compare.check_item(data, item_info)
arena_matcher = ArenaMatcher()
if arena.need_query_rank():
defer = arena_matcher.query_ranking(data, arena)
else:
defer = Deferred()
defer.callback(True)
defer.addCallback(self._pack_get_arena_win_num_reward_response, data,
arena, arena_matcher, req, timer)
return defer
def _calc_upgrade_evolution_level(self, data, req, timer):
"""重现客户端升星计算逻辑，和请求进行比较
"""
hero_id = HeroInfo.generate_id(data.id, req.hero.basic_id)
hero = data.hero_list.get(hero_id)
item_id = ItemInfo.generate_id(data.id, req.item[0].basic_id)
item = data.item_list.get(item_id)
if hero is None or item is None:
raise Exception("Hero or item not exist")
#使用突破石
consume_num = item.num - req.item[0].num
if not hero_business.evolution_level_upgrade(data, hero, item,
consume_num, timer.now):
raise Exception("Hero evolution level upgrade failed]")
#和请求进行比较
if req.hero.evolution_level != hero.evolution_level:
raise Exception(
"Unexpect hero evolution level[expect evolution level=%d]" %
hero.evolution_level)
#验证
compare.check_hero(data, req.hero, with_evolution=True)
compare.check_item(data, req.item[0])
if hero.is_need_broadcast():
#玩家英雄达到一定等级时，广播
try:
self._add_upgrade_evolution_level_broadcast(
data.user.get(), hero)
except:
logger.warning("Send upgrade evolution level broadcast failed")
return DataBase().commit(data)
def _calc_draw(self, data, basic_data, req, type, timer):
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
user = data.user.get()
resource = data.resource.get()
draw = data.draw.get()
resource.update_current_resource(timer.now)
is_draw_with_item = False
draw_item = None
if req.HasField("item"):
#用抽奖券抽
is_draw_with_item = True
item_id = ItemInfo.generate_id(data.id, req.item.basic_id)
draw_item = data.item_list.get(item_id)
if draw_item is None:
raise Exception("Item not exist")
hero_list = []
item_list = []
if type == self._TYPE_GOLD_DRAW:
if not draw_business.draw_with_gold(
basic_data, data, user, resource, draw,
hero_list, item_list, timer.now, draw_item, req.free):
raise Exception("Draw with gold failed")
elif type == self._TYPE_MONEY_DRAW:
if not draw_business.draw_with_money(
user, resource, draw, hero_list, item_list, timer.now, draw_item, req.free):
raise Exception("Draw with money failed")
elif type == self._TYPE_GOLD_MULTI_DRAW:
if not draw_business.multi_draw_with_gold(
basic_data, data, user, resource, draw, hero_list, item_list,
timer.now, draw_item):
raise Exception("Multi draw with gold failed")
elif type == self._TYPE_MONEY_MULTI_DRAW:
if not draw_business.multi_draw_with_money(
user, resource, draw, hero_list, item_list, timer.now, draw_item):
raise Exception("Multi draw with money failed")
#elif type == self._TYPE_TREASURE_DRAW:
# pass
#elif type == self._TYPE_TREASURE_MULTI_DRAW:
# pass
else:
raise Exception("Invalid draw type[type=%d]" % type)
#添加抽奖得到的英雄和物品
for (hero_basic_id, hero_num) in hero_list:
if not hero_business.gain_hero(data, hero_basic_id, hero_num):
raise Exception("Gain hero failed")
if not item_business.gain_item(data, item_list, "draw ", log_formater.DRAW):
raise Exception("Gain item failed")
if is_draw_with_item:
compare.check_item(data, req.item)
#获得S级武将要播广播
for (hero_basic_id, hero_num) in hero_list:
if hero_business.is_need_broadcast(hero_basic_id):
try:
self._add_get_hero_broadcast(data.user.get(), draw, hero_basic_id)
except:
logger.warning("Send get hero broadcast failed")
#构造返回
if type == self._TYPE_GOLD_DRAW or type == self._TYPE_GOLD_MULTI_DRAW:
free_num = draw.gold_draw_free_num
free_time = draw.gold_draw_free_time
else:
free_num = draw.money_draw_free_num
free_time = draw.money_draw_free_time
res = self._pack_draw_response(data, hero_list, item_list, resource,
free_num, free_time, timer.now)
defer = DataBase().commit(data)
defer.addCallback(self._draw_succeed, type, req, res, timer)
return defer
def _calc_start_appoint(self, data, req, timer):
item_id = ItemInfo.generate_id(data.id, req.item.basic_id)
item = data.item_list.get(item_id)
if item is None:
raise Exception("Item not exist")
#扣减1个虎符
if not item.use_appoint_item(1):
raise Exception("Use appoint item failed")
compare.check_item(data, req.item)
#参战team/英雄
teams = []
heroes = []
for team in req.battle.attack_teams:
team_id = TeamInfo.generate_id(data.id, team.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)
if len(teams) == 0:
raise Exception("Appoint teams is NULL")
#敌人信息
node_basic_id = req.node.basic_id
node_id = NodeInfo.generate_id(data.id, node_basic_id)
rival_id = node_id
node = data.node_list.get(node_id)
rival = data.rival_list.get(rival_id)
if node.rival_type in (NodeInfo.ENEMY_TYPE_PVE_BANDIT,
NodeInfo.ENEMY_TYPE_PVE_REBEL):
"""山贼"""
rival.reward_user_exp = int(
float(data_loader.
OtherBasicInfo_dict['bandit_battle_cost_energy'].value))
else:
"""侦察敌军"""
rival.reward_user_exp = int(
float(data_loader.
OtherBasicInfo_dict['keynode_battle_cost_energy'].value))
user = data.user.get()
if not appoint_business.start_appoint(
data, user, node, rival, teams, heroes, timer.now, force=True):
raise Exception("Start appoint failed")
#构造返回
res = self._pack_start_appoint_response(data, timer.now)
defer = DataBase().commit(data)
defer.addCallback(self._start_appoint_succeed, node, rival, req, res,
timer)
return defer
def _calc_finish_battle(self, data, req, timer):
#兵力信息
res = union_boss_pb2.FinishUnionBossBattleRes()
res.status = 0
own_soldier_info = []
for result in req.battle.attack_heroes:
hero_basic_id = result.hero.basic_id
hero = hero_business.get_hero_by_id(data, hero_basic_id)
own_soldier_info.append((
hero.soldier_basic_id,
hero.soldier_level,
result.soldier_survival))
enemy_soldier_info = []
if req.battle.HasField("relive_times"):
for i in range(req.battle.relive_times):
for result in req.battle.defence_heroes:
#攻打世界boss时有重生逻辑，实际杀敌会更多
enemy_soldier_info.append((
result.hero.soldier_basic_id,
result.hero.soldier_level,
0))
for result in req.battle.defence_heroes:
enemy_soldier_info.append((
result.hero.soldier_basic_id,
result.hero.soldier_level,
result.soldier_survival))
#计算杀敌数
kill_soldier_num = battle_business._calc_number_of_death(enemy_soldier_info)
node_id = NodeInfo.generate_id(data.id, UserUnionInfo.get_union_boss_node_basic_id())
node = data.node_list.get(node_id)
rival = data.rival_list.get(node_id)
boss = union_boss_business.get_boss_by_id(data, rival.rival_id)
change_nodes = []
new_items = []
new_mails = []
new_arena_records = []
if req.battle.result == req.battle.WIN:
win = True
if not battle_business.win_battle(
data, node, enemy_soldier_info, own_soldier_info,
change_nodes, timer.now, new_arena_records, is_unionboss=True):
raise Exception("win union boss battle failed")
else:
win = False
if not battle_business.lose_battle(
data, node, timer.now, enemy_soldier_info, own_soldier_info,
change_nodes, new_items, new_mails, new_arena_records):
raise Exception("loss union boss battle failed")
union_boss_business.finish_battle(data, boss, win, kill_soldier_num)
if req.battle.result == req.battle.WIN:
if not compare.check_user_r(data, req.monarch, with_level=True):
res.battle_ret = union_pb2.BATTLE_MONARCH_ERROR
return self._finish_battle_succeed(data, req, res, timer)
for info in req.battle.attack_heroes:
if not compare.check_hero_r(data, info.hero, with_level=True):
res.battle_ret = union_pb2.BATTLE_HERO_ERROR
return self._finish_battle_succeed(data, req, res, timer)
for item_info in req.items:
compare.check_item(data, item_info)
#请求gunion模块
user = data.user.get(True)
union_req = internal_union_pb2.InternalSyncBossReq()
union_req.user_id = data.id
union_req.user_name = user.name
union_req.boss_id = boss.boss_id
union_req.kill_addition = kill_soldier_num
defer = GlobalObject().remote['gunion'].callRemote(
"sync_unionboss", req.union_id, union_req.SerializeToString())
defer.addCallback(self._calc_finish_battle_result, data, req,
own_soldier_info, enemy_soldier_info, kill_soldier_num, boss, timer)
return defer
