def pay_handler(entityID, username, goodsid, amount=None): goodsid = str(goodsid) # 必须是字符串 label = username2label(username) sdktype = username2type(username) sdkconfigs = get_config(RechargeBySdktypeConfig).get(sdktype, []) labconfigs = get_config(RechargeByLabelConfig).get(label, []) configs = get_config(RechargeConfig) ids = {e.id for e in sdkconfigs} & {e.id for e in labconfigs} good = {configs[e].goodsid: configs[e] for e in ids}.get(goodsid) if not good: logger.error("error goodsid %r", goodsid) return p = g_entityManager.get_player(entityID) if p: level = p.level reward = give_goods(p, good, amount=amount) get_gold = reward.get("gold", 0) else: # patch 离线玩家,需要计算可获得金额 p = Player.simple_load( entityID, ["userID", "level", "bought_recharges", "offline_recharges"]) level = p.level if p.offline_recharges: p.offline_recharges.append([good.id, amount]) else: p.offline_recharges = [[good.id, amount]] is_first = (good.id not in (p.bought_recharges or set())) \ and (good.id not in ({i for i, j in p.offline_recharges} or set())) from reward.manager import open_reward, RewardType reward = open_reward(RewardType.Recharge, good, is_first, amount) rs = reward.apply_after() # 仅计算可获金额,并不发货 get_gold = rs.get("gold", 0) p.save() return {"username": username, "level": level, "get_gold": get_gold}
def get_faction_info(factionID): faction = Faction.get(factionID) if not faction: return {} player = Player.simple_load(faction.leaderID, ['prototypeID', 'name']) return dict( factionID=factionID, name=faction.name, level=FactionRankRanking.get_score(faction.factionID) or 1, mcount=len(faction.memberset), acount=len(faction.applyset), totalfp=faction.totalfp, todayfp=faction.todayfp, rank=FactionRankRanking.get_rank(factionID), prototypeID=player.prototypeID, leader=player.name, createtime=faction.createtime, notice=faction.notice, mode=faction.mode, strengthen_hp_level=faction.strengthen_hp_level, strengthen_at_level=faction.strengthen_at_level, strengthen_ct_level=faction.strengthen_ct_level, strengthen_df_level=faction.strengthen_df_level, can_strengthen=get_config(CanStrengthenConfig)[1].can, leaderID=faction.leaderID, dflag=faction.dflag, )
def quit_group(entityID, groupID): g = Group.simple_load(groupID, ["leaderID", "members", "invites"]) if not g: return msgTips.FAIL_MSG_GROUP_NOT_IN_THIS g.members.load() g.invites.load() p = g_entityManager.get_player(entityID) if not p: p = Player.simple_load(entityID, ["groupID", "group_last_kicked_time"]) if not p.groupID: return msgTips.FAIL_MSG_GROUP_HAS_NOT_JOINED # "未加入同门了" if p.entityID not in g.members: return msgTips.FAIL_MSG_GROUP_NOT_IN_THIS del g.members[p.entityID] if p.entityID in g.invites: g.invites.remove(p.entityID) if p.entityID == g.leaderID: rest = sorted(g.members.items(), key=lambda v: v[1]["jointime"]) if rest: new_leaderID, _ = rest[0] g.leaderID = new_leaderID recommend(groupID) g.save() p.groupID = 0 now = int(time.time()) p.group_last_kicked_time = now p.save() return SUCCESS
def clean_faction(entityID): p = g_entityManager.get_player(entityID) if not p: p = Player.simple_load(entityID, ['factionID', 'applyFactions']) if p.factionID: faction = Faction.simple_load(p.factionID, ['memberset']) if faction: safe_remove(faction.memberset, p.entityID) faction.save() p.last_factionID = p.factionID gm_logger.info({ 'faction': { 'entityID': p.entityID, 'type': 'quit_faction', 'factionID': p.factionID, } }) p.factionID = 0 p.fp = 0 p.faction_name = '' p.faction_level = 0 p.faction_is_leader = False p.applyFactions.clear() # p.applyFactionTime = 0 p.save() if g_entityManager.get_player(entityID): p.sync()
def join_group(entityID, groupID): now = int(time.time()) p = g_entityManager.get_player(entityID) if not p: p = Player.simple_load(entityID, ["groupID", "group_last_kicked_time"]) if p.groupID: return msgTips.FAIL_MSG_GROUP_ALREADY_JOINED if now < p.group_last_kicked_time + ONE_DAY: return msgTips.FAIL_MSG_GROUP_KICKED_RECENTLY g = Group.simple_load(groupID, ["members", "applys"]) g.members.load() g.applys.load() if len(g.members) >= MAX_MEMBERS_COUNT: return msgTips.FAIL_MSG_GROUP_LIMITED_EXCEED if p.entityID in g.members: return msgTips.FAIL_MSG_GROUP_ALREADY_JOINED_THIS g.members[p.entityID] = {"jointime": now, "intimate": 0} if len(g.members) >= MAX_MEMBERS_COUNT: unrecommend(groupID) g.applys.clear() else: recommend(groupID) try: del g.applys[p.entityID] except KeyError: pass g.save() p.groupID = groupID p.save() return SUCCESS
def blockdevice(): entityID = int(request.POST.get("entityID") or 0) block = request.POST["block"] == 'True' if not entityID: return FAILURE from player.model import Player userID = Player.simple_load(entityID, ['userID']).userID if not userID: return FAILURE from user.model import User user = User.load(userID) imsi = user.imsi if not imsi: return FAILURE from session.regions import r_block_devices if block: r_block_devices.sadd(imsi) else: r_block_devices.srem(imsi) if block: for regionID, entityIDs in user.roles.items(): for entityID in entityIDs: spawn(proxy_batch_call, 'chat.manager.clear_blocked_message', regionID, entityID) return SUCCESS
def blocktime(): # userID = int(request.POST.get("userID") or 0) entityID = int(request.POST.get("entityID") or 0) blocktime = int(request.POST.get("blocktime") or 0) if not entityID: return FAILURE now = int(time.time()) if blocktime and blocktime < now: return FAILURE from player.model import Player userID = Player.simple_load(entityID, ['userID']).userID if not userID: return FAILURE from user.model import User user = User.load(userID) user.blocktime = blocktime user.save() for regionID, entityIDs in user.roles.items(): for entityID in entityIDs: spawn(proxy_batch_call, 'chat.manager.clear_blocked_message', regionID, entityID) return SUCCESS
def get_lineup_info(playerID, attrs, type=None): from player.model import Player from pet.model import Pet from entity.manager import g_entityManager if not type: type = LineupType.ATK p = g_entityManager.get_player(playerID) if p: pets = [p.pets.get(i, None) for i in p.lineups.get(type, [])] else: # p = Player.batch_load([playerID], ['lineups'])[0] # FIXME p = Player.simple_load(playerID, ["entityID", "lineups"]) p.lineups.load() if p: try: pets = Pet.batch_load(p.lineups.get(type, []), Pet.expend_fields(attrs)) except IndexError: pets = [] result = [] for pos, pet in enumerate(pets): if not pet: continue info = {n: getattr(pet, n) for n in attrs} if type == LineupType.Daily: if info.get("daily_restHP", 0): info["restHP"] = info["daily_restHP"] info['posIndex'] = pos info['isTeamLeader'] = (pos == 0) result.append(info) return result
def lock_device_and_skip_guide(entityID): from entity.manager import g_entityManager from player.model import Player, OfflineAttrType entityID = int(entityID) deviceID = request.POST.getone('deviceID', '') lock_level = int(request.POST.getone('lock_level', '50')) role = g_entityManager.get_player(entityID) if not role: Player.add_offline_attr(entityID, Player.getAttributeIDByName('skip_guide'), True, OfflineAttrType.Set) Player.add_offline_attr(entityID, Player.getAttributeIDByName('lock_level'), lock_level, OfflineAttrType.Set) else: role.skip_guide = True role.lock_level = lock_level role.save() role.sync() # lock device if not role: userID = Player.simple_load(entityID, ['userID']).userID else: userID = role.userID from user.model import User u = User.simple_load(userID, ['lock_device', 'imsi']) u.lock_device = deviceID or u.imsi u.save() return SUCCESS
def loot_target(player, power, loot, count): dvalue = 100 + power * 0.06 s, e = int(max(0, power - dvalue)), int(power + dvalue) samples = set(PlayerPowerRanking.get_range_by_score(s, e, count=16)) - set( [player.entityID]) zombies = set(get_zombies_by_power(s, e, count=5)) # s = max(player.level - 12, 1) # e = max(player.level - 6, 1) # samples = set( # PlayerLevelRanking.get_range_by_score( # s, e, count=16) # ) - set([player.entityID]) # zombies = set(reduce( # lambda x, y: x+y, # [get_zombies_by_level(l)[:5] # for l in range(s, e + 1)])) samples = samples.union(zombies) chosen = choice_one(list(samples)) logger.debug("search targets is {}".format(samples)) if not is_zombie(chosen): rest = search_targets_loot([chosen], loot)[0] p = Player.simple_load(chosen, "loot_protect_time") now = int(time.time()) if PlayerLootLock.locked(chosen) or \ now < p.loot_protect_time and rest < 50 and rest < count: chosen = choice_one(list(zombies)) if not chosen: chosen = choice_one(list(get_zombies())) # # NOTE FIXME FOR DEBUG # chosen = player.entityID return get_opponent_detail(chosen)
def discredit_offline(manager, entityID, current_floor): now = int(time.time()) floor = manager.avail_floor(current_floor) attrs = ['climb_tower_accredit_earnings', 'climb_tower_floor', 'climb_tower_accredit_stash_time', 'climb_tower_accredit_cd'] p = Player.simple_load(entityID, Player.expend_fields(attrs)) if p: if floor: value = p.climb_tower_accredit_earnings # 结束时间作为 score score = p.climb_tower_accredit_cd p.climb_tower_accredit_stash_earnings += value p.climb_tower_accredit_floor = floor p.climb_tower_accredit_stash_time = now # 取消当前层派驻 manager.floors[current_floor].idx.unregister(p.entityID) manager.floors[floor].idx.register(p.entityID, score) else: p.climb_tower_accredit_cd = now manager.floors[current_floor].idx.unregister(p.entityID) p.save()
def sync_rank_offline(entityID, history, fight=None): from player.model import Player FIGHT_HISTORY_LIMIT = 5 pkey = make_key(Player.store_tag, entityID) history['ID'] = '%d:%d' % (history['time'], history['oppID']) if incr_score(entityID, history['score']): from chat.manager import on_news_pvp_first on_news_pvp_first(Player.simple_load(entityID, ["entityID", "name"])) Player.pool.execute('HINCRBY', pkey, 'rank_count', 1) Player.pool.execute("LPUSH", "rank_history_p{%d}" % entityID, Player.fields['rank_history'].encoder(history)) Player.pool.execute("LTRIM", "rank_history_p{%d}" % entityID, 0, 30) if fight: Player.pool.execute("HSET", "rank_fight_history_p{%d}" % entityID, history['ID'], fight) keys = Player.pool.execute('HKEYS', "rank_fight_history_p{%d}" % entityID) if len(keys) > FIGHT_HISTORY_LIMIT: for key in sorted(keys)[:-FIGHT_HISTORY_LIMIT]: Player.pool.execute("HDEL", "rank_fight_history_p{%d}" % entityID, key) if history['isWin']: Player.pool.execute('HINCRBY', pkey, 'rank_win_count', 1) else: Player.pool.execute('HINCRBY', pkey, 'rank_passive_offline_count', 1) return 'FAILURE'
def alter_name(self, msgtype, body): limited, message = self.access_limited() if limited: return fail_msg(msgtype, reason=message) req = poem_pb.AlterNameRequest() req.ParseFromString(body) entityID = req.entityID if not entityID: user = User.load(self.userID) entityIDs = user.roles.get(settings.REGION['ID']) if len(entityIDs) > 1: return fail_msg(msgtype, reason="未指定角色") if entityIDs: entityID = entityIDs[0] if not PlayerDuplicateNamesIndexing.exists(entityID): return fail_msg(msgtype, reason="不可修改名称") session = SessionStore(get_session_pool(), str(req.verify_code)) if not req.userID or session.uid != req.userID: return fail_msg(msgtype, reason="登录超时,请重试") name, error = validate_name(req.name) if error: return fail_msg(msgtype, error) # 名字去重复 try: PlayernameIndexing.register(0, name) # 占位 p = Player.simple_load(entityID, ["name"]) p.name = name p.save() PlayernameIndexing.pool.execute( 'HSET', PlayernameIndexing.key, name, entityID) # 更新 except DuplicateIndexException: return fail_msg(msgtype, reason=_YYTEXT('该名称已存在')) PlayerDuplicateNamesIndexing.unregister(entityID) return success_msg(msgtype, '')
def city_send_mail_offline(entityID, title, content, rewards, key, ID): if not int(Player.pool.execute( "HSET", "city_rewards_recv_p{%d}" % entityID, key, "") or 0): return p = Player.simple_load(entityID, ['factionID']) rank = CityDungeonKillRanking.get_rank(p.factionID) content = content.format(rank) send_mail(entityID, title, content, addition=rewards, configID=ID)
def allow_friend_offline(applyID, entityID): p = Player.simple_load(applyID, ["friendset", "level"]) friend_max_count = get_friend_max_count(p.level) if len(p.friendset) >= friend_max_count: return False if len(p.friendset) + 1 >= friend_max_count: unrecommend(entityID) add_friend_offline(applyID, entityID) return True
def sync_faction_offline(entityID, factionID, level, name): p = Player.simple_load(entityID, ['factionID', 'faction_level', 'faction_name']) if p.factionID == factionID: p.faction_level = level p.faction_name = name p.save() p.sync() return True
def remove_friend_offline(entityID, friendID): p = Player.simple_load(entityID, ["friendset"]) try: p.friendset.remove(friendID) recommend(entityID) except KeyError: pass p.save() return True
def sync_daily_rank_offline(entityID, history=None): p = Player.simple_load(entityID, [ "daily_histories", "daily_history_flag"]) p.daily_histories.load() if p: if history: p.daily_histories.appendleft(history) p.daily_histories.ltrim(0, MAX_HIST_LEN - 1) p.daily_history_flag = True p.save()
def get_group_member_across_region(regionID, entityID): assert regionID == settings.REGION["ID"] p = Player.simple_load(entityID, ["name", "prototypeID", "groupID"]) return { "name": p.name, "groupID": p.groupID, "regionID": regionID, "prototypeID": p.prototypeID, "entityID": entityID, }
def ranking_send_mail_offline(entityID, title, content, rewards, key, ID): p = Player.simple_load(entityID, ["rankingreceiveds"]) if p: if key in p.rankingreceiveds: return if not int( Player.pool.execute("HSET", "ranking_receiveds_p{%d}" % entityID, key, "") or 0): return send_mail(entityID, title, content, addition=rewards, configID=ID)
def apply_friend_offline(entityID, applyID): now = int(time.time()) field = "friend_applys" if not Player.simple_load(entityID, []): return msgTips.FAIL_MSG_PLAYER_NOT_FOUND encode = Player.fields[field].encoder key = "_".join([field, "p{%d}" % entityID]) if not Player.pool.execute( "HSET", key, applyID, encode({"applytime": now})): return msgTips.FAIL_MSG_FRIEND_ALREADY_APPLYED return OK
def join_faction(entityID, factionID): faction = Faction.simple_load(factionID, [ "level", "name", "memberset", "inviteset", "applyset", "strengthen_hp_level", "strengthen_at_level", "strengthen_ct_level", "strengthen_df_level" ]) # recommend level = FactionRankRanking.get_score(factionID) or 1 limit = get_config(FactionLimitConfig)[level].limit if limit - len(faction.memberset) <= 1: unrecommend(factionID) clean_faction(entityID) p = g_entityManager.get_player(entityID) if not p: p = Player.simple_load(entityID, [ 'inviteFactionSet', 'factionID', 'last_factionID', 'strengthen_at_level', 'strengthen_hp_level', 'strengthen_ct_level', 'strengthen_df_level', ]) p.factionID = faction.factionID p.faction_name = faction.name p.faction_level = level now = int(time.time()) p.joinFactionTime = now # FIXME for fid in p.inviteFactionSet: f = Faction.simple_load(fid, ['inviteset']) safe_remove(f.inviteset, p.entityID) f.save() p.inviteFactionSet.clear() if p.factionID != p.last_factionID: p.totalfp = 0 p.todayfp_donate = 0 p.todayfp_task = 0 p.todayfp_sp = 0 faction.memberset.add(p.entityID) safe_remove(faction.applyset, p.entityID) safe_remove(faction.inviteset, p.entityID) if g_entityManager.get_player(entityID): p.load_faction() p.sync() p.save() faction.save() gm_logger.info({ 'faction': { 'entityID': p.entityID, 'type': 'join_faction', 'factionID': faction.factionID, } })
def build_faction_item(self, factionID, item): f = Faction.simple_load( factionID, ["name", "leaderID", "memberset"] ) if f: l = Player.simple_load(f.leaderID, ["prototypeID"]) item.name = f.name item.prototypeID = l.prototypeID item.faction_count = len(f.memberset) item.faction_level = FactionRankRanking.get_score(factionID) or 1 item.entityID = factionID
def broadcast_faction_message(m): msg = success_msg(msgid.RECV_MESSAGE, m) from entity.manager import g_entityManager p = g_entityManager.get_player(m.entityID) if not p: p = Player.simple_load(m.entityID, ["factionID"]) from player.manager import g_playerManager from faction.model import Faction if p.factionID: g_chatManager.cache_message(m, factionID=p.factionID) f = Faction.simple_load(p.factionID, ["memberset"]) if f: g_playerManager.broadcast(f.memberset, msg)
def get_faction_thumb(factionID): faction = Faction.get(factionID) if not faction: return {} player = Player.simple_load(faction.leaderID, ['prototypeID']) return { 'factionID': faction.factionID, 'name': faction.name, 'totalfp': faction.totalfp, 'todayfp': faction.todayfp, 'prototypeID': player.prototypeID, 'mcount': len(faction.memberset), }
def deny_apply_failure(factionID, entityID): faction = Faction.simple_load(factionID, ['applyset', 'leaderID']) safe_remove(faction.applyset, entityID) faction.save() proxy.sync_apply(faction.leaderID) player = Player.simple_load(entityID, ['applyFactions']) if is_apply(player, factionID): # 玩家还没有取消申请 safe_remove(player.applyFactions, factionID) # player.applyFactionTime = 0 faction.save() player.save() return SUCCESS return msgTips.FAIL_MSG_FACTION_ALREADY_CANCEL_APPLY
def send_friend_message_failure(friendID, content, senderID, **extra): now = time.time() message = { "time": now, "content": content, } message.update(extra) p = Player.simple_load(friendID, ['friend_messages']) p.friend_messages.load() messages = p.friend_messages.get(senderID, []) messages.append(message) p.friend_messages[senderID] = messages p.save() return True
def get_gve_entity(entityID): p = g_entityManager.get_player(entityID) if not p: p = Player.simple_load( entityID, ["gve_index", "gve_target", "gve_state", "name", "prototypeID"]) return { "id": entityID, "index": p.gve_index, "target": p.gve_target, "state": p.gve_state, "name": p.name, "prototypeID": p.prototypeID, }
def send_flower_boss_mail_offline(entityID, configID, rank, damage): if not configID: return p = Player.simple_load(entityID, ['friendfb_kill_count']) p.friendfb_kill_count += 1 config = get_config(FriendfbRewardConfig).get(configID) rewards = {} if config: rewards = parse_reward(config.rewards) p.save() title, content, ID = get_mail("FlowerBoss") content = content.format(damage, rank) do_send_mail(entityID, title, content, addition=rewards, configID=ID) return True
def get_group_across_region(regionID, groupID): assert regionID == settings.REGION["ID"] g = Group.simple_load(groupID, ["name", "leaderID", "members"]) g.members.load() members = [] for k in g.members: p = Player.simple_load(k, ["prototypeID"]) members.append({"entityID": p.entityID, "prototypeID": p.prototypeID}) return { "name": g.name, "groupID": groupID, "regionID": regionID, "members": members, }