def pvb_reborn_1704(data, player):
"""
使用元宝复活。
"""
response = CommonResponse()
# 1. 校验元宝
gold = player.finance.gold
money_relive_price = base_config.get('money_relive_price')
need_gold = money_relive_price
print need_gold, gold, "*" * 80
if gold < need_gold:
logger.debug("reborn error: %s" % 102)
response.result = False
response.result_no = 102
return response.SerializePartialToString()
#2. 校验CD
current_time = get_current_timestamp()
if current_time - player.world_boss.last_fight_time > base_config.get(
"free_relive_time"):
logger.debug("reborn error: %s" % 1701)
response.result = False
response.result_no = 1701
return response.SerializePartialToString()
player.finance.gold -= need_gold
player.finance.save_data()
response.result = True
print response
return response.SerializePartialToString()
def eat_feast(player):
""" 吃 """
# (tm_year=2014, tm_mon=9, tm_mday=1, tm_hour=18, tm_min=38, tm_sec=1, tm_wday=0, tm_yday=244, tm_isdst=0)
last_eat_time = time.localtime(player.feast.last_eat_time).tm_hour*60*60 + \
time.localtime(player.feast.last_eat_time).tm_min*60 + time.localtime(player.feast.last_eat_time).tm_sec
eat_times = base_config.get(u'time_vigor_activity')
now = time.localtime().tm_hour * 60 * 60 + time.localtime(
).tm_min * 60 + time.localtime().tm_sec
for eat_time in eat_times:
t1 = eat_time[0].split(':')
time1 = int(t1[0]) * 60 * 60 + int(t1[1]) * 60
t2 = eat_time[1].split(':')
time2 = int(t2[0]) * 60 * 60 + int(t2[1]) * 60
if time2 >= now >= time1:
if time2 >= last_eat_time >= time1:
# 已经吃过
return 1
# 吃
player.stamina.stamina += base_config.get(u'num_vigor_activity')
player.stamina.save_data()
player.feast.last_eat_time = int(time.time())
player.feast.save_data()
return 2
# 没到时间
return 3
def update_boss(self):
"""
boss被打死或者boss到期后，更新下一个boss相关信息。
"""
# 初始化幸运武将
lucky_hero_1_num = base_config.get("lucky_hero_1_num")
lucky_hero_2_num = base_config.get("lucky_hero_2_num")
lucky_hero_3_num = base_config.get("lucky_hero_3_num")
all_high_heros, all_middle_heros, all_low_heros = self.get_hero_category()
self._lucky_high_heros = random.sample(all_high_heros, lucky_hero_1_num)
for k in self._lucky_high_heros: # 去重
all_middle_heros.remove(k)
self._lucky_middle_heros = random.sample(all_middle_heros, lucky_hero_2_num)
for k in self._lucky_middle_heros: # 去重
all_low_heros.remove(k)
self._lucky_low_heros = random.sample(all_low_heros, lucky_hero_3_num)
# 初始化奇遇
debuff_skill = base_config.get("debuff_skill")
self._debuff_skill_no = random_pick_with_percent(debuff_skill)
self.set_next_stage(self._hp<=0)
self._hp = self.get_hp() # 重置血量
instance = self.get_rank_instance()
instance.clear_rank() # 重置排行
#todo: 重置玩家信息
self.save_data()
def price(self):
price = base_config.get('arenaShopRefreshPrice').get(2)[0]
k = base_config.get('arenaShopRefreshFactor')
free_times = base_config.get('arenaShopFreeRefreshTimes')
if self._refresh_times < free_times:
return 0
else:
return price * pow(k, self._refresh_times - free_times)
def encourage_heros_1703(data, player):
"""
使用金币或者元宝鼓舞士气。
"""
# 1. 校验金币或者元宝
# 3. 减少金币
# 4. 更新战斗力
response = CommonResponse()
request = EncourageHerosRequest()
request.ParseFromString(data)
if request.finance_type == 1:
# 金币鼓舞
goldcoin_inspire_price = base_config.get("goldcoin_inspire_price")
goldcoin_inspire_price_multiple = base_config.get(
"goldcoin_inspire_price_multiple")
coin = player.finance.coin
need_coin = goldcoin_inspire_price * (pow(
goldcoin_inspire_price_multiple,
player.world_boss.encourage_coin_num))
if coin < need_coin:
response.result = False
response.result_no = 101
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
player.finance.coin -= need_coin
player.finance.save_data()
player.world_boss.encourage_coin_num += 1
if request.finance_type == 2:
# 钻石鼓舞
money_inspire_price = base_config.get("money_inspire_price")
#money_inspire_price_multiple = base_config.get("money_inspire_price_multiple")
gold = player.finance.gold
need_gold = money_inspire_price
if gold < need_gold:
response.result = False
response.result_no = 102
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
player.finance.gold -= need_gold
player.finance.save_data()
player.world_boss.encourage_gold_num += 1
player.world_boss.save_data()
response.result = True
logger.debug("encourage_coin_num %s" %
player.world_boss.encourage_coin_num)
logger.debug("encourage_gold_num %s" %
player.world_boss.encourage_gold_num)
return response.SerializePartialToString()
def update_slot_activation(self):
# 根据base_config获取卡牌位激活状态
for i in range(1, 7):
slot = self._line_up_slots[i]
__level = base_config.get("hero_position_open_level").get(i)
if self.owner.level.level >= __level:
slot.activation = True
for i in range(1, 7):
slot = self._sub_slots[i]
__level = base_config.get("friend_position_open_level").get(i)
if self.owner.level.level >= __level:
slot.activation = True
def do_brew(self, brew_type):
vip_level = self.owner.vip_component.vip_level
brew_times_max = vip_config.get(vip_level).get('cookingTimes')
MAX_STEPS = len(base_config.get('cookingWinePrice')[brew_type])
self.check_time()
if self._brew_step > MAX_STEPS:
return False
if self.owner.level.level < base_config.get('cookingWineOpenLevel'):
logger.error('char brew level error!!:%s', self.owner.level.level)
return False
critical = base_config.get('cookingWineOutputCrit')
if brew_type not in critical:
logger.error('base config error type:%s', brew_type)
return False
if self.brew_times >= brew_times_max:
logger.error('there is no times to brew:%s', self.brew_times)
return False
brew_prices = base_config.get('cookingWinePrice')
if brew_type not in brew_prices:
logger.error('base config error step:%s', brew_type)
return False
if not self.owner.finance.consume_gold(
brew_prices[brew_type][self._brew_step - 1]):
logger.error('not enough gold to do brew:%s:%s',
self.owner.finance.gold,
brew_prices[brew_type][self._brew_step - 1])
return False
self._brew_step += 1
critical = critical[brew_type]
rand = random.random()
for critical_num, rand_range in critical.items():
if rand < rand_range:
self._nectar_cur = int(critical_num * self._nectar_cur)
break
else:
rand -= rand_range
logger.info(
'brew type:%s, rand:%s nectar:%s nectar\
cur:%s time:%s cri:%s', brew_type, rand, self.nectar, self._nectar_cur,
self.brew_times, critical_num)
self.save_data()
return True
def open_chest_836(data, player):
response = OpenChestResponse()
chest_time = player.travel_component.chest_time
if time.localtime(chest_time).tm_year == time.localtime().tm_year \
and time.localtime(chest_time).tm_yday == time.localtime().tm_yday:
response.res.result = False
response.res.result_no = 816
return response.SerializeToString()
res_drops = response.drops
drops = []
common_bag = BigBag(base_config.get('travelChest'))
common_drop = common_bag.get_drop_items()
drops.extend(common_drop)
drop_data = gain(player, drops)
get_return(player, drop_data, res_drops)
player.travel_component.chest_time = int(time.time())
player.travel_component.save()
response.res.result = True
return response.SerializeToString()
def buy_shoes_832(data, player):
"""buy_shoes"""
args = BuyShoesRequest()
args.ParseFromString(data)
response = BuyShoesResponse()
need_good = 0
for shoes_info in args.shoes_infos:
need_good += base_config.get("travelShoe"+str(shoes_info.shoes_type))[2] \
* shoes_info.shoes_no
if player.finance.gold < need_good:
response.res.result = False
response.res.result_no = 102 # 充值币不足
return response.SerializeToString()
for shoes_info in args.shoes_infos:
player.travel_component.shoes[shoes_info.shoes_type-1] += \
shoes_info.shoes_no
player.finance.gold -= need_good
player.travel_component.save()
player.finance.save_data()
response.res.result = True
return response.SerializeToString()
def continus_sign_in_1402(pro_data, player):
"""连续签到"""
request = ContinuousSignInRequest()
request.ParseFromString(pro_data)
days = request.sign_in_days
response = ContinuousSignInResponse()
sign_in_prize = base_config.get("signInPrize")
if not sign_in_prize:
return
# 验证连续签到日期
if player.sign_in_component.continuous_sign_in_days < days:
response.res.result = False
response.res.result_no = 1402
return response.SerializePartialToString()
if days in player.sign_in_component.continuous_sign_in_prize:
response.res.result = False
response.res.result_no = 1403
return response.SerializePartialToString()
player.sign_in_component.continuous_sign_in_prize.append(days)
player.sign_in_component.save_data()
drop_bag_id = sign_in_prize.get(days)
big_bag = BigBag(drop_bag_id)
gain_data = big_bag.get_drop_items()
return_data = gain(player, gain_data)
get_return(player, return_data, response.gain)
response.res.result = True
return response.SerializePartialToString()
def __init__(self, unit):
super(FriendSkill, self).__init__()
friend_mp_config = base_config.get('huoban_value_config')
self._unit = unit
self._mp_init = friend_mp_config[0]
self._mp = self._mp_init
self._mp_step = friend_mp_config[1]
self._mp_max = friend_mp_config[2]
def check_time(self):
tm = time.localtime(self._brew_date)
local_tm = time.localtime()
if local_tm.tm_year != tm.tm_year or local_tm.tm_yday != tm.tm_yday:
self._brew_date = time.time()
# vip_level = self.owner.vip_component.vip_level
self._brew_times = 0
# logger.debug('brew times vip:%s :%s', vip_level, self._brew_times)
self._nectar_cur = base_config.get('cookingWineOutput')
self._brew_step = 1
def join_guild_802(data, player):
"""加入公会 """
p_id = player.base_info.id
args = JoinGuildRequest()
args.ParseFromString(data)
response = JoinGuildResponse()
g_id = args.g_id
m_g_id = player.guild.g_id
m_exit_time = player.guild.exit_time
the_time = int(time.time()) - m_exit_time
if m_exit_time != 1 and the_time < base_config.get('exit_time'):
response.result = False
response.message = "退出公会半小时内不可加入公会"
response.spare_time = base_config.get('exit_time') - the_time
return response.SerializeToString()
if m_g_id != 0:
response.result = False
response.message = "您已加入公会"
return response.SerializeToString()
data1 = tb_guild_info.getObjData(g_id)
if not data1:
response.result = False
response.message = "公会ID错误"
return response.SerializeToString()
guild_obj = Guild()
guild_obj.init_data(data1)
if guild_obj.get_p_num() >= guild_config.get(guild_obj.level).p_max:
response.result = False
response.message = "公会已满员"
return response.SerializeToString()
else:
guild_obj.join_guild(p_id)
guild_obj.save_data()
response.result = True
return response.SerializeToString()
def repair_sign_in_1403(pro_data, player):
"""补充签到"""
request = RepairSignInRequest()
request.ParseFromString(pro_data)
day = request.day
print "repair_sign_in+++++++++++", day
response = SignInResponse()
sign_in_add = base_config.get("signInAdd")
if not sign_in_add:
return
repair_sign_in_times = player.sign_in_component.repair_sign_in_times
gold = player.finance.gold
# 校验签到次数
if repair_sign_in_times == len(sign_in_add):
response.res.result = False
response.res.result_no = 1404
return response.SerializePartialToString()
# 校验消耗元宝数
consume_gold = sign_in_add[repair_sign_in_times]
if consume_gold > gold:
response.res.result = False
response.res.result_no = 102
return response.SerializePartialToString()
# 消耗
player.finance.gold -= consume_gold
player.finance.save_data()
# 签到奖励
date = datetime.datetime.now()
month = date.month
# 同一天签到校验
if player.sign_in_component.is_signd(month, day):
response.res.result = False
response.res.result_no = 1405
return response.SerializePartialToString()
player.sign_in_component.sign_in(month, day)
player.sign_in_component.save_data()
if not sign_in_config.get(month) or not sign_in_config.get(month).get(day):
return
gain_data = sign_in_config.get(month).get(day)
return_data = gain(player, gain_data)
get_return(player, return_data, response.gain)
player.sign_in_component.repair_sign_in_times += 1
player.sign_in_component.save_data()
response.res.result = True
return response.SerializePartialToString()
def taken_brew(self):
self.check_time()
vip_level = self.owner.vip_component.vip_level
brew_times_max = vip_config.get(vip_level).get('cookingTimes')
if self._brew_times >= brew_times_max:
logger.error('not enough times to taken brew:%s', self._brew_times)
return False
self._nectar += self._nectar_cur
self._nectar_cur = base_config.get('cookingWineOutput')
self._brew_step = 1
self._brew_times += 1
self.save_data()
return True
def __init__(self, skill_no, player_level):
super(BestSkill, self).__init__()
best_mp_config = base_config.get('wushang_value_config')
self._mp = best_mp_config[0]
self._skill_no = skill_no
self._mp_step = best_mp_config[1]
self._mp_max_1 = best_mp_config[2]
self._mp_max_2 = best_mp_config[3]
self._mp_max_3 = best_mp_config[4]
self._skill_buffs = []
self._player_level = player_level
skill_info = skill_config.get(self._skill_no, None)
if skill_info:
for buff_id in skill_info.group:
self._skill_buffs.append(skill_buff_config.get(buff_id))
def process(self):
"""docstring for process"""
battle_round = BattleRound()
if not battle_round.init_round(self._red_units, self._red_best_skill, self._blue_units, self._blue_best_skill, self._firent_skill):
return True
logger.debug_cal("开始战斗...")
for i in range(base_config.get("max_times_fight")):
i = i + 1
logger.debug_cal("第%d回合......" % i)
battle_round.perform_round()
result = battle_round.result
if result == 0: continue
if result == 1:
logger.debug_cal("我赢了。")
return True
if result == -1:
logger.debug_cal("我输了。")
return False
return False
def buy_stamina_6(request_proto, player):
"""购买体力"""
response = CommonResponse()
current_vip_level = player.vip_component.vip_level
current_buy_stamina_times = player.stamina.buy_stamina_times
current_stamina = player.stamina.stamina
current_gold = player.finance.gold
available_buy_stamina_times = vip_config.get(current_vip_level).get("buyStaminaMax")
logger.debug("available_buy_stamina_times:", available_buy_stamina_times,
current_buy_stamina_times)
# 校验购买次数上限
if current_buy_stamina_times >= available_buy_stamina_times:
response.result = False
response.result_no = 11
return response.SerializePartialToString()
need_gold = base_config.get("price_buy_manual").get(current_buy_stamina_times+1)[1]
logger.debug("need_gold++++++++++++++++", need_gold)
# 校验金币是否不足
if need_gold > current_gold:
logger.debug("gold not enough++++++++++++")
response.result = False
response.result_no = 102
return response.SerializePartialToString()
player.finance.gold -= need_gold
player.finance.save_data()
player.stamina.buy_stamina_times += 1
player.save_data()
player.stamina.stamina += 120
player.stamina.save_data()
response.result = True
return response.SerializePartialToString()
def worship_809(data, player):
"""膜拜 """
args = WorshipRequest()
args.ParseFromString(data)
response = GuildCommonResponse()
w_type = args.w_type
m_g_id = player.guild.g_id
data1 = tb_guild_info.getObjData(m_g_id)
if not data1 or m_g_id == 0:
response.result = False
response.message = "公会ID错误"
return response.SerializeToString()
guild_obj = Guild()
guild_obj.init_data(data1)
# {膜拜编号：[资源类型,资源消耗量,获得公会经验,获得公会资金,获得个人贡献值]}
worship_info = base_config.get('worship').get(w_type)
if worship_info[1] == 1: # 1金币 2元宝
if worship_info[2] > player.finance.coin:
response.result = False
response.message = "金币不足"
return response.SerializeToString()
else:
if worship_info[2] > player.finance.gold:
response.result = False
response.message = "元宝不足"
return response.SerializeToString()
if (int(time.time()) - player.guild.worship_time) < (60 * 60 * 24):
if player.vip_component.guild_worship_times > player.guild.worship:
player.guild.worship += 1
player.guild.contribution += worship_info[4]
player.guild.all_contribution += worship_info[3]
guild_obj.fund += worship_info[3]
guild_obj.exp += worship_info[2]
else:
response.result = False
response.message = "今天的膜拜次数已用完"
return response.SerializeToString()
else:
localtime = time.localtime(time.time())
new_time = time.mktime(
time.strptime(time.strftime('%Y-%m-%d 00:00:00', localtime),
'%Y-%m-%d %H:%M:%S'))
player.guild.worship += 1
player.guild.contribution += worship_info[4]
player.guild.all_contribution += worship_info[4]
guild_obj.fund += worship_info[3]
guild_obj.exp += worship_info[2]
player.guild.worship_time = new_time
if guild_obj.exp >= guild_config.get(guild_obj.level).exp:
guild_obj.exp -= guild_config.get(guild_obj.level).exp
guild_obj.level += 1
remote_gate.add_guild_to_rank_remote(
guild_obj.g_id, guild_obj.level + (guild_obj.fund * 100))
player.guild.save_data()
guild_obj.save_data()
# 根据膜拜类型判断减什么钱，然后扣除
if worship_info[1] == 1: # 1金币 2元宝
player.finance.coin -= worship_info[2]
else:
player.finance.gold -= worship_info[2]
player.finance.save_data()
response.result = True
response.message = "膜拜成功"
return response.SerializeToString()
def promotion_808(data, player):
"""晋升 """
response = PromotionResponse()
m_g_id = player.guild.g_id
m_p_id = player.base_info.id
m_position = player.guild.position
if m_position <= 2:
response.result = False
response.message = "您不能再晋升了"
return response.SerializeToString()
data1 = tb_guild_info.getObjData(m_g_id)
guild_obj = Guild()
guild_obj.init_data(data1)
p_list = guild_obj.p_list
t_p_list = p_list.get(m_position - 1)
# 此职位还没有人
if t_p_list and len(t_p_list) >= 1:
list_len = len(t_p_list)
t_position = m_position - 1
flag = 0
if t_position == 2:
if list_len >= base_config.get('pos_p_num')[0]:
flag = 1
elif t_position == 3:
if list_len >= base_config.get('pos_p_num')[1]:
flag = 1
elif t_position == 4:
if list_len >= base_config.get('pos_p_num')[2]:
flag = 1
else:
response.result = False
response.message = "未知错误"
return response.SerializeToString()
# 此职位的人满了
if flag == 1:
guildinfolist = {}
for p_id1 in t_p_list:
guildinfo = tb_character_guild.getObjData(p_id1)
if guildinfo:
guildinfolist.update(
{guildinfo.get('id'): guildinfo.get('info')})
m_guildinfo = tb_character_guild.getObjData(m_p_id)
guildinfolist.update(
{m_guildinfo.get('id'): m_guildinfo.get('info')})
new_list = sorted(guildinfolist.items(),
key=lambda x: (x[1]['contribution']),
reverse=True)
if new_list[-1][0] == m_p_id or new_list[-1][1].get(
'contribution') == new_list[-2][1].get('contribution'):
response.result = False
response.message = "总贡献必须超过上一级职位最低贡献才能晋级"
return response.SerializeToString()
tihuan_id = new_list[-1][0]
character_guild = tb_character_guild.getObjData(tihuan_id)
info = character_guild.get("info")
if info.get("g_id") != player.guild.g_id:
response.result = False
response.message = "未知错误"
return response.SerializeToString()
invitee_player = PlayersManager().get_player_by_id(tihuan_id)
if invitee_player: # 在线
remote_gate.logout_guild_chat_remote(invitee_player.dynamic_id)
invitee_player.guild.position = m_position
invitee_player.guild.save_data()
else:
data = {
'info': {
'g_id': info.get("g_id"),
'position': m_position,
'contribution': info.get("contribution"),
'all_contribution': info.get("all_contribution"),
'k_num': info.get("k_num"),
'worship': info.get("worship"),
'worship_time': info.get("worship_time"),
'exit_time': info.get("exit_time")
}
}
p_guild_data = tb_character_guild.getObj(tihuan_id)
p_guild_data.update_multi(data)
p_list1 = p_list.get(m_position)
p_list1.remove(m_p_id)
p_list1.append(tihuan_id)
p_list2 = p_list.get(m_position - 1)
p_list2.remove(tihuan_id)
p_list2.append(m_p_id)
response.p_id = tihuan_id
else: #此职位还没满
p_list1 = p_list.get(m_position)
p_list1.remove(m_p_id)
p_list2 = p_list.get(m_position - 1)
p_list2.append(m_p_id)
else:
p_list1 = p_list.get(m_position)
p_list1.remove(m_p_id)
p_list2 = [m_p_id]
player.guild.position -= 1
player.guild.save_data()
p_list.update({m_position: p_list1, m_position - 1: p_list2})
guild_obj.p_list = p_list
guild_obj.save_data()
response.result = True
response.message = "晋升成功"
return response.SerializeToString()
def create_guild_801(data, player):
"""创建公会 """
args = CreateGuildRequest()
args.ParseFromString(data)
g_name = args.name
response = GuildCommonResponse()
p_id = player.base_info.id
g_id = player.guild.g_id
if base_config.get('create_level') > player.level.level:
response.result = False
response.message = "等级不够"
return response.SerializeToString()
if base_config.get('create_money') > player.finance.gold:
response.result = False
response.message = "元宝不足"
return response.SerializeToString()
if g_id != 0:
response.result = False
response.message = "您已加入公会"
return response.SerializeToString()
if not g_name:
response.result = False
response.message = "公会名不能为空"
return response.SerializeToString()
match = re.search(u'[\uD800-\uDBFF][\uDC00-\uDFFF]',
unicode(g_name, "utf-8"))
if match:
response.result = False
response.message = "公会名不合法"
return response.SerializeToString()
if trie_tree.check.replace_bad_word(g_name).encode("utf-8") != g_name:
response.result = False
response.message = "公会名不合法"
return response.SerializeToString()
if len(g_name) > 18:
response.result = False
response.message = "名称超过字数限制"
return response.SerializeToString()
# 判断有没有重名
guild_name_data = tb_guild_name.getObjData(g_name)
if guild_name_data:
response.result = False
response.message = "此名已存在"
return response.SerializeToString()
# 创建公会
guild_obj = Guild()
guild_obj.create_guild(p_id, g_name)
remote_gate.add_guild_to_rank_remote(guild_obj.g_id, 1)
data = {'g_name': g_name, 'g_id': guild_obj.g_id}
tb_guild_name.new(data)
player.guild.g_id = guild_obj.g_id
player.guild.worship = 0
player.guild.worship_time = 1
player.guild.contribution = 0
player.guild.all_contribution = 0
player.guild.k_num = 0
player.guild.position = 1
player.guild.save_data()
guild_obj.save_data()
player.finance.gold -= base_config.get('create_money')
player.finance.save_data()
# 加入公会聊天
remote_gate.login_guild_chat_remote(player.dynamic_id, player.guild.g_id)
response.result = True
return response.SerializeToString()
def peroid_of_stamina_recover(self):
return base_config.get('peroid_of_vigor_recover', 300)
def max_of_stamina(self):
return base_config.get('max_of_vigor', 120)
def do_assemble(no,
quality,
break_skills,
hp,
atk,
physical_def,
magic_def,
hit,
dodge,
cri,
cri_coeff,
cri_ded_coeff,
block,
ductility,
position,
level,
is_boss=False,
is_hero=True,
is_break_hero=False,
unit_name=""):
"""组装战斗单位
@param no: 编号
@param quality: 品质
@param normal_skill: 普通技能[技能ID, 技能buffs]
@param rage_skill: 怒气技能[技能ID, 技能buffs]
@param break_skills: 突破技能 [[技能ID, 技能buffs], [技能ID, 技能buffs]]
@param hp: 血
@param atk: 攻
@param physical_def: 物理防御
@param magic_def: 魔法防御
@param hit: 命中
@param dodge: 闪避
@param cri: 暴击
@param cri_coeff: 暴击伤害系数
@param cri_ded_coeff: 暴击减免系数
@param block: 格挡率
@param is_boss: 是否是boss
@return: 战斗单位对象
"""
battle_unit = BattleUnit()
battle_unit.unit_no = no
battle_unit.unit_name = unit_name
battle_unit.quality = quality
battle_unit.hp_max = hp
battle_unit.hp = hp
battle_unit.hp_max = hp
battle_unit.atk = atk
battle_unit.physical_def = physical_def
battle_unit.magic_def = magic_def
battle_unit.hit = hit
battle_unit.dodge = dodge
battle_unit.cri = cri
battle_unit.cri_coeff = cri_coeff
battle_unit.cri_ded_coeff = cri_ded_coeff
battle_unit.block = block
battle_unit.level = level
battle_unit.is_boss = is_boss
battle_unit.slot_no = position
# init skill
mp_config = base_config.get('chushi_value_config')
if is_hero:
battle_unit.skill = HeroSkill(battle_unit, mp_config)
if is_break_hero:
mp_config = base_config.get('stage_break_angry_value')
battle_unit.skill = HeroSkill(battle_unit, mp_config)
else:
battle_unit.skill = MonsterSkill(battle_unit, mp_config)
battle_unit.skill.break_skill_ids = break_skills
return battle_unit
def execute_demage(attacker, target, skill_buff_info, is_block):
"""
执行技能［1，2］
"""
logger.debug_cal(
" 攻方 no(%d), unit_no(%d), name(%s), hp(%f), mp(%f), buff(%s)" %
(attacker.slot_no, attacker.unit_no, attacker.unit_name, attacker.hp,
attacker.mp, attacker.buff_manager))
logger.debug_cal(
" 守方 no(%d), unit_no(%d), name(%s), hp(%f), mp(%f), buff(%s)" %
(target.slot_no, target.unit_no, target.unit_name, target.hp,
target.mp, target.buff_manager))
is_cri = False # 是否暴击
is_trigger = False # 是否trigger
if get_random_int(1, 100) <= skill_buff_info.triggerRate:
is_trigger = True
if not is_trigger:
logger.debug_cal(" 技能未触发。")
if get_random_int(1, 100) < attacker.cri - target.ductility:
is_cri = True
cri_coeff = (attacker.cri_coeff - target.cri_ded_coeff) / 100 # 暴击伤害系数
k1 = attacker.atk # 攻方总实际攻击力
k2 = 0 # 守方总物理或者魔法防御
if skill_buff_info.effectId == 1:
k2 = target.physical_def
elif skill_buff_info.effectId == 2:
k2 = target.magic_def
k3_k4 = base_config.get("a3") # 基础伤害值调整参数
k3 = k3_k4[0]
k4 = k3_k4[1]
base_demage_value = (k1 * k1 / (k1 + k3 * k2)) * k4 # 基础伤害值
block_demage_coeff = base_config.get("a4") # 格挡受伤比参数
#
level_coeff = 1 # 等级压制系数
k1 = attacker.level # 攻方等级
k2 = target.level # 守方等级
temp = base_config.get("a5") # 等级压制调整参数
k3, k4, k5 = temp[0], temp[1], temp[2] # 等级压制调整参数
if (k2 - k1) > 5:
if (1 - k3 / k4 * ((k2 - k1) * (k2 - k1) + (k2 - k1) + k5)) > 0.1:
level_coeff = 1 - k3 / k4 * ((k2 - k1) * (k2 - k1) +
(k2 - k1) + k5)
else:
level_coeff = 0.1
else:
level_coeff = 1
#
temp = base_config.get("a6") # 伤害浮动调整参数
k1, k2 = temp[0], temp[1] #
demage_fluct_coeff = random.uniform(k1, k2) # 伤害浮动系数
if not is_cri:
cri_coeff = 1
if not is_block:
block_demage_coeff = 1
total_demage = base_demage_value * cri_coeff * block_demage_coeff * level_coeff * demage_fluct_coeff # 总伤害值
#
actual_demage = 0 # 实际伤害值
if (skill_buff_info.effectId == 1 or skill_buff_info.effectId
== 2) and skill_buff_info.valueType == 1:
actual_demage = total_demage + skill_buff_info.valueEffect + skill_buff_info.levelEffectValue * attacker.level
#logger.debug_cal(actual_demage, total_demage, skill_buff_info.valueEffect, skill_buff_info.levelEffectValue, attacker.level, type(skill_buff_info.valueType))
elif (skill_buff_info.effectId == 1
or skill_buff_info.effectId == 2) and skill_buff_info.valueType == 2:
actual_demage = total_demage * (
skill_buff_info.valueEffect / 100 +
skill_buff_info.levelEffectValue / 100 * attacker.level)
#logger.debug_cal(actual_demage, total_demage, skill_buff_info.valueEffect, skill_buff_info.levelEffectValue, attacker.level, skill_buff_info.valueType)
#logger.debug_cal(skill_buff_info.valueEffect/100 + skill_buff_info.levelEffectValue/100 * attacker.level)
logger.debug_cal(" 技能ID（%d）,暴击（%s），格挡（%s），基础伤害值(%s)，暴击伤害系数(%s)，等级压制系数(%s)，伤害浮动系数(%s)，总伤害值(%s)，攻方实际伤害值(%s)" \
% (skill_buff_info.id, is_cri, is_block, base_demage_value, cri_coeff, level_coeff, demage_fluct_coeff,
total_demage, actual_demage))
target.hp = target.hp - actual_demage
def strength_max(self):
"""获取装备上限为玩家等级+strength_max"""
return base_config.get("max_equipment_strength", 3)
def travel_831(data, player):
"""游历"""
args = TravelRequest()
args.ParseFromString(data)
stage_id = args.stage_id
response = TravelResponse()
if base_config.get('travelOpenLevel') > player.level.level:
response.res.result = False
response.res.result_no = 811 # 等级不够
return response.SerializeToString()
shoes = player.travel_component.shoes
if shoes[0] + shoes[1] + shoes[2] == 0:
response.res.result = False
response.res.result_no = 812 # 鞋子不足
return response.SerializeToString()
travel_cache = player.travel_component.travel
while (True):
travel_event_id = get_travel_event_id()
flag = 1
if travel_cache.get(stage_id):
for event in travel_cache.get(stage_id):
if travel_event_id == event[0]:
flag = 0
if flag:
break
else:
travel_cache[stage_id] = []
break
event_info = travel_event_config.get('events').get(travel_event_id)
if not event_info:
logger.error('get travel event config error')
response.res.result = False
response.res.result_no = 800 # 未知错误
return response.SerializeToString()
response.event_id = travel_event_id
res_drops = response.drops
drops = []
stage_info = stage_config.get('stages').get(stage_id)
common_bag = BigBag(stage_info.commonDrop)
common_drop = common_bag.get_drop_items()
drops.extend(common_drop)
drop_data = get_drop_data(drops)
get_return(player, drop_data, res_drops)
# 等待 战斗 答题 领取
if event_info.type == 4:
gain(player, drops)
else:
travel_cache.get(stage_id).append([travel_event_id, drops])
if shoes[3] == 0:
for i in [2, 1, 0]:
if shoes[i] != 0:
shoes[3] = i + 1
shoes[4] = 1
break
else:
if base_config.get("travelShoe" + str(shoes[3]))[1] == shoes[4] + 1:
shoes[shoes[3] - 1] -= 1
shoes[4] = 0
shoes[3] = 0
else:
shoes[4] += 1
player.travel_component.save()
response.res.result = True
return response.SerializeToString()
def get_shop_item_ids():
"""随机筛选ids"""
items = get_all_shop_items()
item_num = base_config.get('soulShopItemNum')
return random_multi_pick_without_repeat(items, item_num)
def get_shop_item_ids():
"""随机筛选ids"""
items = get_all_shop_items()
item_num = base_config.get('arena_shop_item_num')
print 'arena_shop_item_num', item_num
return random_multi_pick_without_repeat(items, item_num)
def pvb_fight_start_1705(pro_data, player):
"""开始战斗
"""
logger.debug("fight start..")
request = stage_request_pb2.StageStartRequest()
request.ParseFromString(pro_data)
stage_id = request.stage_id # 关卡编号
unparalleled = request.unparalleled # 无双编号
logger.debug("unparalleled,%s" % unparalleled)
line_up = {} # {hero_id:pos}
for line in request.lineup:
if not line.hero_id:
continue
line_up[line.hero_id] = line.pos
stage_info = fight_start(stage_id, line_up, unparalleled, 0, player)
result = stage_info.get('result')
response = PvbFightResponse()
res = response.res
res.result = result
if stage_info.get('result_no'):
res.result_no = stage_info.get('result_no')
if not result:
logger.info('进入关卡返回数据:%s', response)
return response.SerializePartialToString(), stage_id
red_units = stage_info.get('red_units')
blue_units = stage_info.get('blue_units')
logger.debug("--" * 40)
# 根据鼓舞次数，增加ATK百分比
atk_rate = player.world_boss.encourage_coin_num * base_config.get("worldbossInspireAtk", 0) + \
player.world_boss.encourage_gold_num * base_config.get("worldbossInspireAtkMoney", 0)
for slot_no, red_unit in red_units.items():
red_unit.atk *= (1 + atk_rate)
print red_units
print blue_units
for slot_no, red_unit in red_units.items():
red_add = response.red.add()
assemble(red_add, red_unit)
blue_units = blue_units[0]
for no, blue_unit in blue_units.items():
blue_add = response.blue.add()
assemble(blue_add, blue_unit)
response.red_best_skill = unparalleled
if unparalleled in player.line_up_component.unpars:
response.red_best_skill_level = player.line_up_component.unpars[
unparalleled]
# mock fight.
player_info = {}
player_info["player_id"] = player.base_info.id
player_info["nickname"] = player.base_info.base_name
player_info["level"] = player.level.level
player_info["line_up_info"] = line_up_info(
player).SerializePartialToString()
str_red_units = cPickle.dumps(red_units)
str_blue_units = cPickle.dumps(blue_units)
logger.debug("--" * 40)
print red_units
print blue_units
result = remote_gate['world'].pvb_fight_remote(str_red_units, unparalleled,
str_blue_units, player_info)
response.fight_result = result
# 玩家信息更新
player.world_boss.fight_times += 1
player.world_boss.last_fight_time = get_current_timestamp()
player.world_boss.save_data()
print response
logger.debug("fight end..")
return response.SerializePartialToString()
