def recharge_lenovo_response():
logger.debug('lenovo recharge:%s', request.form)
data = eval(request.form['transdata'])
product_per_price = data['money']
cp_order_id = data['exorderno']
product_id = data['cpprivate']
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 'FAILURE'
child_node = GlobalObject().child(oldvcharacter.node)
result = child_node.lenovo_recharge_remote(oldvcharacter.dynamic_id,
product_id, product_per_price,
cp_order_id, True)
if result is True:
logger.debug('response:success')
return 'SUCCESS'
logger.debug('response:failed')
return 'FAILURE'
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 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 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 new_hero_data(self, hero):
pid = self.owner.character_id
hero_property = hero.hero_proerty_dict()
char_obj = tb_character_info.getObj(pid).getObj('heroes')
result = char_obj.hsetnx(hero_property['hero_no'], hero_property)
if not result:
logger.error('new hero error!:%s', hero_property['hero_no'])
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 get_ipaddress(self, pid):
if pid not in self._connections:
logger.error("kick err>>>%s", pid)
return None
connection = self._connections[pid]
return connection.ipaddress
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 check(self):
"""校验关卡是否开启"""
player = self._player
conf = self.get_stage_config()
tm_time = time.localtime(player.stage_component.elite_stage_info[1])
act_confs = game_configs.activity_config.get(24, [])
is_open = 0
add_times = 0
act_conf1 = None
for act_conf in act_confs:
if player.base_info.is_activiy_open(act_conf.id):
is_open = 1
act_conf1 = act_conf
break
if is_open:
add_times = act_conf1.parameterA
max_times = game_configs.vip_config.get(player.base_info.vip_level). \
eliteCopyTimes - player.stage_component. \
elite_stage_info[0] + add_times
if tm_time.tm_yday == time.localtime().tm_yday \
and max_times < conf.timesExpend:
logger.error("精英关卡开始战斗出错: %s" % 805)
return {'result': False, 'result_no': 805} # 805 次数不足
return {'result': True}
def add_data(self, character_id, attr_id=0):
no = self._base_info.equipment_no
mainAttr, minorAttr, prefix, equip_attr_id = init_equipment_attr(no, attr_id)
print mainAttr, minorAttr, prefix, equip_attr_id, '============================================equipment_attr'
self._attribute.main_attr = mainAttr
self._attribute.minor_attr = minorAttr
self._attribute.prefix = prefix
self._attribute.attr_id = equip_attr_id
data = dict(id=self._base_info.id,
equipment_info=dict(equipment_no=no,
slv=self._attribute.strengthen_lv,
alv=self._attribute.awakening_lv,
is_guard=self._attribute.is_guard,
exp=self._attribute.exp,
main_attr=mainAttr,
minor_attr=minorAttr,
prefix=prefix,
attr_id=equip_attr_id),
enhance_info=self._record.enhance_record,
nobbing_effect=self._attribute.nobbing_effect)
char_obj = tb_character_info.getObj(character_id).getObj('equipments')
result = char_obj.hsetnx(self._base_info.id, data)
if not result:
logger.error('add equipment error!:%s', self._base_info.id)
def check(self):
"""校验关卡是否开启"""
player = self._player
conf = self.get_stage_config()
tm_time = time.localtime(player.stage_component.elite_stage_info[2])
act_confs = game_configs.activity_config.get(24, [])
is_open = 0
add_times = 0
act_conf1 = None
for act_conf in act_confs:
if player.act.is_activiy_open(act_conf.id):
is_open = 1
act_conf1 = act_conf
break
if is_open:
add_times = act_conf1.parameterA
max_times = game_configs.base_config.get('eliteDuplicateTime') + add_times
shengxia_times = max_times - conf.timesExpend - player.stage_component.elite_stage_info[0]
if tm_time.tm_yday == time.localtime().tm_yday \
and shengxia_times < 0:
logger.error("精英关卡开始战斗出错: %s" % 805)
return {'result': False, 'result_no': 805} # 805 次数不足
return {'result': 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 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 __assemble_skills(self, buffs, mold=0):
"""根据突破技能组装技能
@param buffs: 技能buff组
@param mold： 0：普通技能 1：怒气技能
@return: 普通技能ID，普通技能buff组，怒气技能ID，怒气技能buff组
"""
skill_ids = self.break_skill_ids
for skill in skill_ids:
skill_config = game_configs.skill_config.get(skill) # 技能配置
if not skill_config:
logger.error('skill config can not find id:%d' % skill)
group = skill_config.group # buff组
for buff_id in group:
buff_config = game_configs.skill_buff_config.get(buff_id) # buff配置
trigger_type = buff_config.triggerType # 触发类别
# 6-如果普通技能组击中敌人则生效
# 7-如果怒气技能组击中敌人则生效
# 8-普通技能组或怒气技能组击中敌人则生效
# 9-普通技能组或怒气技能是治疗技能则生效
# 10-普通技能组或怒气技能组释放前生效
if trigger_type == 6 and not mold:
buffs.append(buff_id)
continue
if trigger_type == 7 and mold:
buffs.append(buff_id)
continue
if trigger_type == 8 or trigger_type == 9 or trigger_type == 10:
buffs.append(buff_id)
continue
return buffs
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 save_data(self):
mine_obj = tb_character_info.getObj(self.owner.base_info.id)
if mine_obj:
data = {'stones': {'1': self._stones}}
mine_obj.hmset(data)
else:
logger.error('cant find mine:%s', self.owner.base_info.id)
def verify_login(token, ssoid):
"""
登录校验
"""
parameters = {'fileId': ssoid, 'token': token}
url = QUERY_URL + '?' + urllib.urlencode(parameters)
oauthTimestamp = xtime.timestamp(1000)
oauthNonce = xtime.timestamp() + xrand.randomint(0, 9)
base_str = urllib.urlencode({'oauthConsumerKey': APP_KEY}) + '&'
base_str += urllib.urlencode({'oauthToken': token}) + '&'
base_str += urllib.urlencode({'oauthSignatureMethod': 'HMAC-SHA1'}) + '&'
base_str += urllib.urlencode({'oauthTimestamp': oauthTimestamp}) + '&'
base_str += urllib.urlencode({'oauthNonce': oauthNonce}) + '&'
base_str += urllib.urlencode({'oauthVersion': '1.0'}) + '&'
oauthSignature = APP_SECRET + '&'
sign = hmac.new(oauthSignature, base_str,
hashlib.sha1).digest().encode('base64').rstrip()
sign = urllib.urlencode({'': sign})[1:]
result = request_url(url, {'param': base_str, 'oauthSignature': sign})
if result:
js = json.loads(result)
if js["resultCode"] == '200' and js["ssoid"] == ssoid:
return js
logger.error(result)
return None
def get_shop_item_ids(self, shop_type, luck_num):
"""随机筛选ids"""
items = {}
for item in game_configs.shop_config.get(shop_type, []):
if item.weight == -1:
continue
elif item.weight == -2:
weights = sorted(item.get('weightGroup'), reverse=True)
for w in weights:
if luck_num >= w:
items[item.id] = item.get('weightGroup')[w]
break
else:
logger.error('error luck_num:%s:%s', luck_num, item.get('weightGroup'))
else:
items[item.id] = item.weight
shop_item = game_configs.shop_type_config.get(shop_type)
if not shop_item:
raise Exception('error shop type:%s' % shop_type)
item_num = shop_item.get('itemNum')
if item_num == -1:
return items.keys()
if not items:
return []
return random_multi_pick_without_repeat(items, item_num)
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 save_data(self):
shop = tb_character_info.getObj(self.owner.base_info.id)
if shop:
data = {'shop': self._shop_data, 'shop_extra_args': self._shop_extra_args}
shop.hmset(data)
else:
logger.error('cant find shop:%s', self.owner.base_info.id)
def _with_pvp_info(response, character_id):
char_obj = tb_character_info.getObj(character_id)
robot_obj = tb_character_info.getObj('robot')
data = {}
if character_id >= 10000 and char_obj.exists():
keys = ['line_up_slots',
'level',
'nickname',
'attackPoint',
'heads']
data = char_obj.hmget(keys)
heads = Heads_DB()
heads.ParseFromString(data['heads'])
data['head'] = heads.now_head
hero_nos, hero_levels = _get_hero_no_and_level(data['line_up_slots'])
data['hero_ids'] = hero_nos
data['hero_levels'] = hero_levels
data['character_id'] = character_id
elif robot_obj.hexists(character_id):
data = robot_obj.hget(character_id)
else:
logger.error('no pvp info:%s', character_id)
return
response.level = data.get('level')
response.nickname = data.get('nickname')
response.ap = int(data.get('attackPoint'))
response.hero_ids.extend([_ for _ in data['hero_ids']])
response.hero_levels.extend([_ for _ in data['hero_levels']])
response.head_no = data.get('head_no', 0)
response.character_id = data.get('character_id')
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 pvp_fight_revenge_1507(data, player):
request = pvp_rank_pb2.PvpFightRevenge()
response = pvp_rank_pb2.PvpFightResponse()
request.ParseFromString(data)
line_up = request.lineup
skill = request.skill
target_id = request.black_id
if not player.friends.can_revenge(target_id):
logger.error('black id is not in blacklist:%s', target_id)
response.res.result = False
response.res.result_no = 1516
return response.SerializePartialToString()
def settle(player, fight_result):
logger.debug("fight revenge result:%s" % fight_result)
if fight_result:
player.friends.del_blacklist(target_id)
player.friends.save_data()
revenge_reward = game_configs.base_config['arenaRevengeRewards']
return_data = gain(player, revenge_reward, const.FRIEND_REVENGE)
get_return(player, return_data, response.gain)
response.res.result = True
logger.debug("red_units: %s" % response.red)
return response.SerializeToString()
return pvp_fight(player, target_id, line_up, skill, response, settle)
def get_cur(mine_id, now_data, harvest, start, end, now, increase, stype):
# 结算到当前的产出
mine = ConfigData.mine(mine_id)
if now_data >= mine.outputLimited:
logger.error('get_cur:%s > %s', now_data, mine.outputLimited)
now_data = mine.outputLimited
if stype == 1:
num, last = compute(mine_id,
increase,
mine.timeGroup1,
mine.outputGroup1,
now,
start,
end)
stone = gen_stone(num,
mine.group1,
mine.outputLimited,
harvest,
now_data)
else:
num, last = compute(mine_id,
increase,
mine.timeGroupR,
mine.outputGroupR,
now,
start,
end)
stone = gen_stone(num,
mine.randomStoneId,
mine.outputLimited,
harvest,
now_data)
return last, stone
def get_shop_data(self, t):
if t not in self._shop_data:
logger.error('err shop type:%s', t)
return None
self.check_time()
return self._shop_data[t]
def get_blue_units(uid):
record = get_pvp_data(uid)
if not record:
logger.error('player id is not found:%s', uid)
return None
return record
def update_excel(args):
print("update_excell=========1")
if 'excel_url' in args:
url = args['excel_url']
else:
logger.error("excel_url not exists!!!")
# url="http://192.168.1.60:2600/static/upload/server_cfg_1435338130"
return {'success': 0, 'message': 1}
res = urllib.urlretrieve(url, '/tmp/config.zip')
print res
print("update_excell=========2")
os.system("cd /tmp; unzip -o config.zip")
os.system("cp /tmp/excel_cpickle config/excel_cpickle")
os.system("cp -r /tmp/lua/. app/battle/src/app/datacenter/template/config/")
com = "curl localhost:%s/reloadmodule" % MASTER_WEBPORT
os.system(com)
# 通知客户端下线更新
if int(args['force_client_update']):
response = AccountKick()
response.id = 3
remote_gate.push_notice_remote(11,
response.SerializeToString())
return {"success": 1}
def _write_parameter(proto, arg):
if isinstance(arg, str):
proto.proto_param = arg
elif isinstance(arg, bool):
proto.bool_param = arg
elif isinstance(arg, unicode):
proto.string_param = arg
elif isinstance(arg, int) or isinstance(arg, long):
proto.int_param = arg
elif isinstance(arg, float):
proto.float_param = arg
elif arg is None:
proto.is_null = True
elif isinstance(arg, list):
for a in arg:
p = proto.list.add()
_write_parameter(p, a)
else:
proto.null_list = True
elif isinstance(arg, tuple):
for a in arg:
p = proto.tuples.add()
_write_parameter(p, a)
else:
proto.null_tuple = True
elif isinstance(arg, dict):
proto.python_param = marshal.dumps(arg)
else:
logger.error('error type:%s arg:%s', type(arg), arg)
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 settle_1252(data, player):
request = mine_pb2.MineSettleRequest()
response = common_pb2.CommonResponse()
request.ParseFromString(data)
pos = request.pos
result = request.result
is_pvp = player.mine.is_pvp(pos) # 根据矿所在位置判断pve or pvp
logger.debug("pos %s, mine_info %s" % (pos, is_pvp))
pve_check_result = pve_process_check(player,
result,
request.steps,
const.BATTLE_MINE_PVE)
if is_pvp is False and not pve_check_result:
logger.error("mine pve_process_check error!!!!!")
res = response.res
res.result = False
res.result_no = 9041
return response.SerializePartialToString()
# todo: set settle time to calculate acc_mine
process_mine_result(player, pos, result, None, 0, 1)
# 7日奖励 占领矿点
mine_id = player.mine._mine[pos].get("mine_id")
mine_item = game_configs.mine_config.get(mine_id)
logger.debug("mine_id %s mine_item %s" % (mine_id, mine_item))
if mine_item:
player.act.mine_win(mine_item.quality)
target_update(player, [57])
response.result = True
return response.SerializePartialToString()
def get_target_info_1827(data, player):
"""获取任务奖励"""
args = start_target_pb2.GetStartTargetRewardRequest()
args.ParseFromString(data)
target_id = args.target_id
response = start_target_pb2.GetStartTargetRewardResponse()
if not player.act.is_activiy_open(target_id):
response.res.result = False
logger.error("start target dont open")
response.res.result_no = 890 # 不在活动时间内
return response.SerializeToString()
# 第几天登录
day = player.base_info.login_day
target_ids = []
for x in [1, 2, 3, 4, 5, 6, 7]:
if x > day:
continue
for a, b in game_configs.base_config.get('seven' + str(x)).items():
target_ids += b
if target_id not in target_ids:
response.res.result = False
logger.error("this start target dont open")
response.res.result_no = 800
return response.SerializeToString()
target_conf = game_configs.activity_config.get(target_id)
info = get_act_info(player, target_id)
if (target_conf.type != 30
and info.get('state') != 2) or (target_conf.type == 30
and info.get('state') == 3):
response.res.result = False
logger.error("this start target 条件不满足")
response.res.result_no = 800
return response.SerializeToString()
need_gold = 0
if target_conf.type == 30:
need_gold = target_conf.parameterB
def func():
return_data = gain(player, target_conf.reward,
const.START_TARGET) # 获取
get_return(player, return_data, response.gain)
if target_conf.type == 30:
if target_conf.count <= (info.get('jindu') + 1):
player.act.act_infos[target_id] = [3, 0]
else:
player.act.act_infos[target_id] = [1, info.get('jindu') + 1]
else:
player.act.act_infos[target_id] = [3, 0]
tlog_action.log('StartTargetGetGift', player, target_id)
player.pay.pay(need_gold, const.START_TARGET, func)
player.act.save_data()
response.res.result = True
return response.SerializeToString()
def do_shop_buy(shop_id, item_count, shop, vip_level, build_level):
shop_item = game_configs.shop_config.get(shop_id)
shop_id_buyed_num = shop['items'].get(shop_id, 0)
# shop_id_buyed_num_all = shop['all_items'].get(shop_id, 0)
# guild_shop_id_buyed_num_day = shop['guild_items'].get(shop_id, 0)
limit_type = ''
if shop_item.limitVIP:
limit_num = shop_item.limitVIP.get(vip_level, 0)
limit_type = 'all_items'
shop_id_buyed_num = shop['all_items'].get(shop_id, 0)
if shop_id_buyed_num + item_count > limit_num:
logger.error("vip limit shop item:%s:%s limit:%s:%s", shop_id,
item_count, shop_id_buyed_num, limit_num)
return {'res': False, 'no': 502}
# response.limit_item_current_num = shop_id_buyed_num_all
# response.limit_item_max_num = limit_num
elif shop_item.dutyFree:
limit_num = shop_item.dutyFree.get(build_level, 0)
limit_type = 'guild_items'
shop_id_buyed_num = shop['guild_items'].get(shop_id, 0)
if shop_id_buyed_num + item_count > limit_num:
logger.error("limit shop item:%s:%s limit:%s:%s", shop_id,
item_count, shop_id_buyed_num, limit_num)
return {'res': False, 'no': 502}
# response.limit_item_current_num = shop_id_buyed_num_day
# response.limit_item_max_num = limit_num
elif shop_item.contribution:
limit_num = shop_item.contribution.get(build_level, 0)
limit_type = 'items'
shop_id_buyed_num = shop['items'].get(shop_id, 0)
if shop_id_buyed_num + item_count > limit_num:
logger.error("limit shop item:%s:%s limit:%s:%s", shop_id,
item_count, shop_id_buyed_num, limit_num)
return {'res': False, 'no': 502}
# response.limit_item_current_num = shop_id_buyed_num_day
# response.limit_item_max_num = limit_num
elif shop_item.limitVIPeveryday:
limit_num = shop_item.limitVIPeveryday.get(vip_level, 0)
limit_type = 'items'
shop_id_buyed_num = shop['items'].get(shop_id, 0)
if shop_id_buyed_num + item_count > limit_num:
logger.error("limit shop item:%s:%s limit:%s:%s", shop_id,
item_count, shop_id_buyed_num, limit_num)
return {'res': False, 'no': 502}
# response.limit_item_current_num = shop_id_buyed_num_day
# response.limit_item_max_num = limit_num
elif shop_item.batch != -1:
limit_type = 'items'
if shop_id_buyed_num + item_count > shop_item.batch:
return {'res': False, 'no': 502}
if limit_type:
shop[limit_type][shop_id] = shop_id_buyed_num + item_count
_lucky_attr = 0
shop_item_attr = shop_item.get('attr')
if shop_item_attr:
lucky_keys = sorted(shop_item_attr.keys())
for k in lucky_keys:
if shop['luck_num'] >= k:
_lucky_attr = shop_item_attr[k]
else:
break
return {'res': True, 'lucky_attr': _lucky_attr, 'shop': shop}
"""
target = self.getTarget(targetKey)
if not target:
logger.error('command %s not Found on service' % str(targetKey))
return None
# if targetKey not in self.unDisplay:
# logger.info("call method %s on service[%s]" %
# (target.__name__, self._name))
t = time.time()
try:
response = target(*args, **kw)
except Exception, e:
logger.exception(e)
return None
except:
logger.error(traceback.format_exc())
return None
logger.info("call method %s on service[%s]:%f",
target.__name__, self._name, time.time() - t)
return response
class CommandService(Service):
"""A remoting service
According to Command ID search target
"""
def mapTarget(self, target):
"""Add a target to the service.
"""
key = target.__name__.split('_')[-1]
def battle_1253(data, player):
"""docstring for battle"""
request = mine_pb2.MineBattleRequest()
request.ParseFromString(data)
pos = request.pos # 矿所在位置
line_up = request.lineup # 阵容顺序
red_best_skill_id = request.unparalleled # 无双编号
red_units = {}
blue_units = {}
response = mine_pb2.MineBattleResponse()
logger.debug("%s pos" % pos)
if is_not_open(player, FO_MINE):
response.res.result = True
response.res.result_no = 837
return response.SerializePartialToString()
mine_info = player.mine.get_info(pos)
is_pvp = player.mine.is_pvp(pos) # 根据矿所在位置判断pve or pvp
# print mine_info, "*"*80
detail_info = player.mine.detail_info(request.pos)
if not is_pvp:
# pve
stage_id = mine_info.get("stage_id") # todo: 根据pos获取关卡id
stage_type = 8 # 关卡类型
stage_info = pve_process(stage_id,
stage_type,
line_up,
0,
player
)
result = stage_info.get('result')
response.res.result = result
if not result:
logger.info('进入关卡返回数据:%s', response)
response.res.result_no = stage_info.get('result_no')
return response.SerializePartialToString()
red_units = stage_info.get('red_units')
blue_units = stage_info.get('blue_units')
blue_units = blue_units[0]
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
# print red_units, blue_units
else:
# pvp
normal = detail_info['normal']
lucky = detail_info['lucky']
num = sum(normal.values()) + sum(lucky.values())
if player.runt.bag_is_full(num):
response.res.result = False
response.res.result_no = 125308
logger.error('mine harvest bag is full!')
return response.SerializePartialToString()
player.fight_cache_component.stage_id = 0
red_units = player.fight_cache_component.get_red_units()
blue_data = get_blue_units(detail_info['uid'])
blue_units = blue_data.get('copy_units')
seed1, seed2 = get_seeds()
if not blue_units:
fight_result = True
else:
fight_result = pvp_process(player,
line_up,
red_units,
blue_units,
seed1, seed2,
const.BATTLE_MINE_PVP)
hold = request.hold
process_mine_result(player, pos, fight_result, response, 1, hold)
response.fight_result = fight_result
response.seed1 = seed1
response.seed2 = seed2
# print red_units, blue_units
pvp_assemble_units(red_units, blue_units, response)
response.res.result = True
response.hold = request.hold
logger.debug('battle_1253:%s', response)
return response.SerializePartialToString()
def process_mine_result(player, position, fight_result,
response, stype, hold=1):
"""
玩家占领其他人的野怪矿，更新矿点数据，给玩家发送奖励，给被占领玩家发送奖励
@param gain: true or false
"""
result = player.mine.settle(position, fight_result, hold)
normal = result['normal']
lucky = result['lucky']
if stype != 1:
return
# print 'process mine result:', normal, lucky
target = result['old_uid']
nickname = result['old_nickname']
if fight_result is not True:
send_mail(conf_id=122, receive_id=target, nickname=player.base_info.base_name)
return
warFogLootRatio = game_configs.base_config['warFogLootRatio']
normal_a = {}
normal_b = {}
lucky_a = {}
lucky_b = {}
for k, v in normal.items():
if v > 0:
normal_a[k] = int(v*warFogLootRatio)
normal_b[k] = v - int(v*warFogLootRatio)
for k, v in lucky.items():
if v > 0:
lucky_a[k] = int(v*warFogLootRatio)
lucky_b[k] = v - int(v*warFogLootRatio)
prize = []
prize_num = 0
for k, v in normal_b.items():
prize.append({106: [v, v, k]})
prize_num += v
for k, v in lucky_b.items():
prize.append({106: [v, v, k]})
prize_num += v
logger.debug('pvp mine total:normal %s-%s lucky %s-%s prize:%s',
normal_a, normal_b, lucky_a, lucky_b, prize)
if not add_stones(player, normal_a, response.gain):
response.res.result = False
response.res.result_no = 824
logger.error('add_stones fail!!!!!!')
if not add_stones(player, lucky_a, response.gain):
response.res.result = False
response.res.result_no = 824
logger.error('add_stones fail!!!!!!')
mail_id = game_configs.base_config.get('warFogRobbedMail')
send_mail(conf_id=mail_id, receive_id=target, rune_num=prize_num,
prize=str(prize), nickname=player.base_info.base_name)
def buy_coin_activity_1406(data, player):
"""招财进宝
request: 无
respone: BuyCoinResponse
"""
response = buy_coin_activity_pb2.BuyCoinResponse()
all_buy_times = player.buy_coin.buy_times # 购买次数
buy_times = all_buy_times
#extra_can_buy_times = player.buy_coin.extra_can_buy_times
need_gold = 0
gain_info = game_configs.base_config.get("getMoneyValue")
free_times = game_configs.base_config.get("getMoneyFreeTimes")
buy_times_price = game_configs.base_config.get("getMoneyBuyTimesPrice")
# 获取 need_gold
act_confs = game_configs.activity_config.get(26, [])
xs = 1
for act_conf in act_confs:
if player.act.is_activiy_open(act_conf.id):
xs = act_conf.parameterB
free_times += act_conf.parameterA
if act_conf.parameterC[0] <= buy_times:
xs = 1
break
for k in sorted(buy_times_price.keys(), reverse=True):
if buy_times >= k:
need_gold = buy_times_price[k]
break
if free_times > buy_times:
need_gold = 0
logger.debug("need_gold %s, free_times %s, all_buy_times %s, xs %s" %
(need_gold, free_times, all_buy_times, xs))
if need_gold > player.finance.gold:
logger.error("buy_coin_activity_1406: gold not enough %s, %s" %
(need_gold, player.finance.gold))
response.res.result = False
response.res.result_no = 201
return response.SerializePartialToString()
item_no = 63002
item = player.item_package.get_item(item_no)
item_num = 0
if item:
item_num = item.num
if player.base_info.buy_coin_times + free_times <= buy_times and item_num == 0:
logger.error("buy_coin_activity_1406: times not enough %s, %s, %s" %
(item_num, player.base_info.buy_coin_times,
player.buy_coin.buy_times))
response.res.result = False
response.res.result_no = 1406
return response.SerializePartialToString()
coin_nums = 0 # 银币数量
for k in sorted(gain_info.keys(), reverse=True):
if buy_times >= k:
coin_nums = gain_info[k]
break
def func():
if player.base_info.buy_coin_times + free_times <= buy_times:
# 使用招财令
player.item_package.consume_item(item_no, 1)
player.buy_coin.buy_times = all_buy_times + 1
player.buy_coin.last_time = get_current_timestamp()
player.buy_coin.save_data()
add_coin_nums = coin_nums * xs
player.finance.add_coin(int(add_coin_nums), const.BUY_COIN_ACT)
player.finance.save_data()
tlog_action.log('BuyCoin', player, need_gold,
player.buy_coin.buy_times, int(add_coin_nums))
res = player.pay.pay(need_gold, const.BUY_COIN_ACT, func)
response.res.result = res
if not res:
response.res.result_no = 100
return response.SerializeToString()
def pvp_fight_request_1505(data, player):
request = pvp_rank_pb2.PvpFightRequest()
request.ParseFromString(data)
__skill = request.skill
__best_skill = player.line_up_component.get_skill_id_by_unpar(__skill)
__skill_level = 0
if __skill in player.line_up_component.unpars:
__skill_level = player.line_up_component.unpars[request.skill]
else:
logger.error('error skill level:%s,%s', request.skill,
player.line_up_component.unpars.keys())
line_up = {} # {hero_id:pos}
for line in request.lineup:
if not line.hero_id:
continue
line_up[line.hero_id] = line.pos
player.line_up_component.line_up_order = line_up
player.line_up_component.save_data()
prere = dict(character_id=player.base_info.id)
record = util.GetOneRecordInfo(PVP_TABLE_NAME, prere, ['id'])
before_player_rank = 0
if record:
before_player_rank = record.get('id')
refresh_rank_data(player, before_player_rank,
__skill, __skill_level)
if before_player_rank == request.challenge_rank:
logger.error('cant not fight self')
return False
prere = dict(id=request.challenge_rank)
record = util.GetOneRecordInfo(PVP_TABLE_NAME, prere,
['character_id',
'nickname',
'level',
'ap',
'best_skill',
'unpar_skill',
'unpar_skill_level',
'units',
'slots',
'hero_ids'])
blue_units = record.get('units')
# print "blue_units:", blue_units
blue_units = cPickle.loads(blue_units)
# print "blue_units:", blue_units
red_units = player.fight_cache_component.red_unit
player.fight_cache_component.awake_hero_units(blue_units)
player.fight_cache_component.awake_hero_units(red_units)
process = BattlePVPProcess(red_units, __best_skill, player.level.level, blue_units,
record.get('best_skill', 0), record.get('level', 1))
fight_result = process.process()
logger.debug("fight result:%s" % fight_result)
if fight_result:
logger.debug("fight result:True:%s:%s",
before_player_rank,
request.challenge_rank)
if before_player_rank != 0:
if request.challenge_rank < before_player_rank:
prere = dict(id=before_player_rank)
result = util.UpdateWithDict(PVP_TABLE_NAME, record, prere)
logger.info('update result:%s', result)
refresh_rank_data(player, request.challenge_rank,
__skill, __skill_level)
else:
refresh_rank_data(player, request.challenge_rank,
__skill, __skill_level)
else:
logger.debug("fight result:False")
response = pvp_rank_pb2.PvpFightResponse()
response.res.result = True
for slot_no, red_unit in red_units.items():
if not red_unit:
continue
red_add = response.red.add()
assemble(red_add, red_unit)
for slot_no, blue_unit in blue_units.items():
if not blue_unit:
continue
blue_add = response.blue.add()
assemble(blue_add, blue_unit)
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')
lively_event = CountEvent.create_event(EventType.SPORTS, 1, ifadd=True)
tstatus = player.tasks.check_inter(lively_event)
if tstatus:
task_data = task_status(player)
remote_gate.push_object_remote(1234, task_data, [player.dynamic_id])
return response.SerializeToString()
def __init__(self):
try:
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
except IOError, arg:
(_, err_msg) = arg
logger.error(str(err_msg))
def enter_scene_remote(dynamic_id, character_id, pay_arg):
"""进入场景"""
is_new_character = 0
player = PlayersManager().get_player_by_id(character_id)
if not player:
logger.debug('player login:%s', character_id)
player = PlayerCharacter(character_id, dynamic_id=dynamic_id)
if player.is_new_character() and not OPEN_REGISTER:
PlayersManager().drop_player_by_id(character_id)
logger.debug('player login, 4005 open register:%s', OPEN_REGISTER)
return {'player_data': 4005}
is_new_character = init_player(player)
PlayersManager().add_player(player)
else:
if player.is_new_character() and not OPEN_REGISTER:
PlayersManager().drop_player_by_id(character_id)
logger.debug('player login, 4005 open register:%s', OPEN_REGISTER)
return {'player_data': 4005}
logger.debug('player exsit! player.dynamic_id %s new dynamic_id %s' %
(player.dynamic_id, dynamic_id))
if player.dynamic_id != dynamic_id:
logger.error('dynamic id is not same:%s,%s:%s', character_id,
dynamic_id, player.dynamic_id)
player.dynamic_id = dynamic_id
player.pay.set_pay_arg(pay_arg) # 设置支付参数
player.base_info.plat_id = pay_arg.get("plat_id") # ios 0 android 1
logger.debug("plat_id %s" % pay_arg.get("plat_id"))
remote_gate.pull_message_remote(character_id)
remote_gate['push'].online_offline_remote(player.base_info.id, 1)
responsedata = GameLoginResponse()
responsedata.res.result = True
responsedata.id = player.base_info.id
responsedata.nickname = player.base_info.base_name
print server_open_time, '======================'
responsedata.server_open_time = server_open_time
responsedata.level = player.base_info.level
responsedata.exp = player.base_info.exp
responsedata.gag = player.base_info.gag
responsedata.closure = player.base_info.closure
for k, i in enumerate(player.finance._finances):
print(k, i)
responsedata.finances.append(int(i))
responsedata.fine_hero = player.last_pick_time.fine_hero
responsedata.excellent_hero = player.last_pick_time.excellent_hero
responsedata.fine_equipment = player.last_pick_time.fine_equipment
responsedata.excellent_equipment = player.last_pick_time.excellent_equipment
responsedata.fine_hero_times = player.shop.single_coin_draw_times
responsedata.excellent_hero_times = player.shop.single_gold_draw_times
responsedata.pvp_times = player.pvp.pvp_times
responsedata.pvp_refresh_count = player.pvp.pvp_refresh_count
responsedata.pvp_overcome_index = player.pvp.pvp_overcome_current
responsedata.pvp_overcome_stars = player.pvp.pvp_overcome_stars
responsedata.pvp_overcome_refresh_count = player.pvp.pvp_overcome_refresh_count
combat_power = player.line_up_component.combat_power
responsedata.combat_power = combat_power
hight_power = player.line_up_component.hight_power
if hight_power and hight_power >= combat_power:
responsedata.hight_power = hight_power
else:
responsedata.hight_power = combat_power
player.line_up_component.hight_power = combat_power
player.line_up_component.save_data()
responsedata.hight_power = player.line_up_component.hight_power
responsedata.newbee_guide_id = player.base_info.current_newbee_guide
if player.guild.g_id != 0:
responsedata.guild_id = player.guild.g_id
responsedata.vip_level = player.base_info.vip_level
# 体力
responsedata.get_stamina_times = player.stamina.get_stamina_times
responsedata.buy_stamina_times = player.stamina.buy_stamina_times
responsedata.last_gain_stamina_time = player.stamina.last_gain_stamina_time
responsedata.server_time = int(time.time())
responsedata.register_time = player.base_info.register_time
# responsedata.soul_shop_refresh_times = player.soul_shop.refresh_times
buy_times_pb = responsedata.buy_times
for item in player.stamina._stamina.stamina:
item_pb = buy_times_pb.add()
item_pb.resource_type = item.resource_type
item_pb.buy_stamina_times = item.buy_stamina_times
item_pb.last_gain_stamina_time = item.last_gain_stamina_time
logger.debug(
"stami %s buy_stamina_times %s last_gain_stamina_time %s" %
(item.resource_type, item.buy_stamina_times,
item.last_gain_stamina_time))
logger.debug("stamina %s" % buy_times_pb)
if player.base_info.heads.head:
for head in player.base_info.heads.head:
responsedata.head.append(head)
responsedata.now_head = player.base_info.heads.now_head
for _id in player.base_info.first_recharge_ids:
responsedata.first_recharge_ids.append(_id)
responsedata.recharge = player.base_info.recharge # 累计充值
responsedata.tomorrow_gift = player.base_info.tomorrow_gift
responsedata.battle_speed = player.base_info.battle_speed
responsedata.story_id = player.base_info.story_id
for k, i in enumerate(player.base_info._button_one_time):
responsedata.button_one_time.append(int(i))
logger.debug("button_one_time %s" % player.base_info._button_one_time)
# 战力排行
if rank_helper.flag_doublu_day():
rank_name = 'PowerRank2'
else:
rank_name = 'PowerRank1'
rank_no = rank_helper.get_rank_by_key(rank_name, player.base_info.id)
responsedata.fight_power_rank = rank_no
responsedata.is_open_next_day_activity = player.base_info.is_open_next_day_activity
responsedata.first_recharge_activity = player.base_info.first_recharge_activity
responsedata.one_dollar_flowid = str(player.base_info.one_dollar_flowid)
responsedata.q360_recharge_url = SDK360_RECHARGE_URL
logger.debug("character info:----------------------id: %s" %
player.base_info.id)
logger.debug("stage_id: %s" % player.fight_cache_component.stage_id)
logger.debug("vip_level:%d", player.base_info.vip_level)
logger.debug("recharge:%d", player.base_info.recharge)
logger.debug("register_time:%d", player.base_info.register_time)
logger.debug("buy_stamina_times:%d", player.stamina.buy_stamina_times)
logger.debug("first_recharge_activity:%d",
player.base_info.first_recharge_activity)
logger.debug("newbee_guide_id:%d", player.base_info.current_newbee_guide)
# logger.debug("coin:%d", player.finance.coin)
# logger.debug("gold:%d", player.finance.gold)
# logger.debug("hero_soul:%d", player.finance.hero_soul)
# logger.debug("soul_shop_refresh_times:%d", player.soul_shop.refresh_times)
# mock guild
# player.guild.g_id = 1989
# 更新7日奖励的状态
# player.start_target.update_29()
if const.DEBUG:
for slot_no, slot in player.line_up_component.line_up_slots.items():
hero = slot.hero_slot.hero_obj
if not hero:
continue
combat_power_hero_lineup(player, hero, slot_no)
# awake_hero = player.fight_cache_component.change_hero(hero, hero.hero_info["awakeHeroID"])
# combat_power_hero_lineup(player, awake_hero, slot_no, "awake")
logger.debug('login:<%s>%s:%s %s:%s', player, character_id,
responsedata.level, dynamic_id, player.dynamic_id)
return {
'player_data': responsedata.SerializeToString(),
'is_new_character': is_new_character
}
def fight_start(stage_id, line_up, unparalleled, fid, player):
"""开始战斗
"""
result_no = 0
is_travel_event = 0
# 校验关卡是否开启
# if game_configs.stage_config.get('stages').get(stage_id) and \
# game_configs.stage_config.get('stages').get(stage_id).sort == 10:
# pass
# else:
# logger.debug(game_configs.stage_config.get('stages').get(stage_id))
# state = player.stage_component.check_stage_state(stage_id)
# if state == -2:
# return {'result': False, 'result_no': 803} # 803 未开启
conf = 0
if special_stage_config.get('elite_stages').get(stage_id): # 精英关卡
conf = special_stage_config.get('elite_stages').get(stage_id)
# 次数限制
tm_time = time.localtime(player.stage_component.elite_stage_info[1])
if tm_time.tm_mday == time.localtime().tm_mday \
and vip_config.get(player.vip_component.vip_level).eliteCopyTimes - player.stage_component.elite_stage_info[0] < conf.timesExpend:
return {'result': False, 'result_no': 805} # 805 次数不足
elif special_stage_config.get('act_stages').get(stage_id): # 活动关卡
conf = special_stage_config.get('act_stages').get(stage_id)
# 次数限制
tm_time = time.localtime(player.stage_component.act_stage_info[1])
if tm_time.tm_mday == time.localtime().tm_mday \
and vip_config.get(player.vip_component.vip_level).activityCopyTimes - player.stage_component.act_stage_info[0] < conf.timesExpend:
return {'result': False, 'result_no': 805} # 805 次数不足
elif special_stage_config.get('boss_stages').get(stage_id): # boss关卡
pass
else: # 普通关卡
stage_conf = game_configs.stage_config.get('stages').get(stage_id)
if not stage_conf.sort == 10: # 游历战斗事件
if time.localtime(player.stage_component.stage_up_time).tm_mday == time.localtime().tm_mday:
if player.stage_component.get_stage(stage_id).attacks >= stage_conf.limitTimes:
return {'result': False, 'result_no': 810} # 810 本关卡攻击次数不足
else:
player.stage_component.stage_up_time = int(time.time())
player.stage_component.update_stage_times()
player.stage_component.update()
else:
is_travel_event = 1
if conf:
# 星期限制
if conf.weeklyControl:
if time.localtime().tm_wday == 6:
wday = 7
else:
wday = time.localtime().tm_wday + 1
if not conf.weeklyControl[wday]:
logger.error('week error,804:%s', time.localtime().tm_wday)
return {'result': False, 'result_no': 804} # 804 不在活动时间内
# 时间限制
open_time = time.mktime(time.strptime(conf.open_time, '%Y-%m-%d %H:%M'))
close_time = time.mktime(time.strptime(conf.close_time, '%Y-%m-%d %H:%M'))
if not open_time <= time.time() <= close_time:
logger.error('time error,804,:%s', time.time())
return {'result': False, 'result_no': 804} # 804 不在活动时间内
# 保存阵容
player.line_up_component.line_up_order = line_up
player.line_up_component.save_data()
fight_cache_component = player.fight_cache_component
fight_cache_component.stage_id = stage_id
if is_travel_event:
drop_num = 0
red_units, blue_units, drop_num, monster_unpara = fight_cache_component.fighting_start()
print "*"*80
print red_units
print blue_units
# 好友
lord_data = tb_character_lord.getObjData(fid)
f_unit = None
if lord_data:
info = lord_data.get('attr_info').get('info')
f_unit = BattleUnit.loads(info)
else:
logger.info('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=result_no)
def get_player_ids(player_id, player_ap, types, num):
rank_name, _ = rank_helper.get_power_rank_name()
rank = tb_rank.getObj(rank_name)
rank_toal = rank.ztotal()
if rank_toal < num:
if len(robot2_rank) < num:
logger.error('not robot2 exist')
return []
robot_ids = set([])
index = 0
num -= 1
for i in range(len(robot2_rank)):
rid, rap = robot2_rank[i]
if rap > player_ap:
index = i
break
else:
index = len(robot2_rank)
_min = max(index - num, 0)
_max = min(index + num, len(robot2_rank) - 1)
while len(robot_ids) != num:
_id = random.randint(_min, _max)
robot_ids.add(robot2_rank[_id])
robot_ids = sorted(list(robot_ids), key=lambda x: x[1])
ids = []
for _id, ap in robot_ids:
ids.append([_id, ap])
# logger.error('reset overcome not enough player:%s(%s)', ids, index)
return ids
# types = [20001, 20002, 20003]
count = 0
ids = set()
for _id in types:
item1 = game_configs.arena_fight_config.get(_id)
item = CommonItem(item1)
if not item:
logger.error('arena_fight_config:%d', _id)
scope = eval(item.choose, dict(k=player_ap))[0]
count += scope[2]
_min, _max = scope[0], scope[1]
_min *= const.power_rank_xs
_max *= const.power_rank_xs
increment = player_ap * 20 / 100 * const.power_rank_xs
index = 1
while len(ids) < count:
# print(_min, increment, index, "=================")
res = rank.zrangebyscore(_min - increment * (index - 1),
_max + increment * (index - 1),
withscores=True)
index += index
random.shuffle(res)
if len(res) > count:
res = filter(lambda x: int(x[0]) != player_id, res)
ids_index = 0
while len(ids) < count:
ids.add(res[ids_index])
ids_index += 1
overcome_ids = [[0, 0]]
ids = sorted(ids, key=lambda x: x[1])
for _id, ap in ids:
overcome_ids.append([int(_id), int(ap) / const.power_rank_xs])
logger.debug('get overcome %s-%s', overcome_ids, len(overcome_ids))
return overcome_ids
def do_brew(self, brew_type, response):
vip_level = self.owner.base_info.vip_level
brew_times_max = game_configs.vip_config.get(vip_level).get(
'cookingTimes')
MAX_STEPS = len(
game_configs.base_config.get('cookingWinePrice')[brew_type])
self.check_time()
if self._brew_step > MAX_STEPS:
return False
if self.owner.base_info.level < game_configs.base_config.get(
'cookingWineOpenLevel'):
logger.error('char brew level error!!:%s',
self.owner.base_info.level)
return False
critical = game_configs.base_config.get('cookingWineOutputCrit')
if brew_type not in critical:
logger.error('base config error type:%s', brew_type)
return False
if self.brew_times >= brew_times_max:
logger.error('there is no times to brew:%s', self.brew_times)
return False
brew_prices = game_configs.base_config.get('cookingWinePrice')
if brew_type not in brew_prices:
logger.error('base config error step:%s', brew_type)
return False
_consume = brew_prices[brew_type][self._brew_step - 1]
result = is_afford(self.owner, _consume) # 校验
if not result.get('result'):
logger.error('not enough gold to do brew:%s', _consume)
return False
need_gold = get_consume_gold_num(_consume)
critical_type = critical[brew_type]
def func():
return_data = consume(self.owner, _consume, const.DREW)
get_return(self.owner, return_data, response.consume)
self._brew_step += 1
rand = random.random() * sum(critical_type.values())
for critical_num, rand_range in critical_type.items():
if rand < rand_range:
increment = critical_num * game_configs.base_config.get(
'cookingWineOutput')
self._nectar_cur += int(increment)
break
else:
rand -= rand_range
logger.info(
'brew type:%s, rand:%s nectar:%s nectar\
cur:%s time:%s cri:%s', brew_type, rand, self.nectar, self._nectar_cur,
self.brew_times, critical_num)
self.save_data()
self.owner.pay.pay(need_gold, const.DREW, func)
return True
def fight_settlement(stage_id, result, player):
response = stage_response_pb2.StageSettlementResponse()
drops = response.drops
res = response.res
# 校验是否保存关卡
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()
is_travel_event = 0
lively_event = {}
if result:
if game_configs.stage_config.get('stages').get(stage_id): # 关卡
conf = game_configs.stage_config.get('stages').get(stage_id)
if conf.sort == 10:
# travel event
is_travel_event = 1
if player.travel_component.fight_cache[0] and player.travel_component.fight_cache[1]:
if player.travel_component.travel.get(player.travel_component.fight_cache[0]):
stage_cache = player.travel_component.travel.get(player.travel_component.fight_cache[0])
else:
logger.error("travel stage id not found")
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
event_cache = 0
for event in stage_cache:
if event[0] == player.travel_component.fight_cache[1]:
event_cache = event
break
if not event_cache:
logger.error("travel ：event id not found")
response.res.result = False
response.res.result_no = 813
return response.SerializeToString()
if player.travel_component.fight_cache[1] and game_configs.travel_event_config.get('events').get(player.travel_component.fight_cache[1]) and \
stage_id == game_configs.travel_event_config.get('events').get(player.travel_component.fight_cache[1]).parameter.items()[0][0]:
gain(player, event_cache[1])
stage_cache.remove(event_cache)
player.travel_component.fight_cache = [0, 0]
player.travel_component.save()
else:
logger.error('stageid != travel fight cache stage id ')
response.res.result = False
response.res.result_no = 817
return response.SerializeToString()
else:
player.stamina.stamina -= conf.vigor
player.stamina.save_data()
lively_event = CountEvent.create_event(EventType.STAGE_1, 1, ifadd=True)
else:
tm_time = time.localtime(player.stage_component.elite_stage_info[1])
if special_stage_config.get('elite_stages').get(stage_id): # 精英关卡
conf = special_stage_config.get('elite_stages').get(stage_id)
if tm_time.tm_mday == time.localtime().tm_mday:
player.stage_component.elite_stage_info[0] += conf.timesExpend
else:
player.stage_component.elite_stage_info = [conf.timesExpend, int(time.time())]
lively_event = CountEvent.create_event(EventType.STAGE_2, 1, ifadd=True)
elif special_stage_config.get('act_stages').get(stage_id): # 活动关卡
conf = special_stage_config.get('act_stages').get(stage_id)
tm_time = time.localtime(player.stage_component.act_stage_info[1])
if tm_time.tm_mday == time.localtime().tm_mday:
player.stage_component.act_stage_info[0] += conf.timesExpend
else:
player.stage_component.act_stage_info = [conf.timesExpend, int(time.time())]
lively_event = CountEvent.create_event(EventType.STAGE_3, 1, ifadd=True)
player.stage_component.update()
if not is_travel_event:
# 经验
for (slot_no, lineUpSlotComponent) in player.line_up_component.line_up_slots.items():
print lineUpSlotComponent,
hero = lineUpSlotComponent.hero_slot.hero_obj
if hero:
hero.upgrade(conf.HeroExp)
# 玩家金钱
player.finance.coin += conf.currency
# 玩家经验
player.level.addexp(conf.playerExp)
player.save_data()
if not is_travel_event:
settlement_drops = fight_cache_component.fighting_settlement(result)
data = gain(player, settlement_drops)
get_return(player, data, drops)
tstatus = player.tasks.check_inter(lively_event)
if tstatus:
task_data = task_status(player)
remote_gate.push_object_remote(1234, task_data, [player.dynamic_id])
res.result = True
return response.SerializePartialToString()
def travel_831(data, player):
"""游历"""
args = TravelRequest()
args.ParseFromString(data)
stage_id = args.stage_id
response = TravelResponse()
if base_config.get('travelOpenLevel') > player.level.level:
response.res.result = False
response.res.result_no = 811 # 等级不够
return response.SerializeToString()
shoes = player.travel_component.shoes
if shoes[0] + shoes[1] + shoes[2] == 0:
response.res.result = False
response.res.result_no = 812 # 鞋子不足
return response.SerializeToString()
travel_cache = player.travel_component.travel
while (True):
travel_event_id = get_travel_event_id()
flag = 1
if travel_cache.get(stage_id):
for event in travel_cache.get(stage_id):
if travel_event_id == event[0]:
flag = 0
if flag:
break
else:
travel_cache[stage_id] = []
break
event_info = travel_event_config.get('events').get(travel_event_id)
if not event_info:
logger.error('get travel event config error')
response.res.result = False
response.res.result_no = 800 # 未知错误
return response.SerializeToString()
response.event_id = travel_event_id
res_drops = response.drops
drops = []
stage_info = stage_config.get('stages').get(stage_id)
common_bag = BigBag(stage_info.commonDrop)
common_drop = common_bag.get_drop_items()
drops.extend(common_drop)
drop_data = get_drop_data(drops)
get_return(player, drop_data, res_drops)
# 等待 战斗 答题 领取
if event_info.type == 4:
gain(player, drops)
else:
travel_cache.get(stage_id).append([travel_event_id, drops])
if shoes[3] == 0:
for i in [2, 1, 0]:
if shoes[i] != 0:
shoes[3] = i + 1
shoes[4] = 1
break
else:
if base_config.get("travelShoe" + str(shoes[3]))[1] == shoes[4] + 1:
shoes[shoes[3] - 1] -= 1
shoes[4] = 0
shoes[3] = 0
else:
shoes[4] += 1
player.travel_component.save()
response.res.result = True
return response.SerializeToString()
def check_mem_db(delta):
"""同步内存数据到数据库
"""
new_character_ids = tb_character_info.smem('new')
new_character_ids = filter(lambda x: x >= 10000, new_character_ids)
for char_id in new_character_ids:
character_obj = tb_character_info.getObj(char_id)
character_info = character_obj.hgetall()
character_equipments = character_obj.getObj('equipments').hgetall()
character_mails = character_obj.getObj('mails').hgetall()
character_heroes = character_obj.getObj('heroes').hgetall()
user_data = dict(id=char_id,
base_info=cPickle.dumps(character_info),
heroes=cPickle.dumps(character_heroes),
mails=cPickle.dumps(character_mails),
equipments=cPickle.dumps(character_equipments))
insert_result = util.InsertIntoDB(CHARACTER_TABLE_NAME, user_data)
if not insert_result:
logger.error('insert id:%s error', char_id)
result = util.GetOneRecordInfo(CHARACTER_TABLE_NAME,
dict(id=char_id), ['id'])
if result:
tb_character_info.sadd('all', char_id)
tb_character_info.srem('new', char_id)
else:
tb_character_info.sadd('all', char_id)
tb_character_info.srem('new', char_id)
logger.info('new character:%s', char_id)
break
global ALL_CHARACTER_IDS
if not ALL_CHARACTER_IDS:
ALL_CHARACTER_IDS = tb_character_info.smem('all')
for char_id in ALL_CHARACTER_IDS:
character_obj = tb_character_info.getObj(char_id)
character_info = character_obj.hgetall()
character_equipments = character_obj.getObj('equipments').hgetall()
character_mails = character_obj.getObj('mails').hgetall()
character_heroes = character_obj.getObj('heroes').hgetall()
user_data = dict(base_info=cPickle.dumps(character_info),
heroes=cPickle.dumps(character_heroes),
mails=cPickle.dumps(character_mails),
equipments=cPickle.dumps(character_equipments))
pwere = dict(id=char_id)
result = util.GetOneRecordInfo(CHARACTER_TABLE_NAME, pwere, ['id'])
if not result:
logger.error('all insert id:%s error', char_id)
tb_character_info.sadd('new', char_id)
else:
result = util.UpdateWithDict(CHARACTER_TABLE_NAME, user_data,
pwere)
if not result:
logger.error('update id:%s error', char_id)
# else:
# logger.info('save character:%s', char_id)
ALL_CHARACTER_IDS.remove(char_id)
break
if not new_character_ids and not ALL_CHARACTER_IDS:
reactor.callLater(delta * 10, check_mem_db, delta)
else:
reactor.callLater(delta, check_mem_db, delta)
def make_runt_857(data, player):
"""合成宝石"""
args = MakeRuntRequest()
args.ParseFromString(data)
runts = args.runt_no
num = args.num
print args, '==================================', num
response = MakeRuntResponse()
price = game_configs.base_config.get('stonesynthesis')
is_afford_res = is_afford(player, price, multiple=num) # 校验
if num and not is_afford_res.get('result'):
logger.error('make_runt_857, item not enough')
response.res.result = False
response.res.result_no = is_afford_res.get('result_no')
return response.SerializeToString()
if len(runts) < 5:
logger.error('make_runt_857, rune count dont enough')
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
runt_conf = None
runt_ids = [0, 0, 0, 0, 0]
flag = 0
for runt_no in runts:
runt_info = player.runt.m_runt.get(runt_no)
if not runt_info:
logger.error('make_runt_857,runt no dont find,runt no:%s', runt_no)
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
if not runt_conf:
runt_conf = game_configs.stone_config.get('stones').get(runt_info[0])
if runt_conf.id != runt_info[0]:
logger.error('make_runt_857, rune different types')
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
runt_ids[flag] = runt_info[0]
flag += 1
is_afford_res = is_afford(player, runt_conf.consume) # 校验
if num and not is_afford_res.get('result'):
logger.error('make_runt_857, item not enough')
response.res.result = False
response.res.result_no = is_afford_res.get('result_no')
return response.SerializeToString()
for runt_no in runts:
del player.runt.m_runt[runt_no]
if num:
consume(player, price, const.RUNT_MAKE, multiple=num) # 消耗
consume(player, runt_conf.consume, const.RUNT_MAKE) # 消耗
new_runt_no = 0
random_num = runt_conf.synthesis[0]+runt_conf.synthesis[1]*num
if random.random() <= random_num:
get_runt_id = runt_conf.synthesis[2]
else:
get_runt_id = runt_conf.id
new_runt_no = player.runt.add_runt(get_runt_id)
runt_info = player.runt.m_runt.get(new_runt_no)
runt_pb = response.runt
[runt_id, main_attr, minor_attr] = runt_info
player.runt.deal_runt_pb(new_runt_no, runt_id, main_attr,
minor_attr, runt_pb)
tlog_action.log('MakeRunt', player, runt_ids[0], runt_ids[1],
runt_ids[2], runt_ids[3], runt_ids[4], num, runt_id,
new_runt_no)
player.runt.save()
# 7日活动
new_runt_conf = game_configs.stone_config.get('stones').get(get_runt_id)
player.act.mine_mix_runt(new_runt_conf.quality)
response.res.result = True
return response.SerializeToString()
def send_mail(**args):
mail_data, receive_id = deal_mail(**args)
if not netforwarding.push_message('receive_mail_remote', receive_id,
mail_data):
logger.error('mail push message fail')
traceback.print_stack()
def encourage_heros_1703(data, player):
"""
使用金币或者元宝鼓舞士气。
"""
# 1. 校验金币或者元宝
# 3. 减少金币
# 4. 更新战斗力
response = CommonResponse()
request = EncourageHerosRequest()
request.ParseFromString(data)
boss_id = request.boss_id
boss = player.world_boss.get_boss(boss_id)
base_config = boss.get_base_config()
times = 0
if request.finance_type == 1:
# 金币鼓舞
goldcoin_inspire_price = base_config.get("coin_inspire_price")
goldcoin_inspire_price_multiple = base_config.get(
"coin_inspire_price_multi")
goldcoinInspireLimited = base_config.get("coin_inspire_limit")
goldcoin_inspire_CD = base_config.get("coin_inspire_cd")
if get_current_timestamp(
) - boss.last_coin_encourage_time < goldcoin_inspire_CD:
logger.debug("coin encourage CD not enough %s, %s" %
(boss.last_coin_encourage_time, goldcoin_inspire_CD))
response.result = False
response.result_no = 1704
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
if boss.encourage_coin_num >= goldcoinInspireLimited:
logger.debug("coin encourage too many times %s, %s" %
(boss.encourage_coin_num, goldcoinInspireLimited))
response.result = False
response.result_no = 1703
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
coin = player.finance.coin
need_coin = goldcoin_inspire_price * (pow(
goldcoin_inspire_price_multiple, boss.encourage_coin_num))
if coin < need_coin:
response.result = False
response.result_no = 101
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
player.finance.coin -= need_coin
player.finance.save_data()
boss.encourage_coin_num += 1
times = boss.encourage_coin_num
boss.last_coin_encourage_time = get_current_timestamp()
if request.finance_type == 2:
# 钻石鼓舞
money_inspire_price = base_config.get("gold_inspire_price")
moneyInspireLimited = base_config.get("gold_inspire_limit")
#money_inspire_price_multiple = base_config.get("money_inspire_price_multiple")
if boss.encourage_gold_num >= moneyInspireLimited:
logger.error("gold encourage too many times %s, %s" %
(boss.encourage_gold_num, moneyInspireLimited))
response.result = False
response.result_no = 1704
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
gold = player.finance.gold
need_gold = money_inspire_price
if gold < need_gold:
response.result = False
response.result_no = 102
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
def func():
boss.encourage_gold_num += 1
times = boss.encourage_gold_num
player.pay.pay(need_gold, const.ENCOURAGE_HEROS, func)
tlog_action.log('WorldBossEncourage', player, request.finance_type, times)
player.world_boss.save_data()
response.result = True
logger.debug("encourage_coin_num %s" % boss.encourage_coin_num)
logger.debug("encourage_gold_num %s" % boss.encourage_gold_num)
return response.SerializePartialToString()
def add_player_remote(guild_id, task_id, player_info, protect_or_rob, rob_no,
protect_records):
logger.debug("add_player_remote %s %s %s %s %s" %
(guild_id, task_id, player_info, protect_or_rob, rob_no))
guild = guild_manager_obj.get_guild_obj(guild_id)
task = guild.get_task_by_id(task_id)
for protecter in task.protecters:
# 已存在该玩家，则不能再次加入
if protecter.get("id") == player_info.get("id"):
logger.error("已存在该玩家，则不能再次加入")
return {'result': False, 'result_no': 190802}
if protect_or_rob == 2 and task.rob_success_times() >= 2:
# 接受劫运任务，如果该任务已经达到最大劫运次数
logger.error("该任务已经达到最大劫运次数")
return {'result': False, 'result_no': 190803}
if protect_or_rob == 2 and rob_no == -1 and task.has_robbed(
player_info.get("id")):
# 已经被劫了
logger.error("已经被劫了")
return {"result": False, "result_no": 190804}
if protect_or_rob == 2 and rob_no == -1 and task.has_robbing(
player_info.get("id")):
# 已经存在正在劫运的任务
logger.error("已经存在正在劫运的任务")
return {"result": False, "result_no": 190805}
if protect_or_rob == 1 and task.state == 2:
# 任务已经开启
logger.error("押运任务已经开启")
return {"result": False, "result_no": 190806}
rob_task_info = {}
if rob_no != -1:
rob_task_info = task.rob_task_infos[rob_no]
if protect_or_rob == 2 and rob_task_info and rob_task_info.get(
"rob_state") == -1:
# 任务已经开启
logger.error("劫运任务已经完成")
return {"result": False, "result_no": 190807}
if protect_or_rob == 1 and len(task.protecters) >= 3:
# 押运人数已达上限
logger.error("押运人数已达上限")
return {"result": False, "result_no": 190808}
if protect_or_rob == 2 and rob_task_info and len(
rob_task_info.get("robbers", [])) >= 3:
# 押运人数已达上限
logger.error("押运人数已达上限")
return {"result": False, "result_no": 190809}
if protect_or_rob == 2 and rob_task_info.get("rob_state") == 0:
# 任务已取消
logger.error("任务已取消")
return {'result': False, 'result_no': 190810}
if rob_task_info:
for robber in rob_task_info.get("robbers"):
# 已存在该玩家，则不能再次加入
if robber.get("id") == player_info.get("id"):
logger.error("已存在该玩家，则不能再次加入")
return {'result': False, 'result_no': 190802}
if protect_or_rob == 1:
for _task_id, info in protect_records.items():
_task = guild.get_task_by_id(_task_id)
if not _task or _task.state == -1: continue
logger.debug("task_id %s" % _task_id)
for k, protecter in enumerate(_task.protecters):
logger.debug("k %s protecter_id %s player_id %s" %
(k, protecter.get("id"), player_info.get("id")))
if k != 0 and protecter.get("id") == player_info.get("id"):
logger.error("该玩家已经处于辅助劫运中，则不能再次加入!")
return {'result': False, 'result_no': 190811}
player_guild = guild_manager_obj.get_guild_obj(player_info.get("g_id"))
res = task.add_player(player_info, protect_or_rob, rob_no,
player_guild.guild_info())
rob_no = -1
if protect_or_rob == 2:
rob_no = res.get("rob_no")
if len(task.protecters) == 3 and protect_or_rob == 1:
logger.debug("team up, then auto start task!")
start_task(task, guild)
logger.debug("rob_no %s" % rob_no)
return dict(result=True, task=construct_task_data(task, rob_no))
def battle_2403(pro_data, player):
"""
开始战斗
"""
request = guild_pb2.GuildBossBattleRequest()
request.ParseFromString(pro_data)
logger.debug("request %s" % request)
response = guild_pb2.GuildBossBattleResponse()
stage_id = request.stage_id
coolingTime = game_configs.base_config.get("AnimalCoolingTime")
# 冷却时间
if player.guild.guild_boss_last_attack_time.get(
"time") + coolingTime >= get_current_timestamp():
logger.error("attack still in colding time!")
response.res.result = False
response.res.result_no = 240301
return response.SerializePartialToString()
data = remote_gate['world'].guild_boss_init_remote(player.guild.g_id)
logger.debug("return data %s" % data)
boss_info = data.get("guild_boss")
line_up = player.line_up_component
player.fight_cache_component.stage_id = stage_id
red_units = player.fight_cache_component.get_red_units()
str_red_units = cPickle.dumps(red_units)
seed1, seed2 = get_seeds()
red_unpar_data = line_up.get_red_unpar_data()
res = remote_gate['world'].guild_boss_battle_remote(
player.guild.g_id, str_red_units, red_unpar_data, seed1, seed2)
#boss_info = res.get("guild_boss")
blue_units = cPickle.loads(boss_info.get("blue_units"))
pvp_assemble_units(red_units, blue_units, response)
fight_result = res.get("fight_result")
stage_item = game_configs.special_stage_config.get(
"guild_boss_stages").get(stage_id)
return_data = gain(player, stage_item.Animal_Participate,
const.GUILD_BOSS_IN)
get_return(player, return_data, response.gain)
response.fight_result = fight_result
if fight_result:
player.guild.guild_boss_last_attack_time["time"] = 0
player.guild.guild_boss_last_attack_time["time"] = int(
get_current_timestamp())
player.guild.save_data()
response.seed1 = seed1
response.seed2 = seed2
response.guild_skill_point = res.get('guild_skill_point')
response.res.result = res.get("result")
if not res.get("result"):
response.res.result_no = res.get("result_no")
return response.SerializePartialToString()
# add guild activity times
player.guild_activity.add_guild_boss_times(boss_info.get("boss_type"))
player.act.add_guild_boss_times(boss_info.get("boss_type"))
hook_task(player, CONDITIONId.GUILD_BOSS, 1)
result = 0
if fight_result:
result = 1
tlog_action.log('GuildBossBattle', player, player.guild.g_id,
boss_info.get("boss_type"), result)
logger.debug("response %s" % response)
return response.SerializePartialToString()
def get_sign_in_reward(self, num):
for v in game_configs.activity_config[6]:
if v.parameterA == num and self._sign_round == v.parameterB:
return v.reward, v.id
logger.error("can not find reward!")
def save_data(self):
char_obj = tb_character_info.getObj(
self._character_id).getObj('heroes')
data = self.hero_proerty_dict()
if not char_obj.hset(data['hero_no'], data):
logger.error('save hero error:%s', data['hero_no'])
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 battle_2103(pro_data, player):
"""
开始战斗
request:HjqyBattleRequest
response:HjqyBattleResponse
"""
request = hjqy_pb2.HjqyBattleRequest()
request.ParseFromString(pro_data)
response = hjqy_pb2.HjqyBattleResponse()
if player.base_info.is_firstday_from_register(const.OPEN_FEATURE_HJQY):
response.res.result = False
response.res.result_no = 150901
return response.SerializeToString()
boss_id = request.owner_id
attack_type = request.attack_type # 全力一击，普通攻击
logger.debug("request %s" % request)
hjqyExchangeBUFFTime = game_configs.base_config.get("hjqyExchangeBUFFTime")
hjqyItemRate = game_configs.base_config.get("hjqyItemRate")
hjqyExchangeBUFFNumber = game_configs.base_config.get(
"hjqyExchangeBUFFNumber")
hjqyExchangeNumber = game_configs.base_config.get("hjqyExchangeNumber")
need_hjqy_fight_token = hjqyExchangeNumber
if attack_type == 2:
need_hjqy_fight_token = hjqyExchangeBUFFNumber
if is_in_period(hjqyExchangeBUFFTime) and attack_type == 2:
need_hjqy_fight_token = need_hjqy_fight_token * hjqyItemRate
if need_hjqy_fight_token > player.finance[const.HJQYFIGHTTOKEN]:
logger.error("hjqy coin not enough！")
response.res.result = False
response.res.result_no = 210301
return response.SerializePartialToString()
data = remote_gate['world'].get_boss_info_remote(boss_id)
if not data or data.get('state') == const.BOSS_DEAD:
logger.error("hjqy boss dead！")
response.res.result = False
response.res.result_no = 210302
return response.SerializePartialToString()
if data.get('state') == const.BOSS_RUN_AWAY:
logger.error("hjqy boss run away！")
response.res.result = False
response.res.result_no = 210303
return response.SerializePartialToString()
stage_id = data.get("stage_id")
player.fight_cache_component.stage_id = stage_id
red_units = player.fight_cache_component.get_red_units()
blue_units = cPickle.loads(remote_gate['world'].blue_units_remote(boss_id))
seed1, seed2 = get_seeds()
player_info = dict(player_id=player.base_info.id,
nickname=player.base_info.base_name,
user_icon=player.base_info.heads.now_head,
level=player.base_info.level)
str_red_units = cPickle.dumps(red_units)
red_unpar_data = player.line_up_component.get_red_unpar_data()
fight_result, boss_state, current_damage_hp, is_kill = remote_gate[
'world'].hjqy_battle_remote(player_info, boss_id, str_red_units,
red_unpar_data, attack_type, seed1, seed2)
logger.debug("============battle over")
# 消耗讨伐令
player.finance.consume(const.HJQYFIGHTTOKEN, need_hjqy_fight_token,
const.HJQY_BATTLE)
# 功勋奖励
hjqyMeritoriousServiceOpenTime = game_configs.base_config.get(
"hjqyMeritoriousServiceOpenTime")
hjqyMeritoriousServiceRate = game_configs.base_config.get(
"hjqyMeritoriousServiceRate")
meritorious_service = player.fight_cache_component._get_stage_config(
).meritorious_service
logger.debug("========= %s %s ========" %
(is_in_period(hjqyMeritoriousServiceOpenTime),
hjqyMeritoriousServiceOpenTime))
if is_in_period(hjqyMeritoriousServiceOpenTime): # 增加功勋的活动
meritorious_service = meritorious_service * hjqyMeritoriousServiceRate
player.finance.add(const.HJQYCOIN,
meritorious_service,
reason=const.HJQY_BATTLE)
player.finance.save_data()
response.fight_result = fight_result
pvp_assemble_units(red_units, blue_units, response)
response.seed1 = seed1
response.seed2 = seed2
response.attack_type = attack_type
response.hjqy_coin = meritorious_service
response.stage_id = stage_id
response.res.result = True
hook_task(player, CONDITIONId.HJQY, 1)
tlog_action.log('BattleHJQY', player, boss_id, is_kill)
# start target
all_current_damage_hp = remote_gate['world'].\
hjqy_damage_hp_remote(player.base_info.id)
player.act.condition_update(38, current_damage_hp)
player.act.condition_update(39, all_current_damage_hp)
# 更新 七日奖励
target_update(player, [38, 39])
return response.SerializePartialToString()
def get_act_info(player, act_id):
act_info = player.act.act_infos.get(act_id)
act_conf = game_configs.activity_config.get(act_id)
jindu = 0
day = player.base_info.login_day
print act_conf, '==========get act info , act config'
if act_conf.type not in [65, 70, 72, 74]: # 每日的
if act_info and act_info[0] == 3:
return {'state': 3, 'jindu': act_info[1]}
elif act_info and act_info[0] == 2:
return {'state': 2, 'jindu': act_info[1]}
if act_conf.type == 1:
# 累计登录
if not act_info:
player.act.act_infos[act_id] = [1, [1, int(time.time())]]
act_info = player.act.act_infos.get(act_id)
jindu = 1
else:
if days_to_current(act_info[1][1]) > 0:
act_info[1][0] += 1
act_info[1][1] = int(time.time())
jindu = act_info[1][0]
if jindu >= act_conf.parameterA:
act_info[0] = 2
print act_info, '==========get act info 1'
return {'state': act_info[0], 'jindu': act_info[1][0]}
elif act_conf.type == 18:
# 连续登录
if not act_info:
player.act.act_infos[act_id] = [1, [1, int(time.time())]]
act_info = player.act.act_infos.get(act_id)
jindu = 1
else:
if days_to_current(act_info[1][1]) == 1:
act_info[1][0] += 1
act_info[1][1] = int(time.time())
elif days_to_current(act_info[1][1]) > 1:
act_info[1][0] = 1
act_info[1][1] = int(time.time())
# 重置前面的天数里的活动
for up_act_id in act_conf.parameterC:
up_act_info = player.act.act_infos.get(up_act_id)
up_act_conf = game_configs.activity_config.get(up_act_id)
if not up_act_info or not up_act_conf:
continue
up_act_state = 1
if up_act_conf.parameterA == 1:
up_act_state = 2
player.act.act_infos[up_act_id] = [
up_act_state, [1, int(time.time())]
]
jindu = act_info[1][0]
if jindu >= act_conf.parameterA:
act_info[0] = 2
print act_info, '==========get act info 18'
return {'state': act_info[0], 'jindu': act_info[1][0]}
elif act_conf.type == 29:
# jindu = get_condition(conditions, 29)
# if jindu and jindu[int(act_conf.parameterA)-1]:
if day >= act_conf.parameterA:
return {'state': 2}
else:
return {'state': 1}
elif act_conf.type == 30:
if not act_info:
player.act.act_infos[act_id] = [2, 0]
return {'state': 2}
else:
return {'state': act_info[0], 'jindu': act_info[1]}
elif act_conf.type == 31:
if act_info and act_info[0] == 2:
return {'state': 2}
state = 1
jindu = 0
# 上阵全部武将达到20级
line_up_slots = player.line_up_component.line_up_slots
for slot in line_up_slots.values():
if not slot.activation: # 如果卡牌位未激活
continue
hero_obj = slot.hero_slot.hero_obj # 英雄实例
if hero_obj:
if hero_obj.level >= act_conf.parameterA:
jindu += 1
if jindu >= act_conf.parameterB:
state = 2
if state == 2:
player.act.act_infos[act_id][0] = 2
return {'state': 2}
else:
if jindu and act_info and act_info[0] < jindu:
player.act.act_infos[act_id] = [1, jindu]
return {'state': state, 'jindu': jindu}
elif act_conf.type == 32:
state = 1
jindu = 0
# 拥有3名突破1的武将
line_up_slots = player.line_up_component.line_up_slots
for slot in line_up_slots.values():
if not slot.activation: # 如果卡牌位未激活
continue
hero_obj = slot.hero_slot.hero_obj # 英雄实例
if hero_obj:
if hero_obj.break_level >= act_conf.parameterA:
jindu += 1
if jindu >= act_conf.parameterB:
state = 2
if state == 2:
player.act.act_infos[act_id][0] = 2
return {'state': 2}
else:
if jindu and act_info and act_info[0] < jindu:
player.act.act_infos[act_id] = [1, jindu]
return {'state': state, 'jindu': jindu}
elif act_conf.type == 33:
# 竞技场排名到1500名
jindu = player.pvp.pvp_high_rank
if jindu <= act_conf.parameterA:
state = 2
player.act.act_infos[act_id] = [2, jindu]
return {'state': 2}
else:
if not act_info or jindu < act_info[1]:
player.act.act_infos[act_id] = [1, jindu]
return {'state': 1, 'jindu': jindu}
else:
return {'state': 1, 'jindu': act_info[1]}
elif act_conf.type == 34:
state = 1
jindu = 0
# 每个上阵武将经脉激活3个穴位
line_up_slots = player.line_up_component.line_up_slots
for slot in line_up_slots.values():
if not slot.activation: # 如果卡牌位未激活
continue
hero_obj = slot.hero_slot.hero_obj # 英雄实例
if hero_obj:
if hero_obj.refine >= act_conf.parameterA:
jindu += 1
if jindu >= act_conf.parameterB:
state = 2
if state == 2:
player.act.act_infos[act_id][0] = 2
return {'state': 2}
else:
if jindu and act_info and act_info[0] < jindu:
player.act.act_infos[act_id] = [1, jindu]
return {'state': state, 'jindu': jindu}
elif act_conf.type == 35:
# 过关斩将通关第十关
jindu = player.pvp.pvp_overcome_current - 1
if jindu >= act_conf.parameterA:
player.act.act_infos[act_id] = [2, jindu]
return {'state': 2}
else:
if not act_info or jindu > act_info[1]:
player.act.act_infos[act_id] = [1, jindu]
return {'state': 1, 'jindu': jindu}
else:
return {'state': 1, 'jindu': act_info[1]}
elif act_conf.type == 36:
jindu = 0
for equipment_id in player.line_up_component.on_equipment_ids:
equipment_obj = player.equipment_component.get_equipment(
equipment_id)
if equipment_obj.attribute.strengthen_lv >= act_conf.parameterA:
jindu += 1
if jindu >= act_conf.parameterB:
player.act.act_infos[act_id] = [2, jindu]
return {'state': 2}
else:
if not act_info or jindu > act_info[1]:
player.act.act_infos[act_id] = [1, jindu]
return {'state': 1, 'jindu': jindu}
else:
return {'state': 1, 'jindu': act_info[1]}
elif act_conf.type == 37:
# 武将觉醒等级
jindu = 0
line_up_slots = player.line_up_component.line_up_slots
for slot in line_up_slots.values():
if not slot.activation: # 如果卡牌位未激活
continue
hero_obj = slot.hero_slot.hero_obj # 英雄实例
if hero_obj:
if hero_obj.break_level >= act_conf.parameterA:
jindu += 1
if jindu >= act_conf.parameterB:
player.act.act_infos[act_id] = [2, jindu]
return {'state': 2}
else:
if not act_info or jindu > act_info[1]:
player.act.act_infos[act_id] = [1, jindu]
return {'state': 1, 'jindu': jindu}
else:
return {'state': 1, 'jindu': act_info[1]}
elif act_conf.type == 38:
# 黄巾起义 累积伤害
if not act_info:
player.act.act_infos[act_id] = [1, 0]
jindu = 0
else:
jindu = act_info[1]
elif act_conf.type == 39:
# 黄巾起义 最高伤害
if not act_info:
player.act.act_infos[act_id] = [1, 0]
jindu = 0
else:
jindu = act_info[1]
elif act_conf.type == 40:
# 镶嵌A个B级别宝石
jindu = 0
line_up_slots = player.line_up_component.line_up_slots
for slot in line_up_slots.values():
if not slot.activation: # 如果卡牌位未激活
continue
hero_obj = slot.hero_slot.hero_obj # 英雄实例
if hero_obj:
for (runt_type, item) in hero_obj.runt.items():
for (runt_po, runt_info) in item.items():
# [runt_no, runt_id, main_attr, minor_attr] = runt_info
quality = game_configs.stone_config.get('stones'). \
get(runt_info[1]).quality
if quality == act_conf.parameterB:
jindu += 1
if jindu >= act_conf.parameterA:
player.act.act_infos[act_id] = [2, jindu]
return {'state': 2}
else:
if not act_info or jindu > act_info[1]:
player.act.act_infos[act_id] = [1, jindu]
return {'state': 1, 'jindu': jindu}
else:
return {'state': 1, 'jindu': act_info[1]}
elif act_conf.type == 41:
# 占领矿达到a个
if not act_info:
player.act.act_infos[act_id] = [1, 0]
jindu = 0
else:
jindu = act_info[1]
elif act_conf.type == 45:
if player.stage_component.get_stage(act_conf.parameterA).state != 1:
return {'state': 1}
else:
return {'state': 2}
elif act_conf.type == 44:
if not act_info:
player.act.act_infos[act_id] = [1, 0]
jindu = 0
else:
jindu = act_info[1]
elif act_conf.type == 43:
# 战队等级 达到a
jindu = player.base_info.level
elif act_conf.type == 46:
# 战斗力达到a
jindu = int(player.line_up_component.hight_power)
elif act_conf.type == 55:
# 阵容条件: 武将数量，品质，突破等级
jindu = line_up_activity_jindu(player, act_conf)
logger.debug("jindu %s " % jindu)
elif act_conf.type in [56, 57, 58, 59]:
# 秘境条件: 刷新秘境，占领矿点，宝石收取，宝石合成
jindu = player.act.mine_activity_jindu(act_conf)
if jindu >= act_conf.parameterA:
return {'state': 2, 'jindu': jindu}
else:
return {'state': 1, 'jindu': jindu}
elif act_conf.type in [60, 61, 62, 63]:
# 宝物：合成，品质，数量
jindu = player.act.treasure_activity_jindu(act_conf)
if jindu >= act_conf.parameterA:
return {'state': 2, 'jindu': jindu}
else:
return {'state': 1, 'jindu': jindu}
elif act_conf.type == 51:
if not act_info:
player.act.act_infos[act_id] = [0, []]
return {'state': 0, 'jindu': []}
if len(act_info[1]) < int(act_conf.parameterA):
return {'state': 1, 'jindu': act_info[1]}
if act_conf.parameterB > player.base_info.level:
return {'state': 1, 'jindu': act_info[1]}
if len(act_conf.parameterC) == 1 and \
act_conf.parameterC[0] > player.line_up_component.hight_power:
return {'state': 1, 'jindu': act_info[1]}
if len(act_conf.parameterD) == 1 and \
player.stage_component.get_stage(act_conf.parameterD[0]).state != 1:
return {'state': 1, 'jindu': act_info[1]}
player.act.act_infos[act_id][0] = 2
return {'state': 2, 'jindu': act_info[1]}
elif act_conf.type == 50:
if not act_info:
player.act.act_infos[act_id] = [0, [0, 0, 0]]
return {'state': 1, 'jindu': [0, 0, 0]}
base_info = player.base_info
if int(act_conf.parameterA) > base_info.vip_level:
return {'state': 1, 'jindu': act_info[1]}
if len(act_conf.parameterC) == 1 and \
not act_conf.parameterC[0] > act_info[1][0]:
return {'state': 1, 'jindu': act_info[1]}
if len(act_conf.parameterD) == 1 and \
not act_conf.parameterD[0] > act_info[1][1]:
return {'state': 1, 'jindu': act_info[1]}
return {'state': 2, 'jindu': act_info[1]}
elif act_conf.type in [70, 72, 74, 65]:
if not act_info:
player.act.act_infos[act_id] = [1, 0, int(time.time())]
return {'state': 1, 'jindu': 0}
if days_to_current(act_info[2]) != 0:
player.act.act_infos[act_id] = [1, 0, int(time.time())]
return {'state': 1, 'jindu': 0}
if act_info and act_info[0] == 3:
return {'state': 3, 'jindu': act_info[1]}
elif act_info and act_info[0] == 2:
return {'state': 2, 'jindu': act_info[1]}
if act_info[1] < int(act_conf.parameterA):
return {'state': 1, 'jindu': act_info[1]}
player.act.act_infos[act_id][0] = 2
return {'state': 2, 'jindu': act_info[1]}
elif act_conf.type in [71, 73, 75, 76, 77]:
if not act_info:
player.act.act_infos[act_id] = [1, 0]
return {'state': 1, 'jindu': 0}
if act_info[1] < int(act_conf.parameterA):
return {'state': 1, 'jindu': act_info[1]}
player.act.act_infos[act_id][0] = 2
return {'state': 2, 'jindu': act_info[1]}
else:
logger.error('get act info type error')
return {'state': 0, 'jindu': 0}
# 到到a的统一在这里返回
if jindu >= act_conf.parameterA:
player.act.act_infos[act_id] = [2, jindu]
return {'state': 2}
else:
if not act_info or jindu > act_info[1]:
player.act.act_infos[act_id] = [1, jindu]
return {'state': 1, 'jindu': jindu}
else:
return {'state': 1, 'jindu': act_info[1]}
def __init__(self, big_bag_config_id):
self.big_bag = game_configs.big_bag_config.get(big_bag_config_id)
if not self.big_bag:
logger.error("big_bag is None %s, %s", big_bag_config_id,
game_configs.big_bag_config)
def character_login_4(key, dynamic_id, request_proto):
"""角色登录 """
ip = groot.child('net').get_ipaddress_remote(dynamic_id)
logger.debug("==============character_login_4===========")
argument = game_pb2.GameLoginRequest()
argument.ParseFromString(request_proto)
pay_arg = dict(plat_id=argument.plat_id,
platform=argument.platform,
openid=argument.open_id,
openkey=argument.open_key,
pay_token=argument.pay_token,
appid=argument.appid,
appkey=argument.appkey,
pf=argument.pf,
pfkey=argument.pfkey,
zoneid=argument.zoneid,
login_channel=argument.login_channel)
data = __character_login(dynamic_id, pay_arg)
response = game_pb2.GameLoginResponse()
if not data.get('result', True):
response.res.result = False
response.res.result_no = data.get('result_no', 0)
return response.SerializePartialToString()
player_data = data.get('player_data')
response.ParseFromString(player_data)
login_time = int(time.time())
if response.closure > login_time or response.closure == -2:
msg = AccountKick()
msg.id = 2
msg.time = response.closure
groot.child('net').kick_by_id_remote(msg.SerializeToString(),
dynamic_id)
response.res.result = False
response.res.result_no = 4004
logger.error("player was banned!")
return response.SerializePartialToString()
# argument.plat_id = 0
# argument.client_version = '0.0.0.1'
# argument.system_software = '1.1'
# argument.system_hardware = '2.2'
# argument.telecom_oper = 'tx'
# argument.network = 'wifi'
# argument.screen_width = 1024
# argument.screen_hight = 2048
# argument.density = 256
# argument.login_channel = 512
# argument.mac = '1.1.1'
# argument.cpu_hardware = 'intel'
# argument.memory = 1024
# argument.gl_render = 'abc'
# argument.gl_version = 'abcd'
# argument.device_id = '1x2y'
tlog_action.log('PlayerLogin', response, argument, ip)
if data.get('is_new_character'):
tlog_action.log('PlayerRegister', response, argument, ip)
nickname = response.nickname
if nickname and response.gag < login_time and response.gag != -2:
# 聊天室登录
GlobalObject().child('chat').login_chat_remote(dynamic_id, response.id,
nickname,
response.guild_id,
response.gag)
return response.SerializePartialToString()
