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 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_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_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
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_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 gain_item(data, infos, str, use_type):
"""获得新物品
如果原来已经拥有物品，物品数量增加
如果原来没有这件物品，添加物品
Args:
infos[list(basic_id, num)]: 奖励的物品信息
Returns:
True: 成功
False: 失败
"""
output_items = []
for (basic_id, num) in infos:
id = ItemInfo.generate_id(data.id, basic_id)
item = data.item_list.get(id)
if item is not None:
item.acquire(num)
else:
item = ItemInfo.create(data.id, basic_id, num)
data.item_list.add(item)
item = [basic_id, num, item.num]
output_items.append("[item=")
output_items.append(utils.join_to_string(item))
output_items.append("]")
item = ''.join(output_items)
log = log_formater.output_item(data, str, use_type, item)
logger.notice(log)
#logger.notice("gain items %s"% ''.join(output_items))
return True
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 strength_herostar(data, star_id, items_id, items_num, cost_money, timer):
"""给将星升级"""
# 1.消耗物品
# 2.消耗金币
# 3.升级将星
# 4.更新英雄的将星
# 5.判断是否需要发送广播
output_items=[]
for i, id in enumerate(items_id):
item = item_business.get_item_by_id(data, id)
if item is None:# or item.num < items_num[i]:
raise Exception("No enough items")
consume = item.consume(min(item.num, items_num[i]))
output_items.append("[item=")
output_items.append(utils.join_to_string(list(consume[1])))
output_items.append("]")
log = log_formater.output_item(data, "herostar", log_formater.STRENGTH_HEROSTAR, ''.join(output_items))
logger.notice(log)
#logger.notice("strength herostar %s"%''.join(output_items))
resource = data.resource.get()
resource.update_current_resource(timer.now)
if not resource.cost_money(cost_money):
raise Exception("No enough money")
new_star_id = _do_strength_herostar(data, star_id)
hero_list = data.hero_list.get_all()
for hero in hero_list:
if star_id in hero.get_herostars_set():
battle_technology_basic_id = technology_module.get_battle_technology_for_soldier(
data.technology_list.get_all(True), hero.soldier_basic_id)
hero.update_herostar(star_id, new_star_id, battle_technology_basic_id)
assert hero_business.post_upgrade(data, hero, timer.now, battle_technology_basic_id)
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 drum(data, item, cost_gold, score, now, drum_count=1):
"""擂鼓
"""
#擂鼓，添加战功
union = data.union.get()
union.drum_for_union_battle(score, drum_count)
#消耗物品或元宝
output_items = []
if item is not None:
consume = item.consume(drum_count)
output_items.append("[item=")
output_items.append(utils.join_to_string(list(consume[1])))
output_items.append("]")
log = log_formater.output_item(data, "drum", log_formater.DRUM,
''.join(output_items))
logger.notice(log)
resource = data.resource.get()
resource.update_current_resource(now)
original_gold = resource.gold
log = log_formater.output_gold(data,
-cost_gold,
log_formater.DRUM,
"Drum by gold",
before_gold=original_gold)
logger.notice(log)
return resource.cost_gold(cost_gold)
def use_herolist_item(self, hero_list, item_list, consume_num):
"""使用国士名册
1 一次使用一个
Args:
item[ItemInfo out]: 国士名册
hero_list[list((int, num)) out]: 获得的英雄 id 和数量
item_list[list((int, num)) out]: 获得的物品 id 和数量
Returns:
使用成功返回 True
失败返回 False
"""
if not self.is_herolist_item() and not self.is_random_package_item():
logger.warning("Not herolist or random package 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 herolist item",
log_formater.HEROLIST_ITEM, item)
logger.notice(log)
herolist_id = data_loader.ItemBasicInfo_dict[self.basic_id].value
min_point = data_loader.HerolistBasicInfo_dict[herolist_id].minPoints
max_point = data_loader.HerolistBasicInfo_dict[herolist_id].maxPoints
ids = data_loader.HerolistBasicInfo_dict[herolist_id].idlist
assert len(ids) >= 1
for index in range(consume_num):
roll_list = []
for id in ids:
weight = data_loader.HerolistDetails_dict[id].weight
point = data_loader.HerolistDetails_dict[id].points
roll_list.append((weight, point, id))
win = ItemInfo._roll_herolist(roll_list, min_point, max_point)
if win is None:
logger.warning("Roll herolist failed[herolist id=%d]" %
herolist_id)
return False
for id in win:
hero_id = data_loader.HerolistDetails_dict[id].heroBasicId
item_id = data_loader.HerolistDetails_dict[id].itemBasicId
item_num = data_loader.HerolistDetails_dict[id].itemNum
if hero_id != 0:
assert item_id == 0
hero_list.append((hero_id, win[id]))
else:
assert item_id != 0
item_list.append((item_id, win[id] * item_num))
return True
def use_appoint_item(self, consume_num):
"""
使用委任物品（虎符）
"""
if not self.is_appoint_item():
logger.warning("Not appoint 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 appoint item",
log_formater.APPOINT_ITEM, item)
logger.notice(log)
return True
def use_soul_item(self, num):
"""使用精魄包物品"""
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 soul item",
log_formater.SOUL_ITEM, item)
logger.notice(log)
if not self.is_soul_item():
logger.warning("Not soul item[basic id=%d]" % self.basic_id)
return None
soul = data_loader.ItemBasicInfo_dict[self.basic_id].value * num
return soul
def respond_aid(data, item_basic_id, honor, exp, gold, now):
"""响应援助，进行捐赠
获得奖励
"""
union = data.union.get()
#消耗物品
item_id = ItemInfo.generate_id(data.id, item_basic_id)
item = data.item_list.get(item_id)
consume = item.consume(1)
if not consume[0]:
return False
output_items = []
output_items.append("[item=")
output_items.append(utils.join_to_string(list(consume[1])))
output_items.append("]")
log = log_formater.output_item(data, "respond aid",
log_formater.RESPOND_AID,
''.join(output_items))
logger.notice(log)
#logger.notice("respond aid %s"%''.join(output_items))
#获得联盟荣誉
union.gain_honor(honor)
#获得主公经验
if not user_business.level_upgrade(data, exp, now, "exp aid",
log_formater.EXP_AID):
return False
#获得元宝奖励
resource = data.resource.get()
resource.update_current_resource(now)
original_gold = resource.gold
resource.gain_gold(gold)
log = log_formater.output_gold(data,
gold,
log_formater.RESPOND_AID_REWARD,
"Gain gold from respond aid",
before_gold=original_gold)
logger.notice(log)
return True
def resolve_starsoul_item(self, consume_num):
"""分解将魂石,返还精魄"""
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 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, "resolve starsoul item",
log_formater.RESOLVE_STARSOUL_ITEM,
item)
logger.notice(log)
soul = self.get_soul_num(self.basic_id) * consume_num
return soul
def use_refresh_item(self, consume_num):
"""
使用商铺刷新代币
"""
if not self.is_refresh_item():
logger.warning("Not refresh 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 refresh item",
log_formater.REFRESH_ITEM, item)
logger.notice(log)
return True
def sell(self, num):
"""出售物品，获取金钱
Args:
num[int] 使用的数量
Returns:
获得金钱数量
计算失败返回 None
"""
consume = self.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, "sell", log_formater.SELL, item)
logger.notice(log)
money = data_loader.ItemBasicInfo_dict[
self.basic_id].sale_money_price * num
return money
def use_monarch_exp_item(self, consume_num):
"""
使用主公经验丹
"""
if not self.is_monarch_exp():
logger.warning("Not monarch 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 monarch exp item",
log_formater.MONARCH_EXP_ITEM, item)
logger.notice(log)
exp = data_loader.ItemBasicInfo_dict[self.basic_id].value * consume_num
return exp
def use_speed_item(self, consume_num):
"""
使用加速物品
"""
if not self.is_speed_item():
logger.warning("Not speed 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 speed item",
log_formater.SPEED_ITEM, item)
logger.notice(log)
speed_time = data_loader.ItemBasicInfo_dict[
self.basic_id].value * consume_num
return speed_time
def use_anneal_attack_num_item(self):
"""使用试炼场攻击次数购买符
Returns:
成功/失败
"""
if not self.is_anneal_attack_num_item():
logger.warning("Not anneal attack num item[basic id=%d]" %
self.basic_id)
return False
consume = self.consume(1)
if not consume[0]:
return False
output_items = []
output_items.append("[item=")
output_items.append(utils.join_to_string(list(consume[1])))
output_items.append("]")
item = ''.join(output_items)
log = log_formater.output_item(self, "use anneal item",
log_formater.ANNEAL_ITEM, item)
logger.notice(log)
return True
def use_equipment_stone_item(self):
"""使用装备的宝石
Returns:
成功/失败
"""
if not self.is_equipment_stone_item():
logger.warning("Not equipment stone item[basic id=%d]" %
self.basic_id)
return False
consume = self.consume(1)
if not consume[0]:
return False
output_items = []
output_items.append("[item=")
output_items.append(utils.join_to_string(list(consume[1])))
output_items.append("]")
item = ''.join(output_items)
log = log_formater.output_item(self, "use stone item",
log_formater.STONE_ITEM, item)
logger.notice(log)
return True
def use_legendcity_buff_item(self):
"""使用史实城 buff 物品
Returns:
成功/失败
"""
if not self.is_legendcity_buff_item():
logger.warning("Not legendcity buff item[basic id=%d]" %
self.basic_id)
return False
consume = self.consume(1)
if not consume[0]:
return False
output_items = []
output_items.append("[item=")
output_items.append(utils.join_to_string(list(consume[1])))
output_items.append("]")
item = ''.join(output_items)
log = log_formater.output_item(self, "use legendcity buff",
log_formater.LEGENDCITY_BUFF, item)
logger.notice(log)
return True
def increase(data, node, rate, use_gold, duration, item, now):
"""进行资源点增产
"""
if node == None:
return False
if not node.is_own_side() or not node.is_exploit_exist():
logger.warning("Wrong node type[node_id=%d][type=%d]" %
(node.id, node.type))
return False
resource = data.resource.get()
original_gold = resource.gold
resource.update_current_resource(now)
if node.is_exploit_money():
key = "businesscity_boost_" + str(duration / 3600)
elif node.is_exploit_food():
key = "agriculturecity_boost_" + str(duration / 3600)
else:
key = "miningcity_boost_" + str(duration / 3600)
need_gold = int(
float(data_loader.OutputIncreaseBasicInfo_dict[key].goldNum))
increase_rate = float(
data_loader.OutputIncreaseBasicInfo_dict[key].increaseRate)
if rate != increase_rate:
logger.warning("Increase rate error[req_rate=%f][rate=%f]" %
(rate, increase_rate))
return False
if use_gold:
if not resource.cost_gold(need_gold):
return False
log = log_formater.output_gold(data,
-need_gold,
log_formater.INCREASE,
"Increase by gold",
before_gold=original_gold,
increase_hour=(duration / 3600))
logger.notice(log)
else:
if ((node.is_exploit_money()
and not item.is_increase_node_money_item()) or
(node.is_exploit_food() and not item.is_increase_node_food_item())
or (node.is_exploit_material()
and not item.is_increase_node_material_item())):
logger.warning("Increase item error[type=%d][item_id=%d]" %
(type, item.basic_id))
return False
consume = item.consume(1)
if not consume[0]:
return False
output_items = []
output_items.append("[item=")
output_items.append(utils.join_to_string(list(consume[1])))
output_items.append("]")
item = ''.join(output_items)
log = log_formater.output_item(data, "use increase item",
log_formater.INCREASE_ITEM, item)
logger.notice(log)
#logger.notice("increase %s"%''.join(output_items))
node.increase(rate, now, duration)
return True
def casting(data, src_info, dest_basic_id, dest_num, building_level):
"""物品熔铸
Args:
src_info[list((basic_id, casting_num))]: 原材料物品信息
dest_basic_id[int]: 熔铸物品的 basic id
building_level[int]:铁匠铺等级
Returns:
True: 合成成功
False:合成失败
"""
if not data_loader.BlackSmithBasicInfo_dict.has_key(building_level):
logger.warning(
"BlackSmith building level is error[building_level=%d]" %
building_level)
return (False, None)
#dest
dest_item_basic = data_loader.ItemBasicInfo_dict[dest_basic_id]
dest_casting_value = dest_item_basic.value
if (dest_item_basic.type != int(
float(data_loader.OtherBasicInfo_dict["item_equipment_upgrade"].
value)) or dest_casting_value == 0):
logger.warning("Casting dest item error[basic_id=%d]" % dest_basic_id)
return (False, None)
if dest_basic_id not in data_loader.BlackSmithBasicInfo_dict[
building_level].itemIds:
logger.warning(
"BlackSmith building level is not reached[building_level=%d][dest_basic_id=%d]"
% (building_level, dest_basic_id))
return (False, None)
#p
p = float(data_loader.OtherBasicInfo_dict["P_BlackSmith"].value)
#src
src_casting_value = 0
output_items = []
for info in src_info:
src_id = ItemInfo.generate_id(data.id, info[0])
src_item = data.item_list.get(src_id)
if not src_item.is_equipment_upgrade_item():
logger.warning("Casting source item type error[basic_id=%d]" %
info[0])
return (False, None)
#消耗熔铸的原材料
consume = src_item.consume(info[1])
if not consume[0]:
logger.warning(
"Casting source item num error[basic_id=%d][num=%d]" %
(src_item.basic_id, src_item.num))
return (False, None)
output_items.append("[item=")
output_items.append(utils.join_to_string(list(consume[1])))
output_items.append("]")
src_casting_value += min(
data_loader.ItemBasicInfo_dict[info[0]].value * p,
dest_casting_value) * info[1]
item = ''.join(output_items)
log = log_formater.output_item(data, "casting consume",
log_formater.CASTING_CONSUME, item)
logger.notice(log)
#logger.notice("casting %s"%''.join(output_items))
#熔铸成功率
p_casting = 1.0 * src_casting_value / (dest_casting_value * dest_num)
random.seed()
p_random = random.random()
dest_item = None
if p_random < p_casting:
#熔铸成功
dest_id = ItemInfo.generate_id(data.id, dest_basic_id)
dest_item = data.item_list.get(dest_id)
if dest_item is None:
#新物品
dest_item = ItemInfo.create(data.id, dest_basic_id, dest_num)
data.item_list.add(dest_item)
else:
dest_item.acquire(dest_num)
casting_item = "[item=" + utils.join_to_string(
[dest_basic_id, dest_num, dest_item.num]) + "]"
log = log_formater.output_item(data, "casting gain",
log_formater.CASTING_GAIN, casting_item)
logger.notice(log)
#logger.notice("gain item[item=%d#%d#%d]"%(dest_basic_id, dest_num, dest_item.num))
logger.debug(
"Casting result[src_value=%d][dest_value=%d][p_casting=%f][p_random=%f]"
% (src_casting_value, dest_casting_value, p_casting, p_random))
return (True, dest_item)
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 protect(data, node, type, use_gold, duration, item, now):
"""进行资源采集
"""
if node == None:
return False
if node.is_dependency():
logger.warning("Wrong node type[node_id=%d][type=%d]" %
(node.id, node.type))
return False
if not node.is_own_side():
logger.warning("Wrong node status[node_id=%d][status=%d]" %
(node.id, node.status))
return False
if node.event_type == NodeInfo.EVENT_TYPE_DEFEND:
logger.warning("Node has defend event[node_id=%d]" % node.id)
return False
if type == NodeInfo.PROTECT_TYPE_CITY:
if not node.is_own_city():
return False
elif type == NodeInfo.PROTECT_TYPE_RESOURCE_NODE:
if node.is_own_city():
return False
else:
logger.warning("protect type error")
return False
resource = data.resource.get()
original_gold = resource.gold
resource.update_current_resource(now)
output_items = []
if use_gold:
if type == NodeInfo.PROTECT_TYPE_CITY:
key = "protect_city_cost_" + str(duration / 3600)
else:
key = "protect_resource_node_cost_" + str(duration / 3600)
need_gold = int(float(data_loader.OtherBasicInfo_dict[key].value))
if not resource.cost_gold(need_gold):
return False
log = log_formater.output_gold(data,
-need_gold,
log_formater.PROTECT,
"Protect by gold",
before_gold=original_gold,
protect_hour=(duration / 3600))
logger.notice(log)
else:
if ((type == NodeInfo.PROTECT_TYPE_CITY
and not item.is_protect_city_item())
or (type == NodeInfo.PROTECT_TYPE_RESOURCE_NODE
and not item.is_protect_resource_node_item())):
logger.warning("protect item error[type=%d][item_id=%d]" %
(type, item.basic_id))
return False
consume = item.consume(1)
if not consume[0]:
return False
output_items.append("[item=")
output_items.append(utils.join_to_string(list(consume[1])))
output_items.append("]")
log = log_formater.output_item(data, "protect", log_formater.PROTECT,
''.join(output_items))
logger.notice(log)
node.protect(now, duration)
if type == NodeInfo.PROTECT_TYPE_CITY:
user = data.user.get()
user.set_in_protect(True)
return True
