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()