async def get_sql(self, **kwargs: object) -> Optional[Player]: """Get a player by token, id, or name from sql.""" attr, val = self._parse_attr(kwargs) # try to get from sql. res = await glob.db.fetch( "SELECT id, name, priv, pw_bcrypt, " "silence_end, clan_id, clan_priv, api_key " f"FROM users WHERE {attr} = %s", [val], ) if not res: return # encode pw_bcrypt from str -> bytes. res["pw_bcrypt"] = res["pw_bcrypt"].encode() if res["clan_id"] != 0: res["clan"] = glob.clans.get(id=res["clan_id"]) res["clan_priv"] = ClanPrivileges(res["clan_priv"]) else: res["clan"] = res["clan_priv"] = None return Player(**res, token="")
def add_player(self, pid): """ Adds a player using the player's ID @param pid: The Player ID you want to add @type pid: int @return: if successful @rtype: bool """ self.notify.debug( f"[add_player] Adding player {pid} to game {self.gid}") p = Player(self.generate_local_id(), pid=pid) self.players.append(p) self.notify.debug(f"[add_player] List of players now: {self.players}") if self.message_all_players(dg_add_player(p.local_id), exclude=[p.local_id]): # send all players to the new player for existing in self.players: if not self.message_player( dg_add_player(existing.local_id, existing.name), p.local_id): return False else: return False return True
async def get_sql(self, **kwargs) -> Optional[Player]: """Get a player by token, id, or name from sql.""" attr, val = self._parse_attr(kwargs) # try to get from sql. res = await glob.db.fetch( 'SELECT id, name, priv, pw_bcrypt, ' 'silence_end, clan_id, clan_priv, api_key ' f'FROM users WHERE {attr} = %s', [val] ) if not res: return # encode pw_bcrypt from str -> bytes. res['pw_bcrypt'] = res['pw_bcrypt'].encode() if res['clan_id'] != 0: res['clan'] = glob.clans.get(id=res['clan_id']) res['clan_priv'] = ClanPrivileges(res['clan_priv']) else: res['clan'] = res['clan_priv'] = None return Player(**res, token='')
def scout_summoner(name: str): try: player = Player(name) except HTTPError: return None champion_mastery = Champions.get_champion_mastery(name) ret = '' """ Name (Main Role) - Solo/Duo Rank OTP: [Champ] (if they otp a champ) Most Played: Top 5 played champs in ranked Recently Played: Top 5 recently played champs Most Mastery: Top 5 mastery on champs """ ret += player.name + ' (Role) - ' + player.solo_rank + '\n' ret += '\tOTP: ' + '\n' ret += '\tMost Played: ' + '\n' ret += '\tRecently Played: ' + '\n' ret += '\tMost Mastery: ' length = len(champion_mastery) for i in range(length): ret += champion_mastery[i].get('name') if i != (length - 1): ret += ', ' ret += '\n' return ret
def new(self): self.score = 0 self.player = Player(0, (screenHeight / 2 - 60), 60, 60) self.font = pg.font.SysFont('helvetica', 30, True) self.bullets = [] # container for our bullet self.packages = [] self.shark = Enemy(screenWidth - 100, (screenHeight / 2 - 60), 60, 40, 800) self.shark2 = Enemy(screenWidth - 200, (screenHeight / 3 - 60), 60, 40, 800) self.shark3 = Enemy(screenWidth - 300, (screenHeight / 5 - 60), 60, 40, 800) self.shark4 = Enemy(screenWidth - 200, (400 - 60), 60, 40, 800) self.shark5 = Enemy(screenWidth - 300, (500 - 60), 60, 40, 800) self.inkLoop = 0 self.music = pg.mixer.music.load('music.mp3') pg.mixer.music.play(-1) self.ink = pg.mixer.Sound('inkshoot.wav') self.hurt = pg.mixer.Sound('hurt.wav') self.pickup = pg.mixer.Sound('pickup.wav') self.whirlpool = pg.mixer.Sound('whirlpool.wav') ## randomize squid coord: self.squidSize = 60 self.sX = random.randint(0, screenWidth - self.squidSize) self.sY = random.randint(0, screenHeight - self.squidSize) self.squid = Neighbor( self.sX, self.sY, 40, 60, 600) # randomize the squid velocity & position, up & down motion # run has to be last on the list self.run()
def joinGame(data): """Socket to join game""" print(request.sid, "Wants to join") username = data['player']['username'] email = data['player']['email'] userid = data['player']['userid'] gameid = data['gameid'] player = Player(userid, username, email) if(gameid in gameLst): if(player.userid in gameLst[gameid].players): emit('join-game', {"status": "success", "reason": "You are already in this game", "gameid": gameid}, room=request.sid) join_room(gameid) return else: join_room(gameid) gameLst[gameid].addPlayer(player) emit('join-game', {"status": "success", "gameid": gameid}, room=request.sid) else: print("Not a valid gameid: " + gameid) emit('join-game', {"status": "failure", "reason": "Not a valid gameid"}, room=request.sid) return
async def run_server(addr: Address) -> None: glob.version = Version(2, 8, 5) glob.http = aiohttp.ClientSession(json_serialize=orjson.dumps) loop = asyncio.get_event_loop() try: loop.add_signal_handler(signal.SIGINT, loop.stop) loop.add_signal_handler(signal.SIGTERM, loop.stop) except NotImplementedError: pass glob.db = AsyncSQLPoolWrapper() await glob.db.connect(**glob.config.mysql) # create our bot & append it to the global player list. glob.bot = Player(id=1, name='Aika', priv=Privileges.Normal) glob.bot.last_recv_time = 0x7fffffff glob.players.add(glob.bot) # add all channels from db. async for chan in glob.db.iterall('SELECT * FROM channels'): await glob.channels.add(Channel(**chan)) # run background process to # disconnect inactive clients. loop.create_task(disconnect_inactive()) async with AsyncTCPServer(addr) as glob.serv: log(f'Gulag v{glob.version} online!', AnsiRGB(0x00ff7f)) async for conn in glob.serv.listen(glob.config.max_conns): loop.create_task(handle_conn(conn))
def initialize_match(self): from modules.matches import Matches self.season = Matches.get_season_by_id(self.raw_match['seasonId']) self.queue = Matches.get_queue_by_id(self.raw_match['queueId']) participant_identities = self.raw_match['participantIdentities'] for pid in participant_identities: try: player = Player(pid['player']['summonerName']) player.participant_id = pid['participantId'] self.players.append(player) except HTTPError as err: if err.response.status_code == 429: print('We should retry in {} seconds.') print( 'this retry-after is handled by default by the RiotWatcher library' ) print( 'future requests wait until the retry-after time passes' ) elif err.response.status_code == 404: print('Failed to fetch summoner!') else: raise
async def run_server(addr: cmyui.Address) -> None: glob.version = cmyui.Version(2, 7, 0) glob.http = aiohttp.ClientSession(json_serialize=orjson.dumps) loop = asyncio.get_event_loop() try: loop.add_signal_handler(signal.SIGINT, lambda: loop.stop()) loop.add_signal_handler(signal.SIGTERM, lambda: loop.stop()) except NotImplementedError: pass glob.db = cmyui.AsyncSQLPoolWrapper() await glob.db.connect(**glob.config.mysql) # Aika glob.bot = Player(id = 1, name = 'Aika', priv = Privileges.Normal) glob.bot.ping_time = 0x7fffffff await glob.bot.stats_from_sql_full() # no need to get friends await glob.players.add(glob.bot) # Add all channels from db. async for chan in glob.db.iterall('SELECT * FROM channels'): await glob.channels.add(Channel(**chan)) async with cmyui.AsyncTCPServer(addr) as glob.serv: plog(f'Gulag v{glob.version} online!', Ansi.LGREEN) async for conn in glob.serv.listen(glob.config.max_conns): asyncio.create_task(handle_conn(conn))
def __init__(self, *args, **kwargs): super(MainWindow, self).__init__(*args, **kwargs) self.set_location(SCREEN_POS_X - (self.width // 2), SCREEN_POS_Y - (self.height // 2)) self.title = 'PyMMO' self.player: Player = Player() self.network = None
def __init__(self, cursor, levels, pause_menu, background, *args, **kwrgs): super().__init__(*args, **kwrgs, vsync=False) pyglet.gl.glClearColor(0.7, 0.6, 0.4, 0.29) self.cursor = cursor self.levels = levels self.current_level = 0 self.level_background = background self.level_active = False self.enemy_handler = self.spawn_enemies_for_level(self.current_level) self.player = Player(self.width / 2, 40, self.level_background) self.bullet_handler = BulletHandler(self.player, self.level_background) self.player_handler = PlayerHandler(self.player, self.width, self.height, self.bullet_handler, self.cursor) self.hud = HUD(self.width, self.height, len(self.enemy_handler.enemies), (255, 69, 0, 255)) self.pause_menu = pause_menu self.menu_visible = True self.end_screen = EndScreen(self.width, self.height, 0, 0, 0) self.end_screen_visible = False self.mouse_x = 0 self.mouse_y = 0 self.game_event_handler = GameEventHandler( self.update_mouse_coordinates, self.toggle_menu, self.mouse_click_tracker, self.mouse_motion_tracker, self.player_handler.player_action_handler, ) self.push_handlers(self.game_event_handler)
def build_fixtures(): cache_dir = __file__.replace("loader.py", "cache") obj_map = { "division": list(Division()), "position": list(Position()), "category": list(Category()), "team": list(Team()), "record": list(Record()), "profile": list(Profile()), "color": list(Color()), "teamnav": list(TeamNav()), "player": list(Player()), "playernav": list(PlayerNav()), "stat": list(Stat()), "teamstat": list(TeamStat()), "oppstat": list(OppStat()), "playerstat": list(PlayerStat()) } fixture_dir = f"{cache_dir}/fixtures" os.makedirs(fixture_dir, exist_ok=True) fixtures = [] for key, value in obj_map.items(): filename = f"{fixture_dir}/{key}.json" with open(filename, "w") as f: json.dump(value, f) fixtures += value with open(f"{fixture_dir}/all.json", "w") as f: json.dump(fixtures, f)
async def on_start() -> None: glob.http = aiohttp.ClientSession(json_serialize=orjson.dumps) # connect to mysql glob.db = cmyui.AsyncSQLPool() await glob.db.connect(glob.config.mysql) # run the sql updater updater = Updater(glob.version) await updater.run() await updater.log_startup() # create our bot & append it to the global player list. glob.bot = Player(id=1, name='Aika', priv=Privileges.Normal) glob.bot.last_recv_time = float(0x7fffffff) glob.players.append(glob.bot) # add all channels from db. async for chan in glob.db.iterall('SELECT * FROM channels'): chan['read_priv'] = Privileges(chan.pop('read_priv', 1)) chan['write_priv'] = Privileges(chan.pop('write_priv', 2)) glob.channels.append(Channel(**chan)) # add all mappools from db. async for pool in glob.db.iterall('SELECT * FROM tourney_pools'): # overwrite basic types with some class types creator = await glob.players.get(id=pool['created_by'], sql=True) pool['created_by'] = creator # replace id with player object pool = MapPool(**pool) await pool.maps_from_sql() glob.pools.append(pool) # add new donation ranks & enqueue tasks to remove current ones. # TODO: this system can get quite a bit better; rather than just # removing, it should rather update with the new perks (potentially # a different tier, enqueued after their current perks). async def rm_donor(userid: int, delay: int): await asyncio.sleep(delay) p = await glob.players.get(id=userid, sql=True) await p.remove_privs(Privileges.Donator) log(f"{p}'s donation perks have expired.", Ansi.MAGENTA) query = ('SELECT id, donor_end FROM users ' 'WHERE donor_end > UNIX_TIMESTAMP()') async for donation in glob.db.iterall(query): # calculate the delta between now & the exp date. delta = donation['donor_end'] - time.time() if delta > (60 * 60 * 24 * 30): # ignore donations expiring in over a months time; # the server should restart relatively often anyways. continue asyncio.create_task(rm_donor(donation['id'], delta))
def on_resize(self, width, height): self.width = width self.height = height # reinitialize score with current values: current_score = self.hud.score.value current_kill_count = self.hud.kill_count.killed self.hud = HUD(self.width, self.height, self.levels[self.current_level]['enemy_amount'], (255, 69, 0, 255)) self.hud.score.update_score(current_score) self.hud.kill_count.killed = current_kill_count # reinit player and player_handler self.player = Player(self.width / 2, 40, self.level_background) self.bullet_handler = BulletHandler(self.player, self.level_background) self.player_handler = PlayerHandler(self.player, self.width, self.height, self.bullet_handler, self.cursor) # reinit menus: self.pause_menu = Menu(self.width, self.height) # add handlers: self.pop_handlers() self.game_event_handler = GameEventHandler( self.update_mouse_coordinates, self.toggle_menu, self.mouse_click_tracker, self.mouse_motion_tracker, self.player_handler.player_action_handler, ) self.push_handlers(self.game_event_handler) return super().on_resize(width, height)
def __init__(self, conf: Config, screen: pg.Surface): self.conf = conf self.screen = screen self.player = Player(conf) self.blocks = list() self.score = Score(conf) self.clock = pg.time.Clock()
class PlayerList(Sequence): """A class to represent all players online on the gulag. Attributes ----------- players: List[:class:`Player`] A list of player objects representing the online users. """ __slots__ = ('players', ) def __init__(self): self.players = [] def __getitem__(self, index: Slice) -> Player: return self.players[index] def __contains__(self, p: Union[Player, str]) -> bool: # Allow us to either pass in the player # obj, or the player name as a string. if isinstance(p, str): return p in (player.name for player in self.players) else: return p in self.players def __len__(self) -> int: return len(self.players) @property def ids(self) -> Tuple[int, ...]: return (p.id for p in self.players) def enqueue(self, data: bytes, immune: Tuple[Player, ...] = ()) -> None: for p in self.players: if p not in immune: p.enqueue(data) def get(self, token: str) -> Player: for p in self.players: # might copy if p.token == token: return p def get_by_name(self, name: str, sql: bool = False) -> Player: for p in self.players: # might copy if p.name == name: return p if not sql: # Don't fetch from SQL # if not specified. return # Try to get from SQL. if not (res := glob.db.fetch( 'SELECT id, priv, silence_end ' 'FROM users WHERE name = %s', [name])): return return Player(**res)
def add_player(self, local_id, name): """ Adds a player to the self.players dict """ new_player = Player(local_id, name=name) self.players[local_id] = new_player self.notify.debug(f"[add_player] Added local player {local_id}") if self.active_level == LOBBY: self.levels[LOBBY].update_player()
def enable_bot_and_player(_game): player = Player(settings.PLAYER_SKINS[0], 175, 100, 290, "Player") bot = Bot(settings.BOT_SKINS[0], 75, 200, 300, 290, "Bot") obs_player = Observer(player, [wall]) obs_bot = Observer(bot, [wall]) player.obs = obs_player bot.set_target(wall) bot.obs = obs_bot _game.player = player _game.add_object(bot)
def __init__(self): pygame.init() pygame.display.set_caption('Orgs') self.running = True self.size = self.width, self.height = 860, 450 self.display_surf = pygame.display.set_mode(self.size) self.map = Game_map() self.enemies = [] self.player = Player('@', (100,200,100), 30, 1, 1) self.gui = Gui(self.player, self.display_surf) self.create_monster('G', (255,50,50), 20, 12) self.gui.log('Find the Amulet of Yendor!')
def __init__(self, game): super().__init__(game) self.game = game self.game.state.cycle() self.map = Map(self) self.player = Player(self, pos=self.game.state.last_player_position) self.characters = [Rando(self, pos=(8, 5))] self.camera = Camera(pos=self.game.state.last_player_position) self.dialogue_box = DialogueBox(self) self.dialogue_box.hide() self.objects = [self.player, self.camera ] + self.characters + self.map.get_plots() self.next_scene = None
def __init__(self): self.scroll = 0 self.player = Player(WIN_WIDTH / 2, 360) self.items = [Chest(WIN_WIDTH / 2 + 540, 310, 'images/case.png', "Сейф 1", 320 // 4, 240 // 3), Picture(WIN_WIDTH / 2 - 150, 240, 'images/picture.png', "Картина", 320 // 4, 240 // 3), Books(WIN_WIDTH / 2 + 200, 300, 'images/books.png', "Книги",320 // 2, 240 // 2), Jail(WIN_WIDTH / 2 + 750, 269, 'images/jail.png', "Заключенный", 320, 240), Table(WIN_WIDTH / 2 - 300, 300, 'images/table.png', "Стол", 320 // 2, 240 // 2)] self.dialog = Dialog("- Добро пожаловать в мир твоих самых страшных кошмаров, жалкий офисный червяк.") self.left = self.right = self.up = self.down = False
def __init__(self, width, height): pygame.init() pygame.display.set_caption('Pykémon') self.window_width = width self.window_height = height self.win = pygame.display.set_mode( (self.window_width, self.window_height)) self.player = Player(self.window_width / 2, self.window_height / 2, self.win) self.pokeballs = [] self.background = Background(self.window_width, self.window_height, self.win) self.pokemon = '' self.run = True
async def get_by_id(self, pid: int, sql: bool = False) -> Player: for p in self.players: if p.id == pid: return p if not sql: # Don't fetch from SQL # if not specified. return # Try to get from SQL. res = await glob.db.fetch( 'SELECT name, priv, silence_end ' 'FROM users WHERE id = %s', [pid]) return Player(**res, id=pid) if res else None
async def get_by_name(self, name: str, sql: bool = False) -> Player: for p in self.players: if p.name == name: return p if not sql: # Don't fetch from SQL # if not specified. return # Try to get from SQL. res = await glob.db.fetch( 'SELECT id, priv, silence_end ' 'FROM users WHERE name = %s', [name]) return Player(**res, name=name) if res else None
async def get_summoner(self, ctx, name: str): """Display information on a summoner""" try: player = Player(name) except HTTPError as err: await ctx.send('Failed to fetch summoner! Error code {}'.format( err.response.status_code)) return ret = 'Name: ' + player.name + '\n' ret += '\tLevel: ' + player.summoner_level + '\n' ret += '\tRanked: \n' ret += '\t\tSolo/Duo - ' + player.solo_rank + '\n' ret += '\t\tFlex 5v5 - ' + player.flex_rank + '\n' ret += '\t\tFlex 3v3 - ' + player.threes_rank await ctx.send(ret)
async def get_by_name(self, name: str, sql: bool = False) -> Player: name_safe = Player.make_safe(name) for p in self.players: if p.safe_name == name_safe: return p if not sql: # don't fetch from sql # if not specified. return # try to get from sql. res = await glob.db.fetch( 'SELECT id, priv, silence_end ' 'FROM users WHERE name_safe = %s', [name_safe]) return Player(**res, name=name) if res else None
def __init__(self, screen): self.__screen = screen source.sounds['song2'].play(-1) #create accessory objects camera = Camera() background = Background(color=setting.color_background_game) #create game objects player = Player(setting.size_screen[0] / 2, setting.size_screen[1] / 2) rockManager = RockManager() flameManager = FlameManager() scoreText = ScoreText(score=0) highscoreText = HighscoreText() #bind(link) objects player.bind(camera, rockManager, flameManager, scoreText) rockManager.bind(camera, player) flameManager.bind(camera) #list gameobjects #append first = draw first gameObjects = [] gameObjects.append(background) gameObjects.append(scoreText) gameObjects.append(highscoreText) gameObjects.append(flameManager) gameObjects.append(player) gameObjects.append(rockManager) gameObjects.append(camera) self.__camera = camera self.__background = background self.__player = player self.__rockManager = rockManager self.__flameManager = flameManager self.__scoreText = scoreText self.__highscoreText = highscoreText self.__gameObjects = gameObjects self.__state = 'play' self.__timeCounter = 0
async def initialize_ram_caches(db_cursor: aiomysql.DictCursor) -> None: """Setup & cache the global collections before listening for connections.""" # dynamic (active) sets, only in ram glob.matches = Matches() glob.players = Players() # static (inactive) sets, in ram & sql glob.channels = await Channels.prepare(db_cursor) glob.clans = await Clans.prepare(db_cursor) glob.pools = await MapPools.prepare(db_cursor) bot_name = await misc.utils.fetch_bot_name(db_cursor) # create bot & add it to online players glob.bot = Player( id=1, name=bot_name, login_time=float(0x7FFFFFFF), # (never auto-dc) priv=Privileges.NORMAL, bot_client=True, ) glob.players.append(glob.bot) # global achievements (sorted by vn gamemodes) glob.achievements = [] await db_cursor.execute("SELECT * FROM achievements") async for row in db_cursor: # NOTE: achievement conditions are stored as stringified python # expressions in the database to allow for extensive customizability. condition = eval(f'lambda score, mode_vn: {row.pop("cond")}') achievement = Achievement(**row, cond=condition) glob.achievements.append(achievement) # static api keys await db_cursor.execute( "SELECT id, api_key FROM users WHERE api_key IS NOT NULL") glob.api_keys = {row["api_key"]: row["id"] async for row in db_cursor}
async def run_server(loop: uvloop.Loop, addr: cmyui.Address): glob.version = cmyui.Version(2, 2, 8) glob.http = aiohttp.ClientSession(json_serialize=orjson.dumps) glob.db = cmyui.AsyncSQLPool() await glob.db.connect(loop, **glob.config.mysql) # Aika glob.bot = Player(id=1, name='Aika', priv=Privileges.Normal) glob.bot.ping_time = 0x7fffffff await glob.bot.stats_from_sql_full() # no need to get friends await glob.players.add(glob.bot) # Add all channels from db. async for chan in glob.db.iterall('SELECT * FROM channels'): await glob.channels.add(Channel(**chan)) async with cmyui.AsyncTCPServer(addr) as serv: await plog(f'Gulag v{glob.version} online!', Ansi.LIGHT_GREEN) async for conn in serv.listen(loop, glob.config.max_conns): asyncio.create_task(handle_conn(conn))
async def setup_collections() -> None: """Setup & cache many global collections (mostly from sql).""" glob.players = PlayerList() # online players glob.matches = MatchList() # active multiplayer matches glob.channels = await ChannelList.prepare() # active channels glob.clans = await ClanList.prepare() # active clans glob.pools = await MapPoolList.prepare() # active mappools # create our bot & append it to the global player list. res = await glob.db.fetch('SELECT name FROM users WHERE id = 1') glob.bot = Player( id = 1, name = res['name'], priv = Privileges.Normal, login_time = float(0x7fffffff), # never auto-dc bot_client = True ) glob.players.append(glob.bot) # global achievements (sorted by vn gamemodes) glob.achievements = {0: [], 1: [], 2: [], 3: []} async for row in glob.db.iterall('SELECT * FROM achievements'): # NOTE: achievement conditions are stored as # stringified python expressions in the database # to allow for easy custom achievements. condition = eval(f'lambda score: {row.pop("cond")}') achievement = Achievement(**row, cond=condition) # NOTE: achievements are grouped by modes internally. glob.achievements[row['mode']].append(achievement) # static api keys glob.api_keys = { row['api_key']: row['id'] for row in await glob.db.fetchall( 'SELECT id, api_key FROM users ' 'WHERE api_key IS NOT NULL' ) }