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'
)
}
