def get_act_gift_1832(data, player):
args = activity_pb2.GetActGiftRequest()
args.ParseFromString(data)
act_id = args.act_id
response = activity_pb2.GetActGiftResponse()
response.res.result = False
act_conf = game_configs.activity_config.get(act_id)
is_open = player.act.is_activiy_open(act_id)
if not act_conf or not is_open:
response.res.result_no = 800
return response.SerializeToString()
act_type = act_conf.type
received_ids = player.act.received_ids.get(act_type)
if received_ids and act_id in received_ids:
response.res.result_no = 801
return response.SerializeToString()
if act_type == 20: # 战力
res = get_20_gift(player, act_conf, response)
tlog_arg = player.line_up_component.combat_power
elif act_type == 21: # 通关关卡
res = get_21_gift(player, act_conf, response)
tlog_arg = player.stage_component.stage_progress
if res:
if received_ids:
player.act.received_ids.get(act_type).append(act_id)
else:
player.act.received_ids[act_type] = [act_id]
player.act.save_data()
response.res.result = True
tlog_action.log('Activity', player, act_id, tlog_arg)
return response.SerializeToString()
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 inherit_equipment_152(pro_data, player):
"""
装备传承
"""
request = inherit_pb2.InheritEquipmentRequest()
request.ParseFromString(pro_data)
origin_id = request.origin
target_id = request.target
response = common_pb2.CommonResponse()
if is_not_open(player, FO_INHERIT):
response.result = False
response.result_no = 837
return response.SerializeToString()
origin = player.equipment_component.get_equipment(origin_id)
target = player.equipment_component.get_equipment(target_id)
# print origin.attribute.strengthen_lv, target.attribute.strengthen_lv, "+"*10
if not origin or (not target):
logger.error("equip %s or %s not exists" % (origin_id, target_id))
response.result = False
return response.SerializeToString()
if origin.attribute.strengthen_lv <= target.attribute.strengthen_lv:
logger.error(
"origin equip %s strengthen_lv <= target equip %s strengthen_lv!" %
(origin_id, target_id))
response.result = False
return response.SerializeToString()
if origin.equipment_config_info.get(
"quality") != target.equipment_config_info.get("quality"):
logger.error("origin.quality!=target.quality")
response.result = False
return response.SerializeToString()
i_value = 0
def func():
"""docstring for func"""
target.attribute.strengthen_lv = origin.attribute.strengthen_lv
i_value = target.attribute.strengthen_lv
origin.attribute.strengthen_lv = 1
# 传承强化过程
target.enhance_record.enhance_record = origin.enhance_record.enhance_record
origin.enhance_record.enhance_record = []
target.save_data()
origin.save_data()
print origin.attribute.strengthen_lv, target.attribute.strengthen_lv, "+" * 10
gold = game_configs.base_config.get("equInheritPrice")
player.pay.pay(gold, const.INHERIT_EQUIPMENT, func)
response.result = True
tlog_action.log('Inherit', player, 2, origin.base_info.id,
origin.base_info.equipment_no, target.base_info.id,
target.base_info.equipment_no, i_value)
return response.SerializeToString()
def get_act_gift_1832(data, player):
args = activity_pb2.GetActGiftRequest()
args.ParseFromString(data)
act_id = args.act_id
response = activity_pb2.GetActGiftResponse()
response.res.result = False
act_conf = game_configs.activity_config.get(act_id)
is_open = player.act.is_activiy_open(act_id)
if not act_conf or not is_open:
response.res.result_no = 800
return response.SerializeToString()
act_type = act_conf.type
received_ids = player.act.received_ids.get(act_type)
if received_ids and act_id in received_ids:
response.res.result_no = 801
return response.SerializeToString()
if act_type == 20: # 战力
res = get_20_gift(player, act_conf, response)
tlog_arg = player.line_up_component.combat_power
elif act_type == 21: # 通关关卡
res = get_21_gift(player, act_conf, response)
tlog_arg = player.stage_component.stage_progress
if res:
if received_ids:
player.act.received_ids.get(act_type).append(act_id)
else:
player.act.received_ids[act_type] = [act_id]
player.act.save_data()
response.res.result = True
tlog_action.log('Activity', player, act_id, tlog_arg)
return response.SerializeToString()
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 mine_accelerate_1254(data, player):
"""docstring for battle"""
request = mine_pb2.MineAccelerateRequest()
request.ParseFromString(data)
pos = request.pos # 矿所在位置
response = mine_pb2.MineAccelerateResponse()
need_gold = player.mine.get_acc_time_gold(pos)
if need_gold <= 0:
logger.error('gold num error:%s', need_gold)
response.res.result = False
response.res.result_no = 125401
return response.SerializePartialToString()
price = []
price.append(CommonGroupItem(const.COIN, need_gold, need_gold, const.GOLD))
def func():
consume_return_data = item_group_helper.consume(player,
price,
const.MINE_ACC)
item_group_helper.get_return(player,
consume_return_data,
response.consume)
response.res.result = player.mine.acc_mine_time(pos)
player.pay.pay(need_gold, const.MINE_ACC, func)
tlog_action.log('MineAccelerate', player, need_gold)
response.res.result = True
logger.debug('mine accelerate:%s', response)
return response.SerializePartialToString()
def compose_equipment_403(pro_data, player):
"""合成装备
@param dynamic_id:
@param pro_data:
@return:
"""
request = equipment_request_pb2.ComposeEquipmentRequest()
request.ParseFromString(pro_data)
equipment_chip_no = request.no
response = equipment_response_pb2.ComposeEquipmentResponse()
open_stage_id = game_configs.base_config.get('equAssembleOpenStage')
if player.stage_component.get_stage(open_stage_id).state != 1:
response.res.result = False
response.res.result_no = 837
return response.SerializeToString()
data = compose_equipment(equipment_chip_no, player)
result = data.get('result')
res = response.res
if not result:
res.result_no = data.get('result_no')
res.message = data.get('message')
return response.SerializePartialToString()
equipment_obj = data.get('equipment_obj')
equ = response.equ
equipment_obj.update_pb(equ)
tlog_action.log('EquipmentCompose', player,
equipment_obj.base_info.equipment_no,
equipment_obj.base_info.id)
res.result = True
return response.SerializePartialToString()
def melting_equipment(equipment_id, response, player):
"""熔炼
@param dynamic_id:
@param equipment_ids:
@param kwargs:
@return:
"""
if is_not_open(player, FO_EQUIP_SACRIFICE):
return {"result": False, "result_no": 837}
equipment_obj = player.equipment_component.get_equipment(equipment_id)
if not equipment_obj:
return {'result': False, 'result_no': 401, 'message': u''}
melting_items = equipment_obj.melting_item
gain = item_group_helper.gain(player, melting_items,
const.MELTING_EQUIPMENT)
item_group_helper.get_return(player, gain, response.cgr)
tlog_action.log('EquipmentMelting', player,
equipment_obj.base_info.equipment_no,
equipment_obj.base_info.id)
# 删除装备
player.equipment_component.delete_equipment(equipment_id)
# 添加强化金币
strength_coin = 0
for record in equipment_obj.enhance_record.enhance_record:
strength_coin += record[2]
strength_coin = int(strength_coin *
game_configs.base_config.get("equRefundRatio"))
return strength_coin
def upgrade_guild_skill_2404(pro_data, player):
"""
升级军团技能
"""
request = guild_pb2.UpGuildSkillRequest()
request.ParseFromString(pro_data)
logger.error("request %s" % request)
response = guild_pb2.UpGuildSkillResponse()
logger.error("request %s" % request)
skill_type = request.skill_type
data = remote_gate['world'].guild_boss_init_remote(player.guild.g_id)
guild_skills = data.get("guild_skills")
build = data.get("build")
skill_level = guild_skills.get(skill_type)
logger.debug("skill level %s" % skill_level)
# check
guild_skill_item = game_configs.guild_skill_config.get(skill_type).get(skill_level)
logger.debug("guild_skill_config %s" % guild_skill_item)
response.res.result = False
if guild_skills.get(skill_type) >= 10:
logger.debug("guild skill %s has reach the max!" % skill_type)
response.res.result_no = 24044
return response.SerializeToString()
#if not is_afford(player, guild_skill_item.Consume).get('result'):
#logger.debug("consume not enough!")
#response.res.result_no = 24041
#return response.SerializeToString()
for condition2 in guild_skill_item.Skill_condition[2]:
tmp_guild_skill_item = game_configs.guild_skill_config.get(condition2)
_skill_type = tmp_guild_skill_item.type
skill_level = tmp_guild_skill_item.Skill_level
if skill_level > guild_skills[_skill_type]:
logger.debug("skill level conidtion not enough!")
response.res.result_no = 24042
return response.SerializeToString()
for condition1 in guild_skill_item.Skill_condition[1]:
tmp_guild_item = game_configs.guild_config.get(condition1)
guild_type = tmp_guild_item.type
guild_level = tmp_guild_item.level
if guild_level > build[guild_type]:
logger.debug("guild build level not enough!")
response.res.result_no = 24043
return response.SerializeToString()
res = remote_gate['world'].upgrade_guild_skill_remote(player.guild.g_id, skill_type)
if res.get("result"):
# consume
#return_data = consume(player, guild_skill_item.Consume, const.UPGRADE_GUILD_SKILL)
#get_return(player, return_data, response.consume)
response.guild_skill_point = guild_skill_item.Consumption
response.res.result = res.get("result")
tlog_action.log('UpgradeGuildSkill', player, player.guild.g_id,
skill_type, guild_skills.get(skill_type)+1, guild_skill_item.Consumption)
logger.debug("response %s" % response)
return response.SerializeToString()
def change_hero(self, slot_no, hero_no, change_type):
"""更换阵容主将
@param slot_no:
@param hero_no:
@:param change_type: 0:阵容 1：助威
@return:
"""
if not change_type:
slot_obj = self._line_up_slots.get(slot_no)
else:
slot_obj = self._sub_slots.get(slot_no)
origin_hero_no = slot_obj.hero_slot.hero_no
origin_hero = self.owner.hero_component.get_hero(origin_hero_no)
if origin_hero:
origin_hero.is_online = False
else:
origin_hero_no = 0
slot_obj.change_hero(hero_no)
target_hero = self.owner.hero_component.get_hero(hero_no)
if hero_no != 0:
assert target_hero != None, "change hero can not be None!"
target_hero.is_online = True
tlog_action.log('LineUpChange', self.owner, slot_no, origin_hero_no,
hero_no, change_type)
# 如果无双条件不满足，则无双设为空
hero_nos = set(self.hero_nos) # 阵容英雄编号
for skill_id, item in game_configs.warriors_config.items():
if skill_id not in self._unpars:
conditions = item.get('conditions')
if conditions and hero_nos.issuperset(conditions):
self._unpars[skill_id] = 1
def compose_equipment_403(pro_data, player):
"""合成装备
@param dynamic_id:
@param pro_data:
@return:
"""
request = equipment_request_pb2.ComposeEquipmentRequest()
request.ParseFromString(pro_data)
equipment_chip_no = request.no
response = equipment_response_pb2.ComposeEquipmentResponse()
data = compose_equipment(equipment_chip_no, player)
result = data.get('result')
res = response.res
if not result:
res.result_no = data.get('result_no')
res.message = data.get('message')
return response.SerializePartialToString()
equipment_obj = data.get('equipment_obj')
equ = response.equ
equipment_obj.update_pb(equ)
tlog_action.log('EquipmentCompose', player,
equipment_obj.base_info.equipment_no,
equipment_obj.base_info.id)
res.result = True
return response.SerializePartialToString()
def melting_equipment(equipment_id, response, player):
"""熔炼
@param dynamic_id:
@param equipment_ids:
@param kwargs:
@return:
"""
if is_not_open(player, FO_EQUIP_SACRIFICE):
return {"result": False, "result_no": 837}
equipment_obj = player.equipment_component.get_equipment(equipment_id)
if not equipment_obj:
return {'result': False, 'result_no': 401, 'message': u''}
melting_items = equipment_obj.melting_item
gain = item_group_helper.gain(player, melting_items, const.MELTING_EQUIPMENT)
item_group_helper.get_return(player, gain, response.cgr)
tlog_action.log('EquipmentMelting', player,
equipment_obj.base_info.equipment_no,
equipment_obj.base_info.id)
# 删除装备
player.equipment_component.delete_equipment(equipment_id)
# 添加强化金币
strength_coin = 0
for record in equipment_obj.enhance_record.enhance_record:
strength_coin += record[2]
strength_coin = int(strength_coin*game_configs.base_config.get("equRefundRatio"))
return strength_coin
def compose_equipment_403(pro_data, player):
"""合成装备
@param dynamic_id:
@param pro_data:
@return:
"""
request = equipment_request_pb2.ComposeEquipmentRequest()
request.ParseFromString(pro_data)
equipment_chip_no = request.no
response = equipment_response_pb2.ComposeEquipmentResponse()
data = compose_equipment(equipment_chip_no, player)
result = data.get('result')
res = response.res
if not result:
res.result_no = data.get('result_no')
res.message = data.get('message')
return response.SerializePartialToString()
equipment_obj = data.get('equipment_obj')
equ = response.equ
equipment_obj.update_pb(equ)
tlog_action.log('EquipmentCompose', player,
equipment_obj.base_info.equipment_no,
equipment_obj.base_info.id)
res.result = True
return response.SerializePartialToString()
def send_tlog(player, shop_item):
item_type = shop_item.gain[0].item_type
item_id = shop_item.gain[0].item_no
count = shop_item.gain[0].num
money = shop_item.consume[0].num
money_type = shop_item.consume[0].item_no
discount_money = 0
discount_money_type = 0
is_discount = 0
if shop_item.discountPrice:
is_discount = 1
discount_money = shop_item.discountPrice[0].num
discount_money_type = shop_item.discountPrice[0].item_no
limit_vip_everyday = []
if shop_item.limitVIPeveryday:
for i in range(30):
if shop_item.limitVIPeveryday.get(i):
limit_vip_everyday.append(shop_item.limitVIPeveryday.get(i))
limit_vip = []
if shop_item.limitVIP:
for i in range(30):
if shop_item.limitVIP.get(i):
limit_vip.append(shop_item.limitVIP.get(i))
tlog_action.log('ItemMoneyFlow', player, item_type, item_id, count,
money, money_type, discount_money, discount_money_type,
'', '', is_discount)
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 change_hero(self, slot_no, hero_no, change_type):
"""更换阵容主将
@param slot_no:
@param hero_no:
@:param change_type: 0:阵容 1：助威
@return:
"""
if not change_type:
slot_obj = self._line_up_slots.get(slot_no)
else:
slot_obj = self._sub_slots.get(slot_no)
origin_hero_no = slot_obj.hero_slot.hero_no
origin_hero = self.owner.hero_component.get_hero(origin_hero_no)
if origin_hero:
origin_hero.is_online = False
else:
origin_hero_no = 0
slot_obj.change_hero(hero_no)
if hero_no == 0 and slot_no == self.caption_pos:
# 队长下阵，更改队长
self.remove_caption_hero()
target_hero = self.owner.hero_component.get_hero(hero_no)
if hero_no != 0:
assert target_hero != None, "change hero can not be None!"
target_hero.is_online = True
# 更新 七日奖励
target_update(self.owner, [55])
tlog_action.log('LineUpChange', self.owner, slot_no, origin_hero_no,
hero_no, change_type)
def send_tlog(player, shop_item):
item_type = shop_item.gain[0].item_type
item_id = shop_item.gain[0].item_no
count = shop_item.gain[0].num
money = shop_item.consume[0].num
money_type = shop_item.consume[0].item_no
discount_money = 0
discount_money_type = 0
is_discount = 0
if shop_item.discountPrice:
is_discount = 1
discount_money = shop_item.discountPrice[0].num
discount_money_type = shop_item.discountPrice[0].item_no
limit_vip_everyday = []
if shop_item.limitVIPeveryday:
for i in range(30):
if shop_item.limitVIPeveryday.get(i):
limit_vip_everyday.append(shop_item.limitVIPeveryday.get(i))
limit_vip = []
if shop_item.limitVIP:
for i in range(30):
if shop_item.limitVIP.get(i):
limit_vip.append(shop_item.limitVIP.get(i))
tlog_action.log('ItemMoneyFlow', player, item_type, item_id, count, money,
money_type, discount_money, discount_money_type, '', '',
is_discount)
def settle(self, result, response):
"""
战斗结算
"""
player = self._player
stage_id = self._stage_id
conf = self.get_stage_config()
# todo: 更新战斗次数
# 体力
if result:
player.stamina.stamina -= conf.vigor
player.stamina.save_data()
# 活跃度
# 结算
stage_util.settle(player, result, response, conf, stage_type=1)
# hook task
hook_task(player, CONDITIONId.ANY_STAGE, 1)
hook_task(player, CONDITIONId.STAGE, stage_id)
tlog_action.log('RoundFlow', player, stage_id, 1, 0, 1)
else:
tlog_action.log('RoundFlow', player, stage_id, 1, 0, 0)
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 reset_overcome(self):
_times = self.pvp_overcome_refresh_count + 1
if _times > self.owner.base_info.buyGgzj_times:
logger.error('overcome reset times error:%s-%s',
self.pvp_overcome_refresh_count,
self.owner.base_info.buyGgzj_times)
return False
character_info = tb_character_info.getObj(self.owner.base_info.id)
types = [20001, 20002, 20003]
ids = get_player_ids(self.owner.base_info.id,
int(character_info.hget('attackPoint')),
types, 47)
if not ids:
return False
logger.debug('reset overcome:%s', ids)
self._pvp_overcome = ids
self._pvp_overcome_refresh_time = time.time()
self._pvp_overcome_refresh_count += 1
self._pvp_overcome_current = 1
self._pvp_overcome_awards = []
self._pvp_overcome_stars = 0
self._pvp_overcome_buff_init = {}
self._pvp_overcome_buff = {}
self._pvp_overcome_failed = False
self.save_data()
tlog_action.log('OvercomeReset',
self.owner,
self._pvp_overcome_refresh_count)
return True
def change_hero(self, slot_no, hero_no, change_type):
"""更换阵容主将
@param slot_no:
@param hero_no:
@:param change_type: 0:阵容 1：助威
@return:
"""
if not change_type:
slot_obj = self._line_up_slots.get(slot_no)
else:
slot_obj = self._sub_slots.get(slot_no)
origin_hero_no = slot_obj.hero_slot.hero_no
origin_hero = self.owner.hero_component.get_hero(origin_hero_no)
if origin_hero:
origin_hero.is_online = False
else:
origin_hero_no = 0
slot_obj.change_hero(hero_no)
if hero_no == 0 and slot_no == self.caption_pos:
# 队长下阵，更改队长
self.remove_caption_hero()
target_hero = self.owner.hero_component.get_hero(hero_no)
if hero_no != 0:
assert target_hero != None, "change hero can not be None!"
target_hero.is_online = True
# 更新 七日奖励
target_update(self.owner, [55])
tlog_action.log('LineUpChange', self.owner, slot_no, origin_hero_no,
hero_no, change_type)
def settle(self, result, response, star_num=0):
"""
战斗结算
"""
player = self._player
stage_id = self._stage_id
conf = self.get_stage_config()
# todo: 更新战斗次数
# 体力
if result:
#player.stamina.stamina -= conf.vigor
player.finance.consume(const.STAMINA, conf.vigor, const.STAGE)
player.finance.save_data()
player.stamina.save_data()
# 活跃度
# 结算
stage_util.settle(player, result, response, conf, star_num=star_num)
# hook task
hook_task(player, CONDITIONId.ANY_STAGE, 1)
hook_task(player, CONDITIONId.STAGE, stage_id)
# 更新 七日奖励
target_update(player, [45])
tlog_action.log('RoundFlow', player, stage_id, 1, 0, 1)
else:
tlog_action.log('RoundFlow', player, stage_id, 1, 0, 0)
def get_level_gift_1131(data, player):
"""get online gift"""
request = level_gift_pb2.GetLevelGift()
request.ParseFromString(data)
response = level_gift_pb2.GetLevelGiftResponse()
activity_level_gift = game_configs.activity_config.get(3)
if request.gift_id in player.level_gift.received_gift_ids:
response.result = False
return response.SerializeToString()
for a in activity_level_gift:
if request.gift_id == a['id']:
gain_data = a['reward']
return_data = gain(player, gain_data, const.LEVEL_GIFT)
get_return(player, return_data, response.gain)
player.level_gift.received_gift_ids.append(request.gift_id)
player.level_gift.save_data()
tlog_action.log('LevelGift', player, request.gift_id)
response.result = True
return response.SerializeToString()
response.result = False
return response.SerializeToString()
def share_1823(data, player):
"""分享"""
args = task_pb2.ShareRequest()
args.ParseFromString(data)
tid = args.tid
share_type = 0
if args.share_type:
share_type = args.share_type
response = task_pb2.ShareResponse()
player.task.update()
task_conf = game_configs.achievement_config.get('tasks').get(tid)
if task_conf.sort != 4:
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
res = get_condition_info(player, task_conf)
condition_info = res.get('condition_info')
for x in condition_info:
if not x[1] and task_conf.condition.get(x[0])[0] != CONDITIONId.SHARE:
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
player.task.tasks[tid] = 2
player.task.save_data()
tlog_action.log('Share', player, tid, share_type)
response.tid = tid
response.res.result = True
return response.SerializeToString()
def melting_equipment(equipment_id, response, player):
"""熔炼
@param dynamic_id:
@param equipment_ids:
@param kwargs:
@return:
"""
equipment_obj = player.equipment_component.get_equipment(equipment_id)
if not equipment_obj:
return {'result': False, 'result_no': 401, 'message': u''}
melting_items = equipment_obj.melting_item
gain = item_group_helper.gain(player, melting_items, const.MELTING_EQUIPMENT)
item_group_helper.get_return(player, gain, response.cgr)
tlog_action.log('EquipmentMelting', player,
equipment_obj.base_info.equipment_no,
equipment_obj.base_info.id)
# 删除装备
player.equipment_component.delete_equipment(equipment_id)
# 添加强化金币
strength_coin = 0
for record in equipment_obj.enhance_record.enhance_record:
strength_coin += record[2]
strength_coin = int(strength_coin*game_configs.base_config.get("equRefundRatio"))
player.finance.coin += strength_coin
player.finance.save_data()
response.cgr.finance.coin += strength_coin
change = response.cgr.finance.finance_changes.add()
change.item_type = 107
change.item_num = strength_coin
change.item_no = 1
def hero_break_logic(hero_no, player, response):
hero = player.hero_component.get_hero(hero_no)
hero_info = game_configs.hero_config.get(hero_no)
# 验证武将是否突破到上限
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)
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}
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 do_hero_refine(player, hero_no, refine, response):
hero = player.hero_component.get_hero(hero_no)
_refine_item = game_configs.seal_config.get(refine)
if not hero:
logger.error('cant find hero:%s', hero_no)
return {'result': False, 'result_no': 11801}
if not _refine_item:
logger.error('cant find refine item:%s', refine)
return {'result': False, 'result_no': 11802}
current_refine_item = game_configs.seal_config.get(hero.refine)
if current_refine_item and _refine_item.id != current_refine_item.get('next'):
logger.error('not next refine item:%s', refine)
return {'result': False, 'result_no': 11803}
result = is_afford(player, _refine_item.expend) # 校验
if not result.get('result'):
logger.error('cant afford refine:%s:cur%s',
_refine_item.expend,
player.brew.nectar)
return {'result': False, 'result_no': 11804}
tlog_action.log('HeroRefine', player, hero_no, refine)
return_data = consume(player, _refine_item.expend, const.HERO_REFINE)
get_return(player, return_data, response.consume)
hero.refine = refine
player.brew.save_data()
hero.save_data()
return {'result': True}
def share_1823(data, player):
"""分享"""
args = task_pb2.ShareRequest()
args.ParseFromString(data)
tid = args.tid
share_type = 0
if args.share_type:
share_type = args.share_type
response = task_pb2.ShareResponse()
player.task.update()
task_conf = game_configs.achievement_config.get('tasks').get(tid)
if task_conf.sort != 4:
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
res = get_condition_info(player, task_conf)
condition_info = res.get('condition_info')
for x in condition_info:
if not x[1] and task_conf.condition.get(x[0])[0] != CONDITIONId.SHARE:
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
player.task.tasks[tid] = 2
player.task.save_data()
tlog_action.log('Share', player, tid, share_type)
response.tid = tid
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()
# 验证连续签到日期
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 get_level_gift_1131(data, player):
"""get online gift"""
request = level_gift_pb2.GetLevelGift()
request.ParseFromString(data)
response = level_gift_pb2.GetLevelGiftResponse()
activity_level_gift = game_configs.activity_config.get(3)
if request.gift_id in player.level_gift.received_gift_ids:
response.result = False
return response.SerializeToString()
for a in activity_level_gift:
if request.gift_id == a['id']:
gain_data = a['reward']
return_data = gain(player, gain_data, const.LEVEL_GIFT)
get_return(player, return_data, response.gain)
player.level_gift.received_gift_ids.append(request.gift_id)
player.level_gift.save_data()
tlog_action.log('LevelGift', player, request.gift_id)
response.result = True
return response.SerializeToString()
response.result = False
return response.SerializeToString()
def recharge_gain(self, recharge_item, response, is_tencent=False):
"""
充值掉落
"""
logger.debug("recharge_gain========1")
isfirst = 0
if not is_tencent:
return_data = gain(self._owner, recharge_item.get('setting'),
const.RECHARGE) # 获取
get_return(self._owner, return_data, response.gain)
if recharge_item.get('type') == 2:
logger.debug("recharge_gain========")
rebate_call(self._owner, recharge_item)
self._owner.recharge.send_mail(recharge_item) #发送奖励邮件
else:
rres = self._owner.base_info.first_recharge(recharge_item, response)
if rres:
#首次充值
isfirst = 1
self._owner.recharge.send_mail(recharge_item) #发送奖励邮件
tlog_action.log('Recharge', self._owner, isfirst,
recharge_item.get('id'))
charge_num = recharge_item.get('activity') # 充值元宝数量
# vip
self._owner.base_info.recharge += charge_num
self._owner.base_info.set_vip_level(self._owner.base_info.recharge)
# 活动
self._owner.recharge.charge(charge_num)
if not is_tencent:
self._owner.recharge.get_recharge_response(response.info) # recharge
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 settle(self, result, response, star_num=0):
"""
战斗结算
"""
player = self._player
stage_id = self._stage_id
conf = self.get_stage_config()
# todo: 更新战斗次数
# 体力
if result:
#player.stamina.stamina -= conf.vigor
player.finance.consume(const.STAMINA, conf.vigor, const.STAGE)
player.finance.save_data()
player.stamina.save_data()
# 活跃度
# 结算
stage_util.settle(player,
result,
response,
conf,
star_num=star_num)
# hook task
hook_task(player, CONDITIONId.ANY_STAGE, 1)
hook_task(player, CONDITIONId.STAGE, stage_id)
# 更新 七日奖励
target_update(player, [45])
tlog_action.log('RoundFlow', player, stage_id, 1, 0, 1)
else:
tlog_action.log('RoundFlow', player, stage_id, 1, 0, 0)
def func():
player.sign_in_component.sign_in(day)
player.sign_in_component.save_data()
sign_round = player.sign_in_component.sign_round
print game_configs.sign_in_config.get(sign_round), "---------"
print game_configs.sign_in_config.get(sign_round).get(day), "-------"
if not game_configs.sign_in_config.get(sign_round) or not game_configs.sign_in_config.get(sign_round).get(day):
return
sign_in_info = game_configs.sign_in_config.get(sign_round).get(day)
#vip双倍
if player.base_info.vip_level > 0 and \
sign_in_info.get("vipDouble") and \
player.base_info.vip_level >= sign_in_info.get("vipDouble"):
is_double = 1
else:
is_double = 0
if is_double:
return_data = gain(player, sign_in_info.get("reward"), const.REPAIR_SIGN, multiple=2)
get_return(player, return_data, response.gain)
else:
return_data = gain(player, sign_in_info.get("reward"), const.REPAIR_SIGN)
get_return(player, return_data, response.gain)
player.sign_in_component.repair_sign_in_times += 1
player.sign_in_component.save_data()
tlog_action.log('RepairSignIn', player, day, len(player.sign_in_component.sign_in_days), sign_in_info.get("id"))
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 inherit_equipment_152(pro_data, player):
"""
装备传承
"""
request = inherit_pb2.InheritEquipmentRequest()
request.ParseFromString(pro_data)
origin_id = request.origin
target_id = request.target
response = common_pb2.CommonResponse()
if is_not_open(player, FO_INHERIT):
response.result = False
response.result_no = 837
return response.SerializeToString()
origin = player.equipment_component.get_equipment(origin_id)
target = player.equipment_component.get_equipment(target_id)
# print origin.attribute.strengthen_lv, target.attribute.strengthen_lv, "+"*10
if not origin or (not target):
logger.error("equip %s or %s not exists" % (origin_id, target_id))
response.result = False
return response.SerializeToString()
if origin.attribute.strengthen_lv <= target.attribute.strengthen_lv:
logger.error("origin equip %s strengthen_lv <= target equip %s strengthen_lv!" % (origin_id, target_id))
response.result = False
return response.SerializeToString()
if origin.equipment_config_info.get("quality") != target.equipment_config_info.get("quality"):
logger.error("origin.quality!=target.quality")
response.result = False
return response.SerializeToString()
i_value = 0
def func():
"""docstring for func"""
target.attribute.strengthen_lv = origin.attribute.strengthen_lv
i_value = target.attribute.strengthen_lv
origin.attribute.strengthen_lv = 1
# 传承强化过程
target.enhance_record.enhance_record = origin.enhance_record.enhance_record
origin.enhance_record.enhance_record = []
target.save_data()
origin.save_data()
print origin.attribute.strengthen_lv, target.attribute.strengthen_lv, "+"*10
gold = game_configs.base_config.get("equInheritPrice")
player.pay.pay(gold, const.INHERIT_EQUIPMENT, func)
response.result = True
tlog_action.log('Inherit', player, 2, origin.base_info.id,
origin.base_info.equipment_no,
target.base_info.id,
target.base_info.equipment_no,
i_value)
return response.SerializeToString()
def consume_coin(self, num, reason):
if num < self._finances[const.COIN]:
return False
self._finances[const.COIN] -= num
tlog_action.log('ItemFlow', self.owner, const.REDUCE, const.RESOURCE,
num, 1, 0, reason, self._finances[const.COIN], '')
tlog_action.log('MoneyFlow', self.owner, self._finances[const.COIN],
num, reason, const.REDUCE, 1)
return True
def tick():
result = GlobalObject().remote['login'].server_sync_remote(
name, front_ip, front_port, '1', server_no)
if result is False:
reactor.callLater(1, tick)
else:
reactor.callLater(60, tick)
logger.info('server online num:%s', UsersManager().get_online_num())
tlog_action.log('OnlineNum', UsersManager().get_online_num())
def up_guide_1816(data, player):
request = UpGuideRequest()
request.ParseFromString(data)
response = CommonResponse()
guide_id = request.guide_id
tlog_action.log('UpGuide', player, guide_id)
response.result = True
return response.SerializePartialToString()
def settle(player, result, response, conf, stage_type=1, star_num=0):
"""docstring for settle"""
# 保存关卡信息
player.stage_component.save_data()
# 保存活跃度
# 增加玩家和武将经验，增加金币
if not result and stage_type not in [4, 5]:
return
player.finance.coin += conf.currency
player.finance.save_data()
player.base_info.addexp(conf.playerExp, const.STAGE)
player.set_level_related()
player.base_info.save_data()
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(conf.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, 1, 0, 0, 0, 0)
hero.save_data()
# 更新等级相关属性
# 构造掉落
settlement_drops = player.fight_cache_component.fighting_settlement(
result, star_num)
logger.debug("stage_util.drops %s" % settlement_drops)
multiple, part_multiple = get_drop_activity(
player, player.fight_cache_component.stage_id, stage_type, star_num)
data = gain(player,
settlement_drops,
const.STAGE,
multiple=multiple,
part_multiple=part_multiple)
get_return(player, data, response.drops)
logger.debug("stage_util.drops %s" % response.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)
get_return(player, data, response.drops)
def consume_coin(self, num, reason):
if num < self._finances[const.COIN]:
return False
self._finances[const.COIN] -= num
tlog_action.log('ItemFlow', self.owner, const.REDUCE, const.RESOURCE, num,
1, 0, reason, self._finances[const.COIN], '')
tlog_action.log('MoneyFlow', self.owner, self._finances[const.COIN],
num, reason, const.REDUCE, 1)
return True
def send_award_in(self):
""" 参与奖励
"""
mail_id = game_configs.base_config.get("world_boss").get('in_rewards')
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))
send_mail(conf_id=mail_id, receive_id=player_id)
tlog_action.log('WorldBossInReward', player_id, mail_id)
def add_gold(self, num, reason):
if self._owner.pay.REMOTE_DEPLOYED:
self._owner.pay.present(num)
else:
self._finances[const.GOLD] += num
if reason:
tlog_action.log('ItemFlow', self.owner, const.ADD, const.RESOURCE, num,
2, 0, reason, self._finances[const.GOLD], '')
tlog_action.log('MoneyFlow', self.owner, self._finances[const.GOLD],
num, reason, const.ADD, 2)
def func():
item.buy_stamina_times += num
player.finance.add(resource_type,
info.get("one_buy_value") * num,
reason=const.BUY_STAMINA)
item.last_buy_stamina_time = int(time.time())
player.finance.save_data()
player.stamina.save_data()
logger.debug("buy stamina++++++++++++++++++++")
tlog_action.log('BuyStamina', player, resource_type, num)
def one_key_hero_upgrade_logic(hero_no, player):
hero = player.hero_component.get_hero(hero_no)
total_exp = 0
small_exp_item = player.item_package.get_item(10001)
middle_exp_item = player.item_package.get_item(10002)
big_exp_item = player.item_package.get_item(10003)
small_exp = game_configs.item_config.get(10001).get('funcArg1')
middle_exp = game_configs.item_config.get(10002).get('funcArg1')
big_exp = game_configs.item_config.get(10003).get('funcArg1')
need_total_exp = hero.need_exp_to_max(player.base_info.level)
logger.debug('need_total_exp %s' % need_total_exp)
if small_exp_item:
logger.debug("small_exp_item num %s" % small_exp_item.num)
if middle_exp_item:
logger.debug("middle_exp_item num %s" % middle_exp_item.num)
if big_exp_item:
logger.debug("big_exp_item num %s" % big_exp_item.num)
small_exp_num = 0
middle_exp_num = 0
big_exp_num = 0
if small_exp_item:
for i in range(small_exp_item.num):
if total_exp > need_total_exp:
break
total_exp += small_exp
small_exp_num = i + 1
if middle_exp_item:
for i in range(middle_exp_item.num):
if total_exp > need_total_exp:
break
total_exp += middle_exp
middle_exp_num = i + 1
if big_exp_item:
for i in range(big_exp_item.num):
if total_exp > need_total_exp:
break
total_exp += big_exp
big_exp_num = i + 1
beforelevel = hero.level
hero.upgrade(small_exp * small_exp_num + middle_exp * middle_exp_num + big_exp * big_exp_num, player.base_info.level)
hero.save_data()
afterlevel = hero.level
changelevel = afterlevel-beforelevel
tlog_action.log('HeroUpgrade', player, hero_no, changelevel, afterlevel, 3,
small_exp_num, middle_exp_num, big_exp_num, 0)
player.item_package.consume_item(10001, small_exp_num)
player.item_package.consume_item(10002, middle_exp_num)
player.item_package.consume_item(10003, big_exp_num)
return {"result": True, "hero": hero, "small_exp_num": small_exp_num, "middle_exp_num": middle_exp_num, "big_exp_num": big_exp_num}
def runt_set_841(data, player):
"""镶嵌符文"""
args = RuntSetRequest()
args.ParseFromString(data)
hero_no = args.hero_no
runt_type = args.runt_type
runt_set_infos = args.runt_set_info
response = RuntSetResponse()
if is_not_open(player, FO_RUNT_ADD):
response.res.result = False
response.res.result_no = 837
return response.SerializeToString()
hero = player.hero_component.get_hero(hero_no)
for runt_set_info in runt_set_infos:
runt_po = runt_set_info.runt_po
runt_no = runt_set_info.runt_no
if runt_po > game_configs.base_config.get('totemSpaceNum'+str(runt_type)):
response.res.result = False
response.res.result_no = 827
return response.SerializeToString()
if hero.runt.get(runt_type):
if hero.runt.get(runt_type).get(runt_po):
response.res.result = False
response.res.result_no = 821
return response.SerializeToString()
else:
hero.runt[runt_type] = {}
runt_info = player.runt.m_runt.get(runt_no)
if not runt_info:
response.res.result = False
response.res.result_no = 825
return response.SerializeToString()
now = int(time.time())
for runt_set_info in runt_set_infos:
runt_po = runt_set_info.runt_po
runt_no = runt_set_info.runt_no
runt_info = player.runt.m_runt.get(runt_no)
hero.runt.get(runt_type)[runt_po] = [runt_no] + runt_info
player.runt.reduce_runt(runt_no)
tlog_action.log('HeroRuntSet', player, hero_no, now,
runt_no, runt_po, runt_info[0])
target_update(player, [55])
hero.save_data()
player.runt.save()
response.res.result = True
return response.SerializeToString()
def tick():
result = GlobalObject().remote['login'].server_sync_remote(name, front_ip,
front_port,
'1',
server_no)
if result is False:
reactor.callLater(1, tick)
else:
reactor.callLater(60, tick)
logger.info('server online num:%s', UsersManager().get_online_num())
tlog_action.log('OnlineNum', UsersManager().get_online_num())
def add_gold(self, num, reason):
if self._owner.pay.REMOTE_DEPLOYED:
self._owner.pay.present(num)
else:
self._finances[const.GOLD] += num
if reason:
tlog_action.log('ItemFlow', self.owner, const.ADD, const.RESOURCE,
num, 2, 0, reason, self._finances[const.GOLD], '')
tlog_action.log('MoneyFlow', self.owner,
self._finances[const.GOLD], num, reason, const.ADD,
2)
def auto_travel_837(data, player):
args = AutoTravelRequest()
args.ParseFromString(data)
stage_id = args.stage_id
ttime = args.ttime
response = AutoTravelResponse()
auto_travel_config = game_configs.base_config.get('autoTravel').get(ttime)
if player.finance.gold < auto_travel_config[1]:
response.res.result = False
response.res.result_no = 102 # 充值币不足
return response.SerializeToString()
can_auto_travel = 1
auto_is_finish = 1
if player.travel_component.auto.get(stage_id):
auto_is_finish = 0
for auto_travel in player.travel_component.auto.get(stage_id):
if game_configs.base_config.get('autoTravel').get(
auto_travel.get('continued_time'))[0] != auto_travel.get(
'already_times'):
can_auto_travel = 0
else:
for auto_travel_event in auto_travel.get('events'):
if len(auto_travel_event) < 3:
can_auto_travel = 0
if not can_auto_travel:
response.res.result = False
response.res.result_no = 819
return response.SerializeToString()
# 扣元宝
player.finance.consume_gold(auto_travel_config[1], const.TRAVEL_AUTO)
# 逻辑
if auto_is_finish:
player.travel_component.auto[stage_id] = []
info = {
'start_time': int(time.time()),
'continued_time': ttime,
'events': [],
'already_times': 0
}
player.travel_component.auto[stage_id].append(info)
player.finance.save_data()
deal_auto_response(response, player)
response.res.result = True
tlog_action.log('AutoTravel', player, stage_id, ttime)
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)
def get_award_909(pro_data, player):
"""取得章节奖励
"""
request = stage_request_pb2.StarAwardRequest()
request.ParseFromString(pro_data)
chapter_id = request.chapter_id
award_type = request.award_type
response = stage_response_pb2.StarAwardResponse()
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("chapter_info dont find")
response.res.result = False
response.res.result_no = 831
return response.SerializePartialToString()
else:
chapter_obj = chapters_info[0]
conf = chapter_obj.get_conf()
chapter_obj.update(player.stage_component.calculation_star(chapter_id))
if 0 <= award_type <= 2:
if chapter_obj.award_info[award_type] != 0:
logger.error("already receive or can`t receive")
response.res.result = False
response.res.result_no = 832
return response.SerializePartialToString()
else:
chapter_obj.award_info[award_type] = 1
bag_id = conf.starGift[award_type]
drop = get_drop(bag_id)
return_data = gain(player, drop, const.CHAPTER_AWARD)
get_return(player, return_data, response.drops)
player.stage_component.save_data()
tlog_action.log('OpenStarChest', player, chapter_id, award_type)
else:
response.res.result = False
response.res.result_no = 800
return response.SerializePartialToString()
# 满星抽奖
# if chapter_obj.award_info[-1] == -1:
# logger.error("can`t receive")
# response.res.result = False
# response.res.result_no = 833
# return response.SerializePartialToString()
# else:
# pass
response.res.result = True
# logger.debug(response)
return response.SerializePartialToString()
def reset_1242(data, player):
"""
重置地图,ok
"""
request = mine_pb2.resetMap()
request.ParseFromString(data)
response = mine_pb2.resetResponse()
response.free = request.free
# print '1242-request', request
reset_pos = []
if request.free == 1:
if player.mine.can_reset_free():
reset_pos = player.mine.reset_map()
mine_status(player, response.mine)
response.res.result = True
else:
response.res.result = False
response.res.result_no = 12420
response.res.message = u"免费次数已用完"
else:
if not player.mine.can_reset():
response.res.result = False
response.res.result_no = 12421
response.res.message = u"重置次数已用完"
else:
reset_price = player.mine.reset_price()
price = CommonGroupItem(0, reset_price, reset_price, const.GOLD)
result = item_group_helper.is_afford(player, [price]) # 校验
if not result.get('result'):
response.res.result = False
response.res.result_no = result.get('result_no')
response.res.message = u'消费不足！'
else:
need_gold = item_group_helper.get_consume_gold_num([price])
def func():
consume_data = item_group_helper.consume(player,
[price],
const.MINE_RESET)
item_group_helper.get_return(player,
consume_data,
response.consume)
reset_pos = player.mine.reset_map()
mine_status(player, response.mine)
response.res.result = True
player.pay.pay(need_gold, const.MINE_RESET, func)
player.mine.save_data()
player.act.mine_refresh()
target_update(player, [56])
reset_times, _, _ = player.mine.reset_times
tlog_action.log('MineReset', player, reset_times,
str(reset_pos))
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 = game_configs.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 += game_configs.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
"""
last_eat_time = player.feast.last_eat_time
now = int(time.time())
eat_times = game_configs.base_config.get(u'time_vigor_activity')
t = time.localtime(now)
for eat_time in eat_times:
time1 = time.mktime(
time.strptime(time.strftime('%Y-%m-%d ' + eat_time[0] + ':00', t),
'%Y-%m-%d %H:%M:%S'))
time2 = time.mktime(
time.strptime(time.strftime('%Y-%m-%d ' + eat_time[1] + ':00', t),
'%Y-%m-%d %H:%M:%S'))
if time2 >= now >= time1:
if time2 >= last_eat_time >= time1:
# 已经吃过
return 1
# 吃
player.stamina.stamina += game_configs.base_config.get(
u'num_vigor_activity')
player.stamina.save_data()
player.feast.last_eat_time = int(time.time())
player.feast.save_data()
tlog_action.log('Feast', player, player.stamina.stamina)
return 2
# 没到时间
return 3
def func():
consume_data = consume(player, consume_config, const.NEW_GUIDE_STEP)
get_return(player, consume_data, response.consume)
# logger.debug("gain_data %s %s" % (gain_data, request.step_id))
# logger.debug(player.finance.coin)
tlog_action.log('NewGuide', player, new_guide_item.get('Sequence'),
request.step_id)
if my_newbee_sequence < new_guide_item.get('Sequence'):
player.base_info.newbee_guide[new_guide_type] = request.step_id
player.base_info.current_newbee_guide = request.step_id
player.base_info.save_data()
