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_accept_union_battle_box_result(self, union_response, data, req,
timer):
res = union_battle_pb2.QueryUnionBattleBoxRes()
res.status = 0
union_res = internal_union_pb2.InternalUnionBattleBoxRes()
union_res.ParseFromString(union_response)
if union_res.status != 0:
raise Exception("accept union battle box failed")
if union_res.ret != union_pb2.UNION_OK:
res.ret = union_res.ret
return self._accept_union_battle_box_succeed(data, req, res, timer)
item_id = 0
item_num = 0
for member in union_res.box.members:
if member.user_id == data.id:
item_id = member.item_id
item_num = member.item_num
if item_id != 0:
item_business.gain_item(data, [(item_id, item_num)],
"union battle", log_formater.UNION_BATTLE)
res.ret = union_pb2.UNION_OK
res.box.CopyFrom(union_res.box)
defer = DataBase().commit(data)
defer.addCallback(self._accept_union_battle_box_succeed, req, res,
timer)
return defer
def reward_donate_box(user_data, reward, box_id, timer):
"""领取捐献箱奖励"""
id = UserDonateBox.generate_id(user_data.id, box_id)
donate_box = user_data.userdonatebox_list.get(id)
if donate_box == None:
raise Exception("No such box in donate_box list")
donate_box.reward_donate_box()
resource = user_data.resource.get()
resource.update_current_resource(timer.now)
original_gold = resource.gold
resource.gain_money(reward.resource.money)
resource.gain_food(reward.resource.food)
resource.gain_gold(reward.resource.gold)
log = log_formater.output_gold(user_data,
reward.resource.gold,
log_formater.DONATE_REWARD_GOLD,
"Gain gold from donate box",
before_gold=original_gold)
logger.notice(log)
item_list = []
for i, id in enumerate(reward.item_id):
item_list.append([id, reward.item_num[i]])
item_business.gain_item(user_data, item_list, "donate reward",
log_formater.DONATE_REWARD)
def finish_aid(data, item_basic_id, item_num):
"""结束援助
"""
#获得物品
item_business.gain_item(data, [(item_basic_id, item_num)], "finish aid",
log_formater.FINISH_AID)
union = data.union.get()
union.finish_aid()
def open_chest(data, chest, now):
if not chest.is_in_duration(now):
logger.warning("Open chest not in duration[start=%d][now=%d]" %
(chest.next_start_time, now))
#return None
items_info = chest.get_items_info()
#领取物品奖励
if not item_business.gain_item(data, items_info, "chest reward",
log_formater.CHEST_REWARD):
return None
result = copy.deepcopy(chest)
result._calc_next_start_time(now)
#领取资源奖励
resource = data.resource.get()
original_gold = resource.gold
resource.update_current_resource(now)
chest_reward_gold = int(float(chest.gold))
resource.gain_money(int(float(chest.money)))
resource.gain_food(int(float(chest.food)))
resource.gain_gold(chest_reward_gold)
log = log_formater.output_gold(data,
chest_reward_gold,
log_formater.CHEST_REWARD_GOLD,
"Gain gold from chest",
before_gold=original_gold)
logger.notice(log)
chest.update_info(now)
return result
def finish_question_event(data, node, question_id, answer, correct, now):
"""结束问答事件
Args:
data
node[NodeInfo]: 节点信息
question_id[int]: 问题 id
answer[list(int)]: 回答
correct[bool]: 回答是否正确
now[int]: 当前时间戳
Returns:
True/False
"""
#节点上必须有合法的问答随机事件
if node.event_type != NodeInfo.EVENT_TYPE_QUESTION:
logger.warning("Wrong event[type=%d]" % node.event_type)
return False
if not node.is_event_launched():
logger.warning("Lucky event not launched")
return False
#结束问答流程
question = data.question.get()
if correct != question.answer(question_id, answer):
logger.warning("Answer check error")
return False
question.finish()
if correct:
#如果回答正确，用户获得收益（英雄、物品）
hero_basic_id = data_loader.EventQuestionBasicInfo_dict[
question_id].heroBasicId
items_basic_id = data_loader.EventQuestionBasicInfo_dict[
question_id].itemBasicId
items_num = data_loader.EventQuestionBasicInfo_dict[
question_id].itemNum
assert len(items_basic_id) == len(items_num)
item_info = []
for i in range(0, len(items_basic_id)):
item_info.append((items_basic_id[i], items_num[i]))
if hero_basic_id != 0 and not hero_business.gain_hero(
data, hero_basic_id):
return False
if len(item_info) > 0 and not item_business.gain_item(
data, item_info, " question reward",
log_formater.QUESTION_REWARD):
return False
#如果回答正确，获得功勋值
user = data.user.get(True)
resource = data.resource.get()
resource.update_current_resource(now)
ac_base = data_loader.LuckyEventBasicInfo_dict[
node.event_type].achievementBase
ac_coe = data_loader.LuckyEventBasicInfo_dict[
node.event_type].achievementCoefficient
achievement = ac_base + ac_coe * user.level
resource.gain_achievement(achievement)
return node.finish_event(now)
def _use_valid_cdkey(self, data, key, goodybag_id):
"""使用有效的 cdkey，获得奖励
"""
bag = data_loader.GoodyBagBasicInfo_dict[goodybag_id]
resource = data.resource.get()
original_gold = resource.gold
if bag.gold > 0:
resource.gain_gold(bag.gold)
log = log_formater.output_gold(data,
bag.gold,
log_formater.BAG_GOLD,
"Gain gold frome bag",
before_gold=original_gold)
logger.notice(log)
if bag.money > 0:
resource.gain_money(bag.money)
if bag.food > 0:
resource.gain_food(bag.food)
assert len(bag.itemsBasicId) == len(bag.itemsNum)
item_list = []
for i in range(0, len(bag.itemsBasicId)):
item_list.append((bag.itemsBasicId[i], bag.itemsNum[i]))
if not item_business.gain_item(data, item_list, "cdkey reward",
log_formater.CDKEY_REWARD):
raise Exception("Gain item failed")
return self._pack_valid_cdkey_response(data, goodybag_id, resource,
item_list)
def _calc_treasure_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)
item_list = []
if not draw_business.treasure_draw(
basic_data, data, user, resource, draw,
item_list, req, timer.now):
raise Exception("Treasure draw failed")
#添加抽奖得到的英雄和物品
if not item_business.gain_item(data, item_list, "trun draw ", log_formater.DRAW):
raise Exception("Gain item failed")
alltimes = draw.total_treasure_draw_num
res = self._pack_treasure_draw_response(data, item_list, resource, alltimes, timer.now)
defer = DataBase().commit(data)
defer.addCallback(self._draw_treasure_succeed, type, req, res, timer)
return defer
def cat_reward(basic_data, data, activity_basic_id, step_id, now):
"""领取奖励
"""
basic_activity = basic_data.activity_list.get(activity_basic_id)
activity_id = ActivityInfo.generate_id(data.id, activity_basic_id)
activity = data.activity_list.get(activity_id)
if not activity.accept_reward(basic_activity, step_id):
return False
if not activity.is_living(now, basic_activity.style_id):
logger.warning("Activity is not living[basic id=%d]" % activity_basic_id)
return False
#领取奖励后更新activity，保证部分活动可以重新修改活动状态
_update_one_activity(basic_data, data, activity, now)
#获得奖励
stepInfo = basic_data.activity_step_list.get(step_id)
for hero_basic_id in stepInfo.get_heroes_basic_id():
if not hero_business.gain_hero(data, hero_basic_id):
return False
items = stepInfo.get_items()
if not item_business.gain_item(data, items, "activity reward", log_formater.ACTIVITY_REWARD):
return False
cost_gold = 0
min_gold = 0
max_gold = 0
gold = stepInfo.gold
if gold > 0:
cost_gold = gold
min_gold = stepInfo.value1
max_gold = stepInfo.value2
return (cost_gold, min_gold, max_gold)
def get_arena_win_num_reward(data, arena, now):
"""领取奖励
"""
chest = data_loader.ChestInfo_dict[arena.chest_basic_id]
#可以领取奖励
resource = data.resource.get()
original_gold = resource.gold
reward_gold = int(float(chest.reward.gold))
resource.update_current_resource(now)
resource.gain_money(int(float(chest.reward.money)))
resource.gain_food(int(float(chest.reward.food)))
resource.gain_gold(reward_gold)
log = log_formater.output_gold(data,
reward_gold,
log_formater.ARENA_REWORD_GOLD,
"Gain gold from arena",
before_gold=original_gold)
logger.notice(log)
assert len(chest.reward.itemBasicIds) == len(chest.reward.itemNums)
new_items = []
for i in range(len(chest.reward.itemBasicIds)):
basic_id = chest.reward.itemBasicIds[i]
num = chest.reward.itemNums[i]
new_items.append((basic_id, num))
if not item_business.gain_item(data, new_items, "arena reward",
log_formater.ARENA_REWARD):
return False
if not arena.get_win_num_reward():
return False
return True
def accept_individual_step_award(data, target_step, now):
"""领取个人战功阶段奖励
"""
user = data.user.get(True)
award_index = data_loader.UnionBattleIndividualTargetInfo_dict[
user.level].awardIndex[target_step - 1]
award = data_loader.UnionBattleIndivStepAwardInfo_dict[award_index]
#资源
resource = data.resource.get()
original_gold = resource.gold
resource.update_current_resource(now)
resource.gain_gold(award.gold)
log = log_formater.output_gold(data,
award.gold,
log_formater.INDIVIDUAL_STEP_GOLD,
"Gain gold from individual step award",
before_gold=original_gold)
logger.notice(log)
#物品
items = []
for i in range(len(award.itemsBasicId)):
items.append((award.itemsBasicId[i], award.itemsNum[i]))
assert item_business.gain_item(data, items, "individual award",
log_formater.INDIVIDUAL_AWARD)
#联盟荣誉
union = data.union.get()
union.gain_honor(award.honor)
return (award.honor, items)
def calc_sweep_income(data, anneal, attack_num, sweep_rewards, items, now):
"""计算试炼场战斗的扫荡奖励
sweep_reward : list(list(item_basic_id, item_num)) out 记录每轮扫荡的奖励
items[list((ItemInfo) out]
"""
#计算扫荡奖励
reward_items = []
is_normal = True
reward_total_money = 0
reward_total_food = 0
for i in range(attack_num):
if is_normal:
type = AnnealInfo.NORMAL_MODE
is_normal = not is_normal
else:
type = AnnealInfo.HARD_MODE
is_normal = not is_normal
#enemy的level
level = anneal.get_anneal_enemy_level(type, anneal.sweep_floor,
AnnealInfo.LEVEL_NUM_PER_FLOOR)
#随机奖励
spoils = reward_module.random_anneal_spoils(level, type, True,
anneal.sweep_direction)
for spoil in spoils:
reward_items.append(spoil)
#资源奖励
(reward_money, reward_food) = calc_resource_income(level)
reward_total_money += reward_money
reward_total_food += reward_food
sweep_rewards.append((reward_money, reward_food, spoils)) #返回每轮奖励
resource = data.resource.get()
resource.update_current_resource(now)
resource.gain_money(reward_total_money)
resource.gain_food(reward_total_food)
if not item_business.gain_item(data, reward_items, "sweep reward",
log_formater.SWEEP_REWARD):
logger.warning("gain reward item failed")
return False
#合并重复的 item
merge_items = {}
for (basic_id, num) in reward_items:
if basic_id not in merge_items:
merge_items[basic_id] = num
else:
merge_items[basic_id] += num
for key in merge_items:
item_id = ItemInfo.generate_id(data.id, key)
item = data.item_list.get(item_id)
items.append(item) #返回有变化的item列表
return True
def calc_sweep_reward(data, anneal, attack_num, sweep_rewards, items, now):
"""扫荡奖励(新版)"""
reward_total_money = 0
reward_total_food = 0
reward_items = []
for i in xrange(attack_num):
level = anneal.get_anneal_enemy_level(anneal.sweep_mode,
anneal.sweep_floor,
AnnealInfo.LEVEL_NUM_PER_FLOOR)
at_least = False
if i == attack_num - 1 and anneal.sweep_at_least:
"""保底掉落"""
at_least = True
#随机奖励
spoils = reward_module.random_anneal_spoils(anneal.sweep_floor,
anneal.sweep_mode, True,
anneal.sweep_direction,
at_least)
reward_items.extend(spoils)
#资源奖励
(reward_money, reward_food) = calc_resource_income(level)
reward_total_money += reward_money
reward_total_food += reward_food
sweep_rewards.append((reward_money, reward_food, spoils)) #返回每轮奖励
resource = data.resource.get()
resource.update_current_resource(now)
resource.gain_money(reward_total_money)
resource.gain_food(reward_total_food)
if not item_business.gain_item(data, reward_items, "new sweep reward",
log_formater.NEW_SWEEP_REWARD):
logger.warning("gain reward item failed")
return False
#合并重复的 item
merge_items = {}
for (basic_id, num) in reward_items:
if basic_id not in merge_items:
merge_items[basic_id] = num
else:
merge_items[basic_id] += num
for key in merge_items:
item_id = ItemInfo.generate_id(data.id, key)
item = data.item_list.get(item_id)
items.append(item) #返回有变化的item列表
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 _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 gather(data, nodes, new_items, now):
"""进行资源采集
"""
resource = data.resource.get()
resource.update_current_resource(now)
for node in nodes:
if not node.is_able_to_gather(now):
return True #为避免网络失败请求重复发，此处返回true
(money, food, item_count) = node.gather(now)
resource.gain_money(money)
resource.gain_food(food)
gain_items = []
if item_count > 0:
gain_items = reward_module.random_exploit_material(
node.exploit_level, item_count)
item_business.gain_item(data, gain_items, "gather item", log_formater.GATHER)
new_items.extend(gain_items)
return True
def get_pass_reward(data, anneal, type):
"""领取过关奖励
"""
#先判断是否可以领取
if not anneal.is_able_to_get_pass_reward(type):
logger.warning("not able to get pass reward")
return False
#获得奖励物品
items_info = anneal.calc_pass_reward(type)
if not item_business.gain_item(data, items_info, "pass reward",
log_formater.PASS_REWARD):
return False
if not anneal.get_pass_reward(type):
return False
return True
def _award(data, items, gold, honor, now):
"""发放奖励
"""
#资源
resource = data.resource.get()
original_gold = resource.gold
resource.update_current_resource(now)
resource.gain_gold(gold)
log = log_formater.output_gold(data,
gold,
log_formater.AWARD_GOLD,
"Gain gold from award",
before_gold=original_gold)
logger.notice(log)
#物品
assert item_business.gain_item(data, items, "award", log_formater.AWARD)
#联盟荣誉
union = data.union.get()
union.gain_honor(honor)
def use_mail_to_get_reward(data, mail_indexs, now):
"""
使用邮件
1 可能会获取资源和物品奖励
2 标记邮件状态为已读
3 确定邮件是否需要删除
"""
for mail_index in mail_indexs:
mail_id = MailInfo.generate_id(data.id, mail_index)
mail = data.mail_list.get(mail_id)
assert mail.is_system_mail()
#可以领取奖励
resource = data.resource.get()
original_gold = resource.gold
reward_gold = mail.reward_gold
resource.update_current_resource(now)
resource.gain_money(mail.reward_money)
resource.gain_food(mail.reward_food)
resource.gain_gold(reward_gold)
log = log_formater.output_gold(data,
reward_gold,
log_formater.MAIL_REWARD_GOLD,
"Gain gold from mail",
before_gold=original_gold)
logger.notice(log)
new_items = mail.get_reward_items()
if not item_business.gain_item(data, new_items, "mail reward",
log_formater.MAIL_REWARD):
return False
if not mail.use():
return False
if mail.is_need_delete(now):
_delete_mail(data, mail)
return True
def accept_reward(basic_data, data, activity_basic_id, step_id, now):
"""领取奖励
"""
basic_activity = basic_data.activity_list.get(activity_basic_id)
activity_id = ActivityInfo.generate_id(data.id, activity_basic_id)
activity = data.activity_list.get(activity_id)
if not activity.accept_reward(basic_activity, step_id):
return False
if not activity.is_living(now, basic_activity.style_id):
logger.warning("Activity is not living[basic id=%d]" % activity_basic_id)
return False
#领取奖励后更新activity，保证部分活动可以重新修改活动状态
_update_one_activity(basic_data, data, activity, now)
#获得奖励
stepInfo = basic_data.activity_step_list.get(step_id)
for hero_basic_id in stepInfo.get_heroes_basic_id():
if not hero_business.gain_hero(data, hero_basic_id):
return False
items = stepInfo.get_items()
if not item_business.gain_item(data, items, "activity reward", log_formater.ACTIVITY_REWARD):
return False
gold = stepInfo.gold
if gold > 0:
resource = data.resource.get()
original_gold = resource.gold
resource.gain_gold(gold)
log = log_formater.output_gold(data, gold, log_formater.ACCEPT_REWARD_GOLD,
"Gain gold from activity", before_gold = original_gold)
logger.notice(log)
return True
def _calc_signin(self, data, req, timer, force=False):
"""
"""
sign = data.sign.get()
user = data.user.get()
hero_list = []
item_list = []
if not signin_business.signin(sign, req.index, user, hero_list,
item_list, timer.now, force):
raise Exception("Sign in failed")
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, "signin reward",
log_formater.SIGNIN_REWARD):
raise Exception("Gain item failed")
res = self._pack_signin_response(data, hero_list, item_list, timer.now)
defer = DataBase().commit(data)
defer.addCallback(self._signin_succeed, req, res, timer)
return defer
def pay_for_order(data, platform, order_number, reply, now):
"""支付订单
检查支付是否有效，完成购买行为
获得元宝，物品
如果购买月卡，更新月卡信息
Args:
platform[int]: 充值平台
id[int]: 商品 id
reply[string]: 支付响应
now[int]: 当前时间戳
Returns:
(ret, update_paycard, items)
(是否成功, 是否更新了月卡, 获得的物品)
"""
update_paycard = False
items = []
#如果充值已完成（这次是重复的请求） 返回充值内容
record = _get_record_by_order_number(data, order_number)
if record is not None and record.is_finish:
order = PayPool().get(record.order_id)
if order.cardType != 0:
update_paycard = True
for index in range(0, len(order.itemsBasicId)):
items.append((order.itemsBasicId[index], order.itemsNum[index]))
return (True, update_paycard, items)
#获取完成的充值，获得对应的商品信息
infos = PayLogic().check_order_reply(data.id, platform, order_number,
reply, now)
if infos is None or len(infos) == 0:
#临时解决，合服之后多个server_id存在一个服里
infos = PayLogic().check_order_reply(data.id, platform, order_number,
reply, now, data.id / 10000000)
if infos is None or len(infos) == 0:
logger.warning("No finished order")
return (False, update_paycard, items)
#更新商店信息
pay = data.pay.get()
for (order, order_number) in infos:
pay.pay_order(order)
if order.cardType != 0:
#更新月卡
pay.add_card(order.cardType, now)
update_paycard = True
if order.id == 10110200:
#特殊处理,针对一元购的
trainer = data.trainer.get()
trainer.add_buy_daily_discount(1)
#更新充值记录
for (order, order_number) in infos:
record = _get_record_by_order_number(data, order_number)
if record is not None:
record.finish(order)
else:
logger.debug("Record not found[order_number=%s]" % order_number)
#添加充值记录（完成状态）
pay.pre_order(order_number)
record = PayRecordInfo.create(data.id, pay.pay_count, platform,
now)
record.set_detail(order.id, order_number, order.truePrice)
data.pay_record_list.add(record)
record.finish(order)
#获得元宝
for (order, order_number) in infos:
resource = data.resource.get()
original_gold = resource.gold
resource.gain_gold(order.gold)
log = log_formater.output_gold(data,
order.gold,
log_formater.PAY_GOLD,
"Gain gold from pay",
before_gold=original_gold)
logger.notice(log)
#更新用户vip
user = data.user.get()
user.gain_vip_points(order.truePrice)
#获得物品
gain_items = []
for index in range(0, len(order.itemsBasicId)):
gain_items.append(
(order.itemsBasicId[index], order.itemsNum[index]))
items.append((order.itemsBasicId[index], order.itemsNum[index]))
item_business.gain_item(data, gain_items, "pay reward",
log_formater.PAY_REWARD)
return (True, update_paycard, items)
def patch_order(data, platform, id, order_number, now):
"""修复完成订单
检查支付是否有效，完成购买行为
获得元宝，物品
如果购买月卡，更新月卡信息
Args:
platform[int]: 充值平台
id[int]: 商品 id
order_number[string]: 支付订单 id: order number
now[int]: 当前时间戳
Returns:
(ret, update_paycard)
(是否成功, 是否更新了月卡)
"""
update_paycard = False
pay = data.pay.get()
order = pay.patch_order(platform, id, order_number, now)
if order is None:
return (False, update_paycard)
#添加/更新充值记录（已完成）
update_record_id = 0
for record in data.pay_record_list.get_all(True):
if record.order_number == order_number:
update_record_id = record.id
break
if update_record_id == 0:
record = PayRecordInfo.create(data.id, pay.pay_count, platform, now)
record.set_detail(order.id, order_number, order.truePrice)
record.finish()
data.pay_record_list.add(record)
else:
record = data.pay_record_list.get(update_record_id)
record.finish(order)
#更新月卡
if order.cardType != 0:
if not pay.add_card(order.cardType, now):
return (False, update_paycard)
update_paycard = True
#获得元宝
resource = data.resource.get()
original_gold = resource.gold
resource.gain_gold(order.gold)
log = log_formater.output_gold(data,
order.gold,
log_formater.PATCH_PAY_GOLD,
"Gain gold from patch pay",
before_gold=original_gold)
logger.notice(log)
#更新用户vip
user = data.user.get()
user.gain_vip_points(order.truePrice)
#获得物品
items = []
for index in range(0, len(order.itemsBasicId)):
items.append((order.itemsBasicId[index], order.itemsNum[index]))
ret = item_business.gain_item(data, items, "pay reward",
log_formater.PAY_REWARD)
return (ret, update_paycard)
def finish_visit_event(data, node, visit_id, now, use_gold = 0):
"""结束探访事件
Args:
data
node[NodeInfo]: 节点信息
visit_id[int]: 探访选项 visit_id == 0, 表示放弃选择
now[int]: 当前时间戳
Returns:
True/False
"""
#节点上必须有合法的探访随机事件
if node.event_type != NodeInfo.EVENT_TYPE_VISIT:
logger.warning("Wrong event[type=%d]" % node.event_type)
return False
#结束探访流程
visit = data.visit_list.get(node.id)
if visit_id != 0 and not visit.is_candidate_valid(visit_id):
return False
visit.finish()
if visit_id != 0:
#用户花费金钱/元宝，获得收益（英雄、物品）
user = data.user.get(True)
resource = data.resource.get()
original_gold = resource.gold
resource.update_current_resource(now)
money_base = data_loader.EventVisitBasicInfo_dict[visit_id].costMoneyBase
money_coe = data_loader.EventVisitBasicInfo_dict[visit_id].costMoneyCoefficient
gold = data_loader.EventVisitBasicInfo_dict[visit_id].costGold
money = money_base + money_coe * user.level
#如果金钱不够，使用元宝兑换
cost_gold = 0
money_gap = 0
if resource.money < money:
money_gap = money - resource.money
cost_gold = resource.gold_exchange_resource(money = money_gap)
if cost_gold != use_gold:
logger.warning("Gold exchange resource failed"
"[try cost gold=%d][real cost gold=%d]" %
(use_gold, cost_gold))
return False
if not resource.cost_money(money) or not resource.cost_gold(gold):
return False
hero_basic_id = data_loader.EventVisitBasicInfo_dict[visit_id].heroBasicId
item_basic_id = data_loader.EventVisitBasicInfo_dict[visit_id].itemBasicId
item_num = data_loader.EventVisitBasicInfo_dict[visit_id].itemNum
if hero_basic_id != 0 and not hero_business.gain_hero(data, hero_basic_id):
return False
if item_basic_id != 0 and not item_business.gain_item(data, [(item_basic_id, item_num)], "visit reward", log_formater.VISIT_REWARD):
return False
#获得成就值
ac_base = data_loader.LuckyEventBasicInfo_dict[node.event_type].achievementBase
ac_coe = data_loader.LuckyEventBasicInfo_dict[node.event_type].achievementCoefficient
achievement_value = ac_base + ac_coe * user.level
resource.gain_achievement(achievement_value)
if cost_gold + gold > 0:
visit_items_id = []
visit_items_num = []
visit_heroes_id = []
if item_basic_id != 0:
visit_items_id.append(item_basic_id)
visit_items_num.append(item_num)
if hero_basic_id != 0:
visit_heroes_id.append(hero_basic_id)
log = log_formater.output_gold(data, -(cost_gold + gold), log_formater.VISIT,
"Visit by gold", money = money_gap, before_gold = original_gold, achievement = achievement_value,
items_id = visit_items_id, items_num = visit_items_num,
heroes_id = visit_heroes_id)
logger.notice(log)
return node.finish_event(now)
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 try_finish_order_outside(data, platform, now):
"""尝试修复非游戏内正常渠道的充值
tips:
目前只有soha渠道可以这样做，soha不需要order_number，直接一把拿回所有支付数据
"""
update_paycard = False
items = []
#获取完成的充值，获得对应的商品信息
infos = PayLogic().check_order_reply(data.id, platform, None, None, now)
if infos is None:
#临时解决，合服之后多个server_id存在一个服里
infos = PayLogic().check_order_reply(data.id, platform, None, None,
now, data.id / 10000000)
if infos is None:
logger.warning("No finished order")
return (False, update_paycard, items)
else:
logger.notice("Get finished order")
#更新商店信息
pay = data.pay.get()
for (order, order_number) in infos:
pay.pay_order(order)
if order.cardType != 0:
#更新月卡
pay.add_card(order.cardType, now)
update_paycard = True
#更新充值记录
for (order, order_number) in infos:
record = _get_record_by_order_number(data, order_number)
if record is not None:
record.finish(order)
else:
logger.debug("Record not found[order_number=%s]" % order_number)
#添加充值记录（完成状态）
pay.pre_order(order_number)
record = PayRecordInfo.create(data.id, pay.pay_count, platform,
now)
record.set_detail(order.id, order_number, order.truePrice)
data.pay_record_list.add(record)
record.finish(order)
#获得元宝
for (order, order_number) in infos:
resource = data.resource.get()
original_gold = resource.gold
resource.gain_gold(order.gold)
log = log_formater.output_gold(data,
order.gold,
log_formater.CHECK_PAY_GOLD,
"Gain gold from check pay",
before_gold=original_gold)
logger.notice(log)
#更新用户vip
user = data.user.get()
user.gain_vip_points(order.truePrice)
#获得物品
gain_items = []
for index in range(0, len(order.itemsBasicId)):
gain_items.append(
(order.itemsBasicId[index], order.itemsNum[index]))
items.append((order.itemsBasicId[index], order.itemsNum[index]))
item_business.gain_item(data, gain_items, "pay reward",
log_formater.PAY_REWARD)
return (True, update_paycard, items)
def buy_goods(data, shop, id, now, tax=0):
"""购买货物
Args:
shop[ShopInfo out]: 酒肆信息
resource[ResourceInfo out]: 资源信息
id[int]: 货物的 id
tax[int]: 税率 [0-100]
Returns:
True/False 是否成功
"""
resource = data.resource.get()
original_gold = resource.gold
resource.update_current_resource(now)
goods = shop.buy_goods(id)
if goods is None:
return False
#记录次数
trainer = data.trainer.get()
if shop.type == ShopInfo.GOODS_TYPE_MONEY:
#消耗金钱
if not resource.cost_money(goods.get_real_price()):
return False
trainer.add_daily_buy_goods_in_wineshop(1)
elif shop.type == ShopInfo.GOODS_TYPE_GOLD:
#消耗元宝
if not resource.cost_gold(goods.get_real_price()):
return False
trainer.add_daily_buy_goods_in_wineshop(1)
elif shop.type == ShopInfo.GOODS_TYPE_ACHIEVEMENT:
#消耗成就值
if not resource.cost_achievement(goods.get_real_price()):
return False
trainer.add_daily_buy_goods_in_achievement_shop(1)
elif shop.type == ShopInfo.GOODS_TYPE_LEGENDCITY:
pass
trainer.add_daily_buy_goods_in_legendcity_shop(1)
elif shop.type == ShopInfo.GOODS_TYPE_UNION:
#消耗联盟荣誉
union = data.union.get()
if not union.consume_honor(goods.get_real_price()):
return False
trainer.add_daily_buy_goods_in_union_shop(1)
elif shop.type == ShopInfo.GOODS_TYPE_ARENA:
#消耗演武场代币
arena = data.arena.get()
if not arena.cost_coin(goods.get_real_price()):
return False
elif shop.type == ShopInfo.GOODS_TYPE_SOUL_SOUL:
#消耗精魄
if not resource.cost_soul(goods.get_real_price()):
return False
trainer.add_daily_buy_goods_in_soul_shop(1)
elif shop.type == ShopInfo.GOODS_TYPE_SOUL_GOLD:
#消耗元宝
if not resource.cost_gold(goods.get_real_price()):
return False
trainer.add_daily_buy_goods_in_soul_shop(1)
else:
logger.warning("Invalid shop type[type=%d]" % shop.type)
return False
#得到物品
if not item_business.gain_item(data, [(goods.item_basic_id, goods.item_num)
], "shop", log_formater.SHOP):
return False
id = ItemInfo.generate_id(data.id, goods.item_basic_id)
item = data.item_list.get(id)
if shop.type == ShopInfo.GOODS_TYPE_GOLD:
log = log_formater.output_gold(data,
-goods.get_real_price(),
log_formater.BUY_GOODS,
"Buy goods by gold",
before_gold=original_gold,
items_id=[goods.item_basic_id],
items_num=[goods.item_num])
logger.notice(log)
return True
def choose_card(data, choose_index, cost_gold):
"""翻牌
"""
pray = data.pray.get()
#消耗祈福令
cost_item = pray.calc_choose_card_use_item()
id = ItemInfo.generate_id(data.id, cost_item[0])
item = data.item_list.get(id)
if cost_item[1] != 0 and item == None and cost_gold == 0:
logger.warning("Pray item and gold error")
return False
if cost_item[1] != 0:
need_gold = 0
output_items = []
if item == None:
need_gold = cost_item[1] * int(
float(
data_loader.OtherBasicInfo_dict["ItemPrayGoldCost"].value))
elif cost_item[1] > item.num:
need_gold = (cost_item[1] - item.num) * int(
float(
data_loader.OtherBasicInfo_dict["ItemPrayGoldCost"].value))
consume = item.consume(item.num)
output_items.append("[item=")
output_items.append(utils.join_to_string(list(consume[1])))
output_items.append("]")
else:
consume = item.consume(cost_item[1])
output_items.append("[item=")
output_items.append(utils.join_to_string(list(consume[1])))
output_items.append("]")
log = log_formater.output_item(data, "choose card",
log_formater.CHOOSE_CARD,
''.join(output_items))
logger.notice(log)
if need_gold != cost_gold:
logger.warning(
"choose card gold cost is error[need_gold=%d][cost_gold=%d]" %
(need_gold, cost_gold))
return False
resource = data.resource.get()
original_gold = resource.gold
if need_gold != 0 and not resource.cost_gold(need_gold):
logger.warning("not enough gold[need_gold=%d][has_gold=%d]" %
(need_gold, resource.gold))
return False
log = log_formater.output_gold(data,
-need_gold,
log_formater.CHOOSE_CARD,
"Choose card by gold ",
before_gold=original_gold)
logger.notice(log)
#翻牌
get_item = pray.choose_card(choose_index)
if get_item is None:
return False
if not PrayInfo.is_item_pray_multi(get_item[0]):
id = ItemInfo.generate_id(data.id, get_item[0])
item = data.item_list.get(id)
#if item == None:
items = []
items.append(get_item)
item_business.gain_item(data, items, "choose card",
log_formater.CHOOSE_CARD)
#else:
# item.acquire(get_item[1])
#统计
trainer = data.trainer.get()
trainer.add_daily_choose_card_num(1)
return True
def finish_exploit_event(data, node, now, end_time, change_nodes,
new_items, new_mails, force = True, ret = Ret()):
"""
结束开采事件
1 结算资源、物品奖励
2 结算英雄经验
3 将相关信息填充进邮件
Args:
data[UserData]
node[NodeInfo]: 节点信息
end_time[int]: 结束的时间戳
new_items[list(basic_id, num) out]
new_mails[list(MailInfo) out]
now[int]: 当前时间戳
force[bool]: 是否强制结束
"""
user = data.user.get(True)
resource = data.resource.get()
#节点上必须有合法的随机事件
if (node.event_type != NodeInfo.EVENT_TYPE_TAX and
node.event_type != NodeInfo.EVENT_TYPE_FARM and
node.event_type != NodeInfo.EVENT_TYPE_MINING and
node.event_type != NodeInfo.EVENT_TYPE_GOLD and
node.event_type != NodeInfo.EVENT_TYPE_SEARCH and
node.event_type != NodeInfo.EVENT_TYPE_DEEP_MINING and
node.event_type != NodeInfo.EVENT_TYPE_HERMIT):
logger.warning("Wrong event[type=%d]" % node.event_type)
ret.setup("NOT_EXPLOITING")
return False
if not node.is_able_to_finish_exploit(end_time, force, ret):
logger.warning("Not able to finish exploit")
return False
is_offline = False
if node.is_exploit_offline():
is_offline = True
gain_items = []
if not is_offline:
#结算资源点资源采集
resource.update_current_resource(now)
original_gold = resource.gold
(money, food, gold, material_count) = node.calc_exploit_income(end_time)
resource.gain_money(money)
resource.gain_food(food)
resource.gain_gold(gold)
log = log_formater.output_gold(data, gold, log_formater.EXPLOIT_GOLD,
"Gain gold from exploit", before_gold = original_gold)
logger.notice(log)
if material_count > 0:
gain_items = reward_module.random_exploit_material(
node.exploit_level, material_count)
else:
money = 0
food = 0
gold = 0
#采集随机物品奖励
if is_offline:
#离线开采奖励物品个数
exploitation = data.exploitation.get()
(reward_level, reward_num) = exploitation.get_offline_exploit_reward(node, now)
reward_items = reward_module.random_exploit_offline(node.event_type, reward_level, reward_num)
else:
progress = node.get_exploit_progress(end_time)
reward_items = reward_module.random_exploit_gift(node.exploit_level, progress)
gain_items.extend(reward_items)
if not item_business.gain_item(data, gain_items, "exploit reward", log_formater.EXPLOIT_REWARD):
logger.warning("Merge reward item failed")
return False
new_items.extend(gain_items)
#如果开采正常结束，获取成就值
if node.is_exploit_over(end_time):
ac_base = data_loader.LuckyEventBasicInfo_dict[node.event_type].achievementBase
ac_coe = data_loader.LuckyEventBasicInfo_dict[node.event_type].achievementCoefficient
achievement = ac_base + ac_coe * node.level
resource.gain_achievement(achievement)
if is_offline:
exploitation = data.exploitation.get()
exploitation.finish(node, now)
#采集完成邮件
mail = mail_business.create_exploitation_mail(data, node.basic_id, end_time)
new_mails.append(mail)
mail.attach_reward(money, food, gold, gain_items)
mail.attach_node_info(node)
#移除英雄，结算经验
work_heroes = [] #参与开采的英雄
work_heroes_id = node.get_exploit_hero()
for hero_id in work_heroes_id:
if hero_id == 0:
work_heroes.append(None)
else:
hero = data.hero_list.get(hero_id)
work_heroes.append(hero)
if not _reclaim_exploit_hero(data, node, user, work_heroes, end_time, now):
return False
if not node.finish_exploit(work_heroes, is_offline):
return False
#统计信息
trainer = data.trainer.get()
trainer.add_daily_finish_event_num(node.event_type, 1)
if not node.finish_event(now, overtime = True):
return False
#金矿资源在采集完成后消失
if node.is_exploit_gold():
map = data.map.get()
node.reset_dependency(map)
change_nodes.append(node)
if is_offline:
node.clear_key_node()
change_nodes.append(node)
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()
