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()