async def rating(self, ctx, platform: Platform, *, username):
"""Returns player ranks.
`<platform>` - The platform of the player to get ranks for.
`<username>` - The username of the player to get ranks for.
Platforms
- pc (bnet)
- playstation (ps, psn, play)
- xbox (xbl)
- nintendo-switch (nsw, switch)
Username formatting
- pc: BattleTag (format: name#0000)
- playstation: Online ID
- xbox: Gamertag
- nintendo-switch: Nintendo Switch ID (format: name-code)
BattleTag example: Timmy#22340
Nintendo Switch ID example: name-7alf327e36d5d1d8f507e765u5a2ech7
"""
try:
message = await ctx.send(embed=self.bot.loading_embed())
data = await Request(platform=platform, username=username).get()
except RequestError as e:
await self.bot.cleanup(message)
return await ctx.send(e)
profile = Player(data, platform=platform, username=username)
if profile.is_private:
embed = profile.private()
else:
embed = await profile.get_ratings(ctx)
await message.edit(embed=embed)
def _get_players(self):
players = []
for P in self.replaydata['blue']['players']:
kwargs = {
"team": "blue",
"name": P.get('name', None),
"steam": P['id']['id'] if P['id']['platform'] == 'steam' else None,
"game": self,
"score": P['stats']['core']['score'],
"goals": P['stats']['core']['goals'],
"saves": P['stats']['core']['saves'],
"camera": P.get('camera'),
"rank": P.get('rank'),
"platform": P['id']['platform']
}
p = Player(**kwargs)
players.append(p)
for P in self.replaydata['orange']['players']:
kwargs = {
"team": "orange",
"name": P.get('name', None),
"steam": P['id']['id'] if P['id']['platform'] == 'steam' else None,
"game": self,
"score": P['stats']['core']['score'],
"goals": P['stats']['core']['goals'],
"saves": P['stats']['core']['saves'],
"camera": P.get('camera', None)
}
p = Player(**kwargs)
players.append(p)
return players
async def hero(
self,
ctx,
hero: Hero,
platform: Platform,
*,
username,
):
"""Returns player both quick play and competitive statistics for a given hero.
`<hero>` - The name of the hero you want to see stats for.
`<platform>` - The platform of the player to get stats for.
`<username>` - The username of the player to get stats for.
Platforms
- pc (bnet)
- playstation (ps, psn, play)
- xbox (xbl)
- nintendo-switch (nsw, switch)
Username formatting
- pc: BattleTag (format: name#0000)
- playstation: Online ID
- xbox: Gamertag
- nintendo-switch: Nintendo Switch ID (format: name-code)
BattleTag example: Timmy#22340
Nintendo Switch ID example: name-7alf327e36d5d1d8f507e765u5a2ech7
"""
try:
message = await ctx.send(embed=self.bot.loading_embed())
data = await Request(platform=platform, username=username).get()
except RequestError as e:
await self.bot.cleanup(message)
return await ctx.send(e)
profile = Player(data, platform=platform, username=username)
if profile.is_private:
embed = profile.private()
else:
try:
embed = profile.get_hero(ctx, hero)
except PlayerException as e:
await self.bot.cleanup(message)
return await ctx.send(e)
await self.bot.cleanup(message)
await self.bot.paginator.Paginator(pages=embed).start(ctx)
def __init__(self, players: list):
self.players = list()
for name in players:
self.players.append(Player(name)) #add name in self.players list
self.turn_count = 0
self.active_cards = list()
self.history_cards = list()
def get_player(self, ctx):
try:
player = self.players[ctx.guild.id]
except KeyError:
player = Player(ctx)
self.players[ctx.guild.id] = player
return player
def start_game(self):
print("Are you ready The game will start " )
number_of_players = int(input("How many wants to play "))
number_cards4eachp = 52 // number_of_players
for i in range(1, number_of_players + 1):
player_name = input("Please enter the name of player " + str(i) )
pname = Player(player_name)
Deck.distribute(pname, number_cards4eachp, )
async def hero(
self, ctx, hero: Hero, index: Index = None, member: discord.Member = None
):
"""Shows a member's Overwatch both quick play and competitive statistics for a given hero.
`<hero>` - The name of the hero you want to see stats for.
`[index]` - The profile's index you want to see the ranks for.
`[member]` - The mention or the ID of a Discord member of the current server.
If no index is given then the profile used will be the main one.
If no member is given then the statistics returned will be yours.
If you want to see a member's stats, you must enter both the index and the member.
"""
async with ctx.typing():
member = member or ctx.author
try:
_, platform, username = await self.get_profile(member, index=index)
except MemberHasNoProfile as e:
return await ctx.send(e)
except IndexError:
return await ctx.send(
f'Invalid index. Use "{ctx.prefix}help profile hero" for more info.'
)
try:
data = await Request(platform=platform, username=username).get()
except RequestError as e:
return await ctx.send(e)
profile = Player(data, platform=platform, username=username)
if profile.is_private:
embed = profile.private()
else:
try:
embed = profile.get_hero(ctx, hero)
except NoHeroStatistics as e:
return await ctx.send(e)
await self.bot.paginator.Paginator(pages=embed).start(ctx)
async def rating(self, ctx, index: Index = None, member: discord.Member = None):
"""Shows a member's Overwatch ranks.
`[index]` - The profile's index you want to see the ranks for.
`[member]` - The mention or the ID of a Discord member of the current server.
If no index is given then the profile used will be the main one.
If no member is given then the ranks returned will be yours.
If you want to see a member's stats, you must enter both the index and the member.
"""
async with ctx.typing():
member = member or ctx.author
try:
id, platform, username = await self.get_profile(member, index=index)
except MemberHasNoProfile as e:
return await ctx.send(e)
except IndexError:
return await ctx.send(
f'Invalid index. Use "{ctx.prefix}help profile rating" for more info.'
)
try:
data = await Request(platform=platform, username=username).get()
except RequestError as e:
return await ctx.send(e)
profile = Player(data, platform=platform, username=username)
if profile.is_private:
embed = profile.private()
else:
embed = await profile.get_ratings(ctx, save=True, profile_id=id)
# if the index is None that means it's the main profile
if not index and member.id == ctx.author.id:
await self.update_nickname_sr(ctx.author, profile=profile)
await self.bot.paginator.Paginator(pages=embed).start(ctx)
def main(config, modelParam):
if config['network'] == 'CartPole_v1_image':
env = EnvironmentWrapper_image(modelParam)
else:
env = EnvironmentWrapper(modelParam)
# create an instance of the model you want
model = Model(config, modelParam, env)
# create an instacne of the saver and resoterer class
saveRestorer = SaverRestorer(config, modelParam)
model = saveRestorer.restore(model)
# here you train your model
if modelParam['play'] == False:
trainer = Trainer(model, modelParam, config, saveRestorer, env)
trainer.train()
#play
if modelParam['play'] == True:
player = Player(model, modelParam, config, saveRestorer, env)
player.play_episode()
return
def login():
id = request.values['_id']
if id.startswith('16DRL_'):
if id not in PLAYER_DB['player']:
abort(404)
else:
# Init Map
map = Map(13)
player = Player(id)
map.reset(player)
showMap = map.show_map(player)
level = map.show_total_map(player)
# Save Map
save(player, map)
id = player.hashID
return redirect("/map/" + id, code=303)
def start_game(self) -> None:
"""
Start the game,
Fill a Deck,
Distribute the cards of the Deck to the players.
Make each Player play() a Card , where each player should only play 1 card per turn, and all players have to play at each turn until they have no cards left.
At the end of each turn, print:
The turn count.
The list of active cards.
The number of cards in the history_cards.
"""
# Start board & player setup
name = " "
names = []
while name or len(names) < 2:
name = input("Write player name (ENTER when done): ")
if name and name not in names:
names.append(name)
self.players.append(Player(name))
# Shuffle players
shuffle(self.players)
deck = Deck()
deck.fill_deck()
deck.shuffle()
self.players = deck.distribute(self.players)
# Start game loop
nb_cards_in_hands = 52
while nb_cards_in_hands > 0:
print(nb_cards_in_hands)
nb_cards_in_hands = 0
for player in self.players:
# If one turn has passed (cards in self.active_cards), put old cards to graveyard
if self.turn_count > 0:
self.history_cards.append(self.active_cards.pop(0))
# Check if user has still cards left. If true, play one
if player.number_of_cards > 0:
self.active_cards.append(player.play())
nb_cards_in_hands += player.number_of_cards
self.turn_count += 1
active_cards_str = [card.__str__() for card in self.active_cards]
print(f"Turn: {self.turn_count}\n\
Cards on board: {active_cards_str}\n\
Graveyard: {len(self.history_cards)}")
def __init__(self):
self.version = 1.27
self.uptime = datetime.now()
# free disk space
self.disk = Player.free_space()
# initialise database
self.db = SQLite(options.db)
# initialise alerts
self.alerts = Alert()
# initialise playlist
sql = 'SELECT id, artist, title, length, enabled FROM songs WHERE processed = 1 ORDER BY RANDOM()'
self.playlist = Playlist((x.id, x.artist, x.title, x.length, x.enabled) for x in self.db.query(sql))
# initialise player
self.player = Player(self.playlist)
# initialise WSO
self.wso = WSO(self.player)
# initialise application
super(Application, self).__init__(
[
(r'/', MainHandler),
(r'/login', LoginHandler),
(r'/logout', LogoutHandler),
(r'/upload', UploadHandler),
(r'/songs/(\d+)', SongHandler),
(r'/users(?:/([^/]+))?', UserHandler),
(r'/list', ListHandler),
(r'/wso', WSOHandler),
],
login_url='/login',
cookie_secret='xWP6dkmS489K14Uaj16w416P8Y7b2L474807tjwJ',
template_path=os.path.join(os.path.dirname(__file__), 'templates'),
static_path=os.path.join(os.path.dirname(__file__), 'static'),
debug=options.debug,
xsrf_cookies=True,
gzip=True,
)
async def nickname(self, ctx):
"""Update your server nickname and set it to your SR.
The nickname can only be set in one server.
The nickname will automatically be updated everytime `-profile rating` is used
and the profile is the main one.
"""
if not await self.has_nickname(ctx.author.id):
if not await ctx.prompt("Do you want to display your SR in your nickname?"):
return
if ctx.guild.me.top_role < ctx.author.top_role:
return await ctx.send(
"This server's owner needs to move the `OverBot` role higher, so I will "
"be able to update your nickname. If you are this server's owner, there's "
"not way for me to change your nickname, sorry!"
)
id, platform, username = await self.get_profile(ctx.author, index=None)
try:
data = await Request(platform=platform, username=username).get()
except RequestError as e:
return await ctx.send(e)
profile = Player(data, platform=platform, username=username)
if profile.is_private:
return await ctx.send(
f"{str(profile)}'s profile is set to private. Profiles must be "
"set to public in order for me to retrieve their data."
)
try:
await self.set_or_remove_nickname(ctx, profile=profile, profile_id=id)
except Exception as e:
await ctx.send(e)
else:
if await ctx.prompt("Do you want to **remove** your SR in your nickname?"):
try:
await self.set_or_remove_nickname(ctx, remove=True)
except Exception as e:
await ctx.send(e)
def parse_input_file():
file = open('input.txt', 'r')
__input = file.read()
file.close()
player_list = []
snake_list = []
ladder_list = []
__input = __input.split('\n')
__snake_cnt = int(__input[0])
__line_no = 1
while(__snake_cnt!=0):
_source, _destination = __input[__line_no].split()
snake_list.append(Movable(int(_source), int(_destination)))
__line_no += 1
__snake_cnt -= 1
__ladder_cnt = int(__input[__line_no])
__line_no += 1
while(__ladder_cnt!=0):
_source, _destination = __input[__line_no].split()
ladder_list.append(Movable(int(_source), int(_destination)))
__line_no += 1
__ladder_cnt -= 1
__player_cnt = int(__input[__line_no])
__line_no += 1
while(__player_cnt!=0):
_name = __input[__line_no]
player_list.append(Player(_name))
__line_no += 1
__player_cnt -= 1
return player_list, snake_list, ladder_list
def callback(success, artist, title, song_id, path):
if success:
try:
# read mp3
mf = Player.open(path)
length = mf.total_time()
sql = 'UPDATE songs SET length = ?, bitrate = ?, samplerate = ?, processed = 1 WHERE id = ?'
self.db.execute(sql, length, mf.bitrate() / 1000, mf.samplerate(), song_id)
# update lists
self.player.playlist.append(song_id, artist, title, length)
self.application.wso.new(song_id)
# update free space
self.application.disk = self.player.free_space()
self.application.wso.disk(self.application.disk)
message = u'Song "%s \u2014 %s" was added to the playlist' % (artist, title)
return self.alert(message, self.ALERT_SUCCESS)
except: pass
self.db.execute('DELETE FROM songs WHERE id = ?', song_id)
self.alert(u'File for song "%s \u2014 %s" is broken' % (artist, title))
def post(self):
artists = self.get_body_arguments('artist[]')
titles = self.get_body_arguments('titles[]')
mp3s = self.request.files.get('mp3[]', [])
lame = LAME()
for i, mp3 in enumerate(mp3s):
try:
artist, title = artists[i][:64], titles[i][:128].title()
if not artist or not title:
raise Exception('Song %s should have artist and title' % (i + 1))
if os.path.splitext(mp3['filename'])[1].lower() != '.mp3':
raise Exception('Song %s should have MP3 format' % (i + 1))
sql = 'INSERT INTO songs (user, artist, title) VALUES (?, ?, ?)'
song_id = self.db.execute(sql, self.current_user.login, artist, title)
path = Player.song2path(song_id)
with open(path, 'wb') as fp:
fp.write(mp3['body'])
lame.add(path, artist, title, song_id, path)
except ValueError:
return self.send_error(400)
except Exception as e:
self.alert(e)
if not lame.queue:
return self.redirect('/upload')
def callback(success, artist, title, song_id, path):
if success:
try:
# read mp3
mf = Player.open(path)
length = mf.total_time()
sql = 'UPDATE songs SET length = ?, bitrate = ?, samplerate = ?, processed = 1 WHERE id = ?'
self.db.execute(sql, length, mf.bitrate() / 1000, mf.samplerate(), song_id)
# update lists
self.player.playlist.append(song_id, artist, title, length)
self.application.wso.new(song_id)
# update free space
self.application.disk = self.player.free_space()
self.application.wso.disk(self.application.disk)
message = u'Song "%s \u2014 %s" was added to the playlist' % (artist, title)
return self.alert(message, self.ALERT_SUCCESS)
except: pass
self.db.execute('DELETE FROM songs WHERE id = ?', song_id)
self.alert(u'File for song "%s \u2014 %s" is broken' % (artist, title))
lame.start(callback)
total = len(lame.queue)
self.alert('%s song%s uploaded, now processing...' %
(total, ' was' if total == 1 else 's were'), self.ALERT_INFO)
self.redirect('/upload')
from time import strftime, localtime
from configparser import ConfigParser
from utils.sheet import Sheet
from utils.steam import Steam
from utils.player import Player
config = ConfigParser()
config.read("config.ini")
sheet = Sheet(
sheet_key=config.get("accmgr", "sheet_key"),
credentials="credentials.json",
url_column=config.get("accmgr", "url_column"),
ban_column=config.get("accmgr", "ban_column"),
)
steam = Steam(config.get("accmgr", "steam_api"))
profile_urls = sheet.get_profile_links()
player_bans = steam.fetch_player_bans(profile_urls)
players = Player().from_dict(player_bans)
updated = sheet.update_game_bans(players)
print(
strftime("%y-%m-%d %H:%M:%S", localtime()),
"Updated Cells:",
updated["updatedCells"],
)
import av
import time
import numpy as np
import sounddevice as sd
from utils.player import Player
plr = Player()
cap = av.open("rtsp://*****:*****@192.168.100.1/cam1/h264")
stream = [s for s in cap.streams
][1] # set stream to video stream, [1] is audio stream
for packet in cap.demux(stream):
for frame in packet.decode(): # rate is 8000
audio = np.frombuffer(frame.planes[0], dtype=np.int16)
butter = np.array([1, -1, 1, -1, 1, -1, 1, -1])
audio = np.array(np.convolve(audio, butter, mode="same"),
dtype=np.int16)
# print(audio)
if audio is not None:
sd.play(audio, 8000)
print("Done")
from utils.game import Board
from utils.player import Player
if __name__ == "__main__":
print("**************************************************")
print("*** WE TAKE YOUR MONEY ***")
print("*** Enjoy your experience ***")
print("**************************************************")
print("\n")
player1 = Player("Alan Turing")
player2 = Player("Rachel Thomas")
player3 = Player("Tom Crasset")
while True:
take_a_seat = input("Do you want to take a seat (Y/N) :")
if take_a_seat in ("Y", "y", "N", "n"):
if take_a_seat in ("Y", "y"):
player4 = Player(input("What's your name ? "), True)
else:
player4 = Player("Jérôme Coumont")
break
game = Board([player1, player2, player3, player4])
game.start_game()
def main():
record = True
plr = Player(colour=True, record=False)
# initialize placeholder point clouds
pc_left = rs.pointcloud()
pc_right = rs.pointcloud()
# create prefix and directories for naming files
current_time = datetime.datetime.now()
prefix = current_time.strftime("%Y-%m-%d:%H:%M")
npy_dir = "data/" + prefix + "/npys/"
ply_dir = "data/" + prefix + "/plys/"
os.makedirs(npy_dir)
os.makedirs(ply_dir)
# initialise counters for naming files
ply_counter = npy_counter = 0
try:
while True:
[frame_left, frame_right] = plr.getFrames()
if not frame_left or not frame_right:
continue
depth_frame_left = frame_left.get_depth_frame()
depth_frame_right = frame_right.get_depth_frame()
depth_color_frame_left = rs.colorizer().colorize(depth_frame_left)
depth_color_frame_right = rs.colorizer().colorize(
depth_frame_right)
# Convert depth_frame to numpy array to render image
depth_color_image_left = np.asanyarray(
depth_color_frame_left.get_data())
depth_color_image_right = np.asanyarray(
depth_color_frame_right.get_data())
depth_color_image = np.hstack(
(depth_color_image_left, depth_color_image_right))
# resize to fit screen, change as desired
image = cv2.resize(depth_color_image, (1440, 720))
# Render image in opencv window
cv2.imshow("Depth Stream", image)
key = cv2.waitKey(1)
# if s is pressed save .npy
if key == ord('s') and not record:
points_left = pc_left.calculate(depth_frame_left)
points_right = pc_right.calculate(depth_frame_right)
np.save(npy_dir + str(npy_counter) + "left",
np.array(points_left.get_vertices()))
print("File saved to " + npy_dir + str(npy_counter) +
"left.npy")
np.save(npy_dir + str(npy_counter) + "right",
np.array(points_right.get_vertices()))
print("File saved to " + npy_dir + str(npy_counter) +
"right.npy")
npy_counter += 1
if record:
# convert and save left file
points_left = pc_left.calculate(depth_frame_left)
points_left = np.array(points_left.get_vertices())
# print(points_left.shape)
points_left = points_left[np.nonzero(points_left)]
np.save(npy_dir + str(npy_counter) + "left", points_left)
print("File saved to " + npy_dir + str(npy_counter) +
"left.npy")
# convert and save right file
points_right = pc_right.calculate(depth_frame_right)
points_right = np.array(points_right.get_vertices())
points_right = points_right[np.nonzero(points_right)]
np.save(npy_dir + str(npy_counter) + "right", points_right)
print("File saved to " + npy_dir + str(npy_counter) +
"right.npy")
npy_counter += 1
if npy_counter > 200:
raise Exception("finished recording")
# time.sleep(0.1)
# if a is pressed save .ply
if key == ord('a'):
color_frame_left = frame_left.get_color_frame()
color_frame_right = frame_right.get_color_frame()
# ply's require a colour mapping
pc_left.map_to(color_frame_left)
pc_right.map_to(color_frame_right)
points_left = pc_left.calculate(depth_frame_left)
points_right = pc_right.calculate(depth_frame_right)
points_left.export_to_ply(
ply_dir + str(ply_counter) + "left.ply", color_frame_left)
print("File saved to " + ply_dir + str(ply_counter) +
"left.ply")
points_right.export_to_ply(
ply_dir + str(ply_counter) + "right.ply",
color_frame_right)
print("File saved to " + ply_dir + str(ply_counter) +
"right.ply")
ply_counter += 1
# if pressed escape exit program
if key == 27:
cv2.destroyAllWindows()
break
finally:
print("Stopping pipelines.")
plr.stop()
print("Compacting files.")
def set_table(self, names):
self.player_names = names
self.table = Table([Player(n) for n in self.player_names])
import PyQt5
from utils.driver import Driver
from utils.neuron import Neuron
from utils.detector import Detector
from utils.player import Player
import numpy as np
from scipy import signal
import matplotlib.pyplot as plt
import time
import keyboard
from brian2 import NeuronGroup, ms
# initialise classes
det = Detector("hand")
plr = Player()
drv = Driver()
time.sleep(0.1)
drv.lowerTurn()
## Comment to remove plottingqq
fig, ax = plt.subplots()
ax.set_ylim([-0.08, 0.07])
line1, = ax.plot(np.linspace(0, 10000, 10000), np.zeros(10000), 'r-')
line2, = ax.plot(np.linspace(0, 10000, 10000), np.zeros(10000), 'b-')
line3, = ax.plot(np.linspace(0, 10000, 10000), np.zeros(10000), 'g-')
plt.show(block=False)
fig.canvas.draw()
## /Comment to remove plotting
# Izhikevitch Neuron Model from http://brian2.readthedocs.io/en/stable/introduction/brian1_to_2/library.html
def add_player(self, p_name):
self.players.append(Player(p_name))
device = AmazonBasics(array('B', [0x61, 0x8E, 0x9C, 0xCD, 0x03]), [3], array('B', [0x3C, 0x2A]))
# device = Device(array('B', [0x61, 0x8E, 0x9C, 0xCD, 0x03]), [3], [], 'Test')
device.status = 'Test'
config.devices.append(device)
device = Device(array('B', [0x98, 0xA3, 0x24, 0x69, 0x07]), [62], [], 'Test')
device.status = 'Test'
config.devices.append(device)
device = LogitechMouse(array('B', [0x42, 0x66, 0x0A, 0xB1, 0x04]), [62], array('B', [0x00, 0xC2]), array('B', [0, 0x4F, 0, 0, 0x6E, 0, 0, 0, 0, 0x43]), 'Unencrypted')
device.status = 'Test'
config.devices.append(device)
# for i in range(10):
# device = Device(array('B', [0x98, 0xA3, 0x24, 0x69, i]), [i], [], 'Test')
# device.status = 'Test'
# config.devices.append(device)
if __name__ == "__main__":
# test_devices()
init_commands()
messager = Messager()
messager.start()
player = Player()
player.start()
try:
while True:
c = display.stdscr.getch()
check_command(c)
display.refresh()
except KeyboardInterrupt:
quit_app()
from play.play_round import Round
from utils.player import Player
from utils.table import Table
import random
player_names = ['anil', 'pogo', 'mangal', 'ramya', 'harsha']
players = [Player(name) for name in player_names]
table = Table(players)
r = Round(table)
print(r.table)
r.table.move_player_to_front_by_name('ramya')
print(r.table)
r.table.move_player_to_front_by_name('harsha')
print(r.table)
# r.table.move_dealer()
# print(r.table)
r.table.remove_player("anil")
print(r.table)
print("Trump is : {}".format(r.trump_card))
# cards_played = {'anil': random.choice(players[0].hand.cards),
# 'pogo': random.choice(players[1].hand.cards),
# 'mangal': random.choice(players[2].hand.cards),
# 'ramya': random.choice(players[3].hand.cards),
# 'harsha': random.choice(players[4].hand.cards)}
#
# r.play_round(cards_played)
# print(r.players)
from utils.player import Player
from utils.deck import Deck
p = Player(name='anil')
d = Deck()
for i in range(5):
p.add_card_to_hand(d.get_random_card())
print(p.hand)
p.remove_card(p.hand.cards[3])
print(p.hand)
p.add_card_to_hand(d.get_random_card())
print(p.hand)
from utils.game import Board
from utils.player import Player
from copy import deepcopy
all_player_names = [] # list of strings containing the names of all players
list_of_players = [] # list of all players of type Player
number_of_players = int(input('How may players?'))
for i in range(
number_of_players): # add name of players to list all_player_names
all_player_names.append(input('What is your name?'))
for i in range(
number_of_players): # creating the list list_of_players of type Player
k = Player(all_player_names[i])
list_of_players.append(k)
player_board = Board(
list_of_players) #creating object of type Board from game.py
player_board.start_game() #method start_game from class Board