def add_buff(self, buff_id, now): """添加 buff """ buffs = utils.split_to_int(self.buffs) buffs_start_time = utils.split_to_int(self.buffs_start_time) #清除已经过期的 buff for index in range(0, len(buffs)): id = buffs[index] if id == 0: continue end_time = (buffs_start_time[index] + data_loader.LegendCityBuffBasicInfo_dict[id].duration) if now >= end_time: buffs[index] = 0 ok = False for index in range(0, len(buffs)): if buffs[index] == 0: buffs[index] = buff_id buffs_start_time[index] = now ok = True break if not ok: logger.warning("Not able to add legendcity buff") return False self.buffs = utils.join_to_string(buffs) self.buffs_start_time = utils.join_to_string(buffs_start_time) return True
def reset(self, basic_activity, basic_steps): """重制活动进度和奖励 """ info = basic_activity progress = [0] * len(info.get_steps()) self.progress = utils.join_to_string(progress) target = [] for step_id in info.get_steps(): for basic_step in basic_steps: if step_id == basic_step.id: target.append(basic_step.target) break self.target = utils.join_to_string(target) status = [] for step_id in info.get_steps(): default_lock = False for basic_step in basic_steps: if step_id == basic_step.id: default_lock = basic_step.default_lock break if default_lock: status.append(ActivityInfo.REWARD_LOCKED) else: status.append(ActivityInfo.REWARD_AVAILABLE) self.status = utils.join_to_string(status)
def change_rivals(self, delete_rivals_id, rivals_info, now): """更改对手 """ rivals_id = utils.split_to_int(self.rivals_id) rivals_is_robot = utils.split_to_int(self.rivals_is_robot) rivals_position_level = utils.split_to_int(self.rivals_position_level) for id in delete_rivals_id: if id not in rivals_id: continue index = rivals_id.index(id) rivals_position_level.pop(index) rivals_is_robot.pop(index) rivals_id.pop(index) for (id, is_robot, position) in rivals_info: rivals_id.append(id) rivals_is_robot.append(int(is_robot)) rivals_position_level.append(position) self.rivals_id = utils.join_to_string(rivals_id) self.rivals_is_robot = utils.join_to_string(rivals_is_robot) self.rivals_position_level = utils.join_to_string( rivals_position_level) self.update_time = now logger.debug( "change rivals[rivals_id=%s][is_robot=%s][position_level=%s]" % (self.rivals_id, self.rivals_is_robot, self.rivals_position_level))
def set_reward(self, reward_money, reward_food, reward_hero_exp, reward_user_exp, reward_items): """设置战利品 """ self.reward_money = reward_money self.reward_food = reward_food self.reward_hero_exp = reward_hero_exp self.reward_user_exp = reward_user_exp #合并重复的 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 reward_items_basic_id = [] reward_items_num = [] for item_basic_id in merge_items: item_num = merge_items[item_basic_id] reward_items_basic_id.append(item_basic_id) reward_items_num.append(item_num) self.reward_items_basic_id = utils.join_to_string( reward_items_basic_id) self.reward_items_num = utils.join_to_string(reward_items_num)
def start(self, node, rival, mail, teams, heroes, now, vip_level): """开始战斗 """ assert rival.id != INVALID_RIVAL self.rival_id = rival.id if mail is not None: self.mail_id = mail.id if node is not None: self.node_id = node.id teams_index = [team.index for team in teams] self.teams_index = utils.join_to_string(teams_index) heroes_id = [hero.id for hero in heroes] self.heroes_id = utils.join_to_string(heroes_id) self.time = now if self.is_appoint: appoint_time = int( float(data_loader.OtherBasicInfo_dict["BattleTime"].value)) deduction_time = int( data_loader.VipBasicInfo_dict[vip_level].appointTimeDeduction) self.appoint_total_time = max(0, appoint_time - deduction_time) return True
def finish_battle(self, attacker_user_id, kills_num): """结束战斗 """ #assert self.status == self.NODE_STATUS_ENGAGED if self.status != self.NODE_STATUS_ENGAGED: return else: self.current_soldier_num = max( 0, self.current_soldier_num - kills_num) self.attacker_num = max(0, self.attacker_num - 1) #删除记录的user_id和他的开始战斗时间 users_id = utils.split_to_int(self.attacker_user_id) start_times = utils.split_to_int(self.battle_start_time) del_index = users_id.index(attacker_user_id) del (users_id[del_index]) del (start_times[del_index]) self.attacker_user_id = utils.join_to_string(users_id) self.battle_start_time = utils.join_to_string(start_times) if self.current_soldier_num == 0: self.status = self.NODE_STATUS_BEATEN self.attacker_num = 0 return if self.attacker_num == 0: self.status = self.NODE_STATUS_DEPLOYED
def create(user_id, index, basic_id, now): """ 新建一封邮件 Args: basic_mail_id : 用户的下一个可用mail_id basic_id : 邮件类型 user_id :给谁发的邮件 _forward_legendcity_mail()""" mail_id = MailInfo.generate_id(user_id, index) mail = MailInfo(mail_id, user_id, basic_id) mail.time = now info = data_loader.MailKeyInfo_dict[basic_id] mail.type = info.type if info.lastTime == 0: mail.delete_after_used = True mail.delete_time = 0 else: mail.delete_after_used = False seconds_per_hour = 3600 mail.delete_time = now + info.lastTime * seconds_per_hour mail.reward_money = info.rewardMoney mail.reward_food = info.rewardFood mail.reward_gold = info.rewardGold items_basic_id = info.rewardItemBasicId items_num = info.rewardItemNum assert len(items_basic_id) == len(items_num) mail.reward_items_basic_id = utils.join_to_string(items_basic_id) mail.reward_items_num = utils.join_to_string(items_num) return mail
def _calc_next_reward(self): """生成下次抽红包的奖励 """ self.level = 0 self.money = 0 self.food = 0 self.gold = 0 self.items_id = "" self.items_num = "" pool = getattr(data_loader, "BoxInfo_dict") total_weight = 0 for id in pool: total_weight += pool[id].weight roll = random.randint(0, total_weight - 1) sum = 0 for id in pool: sum += pool[id].weight if roll < sum: self.level = pool[id].level self.money = pool[id].reward.money self.food = pool[id].reward.food self.gold = pool[id].reward.gold self.items_id = utils.join_to_string( pool[id].reward.itemBasicIds) self.items_num = utils.join_to_string(pool[id].reward.itemNums) break return True
def pay_order(self, order): """完成支付,修改商店中下一件商品信息,支付金额信息 """ if order.type == PayPool.ORDER_TYPE_NORMAL: store = utils.split_to_int(self.order_normal_ids) elif order.type == PayPool.ORDER_TYPE_CARD: store = utils.split_to_int(self.order_card_ids) elif order.type == PayPool.ORDER_TYPE_PACKAGE: store = utils.split_to_int(self.order_package_ids) self.pre_order_number = "" self.pay_amount += order.truePrice #计算下一个可以购买的商品 id = order.id if id in store: index = store.index(id) if order.nextId == 0: store.remove(id) else: store[index] = order.nextId if order.type == PayPool.ORDER_TYPE_NORMAL: self.order_normal_ids = utils.join_to_string(store) elif order.type == PayPool.ORDER_TYPE_CARD: self.order_card_ids = utils.join_to_string(store) elif order.type == PayPool.ORDER_TYPE_PACKAGE: self.order_package_ids = utils.join_to_string(store)
def compose(data, src_info, dest_basic_id, now, dest_num=1): """物品合成 Args: src_info[list(basic_id)]: 原材料物品信息 dest_basic_id[int]: 合成物品的 basic id dest_num[int]: 合成的物品的数量,默认是1 Returns: True: 合成成功 False:合成失败 """ src_basic_id = data_loader.ItemComposeBasicInfo_dict[dest_basic_id].srcId src_num = data_loader.ItemComposeBasicInfo_dict[dest_basic_id].srcNum money_cost = data_loader.ItemComposeBasicInfo_dict[ dest_basic_id].moneyCost * dest_num assert len(src_basic_id) == len(src_num) #花费金钱 resource = data.resource.get() resource.update_current_resource(now) if not resource.cost_money(money_cost): logger.warning("not enough money[money=%d][need=%d]" % (resource.money, money_cost)) return False if set(src_info) != set(src_basic_id): logger.debug("Source item error[expect=%s][source=%s]" % (src_basic_id, src_info)) return False output_items = [] for index in range(0, len(src_basic_id)): src_id = ItemInfo.generate_id(data.id, src_basic_id[index]) src_item = data.item_list.get(src_id) consume = src_item.consume(src_num[index] * dest_num) if not consume[0]: return False output_items.append("[item=") output_items.append(utils.join_to_string(list(consume[1]))) output_items.append("]") item = ''.join(output_items) log = log_formater.output_item(data, "compose consume", log_formater.COMPOSE_CONSUME, item) logger.notice(log) dest_id = ItemInfo.generate_id(data.id, dest_basic_id) dest = data.item_list.get(dest_id) if dest is None: #新物品 dest = ItemInfo.create(data.id, dest_basic_id, dest_num) data.item_list.add(dest) else: dest.acquire(dest_num) compose_item = "[item=" + utils.join_to_string( [dest_basic_id, dest_num, dest.num]) + "]" log = log_formater.output_item(data, "compose gain", log_formater.COMPOSE_GAIN, compose_item) logger.notice(log) return dest
def refresh_goods(self, pool_name, goods_num, discount_num, discount, goods_list, now, free): """刷新酒肆中可以购买的货物 Args: pool_name[string]: 货物池名称 goods_num[int]: 选出的货物数量 discount_num[int]: 有折扣的货物数量 discount[int]: 折扣 [1-10] goods_list[list(GoodsInfo) out]: 可以购买的货物列表 now[int]: 当前时间戳 free[bool]: 是否免费刷新 """ pool_name = "%s_dict" % pool_name pool = getattr(data_loader, pool_name) self.goods_pool = pool_name logger.debug("refresh goods[type=%d][index=%d][pool=%s]" % (self.type, self.index, self.goods_pool)) #在货物池中随机选择可以购买的货物 candidate = [] for id in pool: candidate.append((id, pool[id].weight)) goods_num = min(len(candidate), goods_num) results = ShopInfo._roll(candidate, goods_num) if len(results) == 0: logger.warning("Roll goods failed") return False #计算出所有商品的折扣 MAX_DISCOUNT = 10#不打折 goods_discount = [] for i in range(0, discount_num): goods_discount.append(discount) for i in range(discount_num, len(results)): goods_discount.append(MAX_DISCOUNT) random.shuffle(goods_discount) #更新货物状态 self.goods_ids = utils.join_to_string([id for (id, weight) in results]) self.goods_status = utils.join_to_string([self.ONSALE] * len(results)) self.goods_discount = utils.join_to_string(goods_discount) i = 0 for (id, weight) in results: goods = self._create_goods(self.goods_pool, id, self.ONSALE, goods_discount[i]) goods_list.append(goods) i += 1 #如果免费刷新,不更新刷新次数 if not free: self.refresh_num += 1 #更新下次免费刷新的时间 self.calc_next_free_refresh_time(now) return True
def create(user_id, basic_id, basic_activity, basic_steps, now): """创建 """ id = ActivityInfo.generate_id(user_id, basic_id) info = basic_activity if info.start_time == "": start_time = 0 else: start_time = utils.get_start_second_by_timestring(info.start_time) #开始时间为5点 start_time = utils.get_start_second(start_time + 1) if info.end_time == "": end_time = 0 else: end_time = utils.get_end_second_by_timestring(info.end_time) if now != 0 and info.start_day != 0: start_time = utils.get_start_second(now + 86400 * (info.start_day - 1)) if info.end_day != 0: end_time = utils.get_end_second(now + 86400 * (info.end_day - 1)) progress = [0] * len(info.get_steps()) progress = utils.join_to_string(progress) target = [] for step_id in info.get_steps(): for basic_step in basic_steps: if step_id == basic_step.id: target.append(basic_step.target) break target = utils.join_to_string(target) status = [] for step_id in info.get_steps(): default_lock = False for basic_step in basic_steps: if step_id == basic_step.id: default_lock = basic_step.default_lock break if default_lock: status.append(ActivityInfo.REWARD_LOCKED) else: status.append(ActivityInfo.REWARD_AVAILABLE) status = utils.join_to_string(status) activity = ActivityInfo(id, user_id, basic_id, start_time, end_time, 0, progress, target, status) return activity
def attach_reward(self, money=0, food=0, gold=0, items=[]): self.reward_money = money self.reward_food = food self.reward_gold = gold items_basic_id = [] items_num = [] for (basic_id, num) in items: items_basic_id.append(basci_id) items_num.append(num) self.reward_items_basic_id = utils.join_to_string(items_basic_id) self.reward_items_num = utils.join_to_string(items_num)
def add_invitee(self, invitee_id, level): """增加受请人,若受请数量已达上限则返回False,成功返回True """ invitees = utils.split_to_int(self.invitee) if len(invitees) >= 15: return False invitees.append(invitee_id) self.invitee = utils.join_to_string(invitees) invitee_levels = utils.split_to_int(self.invitee_level) invitee_levels.append(level) self.invitee_level = utils.join_to_string(invitee_levels) return True
def _calc_receive_legendcity_notice(self, data, req, timer): """接收到史实城战斗结果通知 添加战斗记录 """ legendcity = data.legendcity_list.get( LegendCityInfo.generate_id(data.id, req.city_id)) user = data.user.get(True) guard = data.guard_list.get(data.id, True) #传过来的是对手的战斗记录,根据对手的战斗记录,进行赋值 record = legendcity_business.add_battle_record(data, legendcity) if req.record.result == req.record.WIN: win = False else: win = True record.set_result(win, False, timer.now) rival_buffs = utils.join_to_string( [buff.city_buff_id for buff in req.record.rival.buffs]) record.set_user(user, guard.get_team_score(), req.record.rival.level, rival_buffs) user_buffs = utils.join_to_string( [buff.city_buff_id for buff in req.record.user.buffs]) record.set_rival_detail(req.record.user.user.user_id, req.record.user.user.name, req.record.user.user.level, req.record.user.user.headicon_id, req.record.user_battle_score, req.record.user.level, user_buffs) #防守方需要收到邮件 mail = mail_business.create_legendcity_defense_mail( data, win, timer.now) mail.attach_battle_info(win) mail.attach_enemy_detail(req.record.user.user.name, req.record.user.user.user_id, NodeInfo.ENEMY_TYPE_LEGENDCITY) mail.attach_legendcity_detail(req.record.user.city_id, req.record.user.level) self._push_mail(data.id, mail, timer) #如果是太守发送广播 if req.record.rival.level == 7: try: self._receive_broadcast(data, req, timer) except: logger.warning("Send receive broadcast failed") defer = DataBase().commit(data) defer.addCallback(self._receive_legendcity_notice_succeed, req, timer) return defer
def refresh(self, now, test=False, multi_count=False, pattern=1): """刷新 只会刷新礼包类商品 """ package_count = int( float(data_loader.OtherBasicInfo_dict["pay_package_count"].value)) package_ids = PayPool().random_package(package_count, test) self.order_package_ids = utils.join_to_string(package_ids) refresh_gap = int( float(data_loader.OtherBasicInfo_dict["pay_refresh_gap"].value)) self.refresh_time = now + refresh_gap #重新刷新月卡(中途添加了新月卡) card = [] for id in data_loader.InitUserBasicInfo_dict[pattern].payBasicId: order = PayPool().get(id) if order.type == PayPool.ORDER_TYPE_CARD: card.append(id) self.order_card_ids = utils.join_to_string(card) #如果需要支持购买多份同一个product_id但order_id不同的物品 if multi_count: normal_ids = utils.split_to_int(self.order_normal_ids) #如果已有多份的order,先删掉 multi_count_ids = [] for id in normal_ids: if data_loader.PayBasicInfo_dict[id].productCount > 1: multi_count_ids.append(id) for id in multi_count_ids: normal_ids.remove(id) for id in data_loader.PayBasicInfo_dict: info = data_loader.PayBasicInfo_dict[id] if info.productCount > 1: normal_ids.append(id) self.order_normal_ids = utils.join_to_string(normal_ids) if test: normal = [] for id in data_loader.PayBasicInfo_dict: info = data_loader.PayBasicInfo_dict[id] if info.type == PayPool.ORDER_TYPE_NORMAL: if info.productId == 'com.anqu.zwsgApp.zwsg99999999': continue normal.append(id) self.order_normal_ids = utils.join_to_string(normal) return True
def start_battle(self, attacker_user_id, now): """开始战斗 """ #assert self.status == self.NODE_STATUS_DEPLOYED self.status = self.NODE_STATUS_ENGAGED self.attacker_num += 1 start_times = utils.split_to_int(self.battle_start_time) start_times.append(now) users_id = utils.split_to_int(self.attacker_user_id) users_id.append(attacker_user_id) self.battle_start_time = utils.join_to_string(start_times) self.attacker_user_id = utils.join_to_string(users_id)
def update(self, target, default_lock, heroes_basic_id, items_id, items_num, gold, description, value1, value2): """ """ self.target = target self.default_lock = default_lock self.heroes_basic_id = utils.join_to_string(heroes_basic_id) self.items_id = utils.join_to_string(items_id) self.items_num = utils.join_to_string(items_num) self.gold = gold #默认已经传的description已经是base64编码过 self.description = description #base64.b64encode(description) self.value1 = value1 self.value2 = value2
def attach_reward(self, money, food, gold, items): self.reward_money = money self.reward_food = food self.reward_gold = gold #merge same items reward_items = {} for (basic_id, num) in items: if basic_id not in reward_items: reward_items[basic_id] = num else: reward_items[basic_id] += num self.reward_items_basic_id = utils.join_to_string(reward_items.keys()) self.reward_items_num = utils.join_to_string(reward_items.values())
def reset(self, now): """重置anneal相关信息 Returns: None """ self.buy_num = 0 anneal_max_floor = int( float(data_loader.AnnealConfInfo_dict['anneal_max_floor'].value)) array = [0] * anneal_max_floor self.hard_attack_num = utils.join_to_string(array) self.hard_reset_num = utils.join_to_string(array) tomorrow = now + utils.SECONDS_OF_DAY self.next_refresh_time = utils.get_start_second(tomorrow)
def trigger_custom_event(data, now, node_basic_id, event_type, change_nodes): """触发特定的事件 可以指定发生事件的节点,事件的类型 """ logger.debug("Trigger custom event") map = data.map.get() node_id = NodeInfo.generate_id(data.id, node_basic_id) node = data.node_list.get(node_id) candidate = _calc_candidate_event(data, node, now) candidate.extend(_calc_candidate_event(data, node, now, False)) if len(candidate) == 0: logger.warning("Node not prepared for event[node basic id=%d]" % node.basic_id) return False if event_type not in candidate: logger.warning("Node not matched event" "[node basic id=%d][event type=%d][available=%s]" % (node.basic_id, event_type, utils.join_to_string(candidate))) return False if not _node_arise_event(data, node_id, event_type, now, change_nodes, [], []): return False change_nodes.append(node) logger.debug("node trigger event[basic id=%d][event type=%d]" % (node.basic_id, node.event_type)) map.update_next_luck_time(now) return True
def _clear_exploit_hero(self, heroes): """清除参与开发的英雄 """ assert len(heroes) == EXPLOIT_HERO_COUNT heroes_id = utils.split_to_int(self.exploit_team) for hero in heroes: if hero is None: continue if hero.id not in heroes_id: logger.warning("Hero not match exploitation" "[hero id=%d][node exploit heroes=%s]" % (hero.id, node.exploit_team)) return False index = heroes_id.index(hero.id) heroes_id[index] = NONE_HERO self.exploit_team = utils.join_to_string(heroes_id) if self.exploit_team != EMPTY_HEROES: logger.warning("Exploit heroes not clear") return False return True
def use_energy_item(self, num): """使用政令符物品 Args: num[int] 使用的数量 Returns: 获得政令值 计算失败返回 None """ consume = self.consume(num) 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("]") item = ''.join(output_items) log = log_formater.output_item(self, "use energy item", log_formater.ENERGY_ITEM, item) logger.notice(log) if not self.is_energy_item(): logger.warning("Not energy item[basic id=%d]" % self.basic_id) return None energy = data_loader.ItemBasicInfo_dict[self.basic_id].value * num return energy
def use_starsoul_item(self, consume_num): """使用将魂石物品 1 判断物品是不是将魂石 2 判断将魂石是不是和英雄对应,如果传入的 hero 为None,不进行此判断 3 消耗掉将魂石,计算将魂石可以获得的将魂数量 Args: consume_num[int] 消耗的数量 Returns: 使用将魂石之后可以获得的英雄的 basic id 和将魂数量,返回元组(basic_id, num) 计算失败返回 None """ if not self.is_starsoul_item(): logger.warning("Not starsoul item[basic id=%d]" % self.basic_id) return None consume = self.consume(consume_num) if not consume[0]: return None output_items = [] output_items.append("[item=") output_items.append(utils.join_to_string(list(consume[1]))) output_items.append("]") item = ''.join(output_items) log = log_formater.output_item(self, "use starsoul item", log_formater.STARSOUL_ITEM, item) logger.notice(log) corresponding_hero_basic_id = data_loader.ItemBasicInfo_dict[ self.basic_id].value return (corresponding_hero_basic_id, consume_num)
def use_evolution_item(self, consume_num): """使用突破石物品 1 判断物品是不是突破石 2 消耗掉将魂石,计算将魂石可以获得的将魂数量 Args: consume_num[int] 消耗的数量 Returns: 计算失败返回 False """ if not self.is_evolution_item(): logger.warning("Not evolution item[basic id=%d]" % self.basic_id) return False consume = self.consume(consume_num) 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("]") item = ''.join(output_items) log = log_formater.output_item(self, "use evolution item", log_formater.EVOLUTION_ITEM, item) logger.notice(log) return True
def use_cdkey(self, bag_id): """使用激活码 """ ids = utils.split_to_int(self.cdkey) assert bag_id not in ids ids.append(bag_id) self.cdkey = utils.join_to_string(ids)
def use_package_item(self, num): """使用vip物品 Args: num[int] 使用的数量 Returns: PackageBasicInfo 计算失败返回 None """ consume = self.consume(num) 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("]") item = ''.join(output_items) log = log_formater.output_item(self, "use package item", log_formater.PACKAGE_ITEM, item) logger.notice(log) if not self.is_package_item(): logger.warning("Not package item[basic id=%d]" % self.basic_id) return None package_id = data_loader.ItemBasicInfo_dict[self.basic_id].value return data_loader.PackageBasicInfo_dict[package_id]
def use_exp_item(self, consume_num): """使用英雄经验丹物品 1 拥有的物品数量必须大于消耗的数量,消耗的数量必须大于0 2 物品必须是经验丹 3 消耗掉经验丹,计算可以获得的经验值 Args: consume_num[int] 消耗的数量 Returns: 使用经验丹之后获得的经验值 计算失败返回 None """ if not self.is_hero_exp(): logger.warning("Not hero exp item[basic id=%d]" % self.basic_id) return None consume = self.consume(consume_num) if not consume[0]: return None output_items = [] output_items.append("[item=") output_items.append(utils.join_to_string(list(consume[1]))) output_items.append("]") item = ''.join(output_items) log = log_formater.output_item(self, "use exp item", log_formater.EXP_ITEM, item) logger.notice(log) exp = data_loader.ItemBasicInfo_dict[self.basic_id].value * consume_num return exp, consume[1]
def use_vip_point_item(self, num): """使用vip物品 Args: num[int] 使用的数量 Returns: 获得vip点数 计算失败返回 None """ consume = self.consume(num) 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("]") item = ''.join(output_items) log = log_formater.output_item(self, "use vip item", log_formater.VIP_ITEM, item) logger.notice(log) if not self.is_vip_point_item(): logger.warning("Not vip point item[basic id=%d]" % self.basic_id) return None vip_point = data_loader.ItemBasicInfo_dict[self.basic_id].value * num return vip_point
def use_food_item(self, num): """使用粮包物品 Args: item[ItemInfo out] 粮包物品 num[int] 使用的数量 Returns: 获得粮草数量 计算失败返回 None """ consume = self.consume(num) 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("]") item = ''.join(output_items) log = log_formater.output_item(self, "use food item", log_formater.FOOD_ITEM, item) logger.notice(log) if not self.is_food_item(): logger.warning("Not food item[basic id=%d]" % self.basic_id) return None food = data_loader.ItemBasicInfo_dict[self.basic_id].value * num return food