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
