def use_monarch_exp(data, item, num, now):
"""使用主公经验丹，提升用户经验，可能会升级
"""
exp = item.use_monarch_exp_item(num)
if exp is None:
return False
return user_business.level_upgrade(data, exp, now, "monarch exp",
log_formater.EXP_MONARCH)
def _calc_mission(data, mission, now, force):
"""结算已经完成的任务
1 获得奖励
2 开启后续任务（如果有后续的话）
"""
#检查是否结束
user = data.user.get(True)
if not force and not mission.is_finish(user.level):
logger.warning("Mission not finish[basic id=%d]" % (mission.basic_id))
return False
reward = data_loader.AllMission_dict[mission.basic_id].reward
#获得资源
resource = data.resource.get()
original_gold = resource.gold
resource.update_current_resource(now)
resource.gain_money(reward.money)
resource.gain_food(reward.food)
resource.gain_gold(reward.gold)
log = log_formater.output_gold(data,
reward.gold,
log_formater.MISSION_REWARD_GOLD,
"Gain gold from compelete mission",
before_gold=original_gold)
logger.notice(log)
#获得政令
energy = data.energy.get()
energy.update_current_energy(now)
energy.gain_energy(reward.energy)
#获得战利品
item_list = mission.get_reward_items()
if not item_business.gain_item(data, item_list, "mission reward",
log_formater.MISSION_REWARD):
return False
for i in range(0, len(item_list)):
id = ItemInfo.generate_id(data.id, item_list[i][0])
item = data.item_list.get(id)
#用户获得经验
if not user_business.level_upgrade(data, reward.monarchExp, now,
"mission exp",
log_formater.EXP_MISSION):
return False
#创建后续任务
next_mission = mission.create_next()
if next_mission is not None:
data.mission_list.add(next_mission)
return True
def win_battle(data, enemy_soldier_info, own_soldier_info, score, now):
"""战斗胜利
"""
user = data.user.get(True)
union = data.union.get()
node_id = NodeInfo.generate_id(data.id,
union.get_battle_mapping_node_basic_id())
battle = data.battle_list.get(node_id)
rival = data.rival_list.get(node_id)
#获得战利品
resource = data.resource.get()
resource.update_current_resource(now)
resource.gain_money(battle.reward_money)
resource.gain_food(battle.reward_food)
if not item_business.gain_item(data, battle.get_reward_items(),
"win battle", log_formater.WIN_BATTLE):
return False
#根据杀敌，增加战功
_gain_union_battle_individual_score_of_battle(union, enemy_soldier_info,
score)
#返还己方存活士兵
if not battle_business._reclaim_soldier(data, battle, now,
own_soldier_info):
return False
#用户获得经验
if not user_business.level_upgrade(data, battle.reward_user_exp, now,
"exp win union battle",
log_formater.EXP_WIN_BATTLE):
return False
#参战英雄获得经验
heroes_id = battle.get_battle_hero()
exp = int(battle.reward_hero_exp / len(heroes_id))
for hero_id in heroes_id:
hero = data.hero_list.get(hero_id)
if not hero_business.level_upgrade(data, hero, exp, now):
return False
#更新统计信息
if not battle_business._update_statistics(data, battle, True, rival, None,
enemy_soldier_info,
own_soldier_info):
return False
#清除原有的敌人信息
rival.clear()
return battle.finish()
def respond_aid(data, item_basic_id, honor, exp, gold, now):
"""响应援助，进行捐赠
获得奖励
"""
union = data.union.get()
#消耗物品
item_id = ItemInfo.generate_id(data.id, item_basic_id)
item = data.item_list.get(item_id)
consume = item.consume(1)
if not consume[0]:
return False
output_items = []
output_items.append("[item=")
output_items.append(utils.join_to_string(list(consume[1])))
output_items.append("]")
log = log_formater.output_item(data, "respond aid",
log_formater.RESPOND_AID,
''.join(output_items))
logger.notice(log)
#logger.notice("respond aid %s"%''.join(output_items))
#获得联盟荣誉
union.gain_honor(honor)
#获得主公经验
if not user_business.level_upgrade(data, exp, now, "exp aid",
log_formater.EXP_AID):
return False
#获得元宝奖励
resource = data.resource.get()
resource.update_current_resource(now)
original_gold = resource.gold
resource.gain_gold(gold)
log = log_formater.output_gold(data,
gold,
log_formater.RESPOND_AID_REWARD,
"Gain gold from respond aid",
before_gold=original_gold)
logger.notice(log)
return True
def _calc_build_exp(data, building, user, heroes, now):
"""参与升级，英雄可以获得的经验，用户（主公）也可以获得经验
在建升级完成之后，经验才会结算
Args:
building[BuildingInfo out]: 建筑信息
user[UserInfo]: 用户（主公）信息
heroes[list(HeroInfo) out]: 英雄信息列表
now[int]: 当前时间戳
Returns:
True 计算成功
False 计算失败
"""
#用户得到经验
base_exp = int(
float(data_loader.OtherBasicInfo_dict["BuildingMonarchGetExp"].value))
user_exp = (int(user.level / 10) + 1) * base_exp
if not user_business.level_upgrade(data, user_exp, now, "building exp",
log_formater.EXP_BUILDING):
logger.warning("User upgrade failed")
return False
#英雄经验
#如果使用『立即完成』，英雄也只会获得到到当前时间为止的经验
end_time = min(building.upgrade_start_time + building.upgrade_consume_time,
now)
exp_per_hour = data_loader.MonarchLevelBasicInfo_dict[
user.level].buildExpPerHour
for hero in heroes:
if hero is None:
continue
if not hero_business.level_upgrade_by_working(data, hero, exp_per_hour,
end_time, now):
logger.warning("Hero upgrade failed[hero basic id=%d]" %
hero.basic_id)
return False
return True
def trigger_specified_event(data, event_type, now,
change_nodes = [], new_items = [], new_mails = []):
"""触发指定事件
"""
user = data.user.get(True)
##检查当前玩家等级
#need_level = int(float(
# data_loader.LuckyEventConfInfo_dict["lucky_event_unlock_level"].value))
#if user.level < need_level:
# logger.debug("User level not statisfy, not trigger lucky event[level=%d]" % user.level)
# return True
#判断是否有足够政令值触发指定事件
energy = data.energy.get()
need_energy = energy.calc_energy_consume_of_event(event_type)
if need_energy is None:
logger.warning("Not able to calc energy consume[type=%d]" % event_type)
return False
energy.update_current_energy(now)
if need_energy > energy.energy:
logger.warning("Not enough energy to trigger event[type=%d][need_energy=%d][energy=%d]" %
(event_type, need_energy, energy.energy))
return False
#扣减政力值
if not energy.cost_energy(need_energy, event_type, now):
return False
#用户获得经验(1点政力值获得1点主公经验)
monarch_per_energy = 1
if data_loader.OtherBasicInfo_dict.has_key("monarch_per_energy"):
monarch_per_energy = int(float(data_loader.OtherBasicInfo_dict["monarch_per_energy"].value))
if not user_business.level_upgrade(data, need_energy * monarch_per_energy, now, "event exp", log_formater.EXP_EVENT):
return False
logger.debug("Trigger specified event")
node_list = _get_nodes_can_arise_specified_event(data, event_type, now)
if len(node_list) == 0:
logger.debug("No node to trigger specified event[type=%d]" % event_type)
return True
trigger_nodes = []
if (event_type == NodeInfo.EVENT_TYPE_VISIT
or event_type == NodeInfo.EVENT_TYPE_DUNGEON
or event_type == NodeInfo.EVENT_TYPE_SEARCH
or event_type == NodeInfo.EVENT_TYPE_DEEP_MINING
or event_type == NodeInfo.EVENT_TYPE_HERMIT):
#visit事件、dungeon事件和离线开采事件，随机选一个点
index = random.randint(0, len(node_list) - 1)
trigger_nodes.append(node_list[index])
else:
limit_min = _get_event_trigger_limit_min(event_type, user)
enemy_neighbor_count = 0
if event_type == NodeInfo.EVENT_TYPE_SCOUT:
enemy_neighbor_count = _get_all_enemy_neighbor_count(data)
for node in node_list:
if _is_node_arise_specified_event(data, node, event_type, now, enemy_neighbor_count):
trigger_nodes.append(node)
#保证最少触发limit_min个点
if len(trigger_nodes) < limit_min:
diff = limit_min - len(trigger_nodes)
diff = min(diff, len(node_list) - len(trigger_nodes))
left_nodes = [ node for node in node_list if node not in trigger_nodes ]
trigger_nodes.extend(random.sample(left_nodes, diff))
for node in trigger_nodes:
change_nodes.append(node)
if not _node_arise_event(data, node.id, event_type, now,
change_nodes, new_items, new_mails):
return False
logger.debug("trigger specified event[basic id=%d][event type=%d][nodes_num=%d]" %
(node.basic_id, node.event_type, len(trigger_nodes)))
return True
def win_battle(data, node, enemy_soldier_info, own_soldier_info,
change_nodes, now, new_arena_records = [],
is_legendcity = False, is_unionboss = False, is_plunder = False):
"""战斗胜利
1 获得战利品
2 获得经验：用户经验，英雄经验
3 返还存活士兵
4 更新统计信息
5 结算节点影响
Args:
change_nodes[list(NodeInfo) out]: 发生变化的节点列表
"""
if node == None:
#通过邮件复仇、试炼场,不存在node
node_id = NodeInfo.generate_id(data.id, 0) #0表示主城
else:
node_id = node.id
battle = data.battle_list.get(node_id)
if battle is None:
logger.warning("Battle is not exist[battle node id=%d]" % node_id)
return False
node = data.node_list.get(node_id)
rival = data.rival_list.get(battle.rival_id)
force = False
#如果dependence节点所在key node已不可见，强制结束战斗
if node is not None and node.is_dependency():
parent_basic_id = MapGraph().get_parent(node.basic_id)
parent_id = NodeInfo.generate_id(data.id, parent_basic_id)
parent = data.node_list.get(parent_id, True)
if not parent.is_visible() or not parent.is_own_side():
force = True
if not battle.is_able_to_finish(now, force):
logger.warning("Not able to finish battle[battle node id=%d][battle rival id=%d]" %
(battle.node_id, battle.rival_id))
return False
#获得战利品
resource = data.resource.get()
resource.update_current_resource(now)
resource.gain_money(battle.reward_money)
resource.gain_food(battle.reward_food)
if not item_business.gain_item(data, battle.get_reward_items(), "win battle", log_formater.WIN_BATTLE):
return False
if not rival.is_melee_player():
#返还己方存活士兵
if not _reclaim_soldier(data, battle, now, own_soldier_info):
return False
#用户获得经验,扣除政令
if 'is_battle_cost_energy' in account_business.get_flags():
energy = data.energy.get()
energy.update_current_energy(now)
if not energy.cost_energy(battle.reward_user_exp, None, now):
return False
if not user_business.level_upgrade(data, battle.reward_user_exp, now, "exp win battle", log_formater.EXP_WIN_BATTLE):
return False
#参战英雄获得经验
heroes_id = battle.get_battle_hero()
exp = int(battle.reward_hero_exp / len(heroes_id)) if len(heroes_id) > 0 else 0
for hero_id in heroes_id:
hero = data.hero_list.get(hero_id)
if not hero_business.level_upgrade(data, hero, exp, now):
return False
#更新统计信息
if not _update_statistics(data, battle, True, rival, node,
enemy_soldier_info, own_soldier_info):
return False
#如果是复仇成功，更新邮件
mail_id = battle.mail_id
if mail_id != 0:
mail = data.mail_list.get(mail_id)
if not mail_business.use_mail_to_revenge_succeed(data, mail, now):
return False
rival.clear()
#如果是演武场的对手
if rival.is_arena_player():
arena = data.arena.get()
record = arena_business.calc_arena_battle_finish(data, arena, True, rival)
new_arena_records.append(record)
rival.clear()
#如果是乱斗场的对手
if rival.is_melee_player():
melee = data.melee.get()
record = melee_business.calc_melee_battle_finish(data, melee, True, rival)
new_arena_records.append(record)
rival.clear()
#如果是试炼场
if rival.is_anneal_rival():
rival.clear()
#如果是世界boss
if rival.is_worldboss_rival():
rival.clear()
if (not is_legendcity and not is_unionboss and not is_plunder and
node.event_type not in (
NodeInfo.EVENT_TYPE_EXPAND_DUNGEON,
NodeInfo.EVENT_TYPE_ARENA,
NodeInfo.EVENT_TYPE_WORLDBOSS) and
node.basic_id != 0 and
not _update_node_of_win_battle(data, node, now, change_nodes)):
logger.warning("Update node of win battle failed")
return False
#取消战斗状态
if node is not None:
node.clear_in_battle()
return battle.finish()