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 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 __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, 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 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)}")
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)
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)
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
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
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
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 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"], )