def guild_boss_init_remote(guild_id):
"""
初始化信息
"""
guild = guild_manager_obj.get_guild_obj(guild_id)
if not guild:
return {'result': False, 'result_no': 844}
guild.guild_boss.check_time()
guild.save_data()
# 重置召唤次数
guild.reset_guild_boss_trigger_times()
res = dict(
result=True,
guild_skills=guild.guild_skills,
guild_boss_trigger_times=guild.guild_boss_trigger_times,
guild_boss=guild.guild_boss.property_dict(),
build = guild.build,
)
logger.debug("result %s" % res)
return res
def check_time(self):
current_date_time = time.time()
current_day = localtime(current_date_time).tm_yday
for k, v in self._shop_data.items():
refresh_day = localtime(v['last_refresh_time']).tm_yday
if current_day != refresh_day:
v['refresh_times'] = 0
v['limit_items'] = {}
v['last_refresh_time'] = time.time()
luck_day = localtime(v['luck_time']).tm_yday
if current_day != luck_day:
v['luck_time'] = time.time()
v['luck_num'] = 0.0
v['limit_items'] = {}
if 'limit_items' not in v:
v['limit_items'] = {}
if 'vip_limit_items' not in v:
v['vip_limit_items'] = {}
#自动刷新列表
shop_type_info = game_configs.shop_type_config.get(k)
freeRefreshTime = shop_type_info.freeRefreshTime
if shop_type_info.freeRefreshTime == "-1":
continue
logger.debug("%s %s" % (freeRefreshTime, v['last_auto_refresh_time']))
if time.time() > is_past_time(freeRefreshTime, v['last_auto_refresh_time']):
self.auto_refresh_items(k)
def __login(uid, session):
"""login """
res = verify_login(uid, session)
logger.debug(res)
if res.get('errcode') == 200:
return str({'result': True, 'uid': '\'%s\'' % uid})
return str({'result': False})
def pvp_daily_award():
logger.debug('pvp daily send award mail ')
arena_award = game_configs.base_config.get('arena_day_points')
records = tb_pvp_rank.zrangebyscore(0, 10000, withscores=True)
childs = groot.childsmanager.childs
for k, v in records:
rank = int(v)
character_id = int(k)
if character_id < 10000:
continue
for up, down, mail_id in arena_award.values():
if rank >= up and rank <= down:
break
else:
logger.error('pvp daily award error:%s-%s', rank, character_id)
continue
mail_data, _ = deal_mail(conf_id=mail_id, receive_id=character_id)
for child in childs.values():
if 'gate' in child.name:
result = child.pull_message_remote('receive_mail_remote',
character_id,
(mail_data,))
if type(result) is bool and result:
break
else:
logger.debug('pvp_daily_award_tick result:%s,%s,%s',
result, k, mail_data)
else:
message_cache.cache_time('receive_mail_remote', character_id, 60*60*24*180, mail_data)
tlog_action.log('PvpDailyAward', character_id, mail_id, rank)
def get_task_by_id(self, task_id):
task = self._escort_tasks.get(task_id)
if not task:
logger.debug("task_id %s not exists!" % task_id)
return None
task.update_task_state()
return task
def send_award_in(self):
""" 参与奖励
"""
logger.debug("send_award_in=========== %s", self._rank_instance.get(1, 0))
for player_id, v in self._rank_instance.get(1, 0):
logger.debug("send_award_in==== %s %s" % (player_id, v))
self.send_award(player_id, const.PVB_IN_AWARD, int(v))
def continus_sign_in_1402(pro_data, player):
"""累积签到"""
request = ContinuousSignInRequest()
request.ParseFromString(pro_data)
days = request.sign_in_days
response = ContinuousSignInResponse()
# 验证连续签到日期
if len(player.sign_in_component.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()
reward, config_id = player.sign_in_component.get_sign_in_reward(days)
if not reward:
response.res.result = False
response.res.result_no = 1404
return response.SerializePartialToString()
return_data = gain(player, reward, const.CONTINUS_SIGN)
get_return(player, return_data, response.gain)
tlog_action.log('ContinusSignIn', player, days, config_id)
response.res.result = True
logger.debug(response)
return response.SerializePartialToString()
def check_time(shop_data):
# 1 个人 2 军团
current_date_time = int(time.time())
# current_day = localtime(current_date_time).tm_yday
for k, v in shop_data.items():
shop_type_info = game_configs.shop_type_config.get(k)
freeRefreshTime = shop_type_info.freeRefreshTime
if freeRefreshTime != '-1' and current_date_time > is_past_time(
freeRefreshTime, v['last_refresh_time']):
v['refresh_times'] = 0
v['guild_items'] = {}
v['items'] = {}
v['last_refresh_time'] = current_date_time
v['luck_time'] = current_date_time
v['luck_num'] = 0.0
# 自动刷新列表
refresh = shop_type_info.refresh
if refresh == -1:
continue
logger.debug("auto refresh %s %s" %
(refresh, v['last_auto_refresh_time']))
tm_now = time.localtime(current_date_time)
tm_refresh = time.localtime(v['last_auto_refresh_time'])
if tm_now.tm_yday != tm_refresh.tm_yday or \
tm_now.tm_hour / refresh * refresh > tm_refresh.tm_hour:
do_auto_refresh_items(k, shop_data)
def assemble_monster(stage_id, stage_config, stage_type_name):
"""组装怪物战斗单位
"""
stage_config = stage_config.get(stage_type_name).get(stage_id)
monsters = []
for i in range(3):
logger.debug("stage_id %s" % stage_id)
logger.debug(
"stage_group_id %s" %
getattr(
stage_config, 'round%s' %
(i + 1)))
monster_group_id = getattr(stage_config, 'round%s' % (i+1))
if not monster_group_id:
continue
monster_group_config = game_configs.monster_group_config.get(monster_group_id)
round_monsters = {}
boss_position = monster_group_config.bossPosition
for j in range(6):
pos = j + 1
monster_id = getattr(monster_group_config, 'pos%s' % pos)
if not monster_id:
continue
is_boss = False
if j + 1 == boss_position:
is_boss = True
monster_config = game_configs.monster_config.get(monster_id)
logger.info('怪物ID：%s' % monster_id)
battle_unit = do_assemble(
0,
monster_config.id,
monster_config.quality,
[],
monster_config.hp,
monster_config.atk,
monster_config.physicalDef,
monster_config.magicDef,
monster_config.hit,
monster_config.dodge,
monster_config.cri,
monster_config.criCoeff,
monster_config.criDedCoeff,
monster_config.block,
monster_config.ductility,
pos,
monster_config.monsterLv,
0,
is_boss,
is_hero=False)
round_monsters[pos] = battle_unit
monsters.append(round_monsters)
# 保存关卡怪物信息, 掉落信息
logger.info('关卡怪物信息: %s ' % monsters)
return monsters
def delete_hero(self, hero_no):
if self._heros.get(hero_no):
hero = self._heros[hero_no]
hero.delete()
del self._heros[hero_no]
else:
logger.debug("don't find hero_no from self._heros")
def gm():
print("gm================")
response = {}
res = {}
admin_command = ['reset_star_gift', 'update_excel', 'get_user_info', 'send_mail',
'get_user_hero_chips', 'get_user_eq_chips',
'get_user_finances', 'get_user_items',
'get_user_guild_info', 'get_user_heros',
'get_user_eqs', 'copy_user', 'update_server_list',
'add_push_message']
print request.args, type(request.args)
if request.args:
t_dict = request.args
else:
t_dict = request.form
logger.info('gm2admin,command:%s', t_dict['command'])
if t_dict['command'] in admin_command:
com = t_dict['command'] + "(t_dict)"
res = eval(com)
else:
res = remote_gate.from_admin_rpc_remote(cPickle.dumps(t_dict))
if res['success'] == 2:
com = t_dict['command'] + "(t_dict)"
logger.debug("gm=======%s" % com)
res = eval(com)
logger.info('######################################,server2gm:%s', res)
return json.dumps(res)
def func():
consume_return_data = consume(player, price,
get_reason(shop_item.get('type')),
multiple=item_count,
shop=shop,
luck_config=shop_type_item) # 消耗
return_data = gain(player,
shop_item.gain,
get_reason(shop_item.get('type')),
multiple=item_count,
lucky_attr_id=_lucky_attr) # 获取
get_return(player, consume_return_data, response.consume)
get_return(player, return_data, response.gain)
if shop_item.ExchangeValue:
lucky_data = gain(player,
shop_item.ExchangeValue,
get_reason(shop_item.get('type')))
get_return(player, lucky_data, response.gain)
for _ in range(item_count):
send_tlog(player, shop_item)
logger.debug("allBuyRefresh %s" % shop_type_item.allBuyRefresh)
if not shop['item_ids'] and shop_type_item.allBuyRefresh:
logger.debug("shop auto refresh =============")
player.shop.auto_refresh_items(shop_item.get('type'))
response.is_all_buy = True
def set_next_stage(self, kill_or_not=False):
"""
根据id规则确定下一个关卡
如果boss未被击杀则不升级
"""
logger.debug("current_stage_id1%s" % self._stage_id)
current_stage_id = self._stage_id
origin_stage_id_am = self._stage_id_am
if current_stage_id == 0:
self._stage_id_am = 800101
self._stage_id_pm = 800102
self._stage_id = 800101
return
if kill_or_not: # 如果boss被击杀，则升级boss
logger.debug("kill boss =============")
if current_stage_id == self._stage_id_am: # am
self._stage_id_am = current_stage_id + 100
else: # pm
self._stage_id_pm = current_stage_id + 100
if current_stage_id == origin_stage_id_am:
self._stage_id = self._stage_id_pm
else:
self._stage_id = self._stage_id_am
logger.debug("current_stage_id3%s" % self._stage_id)
logger.debug("current_stage_id_am%s" % self._stage_id_am)
logger.debug("current_stage_id_pm%s" % self._stage_id_pm)
def fight_start(stage, fid, player):
"""开始战斗
"""
# 校验信息：是否开启，是否达到次数上限等
res = stage.check()
if not res.get('result'):
return res
fight_cache_component = player.fight_cache_component
fight_cache_component.stage_id = stage.stage_id
fight_cache_component.stage = stage
red_units, blue_units, drop_num, monster_unpara = fight_cache_component.fighting_start()
# 好友
char_obj = tb_character_info.getObj(fid)
lord_data = char_obj.hget('lord_attr_info')
f_unit = None
if lord_data and not is_not_open(player, FO_FRIEND_SUPPORT):
info = lord_data.get('info')
f_unit = BattleUnit.loads(info)
else:
logger.debug('can not find friend id :%d' % fid)
return dict(result=True,
red_units=red_units,
blue_units=blue_units,
drop_num=drop_num,
monster_unpara=monster_unpara,
f_unit=f_unit,
result_no=0)
def invite_1908(data, player):
"""发送/接受邀请"""
request = escort_pb2.InviteEscortTaskRequest()
request.ParseFromString(data)
logger.debug("request %s" % request)
response = common_pb2.CommonResponse()
task_id = request.task_id
send_or_in = request.send_or_in
protect_or_rob = request.protect_or_rob
task_guild_id = request.task_guild_id
rob_no = request.rob_no
escort_open_time_item = game_configs.base_config.get("EscortOpenTime")
if not is_in_period(escort_open_time_item):
logger.error("feature not open!")
response.result = False
response.result_no = 30000
return response.SerializePartialToString()
res = None
if send_or_in == 1:
res = send_invite(player, task_id, protect_or_rob, task_guild_id, rob_no)
elif send_or_in == 2:
res = in_invite(player, task_id, protect_or_rob, task_guild_id, rob_no)
response.result = res.get('result')
if not res.get('result'):
response.result_no = res.get('result_no')
return response.SerializePartialToString()
tlog_action.log('GuildTaskInvite', player, task_id, task_guild_id, send_or_in, protect_or_rob, rob_no)
response.result = True
return response.SerializePartialToString()
def pvp_fight(player, character_id, line_up, skill, response, callback,
is_copy_unit=False):
record = get_pvp_data(character_id)
if not record:
logger.error('player id is not found:%s', character_id)
response.res.result = False
response.res.result_no = 150001
return response.SerializePartialToString()
best_skill, skill_level = player.line_up_component.get_skill_info_by_unpar(skill)
logger.debug("best_skill=================== %s" % best_skill)
if is_copy_unit:
blue_units = record.get('copy_units2')
else:
blue_units = record.get('copy_units')
save_line_up_order(line_up, player, skill)
red_units = player.fight_cache_component.get_red_units()
seed1, seed2 = get_seeds()
fight_result = pvp_process(player, line_up, red_units, blue_units,
best_skill, record.get("best_skill"),
record.get("level"), skill, seed1, seed2,
const.BATTLE_PVP)
pvp_assemble_units(red_units, blue_units, response)
response.seed1 = seed1
response.seed2 = seed2
response.fight_result = fight_result
response.red_skill = skill
response.red_skill_level = skill_level
response.blue_skill = record.get("unpar_skill")
response.blue_skill_level = record.get("unpar_skill_level")
return callback(player, fight_result)
def check_time(self):
"""
时间改变，重置数据
"""
current_time_stamp = get_current_timestamp()
for k, v in self._act_lucky_heros.items():
stage_info = game_configs.special_stage_config.get('act_stages').get(k)
if v.get('time')[0] > current_time_stamp or v.get('time')[1] < current_time_stamp:
v['heros'], v['time'][0], v['time'][1] = update_lucky_hero(stage_info.type, k%10)
logger.debug("character_stage check time")
logger.debug(self._act_stage_info)
if is_next_day(current_time_stamp, self._elite_stage_info[2]):
self._elite_stage_info[0] = 0
self._elite_stage_info[1] = 0
self._elite_stage_info[2] = current_time_stamp
if is_next_day(current_time_stamp, self._act_stage_info[2]):
self._act_stage_info[0] = 0
self._act_stage_info[1] = 0
self._act_stage_info[2] = current_time_stamp
logger.debug("_act_lucky_heros %s" % self._act_lucky_heros)
logger.debug(self._elite_stage_info)
logger.debug(self._act_stage_info)
self.save_data()
def set_pay_arg(self, value):
self._platform = value.get("platform")
self._openid = str(value.get("openid"))
self._openkey = str(value.get("openkey"))
self._pay_token = str(value.get("pay_token"))
self._appid = str(value.get("appid"))
#self._appkey = str(value.get("appkey"))
self._pf = str(value.get("pf"))
self._pfkey = str(value.get("pfkey"))
login_channel = str(value.get("login_channel"))
logger.debug("login_channel %s" % login_channel)
if login_channel != "tencent":
self.REMOTE_DEPLOYED = False
# self._zoneid = str(value.get("zoneid"))
if self.REMOTE_DEPLOYED:
previous_gold = self._owner.finance.gold
self.get_balance() # 登录时从tx拉取gold
add_gold = self._owner.finance.gold - previous_gold
if add_gold == 0:
return
logger.info('tencent add gold:%s', add_gold)
recharge_config = game_configs.recharge_config.get('android')
for k, item in recharge_config.items():
if item.get('activity') == add_gold:
response = GetGoldResponse()
self._owner.recharge.recharge_gain(item, response, 5, True)
break
else:
logger.error('tencent add gold-num:%d', add_gold)
def receive_mail_remote(mail_data, is_online, player):
"""接收邮件"""
mail = Mail_PB()
mail.ParseFromString(mail_data)
logger.debug('receive_mail:%s', mail)
if mail.mail_type == 1:
if mail.sender_id in player.stamina.contributors:
logger.error('this contributor has already given stamina:%s',
mail.sender_id)
return True
else:
player.stamina.contributors.append(mail.sender_id)
if mail.config_id == game_configs.base_config.get('guildInviteMail'):
mails = player.mail_component.get_mails()
for mail_pb in mails:
if mail.guild_id and mail_pb.guild_id == mail.guild_id:
return True
player.mail_component.add_mail(mail)
player.mail_component.save_data()
if is_online:
response = mailbox_pb2.ReceiveMailResponse()
response.mail.CopyFrom(mail)
remote_gate.push_object_remote(1305,
response.SerializePartialToString(),
[player.dynamic_id])
return True
def is_not_open(player, feature_type):
"""
是否开启
"""
logger.debug("feature_type %s player_level %s" % (feature_type,
player.base_info.level))
feature_item = game_configs.features_open_config.get(feature_type)
if not feature_item:
logger.error("there is no such feature_type %s!" % feature_type)
return True
logger.debug("open_type %s open %s" % (feature_item.open_type,
feature_item.open))
if feature_item.open_type == 1:
# 玩家等级
if feature_item.open <= player.base_info.level:
return False
else:
return True
if feature_item.open_type == 2:
# 关卡
open_stage_id = feature_item.open
if player.stage_component.get_stage(open_stage_id).state == 1:
return False
else:
return True
return True
def pvp_award():
arena_award = game_configs.base_config.get('arena_shorttime_points')
records = tb_pvp_rank.zrangebyscore(0, 10000, withscores=True)
childs = groot.childsmanager.childs
for k, v in records:
rank = int(v)
character_id = int(k)
if character_id < 10000:
continue
for up, down, score in arena_award.values():
if rank >= up and rank <= down:
award = score
break
else:
logger.error('pvp award error:%s', k)
continue
for child in childs.values():
if 'gate' in child.name:
result = child.pull_message_remote('pvp_award_remote',
character_id,
(award,))
if type(result) is bool and result:
logger.debug('pvp_award_tick result:%s,%s,%s',
result, k, award)
break
else:
logger.debug('pvp_award_tick cache:%s,%s', k, award)
message_cache.cache('pvp_award_remote', character_id, award)
def guild_boss_battle_remote(guild_id, str_red_units, red_unpar_data, seed1, seed2):
"""开始战斗
"""
logger.debug("hjqy_battle_remote======")
guild = guild_manager_obj.get_guild_obj(guild_id)
boss = guild.guild_boss
red_units = cPickle.loads(str_red_units)
blue_units = boss.blue_units
logger.debug("blue unit length %s" % len(blue_units))
origin_hp = boss.hp
fight_result = guild_boss_start(red_units, blue_units, red_unpar_data, {}, seed1, seed2)
logger.debug("blue unit length %s" % len(blue_units))
boss.blue_units = blue_units
current_damage_hp = origin_hp - boss.hp
logger.debug("origin_hp %s, current_hp %s, current_damage_hp %s" % (origin_hp, boss.hp, current_damage_hp))
guild_skill_point = 0
if fight_result:
stage_item = game_configs.special_stage_config.get("guild_boss_stages").get(boss.stage_id)
guild.skill_point += stage_item.Animal_Kill_Over
guild_skill_point = stage_item.Animal_Kill_Over
boss.reset()
guild.save_data()
logger.debug("guildboss_battle_remote over===================")
guild.save_data()
return dict(
result=True,
fight_result = fight_result,
guild_skill_point = guild_skill_point,
)
def receive_rob_task(player, task_id, task_guild_id):
"""
接受劫运任务
"""
receive_rob_times = player.finance[const.GUILD_ESCORT_ROB_TIMES]
escort_open_time_item = game_configs.base_config.get("EscortOpenTime")
if not is_in_period(escort_open_time_item):
logger.error("feature not open!")
return {'result': False, 'result_no': 30000}
if receive_rob_times <= 0:
logger.error("receive_rob_times! %s" % receive_rob_times)
return {'result': False, 'result_no': 190901}
escort_component = player.escort_component
task = remote_gate["world"].get_task_by_id_remote(task_guild_id, task_id)
if task.get('state') != 2:
logger.error("task state not right! %s" % task.get("state"))
return {'result': False, 'result_no': 190902}
#if player.base_info.id in task.get('rob_task_infos') and task.get():
#logger.debug("this task has been robbed!")
#return {'result': False, 'result_no': 190902}
logger.debug("receive_rob_task, start=======")
res = remote_gate["world"].add_player_remote(task_guild_id, task_id, get_player_info(player), 2, -1, {})
logger.debug("receive_rob_task, end=======")
if res.get('result'):
escort_component.rob_records[task.get("task_id")] = dict(guild_id=task_guild_id, rob_no=res.get('task').get('rob_task_infos')[0].get('rob_no'))
escort_component.save_data()
return res
def refresh_tasks_1904(data, player):
"""刷新任务列表"""
response = escort_pb2.RefreshEscortTaskResponse()
response.res.result = True
escort_component = player.escort_component
if escort_component.refresh_times >= game_configs.base_config.get("EscortRefreshFrequencyMax"):
logger.error("reach the max refresh time!")
response.res.result = False
response.res.result_no = 190401
return response.SerializePartialToString()
price = game_configs.base_config.get("EscortRefreshPrice")
need_gold = price[escort_component.refresh_times]
def func():
escort_component.refresh_tasks() #刷新任务
escort_component.refresh_times = escort_component.refresh_times + 1
escort_component.save_data()
for _, task in escort_component.tasks.items():
task_pb = response.tasks.add()
update_task_pb(task, task_pb)
player.pay.pay(need_gold, const.REFRESH_ESCORT_TASKS, func)
tlog_action.log('RefreshEscortTasks', player, escort_component.refresh_times+1)
logger.debug("response %s" % response)
return response.SerializePartialToString()
def start_rob_escort(player, task_id, response, task_guild_id, rob_no):
"""
手动开始劫运
"""
res = remote_gate["world"].start_rob_escort_remote(task_guild_id, task_id, rob_no, player.base_info.id)
if res.get("result"):
player.finance.consume(const.GUILD_ESCORT_ROB_TIMES, 1, const.ESCORT_ROB)
player.finance.save_data()
update_rob_task_info_pb(res.get("protecters", []), res.get("rob_task_info", {}), response.rob_task_info, protect_or_rob=2)
# push info to head players
push_response = escort_pb2.InviteEscortTaskPushResponse()
task = res.get("task")
update_task_pb(task, push_response.task)
push_response.protect_or_rob = 2
logger.debug("19101 push_response %s" % push_response)
for player_info in res.get("rob_task_info", {}).get("robbers"):
remote_gate.push_object_character_remote(19101, push_response.SerializePartialToString(), [player_info.get("id")])
remote_gate.push_object_character_remote(19102, push_response.SerializePartialToString(), [task.get("protecters")[0].get("id")])
# 参与劫运次数
task = res.get("task")
for no, robber in enumerate(res.get("rob_task_info", {}).get("robbers", [])):
if res.get("rob_task_info").get("rob_result", False):
push_message("add_guild_activity_times_remote", int(robber.get("id")), task.get("task_no"), 2)
if no == 0: continue
push_message("remove_escort_in_times_remote", int(robber.get("id")), 2)
return res
def _get_balance_m(self):
if not self.REMOTE_DEPLOYED:
return
logger.debug("_get_balance_m: platform- %s\
openid- %s \
openkey - %s \
pay_token - %s \
appid - %s \
appkey - %s \
pf - %s \
pfkey - %s \
zoneid - %s "%
(self._platform, self._openid,
self._openkey, self._pay_token,
self._appid, self._appkey,
self._pf,
self._pfkey, self._zoneid))
try:
data = GlobalObject().pay.get_balance_m(self._platform, self._openid, self._appid,
self._appkey, self._openkey, self._pay_token,
self._pf, self._pfkey, self._zoneid)
logger.debug(data)
except Exception, e:
logger.error("get balance error:%s" % e)
logger.error(traceback.format_exc())
return
def send_invite(player, task_id, protect_or_rob, task_guild_id, rob_no):
"""docstring for send_invite"""
AnnouncementCoolingTime = game_configs.base_config.get("AnnouncementCoolingTime", 0)
task = remote_gate["world"].get_task_by_id_remote(task_guild_id, task_id)
if protect_or_rob == 1:
last_send_invite_time = task.get("last_send_invite_time", 0)
if last_send_invite_time + AnnouncementCoolingTime > int(get_current_timestamp()):
logger.error("last_send_invite_time %s AnnouncementCoolingTime %s current %s" % (last_send_invite_time, AnnouncementCoolingTime, int(get_current_timestamp())))
return {'result': False, 'result_no': 1908041}
if protect_or_rob == 2:
last_send_invite_time = task.get("rob_task_infos")[0].get("last_send_invite_time", 0)
if last_send_invite_time + AnnouncementCoolingTime > int(get_current_timestamp()):
logger.error("last_send_invite_time %s AnnouncementCoolingTime %s current %s" % (last_send_invite_time, AnnouncementCoolingTime, int(get_current_timestamp())))
return {'result': False, 'result_no': 1908041}
task = remote_gate["world"].send_escort_task_invite_remote(task_guild_id, task_id, player.guild.g_id, rob_no, protect_or_rob)
if not task:
logger.error("can't find this task!")
return {'result': False, 'result_no': 190801}
push_response = escort_pb2.InviteEscortTaskPushResponse()
update_task_pb(task, push_response.task)
push_response.protect_or_rob = protect_or_rob
guild_info = {}
if protect_or_rob == 1:
guild_info = task.get("protect_guild_info")
if protect_or_rob == 2:
guild_info = task.get("rob_task_infos")[0].get("rob_guild_info")
remote_gate.push_object_character_remote(19082, push_response.SerializePartialToString(), player.guild.get_guild_member_ids(guild_info.get("p_list", {})))
logger.debug("push_response %s" % push_response)
return {'result': True}
def hero_sacrifice_105(data, player):
"""武将献祭"""
args = hero_request_pb2.HeroSacrificeRequest()
args.ParseFromString(data)
response = hero_response_pb2.HeroSacrificeResponse()
heros = player.hero_component.get_heros_by_nos(args.hero_nos)
if len(heros) == 0:
logger.error("hero %s is not exists." % str(args.hero_nos))
response = hero_sacrifice_oper(heros, player)
# remove hero
player.hero_component.delete_heros_by_nos(args.hero_nos)
# hero chip
for hero_chip in args.hero_chips:
sacrifice_gain = game_configs.chip_config.get("chips").get(hero_chip.hero_chip_no).sacrificeGain
return_data = gain(player,
sacrifice_gain,
const.HERO_CHIP_SACRIFICE_OPER,
multiple=hero_chip.hero_chip_num)
get_return(player, return_data, response.gain)
# remove hero_chip
temp = player.hero_chip_component.get_chip(hero_chip.hero_chip_no)
if temp:
temp.consume_chip(hero_chip.hero_chip_num) # 消耗碎片
player.hero_chip_component.save_data()
logger.debug(response)
return response.SerializeToString()
def remove_escort_in_times_remote(protect_or_rob, is_online, player):
logger.debug("remove_escort_in_times_remote========= %s" % protect_or_rob)
if protect_or_rob == 1:
player.escort_component.protect_times += 1
else:
player.escort_component.rob_times += 1
player.escort_component.save_data()
def rand_pick_attr(attr):
attrType, attrValueType, attrValue, attrIncrement = -1, -1, -1, 0
rand_pool = {}
for at, v in attr.items():
rand_pool[at] = int(v[0] * 100)
rand = random.randint(0, sum(rand_pool.values()))
for k, v in rand_pool.items():
if v >= rand:
attrType = k
if len(attr[k]) == 5:
_, attrValueType, valueMin, valueMax, attrIncrement = attr[k]
else:
_, attrValueType, valueMin, valueMax = attr[k]
attrValue = valueMin + random.random() * (valueMax - valueMin)
# add increment formula
inputs = {'EquNumRandom': attrValue,'EquNumMax': valueMax, 'EquNumMin': valueMin, 'grow': attrIncrement}
if valueMax != valueMin:
formula = game_configs.formula_config.get("equGrowUpParameter").get("formula")
assert formula!=None, "formula can not be None"
attrIncrement = eval(formula, inputs)
else:
formula = game_configs.formula_config.get("equGrowUpParameter2").get("formula")
assert formula!=None, "formula can not be None"
attrIncrement = eval(formula, inputs)
logger.debug("increment value: %s %s" % (attrIncrement, attrIncrement))
del attr[k]
break
else:
rand -= v
return attrType, attrValueType, attrValue, attrIncrement
def pull_message_remote(character_id):
count = 0
childs = groot.childsmanager.childs
# print groot.childsmanager
logger.debug("pull all message")
for key, message in message_cache.get(character_id):
topic_id = message.get('topic_id')
character_id = int(message.get('character_id'))
args = (topic_id, character_id, message.get('args'))
kw = message.get('kw')
logger.debug("args:%s", message.get('args'))
logger.debug("message.pull_message_remote")
for child in childs.values():
if 'gate' in child.name:
result = child.pull_message_remote(*args, **kw)
logger.debug("result:%s", result)
if type(result) is bool and result:
message_cache.delete(character_id, key)
count += 1
break
return True
def update_rank_items(k, rank_item_pb, rank_item):
rank_item_pb.nickname = rank_item.get("nickname", "")
rank_item_pb.level = rank_item.get("level", 0)
rank_item_pb.vip_level = rank_item.get("vip_level", 0)
rank_item_pb.now_head = rank_item.get("now_head", 0) #rank_item.get("first_hero_no", 0)
rank_item_pb.demage_hp = int(rank_item.get("demage_hp", 0))
if rank_item.get("line_up_info"):
##rank_item_pb.line_up_info = line_up_pb2.LineUpResponse()
rank_item_pb.line_up_info.ParseFromString(rank_item.get("line_up_info"))
#line_up_info = line_up_pb2.LineUpResponse()
#rank_item_pb.line_up_info.ParseFromString()
rank_item_pb.player_id = rank_item.get("player_id", 0)
rank_item_pb.rank_no = k
logger.debug("player_id %s", rank_item_pb.player_id)
logger.debug("rank_no %s", rank_item_pb.rank_no)
logger.debug("demage_hp %s", rank_item_pb.demage_hp)
def hjqy_battle_remote(player_info, boss_id, str_red_units, red_unpar_data, attack_type, seed1, seed2):
"""开始战斗
"""
logger.debug("hjqy_battle_remote======")
red_units = cPickle.loads(str_red_units)
result = False
boss = hjqy_manager.get_boss(boss_id)
player_id = player_info.get("player_id")
player_level = player_info.get("level")
blue_units = boss.blue_units
origin_hp = boss.hp
result = hjqy_start(red_units, blue_units, red_unpar_data, {}, attack_type, seed1, seed2, player_level)
logger.debug("blue unit length %s" % len(blue_units))
boss.blue_units = blue_units
current_damage_hp = origin_hp - boss.hp
logger.debug("origin_hp %s, current_hp %s, current_damage_hp %s" % (origin_hp, boss.hp, current_damage_hp))
player_info["damage_hp"] = current_damage_hp
hjqy_manager.add_rank_item(player_info) # 添加排行
is_kill = 0
if boss.get_state() == const.BOSS_DEAD: # 击杀boss
is_kill = 1
# send last kill reward mail
hjqyKillBossReward = game_configs.base_config.get("hjqyKillBossRewardID")
mail_data, _ = deal_mail(conf_id=hjqyKillBossReward, receive_id=int(player_id))
remote_gate = GlobalObject().child('gate')
remote_gate.push_message_to_transit_remote('receive_mail_remote',
int(player_id), mail_data)
result = True
#return dict(result=result, state=boss.get_state())
logger.debug("hjqy_battle_remote over===================")
boss.save_data()
return result, boss.get_state(), current_damage_hp, is_kill
def mine_activity_jindu(self, act_conf):
"""
获取秘境活动进度
"""
parameterE = act_conf.parameterE
act_type = act_conf.type
if act_type in [56, 58]:
condition = self._act_infos.get(act_conf.id, 0)
logger.debug("condition %s" % condition)
return condition
elif act_type == 57:
condition = []
if self._act_infos.get(act_conf.id):
condition = self._act_infos.get(act_conf.id)[1]
logger.debug("condition %s" % condition)
mine_num = 0
for temp in condition:
if temp[WIN_MINE_QUALITY] >= parameterE.get(
WIN_MINE_QUALITY, 0):
mine_num += 1
return mine_num
elif act_type == 59:
condition = []
if self._act_infos.get(act_conf.id):
condition = self._act_infos.get(act_conf.id)[1]
logger.debug("condition %s" % condition)
mix_runt_num = 0
for temp in condition:
if temp[MIX_RUNT_QUALITY] >= parameterE.get(
MIX_RUNT_QUALITY, 0):
mix_runt_num += 1
return mix_runt_num
logger.debug("mine_activity_jindu act_type %s haven't process!" %
act_type)
return None
def google_consume_verify_10002(data, player):
request = google_pb2.GoogleConsumeVerifyRequest()
request.ParseFromString(data)
logger.debug(request)
response = google_pb2.GoogleConsumeVerifyResponse()
response.res.result = False
result = verify_signature(request.signature, request.data)
logger.debug('verify_signature:%s', result)
data = eval(request.data)
recharge_item = game_configs.recharge_config.get('android').get(
data.get('productId'))
if result:
if recharge_item is None:
logger.debug('google consume goodid not in rechargeconfig:%s',
data.get('productId'))
else:
player.recharge.recharge_gain(recharge_item, response, 3) #发送奖励邮件
response.res.result = True
logger.debug(response)
return response.SerializeToString()
def refresh_shop_items_507(pro_data, player):
"""刷新商品列表"""
request = shop_pb2.RefreshShopItems()
request.ParseFromString(pro_data)
shop_type = request.shop_type
response = shop_pb2.GetShopItemsResponse()
if not player.shop.check_shop_refresh_times(shop_type):
logger.debug("already reach refresh max!")
response.res.result = False
response.res.result_no = 50701
return response.SerializePartialToString()
response.res.result = player.shop.refresh_price(shop_type, response)
if not response.res.result:
logger.debug("gold not enough!")
response.res.result = False
response.res.result_no = 50702
return response.SerializePartialToString()
shopdata = player.shop.get_shop_data(shop_type)
if not shopdata:
response.res.result = False
return response.SerializePartialToString()
for x in shopdata['item_ids']:
response.id.append(x)
for k, v in shopdata['items'].items():
items = response.items.add()
items.item_id = k
items.item_num = v
for k, v in shopdata['all_items'].items():
all_items = response.all_items.add()
all_items.item_id = k
all_items.item_num = v
for k, v in shopdata['guild_items'].items():
guild_items = response.guild_items.add()
guild_items.item_id = k
guild_items.item_num = v
response.luck_num = int(shopdata['luck_num'])
response.refresh_times = int(shopdata['refresh_times'])
logger.debug("response %s", response)
tlog_action.log('RefreshShop', player, shop_type,
int(shopdata['refresh_times']))
return response.SerializeToString()
def pull_message_remote(key, character_id, args):
oldvcharacter = VCharacterManager().get_by_id(character_id)
logger.debug("pull_message_remote =============,args:%s", args)
if oldvcharacter:
if isinstance(args, tuple):
args = (key, oldvcharacter.dynamic_id) + args + (False, )
else:
args = (key, oldvcharacter.dynamic_id, args, False)
logger.debug(args)
logger.debug(oldvcharacter.node)
child_node = groot.child(oldvcharacter.node)
result = child_node.callbackChild(*args)
# logger('gate found character to pull message:%s %s %s',
# oldvcharacter.__dict__, args, result)
return result
else:
return False
def recharge_huawei_response():
logger.debug('huawei recharge:%s', request.form)
# userName = request.form['userName']
# orderId = request.form['orderId']
# orderTime = request.form['orderTime']
# spending = request.form['spending']
# accessMode = request.form['accessMode']
# payType = request.form['payType']
# productName = request.form['productName']
amount = request.form['amount']
# tradeTime = request.form['tradeTime']
# result = request.form['result']
# notifyTime = request.form['notifyTime']
# sign = request.form['sign']
requestId = request.form['requestId']
extReserved = request.form['extReserved']
# 验证签名
# if sign != hashlib.md5(appid + orderSerial + cooperatorOrderSerial +
# content + secretkey).hexdigest():
# resultCode = "10001"
# resultMsg = "Sign无效"
# print 'error:', sign, 'md5:', hashlib.md5(
# appid + orderSerial + cooperatorOrderSerial + content +
# secretkey).hexdigest()
# return resultMsg
player_id = int(requestId.split('_')[0])
oldvcharacter = VCharacterManager().get_by_id(player_id)
if not oldvcharacter:
logger.error('fail get player node:%s', player_id)
return json.dumps(dict(result=3))
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.huawei_recharge_remote(oldvcharacter.dynamic_id,
extReserved, amount, requestId,
True)
if result is True:
logger.debug('response:success')
return json.dumps(dict(result=0))
logger.debug('response:failed')
return json.dumps(dict(result=3))
def hero_break_logic(hero_no, player, response):
if is_not_open(player, FO_HERO_BREAK):
return {'result': False, 'result_no': 837}
hero = player.hero_component.get_hero(hero_no)
hero_info = game_configs.hero_config.get(hero_no)
break_through = game_configs.base_config.get('breakthrough')
target_break_level = hero.break_level + 1
logger.debug("target_break_level %s" % target_break_level)
if target_break_level not in break_through:
logger.debug("hero_break_logic can find target break level %s" % target_break_level)
return {"result": False, "result_no": 10401}
if hero.level < break_through[target_break_level][0]:
logger.debug("hero_break_logic level is not enough %s" % hero.level)
return {"result": False, "result_no": 10402}
# 验证武将是否突破到上限
if hero.break_level == hero_info.breakLimit:
return {"result": False, "result_no": 201}
consume_info = hero_info.get('consume' + str(hero.break_level+1))
item_group = parse(consume_info)
hero_info = game_configs.hero_config.get(hero.hero_no)
# 判断是否足够
result = is_afford(player, item_group) # 校验
if not result.get('result'):
return {"result": False, "result_no": result.get('result_no')}
# 返回消耗
return_data = consume(player, item_group, const.HERO_BREAK)
get_return(player, return_data, response.consume)
for item in item_group:
if item.item_type == 105 and item.item_no == 20006:
hero.break_item_num += item.num
hero.save_data()
hero.break_level += 1
notice_item = game_configs.notes_config.get(2003)
if hero.break_level in notice_item.parameter1:
push_notice(2003, player_name=player.base_info.base_name, hero_no=hero.hero_no, hero_break_level=hero.break_level)
hero.save_data()
# 3、返回
tlog_action.log('HeroBreak', player, hero_no, hero.break_level)
return {"result": True, "break_level": hero.break_level, "break_item_num": hero.break_item_num}
def google_consume_10001(data, player):
request = google_pb2.GoogleConsumeRequest()
request.ParseFromString(data)
logger.debug(request)
player.base_info.set_google_consume_data(request.data)
response = google_pb2.GoogleConsumeResponse()
response.res.result = True
data = eval(request.data)
recharge_item = game_configs.recharge_config.get('android').get(
data.get('productId'))
if recharge_item is None:
response.res.result = False
logger.debug('google product id is not in rechargeconfig:%s',
data.get('productId'))
logger.debug(response)
return response.SerializeToString()
def get_sign_in_1400(pro_data, player):
"""获取签到初始化信息"""
response = GetSignInResponse()
sign_in_component = player.sign_in_component
logger.debug("get_sign_in %s" % sign_in_component.sign_round)
sign_in_component.clear_sign_days()
logger.debug("get_sign_in %s" % sign_in_component.sign_round)
[response.days.append(i) for i in sign_in_component.sign_in_days]
response.sign_round = sign_in_component.sign_round
response.current_day = sign_in_component.current_day()
[
response.continuous_sign_in_prize.append(i)
for i in sign_in_component.continuous_sign_in_prize
]
response.repair_sign_in_times = sign_in_component.repair_sign_in_times
[
response.box_sign_in_prize.append(i)
for i in sign_in_component.box_sign_in_prize
]
logger.debug("get_sign_in: %s" % response)
return response.SerializePartialToString()
def recharge_meizu_response():
logger.debug('meizu recharge:%s', request.form)
# uid = request.form['uid']
# order_id = request.form['order_id']
# app_id = request.form['app_id']
# sign = request.form['sign']
# buy_amount = request.form['buy_amount']
# create_time = request.form['create_time']
# pay_time = request.form['pay_time']
# trade_status = request.form['trade_status']
# partner_id = request.form['partner_id']
product_id = request.form['product_id']
# pay_type = request.form['pay_type']
# total_price = request.form['total_price']
product_per_price = request.form['product_per_price']
# product_unit = request.form['product_unit']
cp_order_id = request.form['cp_order_id']
# user_info = request.form['user_info']
# sign_type = request.form['sign_type']
# notify_time = request.form['notify_time']
# notify_id = request.form['notify_id']
player_id = int(cp_order_id.split('_')[0])
oldvcharacter = VCharacterManager().get_by_id(player_id)
if not oldvcharacter:
logger.error('fail get player node:%s', player_id)
return json.dumps(dict(code=120014, message='', value='', redirect=''))
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.meizu_recharge_remote(oldvcharacter.dynamic_id,
product_id, product_per_price,
cp_order_id, True)
if result is True:
logger.debug('response:success')
return json.dumps(dict(code=200, message='', value='', redirect=''))
logger.debug('response:failed')
return json.dumps(dict(code=120014, message='', value='', redirect=''))
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 refresh_shop_items_507(pro_data, player):
"""刷新商品列表"""
shop = GetShopItemsResponse()
max_shop_refresh_times = player.vip_component.shop_refresh_times
# cancel vip temprory
# if max_shop_refresh_times <= player.soul_shop.refresh_times:
# logger.debug("already reach refresh max!")
# shop.res.result = False
# shop.res.result_no = 501
# return shop.SerializePartialToString()
price = player.soul_shop.price
if player.finance.gold < price:
logger.debug("gold not enough!")
shop.res.result = False
shop.res.result_no = 101
return shop.SerializePartialToString()
ids = get_shop_item_ids()
player.soul_shop.refresh_times += 1
player.soul_shop.last_refresh_time = int(time.time())
player.soul_shop.save_data()
player.finance.gold -= price
logger.debug("refresh price:" + str(price))
player.finance.save_data()
logger.debug("soul ids:" + str(ids))
for x in ids:
shop.id.append(x)
# save soul shop item ids
player.soul_shop.item_ids = ids
player.soul_shop.save_data()
shop.res.result = True
return shop.SerializeToString()
def uc_recharge_remote(product_id, order_id, is_online, player):
logger.debug('uc_recharge_remote:%s-%s', product_id, order_id)
if player.base_info.one_dollar_flowid == order_id:
player.base_info.one_dollar_flowid = 'done'
logger.debug('one dollar is ok! %s', product_id)
recharge_item = game_configs.recharge_config.get('android').get(product_id)
if recharge_item is None:
logger.error('not in rechargeconfig:%s', product_id)
return False
# if float(fee) != recharge_item.get('currence'):
# logger.error('recharge fee is wrong:%s-%s', fee,
# recharge_item.get('currence'))
# return False
response = apple_pb2.AppleConsumeVerifyResponse()
response.res.result = True
player.recharge.recharge_gain(recharge_item, response, 12) # 发送奖励邮件
remote_gate.push_object_remote(12007, response.SerializeToString(),
[player.dynamic_id])
logger.debug('uc response:%s', response)
return True
def fight_settlement(stage, result, player, star_num, response):
res = response.res
res.result = True
stage_id = stage.stage_id
# 校验是否保存关卡
fight_cache_component = player.fight_cache_component
if stage_id != fight_cache_component.stage_id:
res.result = False
res.message = u"关卡id和战斗缓存id不同"
return response.SerializeToString()
stage.settle(result, response, star_num=star_num)
# 触发黄巾起义
hjqy_stage_id = trigger_hjqy(player, result)
response.hjqy_stage_id = hjqy_stage_id
if hjqy_stage_id:
tlog_action.log('TriggerHJQY', player, stage_id, hjqy_stage_id)
response.battle_res = result
response.star_num = star_num
logger.debug("drops %s" % response.drops)
logger.debug("star_num %s" % response.star_num)
logger.debug("consume %s" % response.consume)
return response.SerializePartialToString()
def check_time(self, resource_type):
"""docstring for _check_time"""
item = self.get_item(resource_type)
info = self.get_info(resource_type, self._owner)
current_time = int(time.time())
logger.debug("info %s" % info)
stamina_add = 0
if info.get("recover_period"):
stamina_add = (current_time - item.last_gain_stamina_time) / info.get("recover_period")
# left_stamina = (current_time - item.last_gain_stamina_time) % info.get("recover_period")
logger.debug("stamina_add %s " % (stamina_add,))
if self.owner.finance[resource_type] < info.get("max_value"):
# 如果原来的超出上限，则不添加
_value = self.owner.finance[resource_type] + int(stamina_add)
if _value < 0:
_value = 0
self.owner.finance._finances[resource_type] = min(_value, info.get("max_value"))
if int(stamina_add) > 0 or int(stamina_add) < 0:
item.last_gain_stamina_time = current_time
if is_next_day(time.time(), item.last_buy_stamina_time):
item.buy_stamina_times = 0
self._owner.finance.save_data()
logger.debug("check_time finance %s" % self.owner.finance._finances)
if resource_type != const.STAMINA:
return
# 体力相关
tm = time.localtime(item.last_mail_day)
dateNow = int(time.time())
local_tm = time.localtime(dateNow)
if local_tm.tm_year != tm.tm_year or local_tm.tm_yday != tm.tm_yday:
item.last_mail_day = dateNow
item.get_stamina_times = 0
item.ClearField('contributors')
def get_player_friend_list_1106(data, player):
response = friend_pb2.GetPlayerFriendsResponse()
response.open_receive = player.stamina._open_receive
# 小伙伴支援
player.friends.check_time()
# if is_next_day(time.time(), player.friends.fight_last_time):
# # clear data in the next day
# player.friends.fight_times = {}
# player.friends.save_data()
_update = False
for pid in player.friends.friends + [player.base_info.id]:
player_data = tb_character_info.getObj(pid)
if player_data.exists():
response_friend_add = response.friends.add()
friend_data = player_data.hmget(['conditions_day', 'last_day'])
response_friend_add.gift = player.friends.last_present_times(pid)
conditions_day = friend_data.get('conditions_day', {})
lively = conditions_day.get(24, 0)
today = time.strftime("%Y%m%d", time.localtime(time.time()))
if today != time.strftime(
"%Y%m%d", time.localtime(friend_data.get('last_day',
'0'))):
lively = 0
response_friend_add.current = lively
response_friend_add.target = game_configs.base_config[
'friendActivityValue']
stat, update = player.friends.get_reward(pid, today)
if update:
_update = True
response_friend_add.stat = stat
# 添加好友主将的属性
_with_battle_info(response_friend_add, player_data)
response_friend_add.gift = player.friends.last_present_times(pid)
response_friend_add.fight_last_time = int(
player.friends.fight_times.get(pid, [0])[0])
response_friend_add.fight_times = len(
player.friends.fight_times.get(pid, []))
else:
logger.error('friend_list, cant find player id:%d' % pid)
player.friends.friends.remove(pid)
if _update:
player.friends.save_data()
for pid in player.friends.blacklist:
player_data = tb_character_info.getObj(pid)
if player_data.exists():
response_blacklist_add = response.blacklist.add()
# 添加好友主将的属性
_with_battle_info(response_blacklist_add, player_data)
else:
logger.error('black_list cant find player id:%d' % pid)
player.friends.blacklist.remove(pid)
for pid in player.friends.applicant_list:
player_data = tb_character_info.getObj(pid)
if player_data.exists():
response_applicant_list_add = response.applicant_list.add()
# 添加好友主将的属性
_with_battle_info(response_applicant_list_add, player_data)
else:
logger.error('applicant_list, cant find player id:%d' % pid)
player.friends.applicant_list.remove(pid)
logger.debug("response.friends %s" % response.friends)
return response.SerializePartialToString()
def fight_settlement_904(pro_data, player):
request = stage_request_pb2.StageSettlementRequest()
request.ParseFromString(pro_data)
logger.debug("fight_settlement_904 id: %s player_id: %s" %
(player.fight_cache_component.stage_id, player.base_info.id))
stage_id = request.stage_id
result = request.result
always_win = request.always_win
# logger.debug("steps:%s", request.steps)
# player.fight_cache_component.red_units
stage = player.stage_component.get_stage(stage_id)
stage_config = player.fight_cache_component._get_stage_config()
response = stage_response_pb2.StageSettlementResponse()
res = response.res
check_res = (True, 1, 1, -1, {})
if not always_win:
if (stage_config.type not in [1, 2, 3]
or stage.star_num != 3) and request.is_skip:
logger.error(
"can not be skip error!================= common stage")
res.result = False
res.result_no = 9041
return response.SerializePartialToString()
if (stage_config.type == 4 or stage.state != 1) and request.is_skip:
logger.error("can not be skip error!=================hide stage")
res.result = False
res.result_no = 9041
return response.SerializePartialToString()
if request.is_skip and stage.state != 1:
logger.error("can not be skip error!=================2")
res.result = False
res.result_no = 9041
return response.SerializePartialToString()
if not request.is_skip:
check_res = pve_process_check(player, result, request.steps,
const.BATTLE_PVE)
if not request.is_skip and not check_res[0]:
logger.error("pve_process_check error!=================")
os.system("cp output ..")
res.result = False
res.result_no = 9041
return response.SerializePartialToString()
# 小伙伴支援消耗
fid = player.fight_cache_component.fid
if fid:
player.friends.check_time()
friend_fight_times = player.friends.fight_times
if fid not in friend_fight_times:
friend_fight_times[fid] = []
supportPrice = game_configs.base_config.get('supportPrice')
f_times = len(friend_fight_times[fid])
price = None
for _ in sorted(supportPrice.keys()):
if f_times >= _:
price = supportPrice[_]
# todo calculate real price
if not is_afford(player, price).get('result'):
logger.error('stage 903 not enough money!:%s', price)
response.res.result = False
response.res.result_no = 101
return response.SerializePartialToString()
return_data = consume(player, price, const.STAGE)
get_return(player, return_data, response.consume)
friend_fight_times[fid].append(int(time.time()))
player.friends.save_data()
logger.debug("damage percent: %s" % check_res[1])
logger.debug("red units: %s" % check_res[2])
player.fight_cache_component.damage_percent = check_res[1]
star = 0 # star num
stage_info = player.fight_cache_component.stage_info
red_units = stage_info.get('red_units')
round_to_kill_num = check_res[4]
red_left_num = check_res[3]
red_left_hp_percent = check_res[2]
death_num = len(red_units) - red_left_num
for i in range(1, 4):
star_condition = game_configs.base_config.get('star_condition')
v = star_condition[i]
if death_num >= v and red_left_num != 0:
star = i
break
if request.is_skip:
star = 3
stage = get_stage_by_stage_type(stage_config.type, stage_id, player)
if stage_config.type == 6 and result:
logger.debug("it is a elite stage!")
conditions = stage_config.ClearanceConditions
for k, cond in conditions.items():
logger.debug("k %s %s condi %s" % (k, type(k), cond))
if k == 1 and (cond[0] in round_to_kill_num
and round_to_kill_num[cond[0]] < cond[1]):
logger.debug("elite condition 1 is not met!")
result = False
break
if k == 2 and (death_num > cond[0]):
logger.debug("elite condition 2 is not met!")
result = False
break
if k == 3 and (red_left_hp_percent < cond[0]):
logger.debug("elite condition 3 is not met!")
result = False
break
if always_win and stage_id in game_configs.stage_show_config:
# 新手引导中的假战斗，必胜，三星
result = True
star = 3
res = fight_settlement(stage, result, player, star, response)
logger.debug("steps:%s", request.steps)
logger.debug("fight_settlement_904 end: %s" % time.time())
return res
def func():
# 武将乱入
fight_cache_component = player.fight_cache_component
fight_cache_component.stage_id = stage_id
red_units, blue_units, drop_num, monster_unpara = fight_cache_component.fighting_start(
)
multiple, part_multiple = get_drop_activity(
player, player.fight_cache_component.stage_id, 1,
stage_obj.star_num)
for _ in range(times):
drop = []
drops = response.drops.add()
low = stage_config.low
high = stage_config.high
drop_num = random.randint(low, high)
for __ in range(drop_num):
common_bag = BigBag(stage_config.commonDrop)
common_drop = common_bag.get_drop_items()
drop.extend(common_drop)
fight_cache_component.get_stage_drop(stage_config, drop)
data = gain(player,
drop,
const.STAGE_SWEEP,
event_id=tlog_event_id,
multiple=multiple,
part_multiple=part_multiple)
get_return(player, data, drops)
# 乱入武将按概率获取碎片
break_stage_id = player.fight_cache_component.break_stage_id
if break_stage_id:
break_stage_info = game_configs.stage_break_config.get(
break_stage_id)
ran = random.random()
if ran <= break_stage_info.reward_odds:
# logger.debug("break_stage_info=============%s %s" % (break_stage_info.reward, 1))
data = gain(player, break_stage_info.reward,
const.STAGE_SWEEP)
get_return(player, data, drops)
player.finance.consume(const.STAMINA, stage_config.vigor,
const.STAGE_SWEEP)
# 经验
for (slot_no, lineUpSlotComponent
) in player.line_up_component.line_up_slots.items():
hero = lineUpSlotComponent.hero_slot.hero_obj
if hero:
beforelevel = hero.level
hero.upgrade(stage_config.HeroExp, player.base_info.level)
afterlevel = hero.level
changelevel = afterlevel - beforelevel
hero.save_data()
if changelevel:
tlog_action.log('HeroUpgrade', player, hero.hero_no,
changelevel, afterlevel, 3, 0, 0, 0, 0)
# 玩家金钱
player.finance.coin += stage_config.currency
# 玩家经验
player.base_info.addexp(stage_config.playerExp, const.STAGE_SWEEP)
# 更新等级相关属性
player.set_level_related()
# hook task
hook_task(player, CONDITIONId.ANY_STAGE, times)
logger.debug("sweep time %s %s" % (times, sweep_item))
return_data = consume(player,
sweep_item,
const.STAGE_SWEEP,
multiple=times)
get_return(player, return_data, response.consume)
player.stage_component.get_stage(stage_id).attacks += times
player.stage_component.save_data()
player.stamina.save_data()
player.base_info.save_data()
player.finance.save_data()
def stage_start_903(pro_data, player):
"""pve开始战斗
"""
request = stage_request_pb2.StageStartRequest()
request.ParseFromString(pro_data)
stage_id = request.stage_id # 关卡编号
line_up = request.lineup # 阵容顺序
red_best_skill_id = request.unparalleled # 无双编号
fid = request.fid # 好友ID
# logger.debug("red_best_skill_id,%s" % red_best_skill_id)
# logger.debug("fid,%s" % fid)
response = stage_response_pb2.StageStartResponse()
player.fight_cache_component.stage_id = stage_id
stage_config = player.fight_cache_component._get_stage_config()
not_open = False
if stage_config.type == 6: # 精英
not_open = is_not_open(player, FO_ELI_STAGE)
if stage_config.type in [4, 5]: # 活动
not_open = is_not_open(player, FO_ACT_STAGE)
if not_open:
response.res.result = False
response.res.result_no = 837
return response.SerializeToString()
stage_info = pve_process(stage_id, stage_config.type, line_up, fid, player)
result = stage_info.get('result')
res = response.res
res.result = result
if not result:
# logger.info('进入关卡返回数据:%s', response)
res.result_no = stage_info.get('result_no')
return response.SerializePartialToString()
red_units = stage_info.get('red_units')
blue_groups = stage_info.get('blue_units')
drop_num = stage_info.get('drop_num')
blue_skill = stage_info.get('monster_unpara')
f_unit = stage_info.get('f_unit')
pve_assemble_units(red_units, blue_groups, response)
pve_assemble_friend(f_unit, response)
if blue_skill:
response.monster_unpar = blue_skill
response.hero_unpar = 0
response.hero_unpar_level = 0
response.drop_num = drop_num
seed1, seed2 = get_seeds()
player.fight_cache_component.seed1 = seed1
player.fight_cache_component.seed2 = seed2
player.fight_cache_component.red_best_skill_id = red_best_skill_id
player.fight_cache_component.stage_info = stage_info
response.seed1 = seed1
response.seed2 = seed2
if f_unit:
player.fight_cache_component.fid = fid
else:
player.fight_cache_component.fid = 0
player.fight_cache_component.red_best_skill_id = 0
logger.debug(response)
return response.SerializePartialToString()
def deal_random_1829(pro_data, player):
"""处理随机出来的倍数，领取或者放弃
"""
request = stage_request_pb2.DealRandomRequest()
request.ParseFromString(pro_data)
chapter_id = request.chapter_id
response = stage_response_pb2.DealRandomResponse()
chapters_info = get_chapter_info(chapter_id, player)
if len(chapters_info) != 1 or chapter_id == 1 or len(
chapters_info[0].award_info) == 0:
logger.error(
"deal_random_1829,chapter_info dont find, chapter_id == 1")
response.res.result = False
response.res.result_no = 800
return response.SerializePartialToString()
else:
chapter_obj = chapters_info[0]
chapter_conf = chapter_obj.get_conf()
chapter_obj.update(player.stage_component.calculation_star(chapter_id))
if chapter_obj.star_gift != 3 or chapter_obj.random_gift_times == 0:
response.res.result = False
response.res.result_no = 800
logger.error(
"deal_random_1829, chapter_obj.star_gift != 3 or chapter_obj.random_gift_times == 0"
)
return response.SerializePartialToString()
drop_num = game_configs.lottery_config.get(
chapter_obj.now_random).Magnification
if request.res == 1:
return_data = gain(player,
chapter_conf.dragonGift,
const.STAGE_STAR_GIFT,
multiple=drop_num) # 获取
return_data1 = []
for rd in return_data:
if not return_data1:
return_data1.append(return_data[0])
else:
return_data1[0][1] += rd[1]
get_return(player, return_data1, response.drops)
chapter_obj.star_gift = 1
else: # res 为2， 放弃
random_num_conf = game_configs.lottery_config.get(
chapter_obj.now_random)
if not random_num_conf.Probability:
# 已经达到最大值
response.res.result = False
response.res.result_no = 800
logger.error("get_star_random_1828, now_random max")
return response.SerializePartialToString()
chapter_obj.star_gift = 2
tlog_action.log('DealStarRandom', player, chapter_obj.now_random,
request.res, chapter_id)
player.stage_component.save_data()
response.res.result = True
logger.debug(response)
return response.SerializeToString()
def get_star_random_1828(pro_data, player):
"""取得满星抽奖随机倍数
"""
request = stage_request_pb2.GetStarRandomRequest()
request.ParseFromString(pro_data)
chapter_id = request.chapter_id
response = stage_response_pb2.GetStarRandomResponse()
chapters_info = get_chapter_info(chapter_id, player)
chapter_obj = chapters_info[0]
chapter_conf = chapter_obj.get_conf()
chapter_obj.update(player.stage_component.calculation_star(chapter_id))
if not chapter_conf.starMagnification or len(
chapters_info[0].award_info) == 0:
logger.error(
"get_star_random_1828, not chapter_conf.starMagnification or len(chapters_info[0].award_info) == 0"
)
response.res.result = False
response.res.result_no = 831
return response.SerializePartialToString()
if chapter_obj.star_gift == 1:
response.res.result = False
response.res.result_no = 800
logger.error("get_star_random_1828, alreaday get gift")
return response.SerializePartialToString()
# chapter_obj.random_gift_times
if not chapter_obj.now_random:
chapter_obj.now_random = chapter_conf.starMagnification
random_num_conf = game_configs.lottery_config.get(chapter_obj.now_random)
if not random_num_conf.Probability:
# 已经达到最大值
response.res.result = False
response.res.result_no = 800
logger.error("get_star_random_1828, now_random max")
return response.SerializePartialToString()
need_gold = game_configs.base_config.\
get('LotteryPrice')[chapter_obj.random_gift_times]
if need_gold > player.finance.gold:
response.res.result = False
response.res.result_no = 102
return response.SerializeToString()
def func():
random_num = 10005
if not request.is_newbee:
random_num = do_get_star_random(random_num_conf)
response.random_num = random_num
chapter_obj.now_random = random_num
chapter_obj.random_gift_times += 1
chapter_obj.star_gift = 3
player.stage_component.save_data()
tlog_action.log('StarRandom', player, random_num,
chapter_obj.random_gift_times, chapter_id)
player.pay.pay(need_gold, const.STAGE_STAR_GIFT, func)
response.res.result = True
logger.debug(response)
return response.SerializeToString()
def hero_sacrifice_oper(heros, player):
"""
武将献祭，返回总武魂、经验药水
:param heros: 被献祭的武将
:return total_hero_soul:总武魂数量, exp_item_no:经验药水编号, exp_item_num:经验药水数量
"""
total_exp = 0
exp_item_no = 0
exp_item_num = 0
awake_item_no = 90001
awake_item_num = 0
break_item_no = 20006
break_item_num = 0
response = hero_response_pb2.HeroSacrificeResponse()
if is_not_open(player, FO_HERO_SACRIFICE):
response.res.result = False
response.res.result_no = 837
return response
gain_response = response.gain
for hero in heros:
sacrifice_gain = game_configs.hero_config.get(hero.hero_no).sacrificeGain
return_data = gain(player, sacrifice_gain, const.HERO_SACRIFICE_OPER)
get_return(player, return_data, gain_response)
# 经验
exp = hero.get_all_exp()
total_exp += exp
tlog_action.log('HeroSacrifice', player, hero.hero_no)
# 觉醒丹
awake_item_num += hero.awake_item_num
# 突破丹
break_item_num += hero.break_item_num
# baseconfig {1000000: 'item_id'}
logger.debug("total_exp %s" % total_exp)
formula_info = game_configs.formula_config.get("sacrificeExp_3")
pre_formula = formula_info.get("precondition")
formula = formula_info.get("formula")
cal_vars = dict(expHero=total_exp)
if eval(pre_formula, cal_vars):
exp_item_no = 10003
exp_item_num = eval(formula, cal_vars)
formula_info = game_configs.formula_config.get("sacrificeExp_2")
pre_formula = formula_info.get("precondition")
formula = formula_info.get("formula")
cal_vars = dict(expHero=total_exp)
if eval(pre_formula, cal_vars):
exp_item_no = 10002
exp_item_num = eval(formula, cal_vars)
formula_info = game_configs.formula_config.get("sacrificeExp_1")
pre_formula = formula_info.get("precondition")
formula = formula_info.get("formula")
cal_vars = dict(expHero=total_exp)
if eval(pre_formula, cal_vars):
exp_item_no = 10001
exp_item_num = eval(formula, cal_vars)
heroAwakeBack = game_configs.base_config.get('heroAwakeBack')
heroBreakBack = game_configs.base_config.get('heroBreakBack')
awake_item_num = int(awake_item_num * heroAwakeBack)
break_item_num = int(break_item_num * heroBreakBack)
player.item_package.add_item(Item(exp_item_no, exp_item_num))
player.item_package.add_item(Item(awake_item_no, awake_item_num))
player.item_package.add_item(Item(break_item_no, break_item_num))
player.item_package.save_data()
if exp_item_no:
item_pb = gain_response.items.add()
item_pb.item_no = exp_item_no
item_pb.item_num = exp_item_num
if awake_item_num:
item_pb = gain_response.items.add()
item_pb.item_no = awake_item_no
item_pb.item_num = awake_item_num
if break_item_num:
item_pb = gain_response.items.add()
item_pb.item_no = break_item_no
item_pb.item_num = break_item_num
response.res.result = True
# print "*"*80
# print response
return response
def trigger_hjqy(player, result, times=1):
"""docstring for trigger_hjqy 触发黄巾起义
return: stage id
"""
if is_not_open(player, FO_HJQY_STAGE):
return 0
# 如果战败则不触发
if not result:
return 0
logger.debug("trigger_hjqy")
# 活动是否开启
if player.base_info.is_firstday_from_register(const.OPEN_FEATURE_HJQY):
logger.debug("hjqy have not open.")
return 0
# 如果已经触发过hjqy，则不触发
if not remote_gate['world'].is_can_trigger_hjqy_remote(
player.base_info.id):
return 0
stage_info = player.fight_cache_component._get_stage_config()
if stage_info.type not in [1, 2, 3]:
# 只有在剧情关卡时，才能触发黄巾起义
return 0
logger.debug(stage_info.chapter)
logger.debug(stage_info.type)
logger.debug(stage_info.id)
logger.debug("can_trigger_hjqy")
# 触发hjqy
open_stage_id = player.stage_component.stage_progress
player.fight_cache_component.stage_id = open_stage_id
stage_info = player.fight_cache_component._get_stage_config()
#rate = 0.01 # for test
hjqytrigger = game_configs.base_config.get("hjqytrigger")
hjqyRandomCheckpoint = game_configs.base_config.get("hjqyRandomCheckpoint")
rate = 1
for i in range(times):
rate = random.random()
if rate <= hjqytrigger[0]:
break
logger.debug("rate: %s, hjqytrigger:%s" % (rate, hjqytrigger))
if rate > hjqytrigger[0]:
return 0
info = {}
for i in range(1, 4):
info[i] = hjqytrigger[i]
stage_index = random_pick_with_weight(info)
logger.debug(
"chapter: %s, stage_index: %s, stage_id: %s, open_stage_id: %s" %
(stage_info.chapter, stage_index,
player.fight_cache_component.stage_id, open_stage_id))
if stage_info.chapter not in hjqyRandomCheckpoint:
return 0
stage_id = hjqyRandomCheckpoint.get(stage_info.chapter)[stage_index - 1]
monster_lv = hjqyRandomCheckpoint.get(stage_info.chapter)[3]
hjqyRule2 = game_configs.base_config.get("hjqyRule2")
if monster_lv - player.base_info.level > hjqyRule2:
logger.debug("monster_lv %s, player.base_info.level %s, hjqyRule2 %s" %
(monster_lv, player.base_info.level, hjqyRule2))
if (stage_info.chapter - 1) not in hjqyRandomCheckpoint:
return 0
stage_id = hjqyRandomCheckpoint.get(stage_info.chapter -
1)[stage_index - 1]
player.fight_cache_component.stage_id = stage_id
blue_units = player.fight_cache_component._assemble_monster()
str_blue_units = cPickle.dumps(blue_units[0])
result = remote_gate['world'].create_hjqy_remote(
player.base_info.id, player.base_info.base_name, str_blue_units,
stage_id)
logger.debug("8============= %s %s" % (stage_id, open_stage_id))
if not result:
return 0
# send trigger reward
hjqyOpenReward = game_configs.base_config.get("hjqyOpenRewardID")
send_mail(conf_id=hjqyOpenReward, receive_id=player.base_info.id)
return stage_id
def do_hero_awake(player, hero_no, awake_item_num, response):
"""docstring for do_hero_awake"""
if is_not_open(player, FO_HERO_AWAKE):
return {'result': False, 'result_no': 837}
hero = player.hero_component.get_hero(hero_no)
if not hero:
logger.error("hero not exist! hero_no %s" % hero_no)
return {'result': False, 'result_no': 11901}
awake_info = game_configs.awake_config.get(hero.awake_level)
logger.debug("hero.awake_level %s, hero_no %s, awake_item_num %s" % (hero.awake_level, hero_no, awake_item_num))
singleConsumption = awake_info.singleConsumption
logger.debug("singleConsumption %s" % singleConsumption)
singleCoin = awake_info.silver
if not is_afford(player, singleConsumption).get("result"):
logger.error("singleConsumption is not afford!")
return {'result': False, 'result_no': 11902}
if not is_afford(player, singleCoin).get("result"):
logger.error("singleCoin is not afford!")
return {'result': False, 'result_no': 11903}
if hero.awake_level >= 10:
logger.error("the hero has reached the max awake level!")
return {'result': False, 'result_no': 11904}
singleConsumptionNum = singleConsumption[0].num
left_awake_item = awake_item_num
before_num = hero.awake_item_num
while left_awake_item >= singleConsumptionNum:
# consume
if not is_afford(player, singleConsumption) or \
not is_afford(player, singleCoin):
break
return_data1 = consume(player, singleConsumption, const.HERO_AWAKE)
return_data2 = consume(player, singleCoin, const.HERO_AWAKE)
get_return(player, return_data1, response.consume)
get_return(player, return_data2, response.consume)
# record awake item num
hero.awake_item_num += singleConsumptionNum
# trigger or not, add exp, add level
exp_percent = hero.awake_exp * 1.0 / awake_info.experience
is_trigger = False
for k in sorted(awake_info.triggerProbability.keys(), reverse=True):
if exp_percent > k:
v = awake_info.triggerProbability[k]
target_percent = random.uniform(v[0], v[1])
if random.random() < target_percent:
is_trigger = True
break
if is_trigger: # 触发满级概率
logger.debug("is_trigger!")
hero.awake_exp = 0
hero.awake_level += 1
break
else:
logger.debug("not is_trigger!")
hero.awake_exp += singleConsumptionNum
if hero.awake_exp >= awake_info.experience:
hero.awake_exp = hero.awake_exp - awake_info.experience
hero.awake_level += 1
left_awake_item -= singleConsumptionNum
# actual_consume_item_num = 0
hero.save_data()
response.awake_level = hero.awake_level
response.awake_exp = hero.awake_exp
response.awake_item_num = hero.awake_item_num
use_num = hero.awake_item_num - before_num
tlog_action.log('HeroAwake', player, hero_no, use_num, hero.awake_level-1)
return {'result': True}
def enhance_equipment(equipment_id, enhance_type, player):
"""装备强化
@param dynamic_id: 客户端动态ID
@param equipment_id: 装备ID
@param enhance_type: 强化类型
@param kwargs:
@return:
"""
if is_not_open(player, FO_EQUIP_ENHANCE):
return {"result": False, "result_no": 837}
equipment_obj = player.equipment_component.get_equipment(equipment_id)
# print equipment_obj, "equipment_obj"
if enhance_type == 2 and not player.base_info.equipment_strength_one_key:
logger.debug('enhance_equipment_vip_error!%d' %
player.base_info.equipment_strength_one_key)
return {'result': False, 'result_no': 403, 'message': u''}
if not equipment_obj:
logger.debug('enhance_equipment_no_equipment!')
return {'result': False, 'result_no': 401, 'message': u''}
enhance_record = []
curr_coin = player.finance.coin # 用户金币
# curr_coin = 1000000
enhance_cost = equipment_obj.attribute.enhance_cost # 强化消耗
if not enhance_cost or curr_coin < enhance_cost:
return {'result': False, 'result_no': 101, 'message': u''}
strength_max = equipment_obj.strength_max(player)
current_strength_lv = equipment_obj.attribute.strengthen_lv
if strength_max <= current_strength_lv:
return {'result': False, 'result_no': 402, 'message': u''}
num = 0
if enhance_type == 1:
result = __do_enhance(player, equipment_obj)
if result.get('record')[1] >= strength_max:
result['record'] = (result.get('record')[0], strength_max,
result.get('record')[2])
enhance_record.append(result.get('record'))
num += 1
else:
while strength_max > current_strength_lv and curr_coin > enhance_cost:
num += 1
result = __do_enhance(player, equipment_obj)
if not result.get('result'):
return result
if result.get('record')[1] >= strength_max:
result['record'] = (result.get('record')[0], strength_max,
result.get('record')[2])
enhance_record.append(result.get('record'))
break
enhance_record.append(result.get('record'))
current_strength_lv = equipment_obj.attribute.strengthen_lv
enhance_cost = equipment_obj.attribute.enhance_cost # 强化消耗
curr_coin = player.finance.coin # 用户金币
print equipment_obj.enhance_record
equipment_obj.enhance_record.enhance_record.extend(enhance_record)
# 保存
equipment_obj.save_data()
player.finance.save_data()
return {
'result': True,
'enhance_record': enhance_record,
'num': num,
'equipment_no': equipment_obj.base_info.equipment_no
}
def gain(player, item_group, reason,
result=None,
multiple=1,
event_id='',
part_multiple=[],
lucky_attr_id=0):
"""获取
@param item_group: [obj,obj]
act 掉落翻倍. [[type_ids], xs] [[翻倍类型列表]，系数]
"""
if result is None:
result = []
after_num = 0
itid = 0
for group_item in item_group:
type_id = group_item.item_type
num = int(group_item.num * multiple)
item_no = group_item.item_no
multiple2 = 1
for _part_multiple in part_multiple:
_times = _part_multiple["times"]
_item_type = _part_multiple["item_type"]
_item_ids = _part_multiple["item_ids"]
if type_id == _item_type:
if not _item_ids[0] or item_no in _item_ids:
multiple2 = _times
logger.debug("multiple %s multiple2 %s" % (multiple, multiple2))
num = int(multiple2 * num)
front_type_id = type_id # 记录类型，用于武将已存在的情况。
if type_id == const.COIN:
player.finance.coin += num
player.finance.save_data()
after_num = player.finance.coin
elif type_id == const.RESOURCE:
if item_no == 27:
hook_task(player, CONDITIONId.GGZJ, num)
elif item_no == const.TEAM_EXPERIENCE:
player.base_info.addexp(num, reason)
player.base_info.save_data()
after_num = player.base_info.exp
else:
player.finance.add(item_no, num)
player.finance.save_data()
after_num = player.finance[item_no]
if item_no == 1 or item_no == 2:
tlog_action.log('MoneyFlow', player, after_num, num, reason,
const.ADD, item_no)
elif type_id == const.GOLD:
player.finance.add_gold(num, 0)
player.finance.save_data()
elif type_id == const.HERO_SOUL:
player.finance.hero_soul += num
player.finance.save_data()
elif type_id == const.PVP:
player.finance.pvp_score += num
player.finance.save_data()
elif type_id == const.HERO_CHIP:
if game_configs.chip_config.get('chips').get(item_no):
hero_chip = HeroChip(item_no, num)
player.hero_chip_component.add_chip(hero_chip)
player.hero_chip_component.save_data()
after_num = player.hero_chip_component.get_chip(item_no).num
else:
logger.error('chip config not found:%', item_no)
elif type_id == const.ITEM:
item = Item(item_no, num)
player.item_package.add_item(item)
player.item_package.save_data()
after_num = player.item_package.get_item(item_no).num
elif type_id == const.HERO:
is_have = player.hero_component.contain_hero(item_no)
if not is_have:
num -= 1
if num != 0:
# 已经存在该武将，自动转换为武将碎片
# 获取hero对应的hero_chip_no, hero_chip_num
hero_chip_config_item = game_configs.chip_config.get("mapping").get(item_no)
hero_chip_no = hero_chip_config_item.id
CardImparirment = 1
if reason == const.SHOP_DRAW_HERO:
CardImparirment = game_configs.base_config.get("CardImparirment")
hero_chip_num = int(hero_chip_config_item.needNum * num * CardImparirment)
hero_chip = HeroChip(hero_chip_no, hero_chip_num)
player.hero_chip_component.add_chip(hero_chip)
player.hero_chip_component.save_data()
after_num = player.hero_chip_component.get_chip(hero_chip_no).num
result.append([const.HERO_CHIP, hero_chip_num, hero_chip_no])
tlog_action.log('ItemFlow', player, const.ADD, type_id,
hero_chip_num, hero_chip_no, itid, reason,
after_num, event_id)
if not is_have:
hero = player.hero_component.add_hero(item_no)
notice_item = game_configs.notes_config.get(2002)
logger.debug("=================%s %s %s" % (reason, hero.hero_info.quality, notice_item.parameter1))
if reason == const.SHOP_DRAW_HERO and hero.hero_info.quality in notice_item.parameter1:
push_notice(2002, player_name=player.base_info.base_name, hero_no=item_no)
after_num = 1
result.append([type_id, 1, item_no])
tlog_action.log('ItemFlow', player, const.ADD, type_id,
1, item_no, itid, reason,
after_num, event_id)
elif type_id == const.BIG_BAG:
big_bag = BigBag(item_no)
for i in range(num):
temp = big_bag.get_drop_items()
gain(player, temp, reason, result)
return result
elif type_id == const.EQUIPMENT:
for _ in range(num):
itid = item_no
equipment = player.equipment_component.add_equipment(itid, lucky_attr_id)
equ_item_no = equipment.base_info.id
after_num = player.equipment_component.get_equipment_num(itid)
notice_item = game_configs.notes_config.get(2004)
if reason == const.COMMON_BUY_PVP and equipment.equipment_config_info.quality in notice_item.parameter1:
push_notice(2004, player_name=player.base_info.base_name, equipment_no=itid)
notice_item = game_configs.notes_config.get(2005)
if reason ==const.COMMON_BUY_MELT and equipment.equipment_config_info.quality in notice_item.parameter1:
push_notice(2005, player_name=player.base_info.base_name, equipment_no=itid)
notice_item = game_configs.notes_config.get(2006)
if reason == const.COMMON_BUY_EQUIPMENT and equipment.equipment_config_info.quality in notice_item.parameter1:
push_notice(2006, player_name=player.base_info.base_name, equipment_no=itid)
result.append([type_id, 1, equ_item_no])
tlog_action.log('ItemFlow', player, const.ADD, type_id, 1,
itid, item_no, reason, after_num, event_id)
elif type_id == const.EQUIPMENT_CHIP:
if game_configs.chip_config.get('chips').get(item_no):
chip = EquipmentChip(item_no, num)
player.equipment_chip_component.add_chip(chip)
player.equipment_chip_component.save_data()
after_num = player.equipment_chip_component.get_chip(item_no).chip_num
else:
logger.error('chip config not found:%', item_no)
elif type_id == const.STAMINA:
player.stamina.stamina += num
# logger.debug(str(num)+" , stamina+++++++++++")
player.stamina.save_data()
elif type_id == const.TEAM_EXPERIENCE:
player.base_info.addexp(num, reason)
player.base_info.save_data()
elif type_id == const.TRAVEL_ITEM:
after_num = num
stage_id = game_configs.travel_item_config.get('items').get(item_no).stageId
flag1 = 1
flag2 = 0
stage_item_info = player.travel_component.travel_item.get(stage_id)
for [travel_item_id, travel_item_num] in stage_item_info:
if travel_item_id == item_no:
the_num = travel_item_num + num
stage_item_info[flag2] = \
[travel_item_id, the_num]
flag1 = 0
after_num = the_num
break
flag2 += 1
if flag1:
stage_item_info.append([item_no, num])
player.travel_component.save()
elif type_id == const.RUNT:
for _ in range(num):
runt_id = player.runt.add_runt(item_no)
result.append([type_id, 1, runt_id])
player.runt.save()
after_num = player.runt.get_runt_num(item_no)
if type_id == const.COIN or type_id == const.GOLD:
tlog_action.log('MoneyFlow', player, after_num, num, reason,
const.ADD, item_no)
is_over = False # 是否累加
for i in result:
if i[0] == type_id and i[2] == item_no and (front_type_id != const.HERO and type_id != const.HERO_CHIP and type_id != const.RUNT and type_id != const.EQUIPMENT and type_id != const.HERO):
i[1] += num
is_over = True
continue
if not is_over and type_id !=const.RUNT and type_id != const.HERO and type_id != const.EQUIPMENT:
result.append([type_id, num, item_no])
# ====tlog======
if type_id != const.TEAM_EXPERIENCE and type_id != const.EQUIPMENT and type_id != const.HERO:
tlog_action.log('ItemFlow', player, const.ADD, type_id, num,
item_no, itid, reason, after_num, event_id)
# ==============
return result
def hjqy_rank_remote(player_id):
""" 获取玩家伤害排名
"""
rank = hjqy_manager.get_rank(player_id)
logger.debug("hjqy_rank_remote:%s" % rank)
return rank
def hjqy_damage_hp_remote(player_id):
""" 获取玩家伤害信息
"""
damage_hp = hjqy_manager.get_damage_hp(player_id)
logger.debug("hjqy_damage_hp_remote : %s" % damage_hp)
return damage_hp
