def main(): players = 4 player_list = [] player_name = ["Pettersson", "Undran", "Ola", "Mr.X", "Bumbi-Bu", "Pelle", "Gerald", "Ronald", "Nisse", "Megamen", "Baby-Jesus", "Tyke", "Kim", "Q"] for i in range(players): temp = random.choice(player_name) player_name.remove(temp) player_list.append(temp) tournament1 = t.Tournament(player_list) print(tournament1.get_scoreboard()) while tournament1.winner_state == 0: print("Players waiting: ", tournament1.waiting_players) random_number = random.randint(0, 1) print("All Opponents: ", tournament1.all_opponents) print("Opponents queue: ", tournament1.opponents_queue) print("Opponents: ", tournament1.opponents) winner = tournament1.opponents[random_number] print("Winner_list_temp: ", tournament1.winner_list_temp) print("Winner_list: ", tournament1.winner_list) print("Winners this game: ", winner) print() print("-------------------------------------------------------------") tournament1.next_game(winner) print(tournament1.get_scoreboard()) print("Winner_list: ", tournament1.winner_list) print("OPPONENTS: ", tournament1.all_opponents) print("WINNER: ", tournament1.winner_list[tournament1.tournament_depth - 1][0])
def local_tour_play(): """ Sig: None Pre: None Post: A tournament played between local players. And termination of program """ g.make_header("Tournament play!") # Determine players player_list, human_dict = decide_offline_tour_players() # Play tournament t = tour.Tournament(player_list) while True: g.make_header("Tournament Standings") print(t.get_scoreboard()) end = t.winner_state players = t.opponents if end == 1: # Last game already played break else: g.make_header("Up next: " + players[0] + " vs " + players[1]) humans = [human_dict[players[0]], human_dict[players[1]]] while True: winner = game.local_vs(players, humans) if winner != "DRAW": break else: g.make_header("Draw game! Replaying game") t.next_game(winner) # Set winner of current game g.make_header(winner + " has advanced to the next round!") g.make_header(winner + " has won the tournament!") sys.exit()
def playLocalTournament(playerList, humanDict): tour = tournament.Tournament(playerList) while (True): print(tour.get_scoreboard()) end = tour.winner_state players = tour.opponents if end == 1: break else: print('Up next: ' + players[0] + ' VS ' + players[1]) humans = [humanDict[players[0]], humanDict[players[1]]] input('Press ENTER to start playing!') while (True): if ((not humans[0] and humans[1]) or (humans[0] and not humans[1])): winner = playVersusAINoReplay(Difficulty.HARD, players[0], players[1]) elif (not humans[0] and not humans[1]): winner = playAIvsAI(Difficulty.HARD, players[0], players[1]) #this is where we make ai vs ai else: winner = playVersusHumanNoReplay(players[0], players[1]) if winner != "DRAW": break else: print("Draw game! Replaying game.") tour.next_game(winner) print(winner + " has advanced to the next round!") # input('') print(winner + " has won the tournament!") input('Press ENTER to go back to the menu') return True
def run_sim_tournament(player_count, **kwargs): tt = tournament.Tournament() rounds = num_rounds(player_count, **kwargs) tt.gen_sim_players(player_count) while rounds > 0: tt.almafi_pairing(rounds) tt.sim_round() rounds -= 1 return tt
def run_sim_partial(player_count, round_stop, **kwargs): tourney = tournament.Tournament() rounds = num_rounds(player_count, **kwargs) tourney.gen_sim_players(player_count) while rounds > round_stop: tourney.almafi_pairing(rounds) tourney.sim_round() rounds -= 1 tourney.almafi_pairing(round_stop) return tourney
def _loadTQ(self): ''' Loads up a currently running tournament (e.g. after a crash). ''' with open(os.path.join('docs', 'status.txt'), 'r') as f: s = f.read() s = s.split('\n') dt = [int(x) for x in s[1].split(' ')] tz = datetime.timezone(datetime.timedelta(hours = dt[5])) sdate = datetime.datetime(year = dt[0], month = dt[1], day = dt[2], hour = dt[3], minute = dt[4], tzinfo = tz) today = datetime.datetime.now(TZ_OFFSET) self.t = tnmt.Tournament(s[0], sdate, datetime.timedelta(days = int(s[2])), int(s[3]), today > sdate)
def createTournament(self, root, dbFile): creationWindow = tk.Toplevel(root) creationWindow.title("Tournament Data") creationWindow.geometry("300x120") creationWindow.attributes("-topmost", True) creationWindow.after(1, lambda: creationWindow.focus_force()) creationWindow.resizable(0, 0) # Not Resizable creationWindow.wm_attributes('-toolwindow', 1) creationWindow.rowconfigure(3, weight=1) creationWindow.columnconfigure(1, weight=1) #Labels tk.Label(creationWindow, text="Tournament Name: ").grid(pady=2.5, padx=2.5, row=0, column=0) tk.Label(creationWindow, text="Acronym (OWC, SFT...): ").grid(pady=2.5, padx=2.5, row=1, column=0) tk.Label(creationWindow, text="Teams Size (1 -> 8): ").grid(pady=2.5, padx=2, row=2, column=0) # Entries tournamentName = tk.Entry(creationWindow, width="30") tournamentName.grid(row=0, column=1, sticky="e", padx=5) tournamentAcronym = tk.Entry(creationWindow, width="30") tournamentAcronym.grid(row=1, column=1, sticky="e", padx=5) teamSize = tk.Spinbox(creationWindow, from_=1, to=8, width="30") teamSize.grid(row=2, column=1, sticky="e", padx=5) # Submit button sendData = tk.Button(creationWindow, text="Submit", command=lambda: tournament.Tournament( tournamentName, tournamentAcronym, teamSize, "tournament.json")) sendData.grid(padx=7.5, row=3, columnspan=2, sticky="e")
def _init_game(game_type, teams, fast, num_turns, back_round=False, log_base_folder=None): logging.info(">>>> INIT GAME") if log_base_folder == None: log_base_folder = configure.load_configuration()['games_path'] + '/' # Generamos el nombre del fichero de log según el tipo de juego log_base_name = filenames.generate_filename(game_type, noExtension=True) log_folder_name = log_base_folder + log_base_name log_file_name = log_folder_name + "/" + game_type + ".txt" logging.info("Fichero de log: %s", log_file_name) logging.info("Carpeta de log: %s", log_folder_name) os.mkdir(log_folder_name) # Lanzamos el tipo de juego apropiado if game_type == 'cup': game = tournament.Tournament(teams, num_turns, log_folder=log_folder_name) else: game = league.League(teams, num_turns, back_round, log_folder=log_folder_name) band = False # Contenedor para clasificaciones classifications = {} results = None # Cada elemento tendrá una tupla de 3: ganadas, empatadas y perdidas estadisticas = { "aux_ghost_team": { "ganadas": 0, "empatadas": 0, "perdidas": 0 } } for equipo in contest.generate_key_names(teams).keys(): estadisticas[equipo] = { "ganadas": 0, "empatadas": 0, "perdidas": 0 } # Mientras no se haya completado el juego while not game.completed( ) and not band and not controlPartida.flagCancelarCampeonato: logging.info("---- START OF THE ROUND") if results != None: # Cargamos el diálogo de resultados R = round_results.roundResults( classifications, results, game.get_prev_round_number() + 1, game.get_number_of_rounds(), show_classifications=(game_type != 'cup'), stats=estadisticas, show_top_teams=True, next_matches=game.matchs[game.get_round_number()]) # Mostramos el diálogo de resultados button_pressed = R.result_dialog.run() while gtk.events_pending(): gtk.main_iteration(False) if button_pressed == -4 or button_pressed == 0: band = True continue # Guardamos el número de la ronda roundNumber = game.get_round_number() if roundNumber == 0: show_round_matches(game) # Por defecto que la barra de progreso no exista progress_bar = None # Si no mostramos el progreso del juego, que salga la barra if fast: progress_bar = pbs.ProgressBarDialog(None, _('Running the contest')) progress_bar_dialog = progress_bar.progress_bar_dialog progress_bar.set_num_elements( game.get_round(roundNumber).number_games) progress_bar_dialog.show() while gtk.events_pending(): gtk.main_iteration(False) # Jugamos esta ronda game.play_round(progress_bar, fast) if controlPartida.flagCancelarCampeonato: return # Guardamos en r la ronda actual, con sus resultados y tal r = game.get_round(roundNumber) # Resultados de la ronda results = r.get_round_results() # Actualizamos el fichero del log update_log_round(log_file_name, results, roundNumber) for partido in results: if partido[1] == 1: estadisticas[partido[0][0]]["ganadas"] += 1 estadisticas[partido[0][1]]["perdidas"] += 1 elif partido[1] == -1: estadisticas[partido[0][1]]["ganadas"] += 1 estadisticas[partido[0][0]]["perdidas"] += 1 else: estadisticas[partido[0][0]]["empatadas"] += 1 estadisticas[partido[0][1]]["empatadas"] += 1 if game_type == 'cup': pass else: # "Puntuations" es una palabra que no existe classifications = game.get_actual_puntuations() # Ocultamos la barra de progreso (que ya habrá acabado) if fast: progress_bar_dialog.hide() logging.info("---- END OF THE ROUND") if not band: # Mostramos los resultados FINALES R = round_results.roundResults( classifications, results, game.get_prev_round_number() + 1, game.get_number_of_rounds(), show_classifications=(game_type != 'cup'), show_top_teams=True, stats=estadisticas) # Mostramos el diálogo de resultados button_pressed = R.result_dialog.run() while gtk.events_pending(): gtk.main_iteration(False) if not band and not controlPartida.flagCancelarCampeonato: if game_type == 'cup': update_log_ending_tournament(log_file_name, estadisticas) dibujoClasificacion = dibujo_clasificacion.DibujoClasificacion( game) else: update_log_ending_league(log_file_name, classifications) logging.info(">>>> END INIT GAME") return (band, classifications)
# input - output and display options input_path = "C:\\Users\\kevin\\Desktop\\spot_market_working\\projects\\" #input_path = "C:\\Users\\Admin\\Notebooks\\envs\\" input_file = "env_0616_4x4w3_sym" t_name = "REU 2017" display = True # market/auction parameters num_buyers = 4 # number of buyers num_sellers = 4 # number of sellers limits = (999,0) # ceiling and floor for bidding num_market_periods = 100 # number of periods auction runs # Put Trader Class Names Here - note traders strategy is named trader class name zi = "ZeroIntelligenceTrader" si = "SimpleTrader" trader_names = [zi, si, zi, si, zi, si, zi, si] # Order of trader strategies in generic trader array # tournament parameters num_trials = 1 # number of times market is run # create objects to run tournament mkt = b.BuildMarketEnv(t_name, 4, 4) # instantiate market object mkt.prepare_market(input_path, input_file) # set and show market parameters da = ins.Auction('da', limits[0], limits[1]) # instantiate auction trn = trna.Tournament(t_name, num_market_periods, da) # instatiate tournament trader_info = trn.prepare_traders(trader_names, mkt, limits) # instantiate traders trn.sim(display, num_trials, trader_info) del mkt
def main_loop(self): # INIT self.toursys = tournament.Tournament(self) system_timer = 1 # Reset the HTML outputs to empty content and 1 second refresh self.update_html_content("", "results.html", 1) self.update_file("", "info.txt") previous_state = self.get_status() # LOOP while (1): # IDLE/REGISTRATION START # Check for status change if previous_state != self.get_status(): previous_state = self.get_status() # Registration started, update files & clients if self.get_status() == REGISTRATION: self.update_file("Registration in progress", "info.txt") # Send message to clients. Twitch is needs the message in two parts message = "Registration is now open for tournament with " + str( self.div ) + " divisions.\nCharacter ID's 0-" + self.get_max_ID( ) + " are accepted.\n" ds_message = "" + message if (USE_TWITCH): # Send part 1 to Twitch self.twch_client.queue_message(message) # Prepare the second part message = "" if self.offset_counter == 0: message += "New character offset was created.\n" message += "Current character offset will be used for " + self.get_offset_duration( ) + " matches.\n" if (USE_TWITCH): # Send part 2 to Twitch self.twch_client.queue_message(message) if (USE_DISCORD): # Send both parts to Discord in one message self.ds_client.queue_message(ds_message + message) if (USE_DISCORD): # Update the discord presence every 5 seconds if system_timer % 5 == 0: self.ds_client.set_presence(self.tournament_status()) # If any queued registrations exists, send them to all clients while self.register_messages: msg = self.register_messages.pop(0) if (USE_DISCORD): self.ds_client.queue_message(msg) if (USE_TWITCH): self.twch_client.queue_message(msg) # Timed message system if self.__timers_active(): for interval in TIMER_INTERVALS: if self.__timer_count == interval: if (USE_DISCORD): self.ds_client.queue_message( self.time_warning(interval)) if (USE_TWITCH): self.twch_client.queue_message( self.time_warning(interval)) self.update_file( "Registration in progress. Tournament starting in " + str(interval), "info.txt") self.__timer_count -= 1 # IDLE/REGISTRATION END # TOURNAMENT START AND RUNNING # Print status then check if timers & tournaments need running if not self.toursys.is_running() and self.__timers_active( ) and self.__timer_count <= 0: # Countdown complete, reset self.lock.acquire() self.state = RUNNING self.lock.release() self.__reset_timers() self.run_tournament() # Check if the toursys was killed by operator. if self.state == RUNNING: # TOURNAMENT END # Change state to finishing up self.lock.acquire() self.state = FINISHING self.lock.release() # RESULTS # Clear the info text self.update_file("", "info.txt") if (USE_DISCORD): # Update Discord presence and show division results: self.ds_client.set_presence(self.tournament_status()) results, results_dict = self.toursys.rankings( self.players, self.ongoing_div - 2) # Send update to Discord if (USE_DISCORD): self.ds_client.queue_message("Division: " + str(self.ongoing_div) + " finished.") # Show division results HTML title = "Division " + str(self.ongoing_div) + " results." self.show_html_results(results_dict, title, RESULT_TIME_DIVISION) self.console_print(MSGNAME, "Showing results") # Send tournament end messages if (USE_TWITCH): self.twch_client.queue_message("Tournament finished.") if (USE_DISCORD): self.ds_client.queue_pic( PICS[random.randint(0, len(PICS) - 1)], "Ah that was nice.") # Create results results, results_dict = self.toursys.final_rankings( self.players, self.div) if (USE_DISCORD): self.ds_client.queue_message(results) # Add scores to highscores and write new scorefile self.__update_scoreboard(self.players) self.__write_scorefile(self.scoreboard, SCOREFILE) # Change state to idle before all time scores. self.lock.acquire() self.state = IDLE self.lock.release() # Update the results.html with results then highscores. # Hold data for RESULT_TIME_FINAL for both, then clear title = "Final tournament scores:" self.show_html_results(results_dict, title, RESULT_TIME_FINAL) # Meanwhile, create HTML table for highscores title = "All time scores:" self.show_html_results(self.scoreboard, title, RESULT_TIME_FINAL) # Reset the previous state, in case someone tries to register before idle loop executes previous_state = "" # Watchdog system # Print system status every DELAY seconds if system_timer > WATCHDOG_DELAY: self.check_mugen() if self.get_status() == IDLE: status = "Ready - Waiting commands" elif self.get_status() == REGISTRATION: status = "Registration ongoing" elif self.get_status() == RUNNING: status = "Tournament running" elif self.get_status() == FINISHING: status = "Tournament ended, displaying results" else: status = "Mugen failure, trying to recover" self.console_print(MSGNAME, status) system_timer = 0 system_timer += 1 # Wait for one second on each cycle of main loop time.sleep(1)
'GroupB5': datetime.datetime(2018, 7, 17, 16, 0), 'GroupC0': datetime.datetime(2018, 7, 6, 16, 0), 'GroupC1': datetime.datetime(2018, 7, 7, 16, 0), 'GroupC2': datetime.datetime(2018, 7, 8, 16, 0), 'GroupC3': datetime.datetime(2018, 7, 9, 16, 0), 'GroupC4': datetime.datetime(2018, 7, 10, 16, 0), 'GroupC5': datetime.datetime(2018, 7, 11, 16, 0), 'GroupD0': datetime.datetime(2018, 6, 24, 16, 0), 'GroupD1': datetime.datetime(2019, 6, 25, 16, 0), 'GroupD2': datetime.datetime(2018, 6, 26, 16, 0), 'GroupD3': datetime.datetime(2018, 6, 27, 16, 0), 'GroupD4': datetime.datetime(2018, 6, 28, 16, 0), 'GroupD5': datetime.datetime(2018, 6, 29, 16, 0) } t = tournament.Tournament(fifa2018, fifa2018_match_dates) # Init game g = tipgame.TipGame(game_name='afc_game', tour=t) # Init players g.add_player('Jancsi') g.add_player('Matyi') # Make tips g.make_tip('Jancsi', ('GroupD1', 'Argentina', 'Iceland'), (1,1)) g.make_tip('Matyi', ('GroupD1', 'Argentina', 'Iceland'), (4,0)) g.make_tip('Jancsi', ('GroupA1', 'Egypt', 'Saudi-Arabia'), (3,1)) g.make_tip('Matyi', ('GroupA1', 'Egypt', 'Saudi-Arabia'), (2,1))
def _initTQ(self, name, startdt, rlength, maxP, started): ''' Q method for initT() ''' if self.t == None: self.t = tnmt.Tournament(name, startdt, rlength, maxP, started)
def start_game(self, random_mode=False): self.enable_bt_scanning(False) self.exclude_out_moves() self.stop_tracking_moves() time.sleep(0.2) self.teams = { serial: self.move_opts[serial][Opts.team.value] for serial in self.tracked_moves.keys() if self.out_moves[serial] == Alive.on.value } game_moves = [ move.get_serial() for move in self.moves if self.out_moves[move.get_serial()] == Alive.on.value ] if len(game_moves ) < self.game_mode.minimum_players and self.ns.settings[ 'enforce_minimum']: Audio('audio/Menu/notenoughplayers.wav').start_effect() self.tracked_moves = {} return self.update_status('starting') if random_mode: good_random_modes = [ game for game in common.Games if game.name in self.ns.settings['random_modes'] ] good_random_modes = [ common.Games[game] for game in self.ns.settings['random_modes'] ] if self.ns.settings['enforce_minimum']: good_random_modes = [ game for game in good_random_modes if game.minimum_players <= len(game_moves) ] if len(good_random_modes) == 0: selected_game = common.Games.JoustFFA #force Joust FFA elif len(good_random_modes) == 1: selected_game = good_random_modes[0] else: if len(self.rand_game_list) >= len(good_random_modes): #empty rand game list, append old game, to not play it twice self.rand_game_list = [self.old_game_mode] selected_game = random.choice(good_random_modes) while selected_game in self.rand_game_list: selected_game = random.choice(good_random_modes) self.old_game_mode = selected_game self.rand_game_list.append(selected_game) self.game_mode = selected_game if self.ns.settings['play_instructions'] and self.ns.settings[ 'play_audio']: self.play_random_instructions() if self.game_mode == common.Games.Zombies: zombie.Zombie(game_moves, self.command_queue, self.ns, self.zombie_music) self.tracked_moves = {} elif self.game_mode == common.Games.Commander: commander.Commander(game_moves, self.command_queue, self.ns, self.commander_music) self.tracked_moves = {} elif self.game_mode == common.Games.Ninja: speed_bomb.Bomb(game_moves, self.command_queue, self.ns, self.commander_music) self.tracked_moves = {} elif self.game_mode == common.Games.Swapper: swapper.Swapper(game_moves, self.command_queue, self.ns, self.joust_music) self.tracked_moves = {} elif self.game_mode == common.Games.Tournament: tournament.Tournament(game_moves, self.command_queue, self.ns, self.joust_music) self.tracked_moves = {} else: if self.game_mode == common.Games.JoustFFA and self.experimental: print("Playing EXPERIMENTAL FFA Mode.") moves = [ common.get_move(serial, num) for num, serial in enumerate(game_moves) ] game = ffa.FreeForAll(moves, self.joust_music) game.run_loop() else: #may need to put in moves that have selected to not be in the game joust.Joust(game_moves, self.command_queue, self.ns, self.joust_music, self.teams, self.game_mode) self.tracked_moves = {} if random_mode: self.game_mode = common.Games.Random if self.ns.settings['play_instructions']: if self.ns.settings['play_audio']: Audio('audio/Menu/tradeoff2.wav').start_effect_and_wait() #reset music self.choose_new_music() #turn off admin mode so someone can't accidentally press a button self.admin_move = None self.random_added = []
def server_side_tournament(): """ Sig: None Pre: None Post: A tournament played between local, and remote players. And termination of program Notes ----- If multiple messages are sent in a row without being received, they will be concatenated in the pipeline \ and the receiving end will be unable to process the message. Therefor it is sometime needed to send \ junk messages to sync the clients """ # Setup c = peer.Peer(True) c.accept_client() player_list, human_dict = decide_online_tour_players(c, False) print("Waiting for remote list of players...") # Sync player lists remote_player_list = c.receive() player_list = player_list + remote_player_list c.send(player_list) remote_human_dict = c.receive() human_dict.update(remote_human_dict) c.send(human_dict) c.receive() # Block needed here to ensure clients are synced # Create tournament and setup instructions t = tour.Tournament(player_list) data = {} # Dictionary containing various data needed by remote peer data["instruction"] = None # Instructions in the form of strings data["players"] = None # players to play next game data["tour"] = t.get_scoreboard( ) # String representing current tournament bracket c.send(data) # Send initial tournament bracket winner = "" while True: g.make_header("Tournament Standings") data["tour"] = t.get_scoreboard() print(data["tour"]) end = t.winner_state players = t.opponents winners = [] # Completed tournament if end == 1: data["instruction"] = "COMPLETE" data["player"] = winner c.send(data) g.make_header(winner + " Has won the tournament!") c.teardown() sys.exit() else: # Setup game g.make_header("Up next: Local " + players[0] + " vs remote " + players[1]) data["players"] = players data["instruction"] = "PLAY" c.send(data) while True: winner = game.online_vs(players[0], c, human_dict[players[0]], True) if winner != "DRAW": break else: g.make_header("Game draw! Replay game") if winner == players[0]: # If local player won winners.append(winner) g.make_header(winner + " has advanced to the next round!") else: # If remote player won winner = players[1] winners.append(winner) g.make_header(winner + " has advanced to the next round!") t.next_game(winner)
def start_game(self, random_mode=False): self.enable_bt_scanning(False) self.exclude_out_moves() self.stop_tracking_moves() time.sleep(0.2) self.teams = { serial: self.move_opts[serial][Opts.team.value] for serial in self.tracked_moves.keys() if self.out_moves[serial] == Alive.on.value } game_moves = [ move.get_serial() for move in self.moves if self.out_moves[move.get_serial()] == Alive.on.value ] if len(game_moves) < common.minimum_players[ self.game_mode] and self.enforce_minimum: Audio('audio/Menu/notenoughplayers.wav').start_effect() self.tracked_moves = {} return self.update_status('starting') if random_mode: if self.enforce_minimum: good_con_games = [ i for i in self.con_games if common.minimum_players[i] <= len(game_moves) ] else: good_con_games = self.con_games if len(good_con_games) == 0: selected_game = 0 #force Joust FFA elif len(good_con_games) == 1: selected_game = good_con_games[0] else: if len(self.rand_game_list) >= len(good_con_games): #empty rand game list, append old game, to not play it twice self.rand_game_list = [self.old_game_mode] selected_game = random.choice(good_con_games) while selected_game in self.rand_game_list: selected_game = random.choice(good_con_games) self.old_game_mode = selected_game self.rand_game_list.append(selected_game) self.game_mode = selected_game if self.instructions and self.audio_toggle: self.play_random_instructions() if self.game_mode == common.Games.Zombies.value: zombie.Zombie(game_moves, self.sensitivity, self.command_queue, self.status_ns, self.audio_toggle, self.zombie_music) self.tracked_moves = {} elif self.game_mode == common.Games.Commander.value: commander.Commander(game_moves, self.sensitivity, self.command_queue, self.status_ns, self.commander_music) self.tracked_moves = {} elif self.game_mode == common.Games.Ninja.value: speed_bomb.Bomb(game_moves, self.command_queue, self.status_ns, self.audio_toggle, self.commander_music) self.tracked_moves = {} elif self.game_mode == common.Games.Swapper.value: swapper.Swapper(game_moves, self.sensitivity, self.command_queue, self.status_ns, self.audio_toggle, self.joust_music) self.tracked_moves = {} elif self.game_mode == common.Games.Tournament.value: tournament.Tournament(game_moves, self.sensitivity, self.command_queue, self.status_ns, self.audio_toggle, self.joust_music) self.tracked_moves = {} else: #may need to put in moves that have selected to not be in the game joust.Joust(self.game_mode, game_moves, self.teams, self.sensitivity, self.command_queue, self.status_ns, self.audio_toggle, self.joust_music) self.tracked_moves = {} if random_mode: self.game_mode = common.Games.Random.value if self.instructions: if self.audio_toggle: Audio('audio/Menu/tradeoff2.wav').start_effect() time.sleep(8) #reset music self.choose_new_music() #turn off admin mode so someone can't accidentally press a button self.admin_move = None self.random_added = []
print("AHHH") return False return commands.check(predicate) @bot.command(pass_context=True) async def message_test(ctx): channel = ctx.message.channel embed = discord.Embed() embed.colour = discord.Colour.dark_blue() embed.set_footer(text="Updated stock for 10/22/2018") embed.description = "The new stock is out!" embed.set_image(url="attachment://res_img.png") with open('res_img.png', 'rb') as f: buffer = io.BytesIO(f.read()) print("got here") data = await bot.http.send_file(channel.id, buffer, guild_id=channel.server.id, filename='res_img.png', embed=embed.to_dict()) returned_message = bot.connection._create_message(channel=channel, **data) bot.pool = bot.loop.run_until_complete(asyncpg.create_pool(config.psql)) bot.add_cog(quizdb.DB(bot)) bot.db = quizdb.DB(bot) bot.add_cog(tournament.Tournament(bot)) bot.run(config.token)
def test_tournament(self): player_list = ["Erik", "Johan", "Fredrik", "Ilda", "Emma", "Sandra", "Davide", "Viktor", "Sam"] with self.assertRaises(Exception): tour.Tournament(player_list) player_list = ["Erik", "Johan"] with self.assertRaises(Exception): tour.Tournament(player_list) player_list = [] with self.assertRaises(Exception): tour.Tournament(player_list) player_list = [[],[],[]] with self.assertRaises(Exception): tour.Tournament(player_list) player_list = ["Erik", "Johan", "Fredrik", "Ilda", "Emma", "Sandra", "Davide", "Viktor"] t8 = tour.Tournament(player_list) initial_bracket = t8.get_scoreboard() players = t8.opponents self.assertEqual(2, len(players)) self.assertNotEqual(players[0], players[1]) t8.next_game(players[0]) players = t8.opponents self.assertNotEqual(initial_bracket, t8.get_scoreboard()) t8.next_game(players[0]) players = t8.opponents t8.next_game(players[0]) players = t8.opponents t8.next_game(players[0]) players = t8.opponents t8.next_game(players[0]) players = t8.opponents t8.next_game(players[0]) players = t8.opponents t8.next_game(players[0]) players = t8.opponents self.assertEqual(0, len(players)) player_list = ["Erik", "Johan", "Fredrik", "Ilda", "Emma", "Sandra", "Davide"] t7 = tour.Tournament(player_list) initial_bracket = t7.get_scoreboard() players = t7.opponents self.assertEqual(2, len(players)) self.assertNotEqual(players[0], players[1]) t7.next_game(players[0]) players = t7.opponents self.assertNotEqual(initial_bracket, t7.get_scoreboard()) t7.next_game(players[0]) players = t7.opponents t7.next_game(players[0]) players = t7.opponents t7.next_game(players[0]) players = t7.opponents t7.next_game(players[0]) players = t7.opponents t7.next_game(players[0]) players = t7.opponents self.assertEqual(0, len(players)) player_list = ["Erik", "Johan", "Fredrik", "Ilda", "Emma", "Sandra"] t6 = tour.Tournament(player_list) initial_bracket = t6.get_scoreboard() players = t6.opponents self.assertEqual(2, len(players)) self.assertNotEqual(players[0], players[1]) t6.next_game(players[0]) players = t6.opponents self.assertNotEqual(initial_bracket, t6.get_scoreboard()) t6.next_game(players[0]) players = t6.opponents t6.next_game(players[0]) players = t6.opponents t6.next_game(players[0]) players = t6.opponents t6.next_game(players[0]) players = t6.opponents self.assertEqual(0, len(players)) player_list = ["Erik", "Johan", "Fredrik", "Ilda", "Emma"] t5 = tour.Tournament(player_list) initial_bracket = t5.get_scoreboard() players = t5.opponents self.assertEqual(2, len(players)) self.assertNotEqual(players[0], players[1]) t5.next_game(players[0]) players = t5.opponents self.assertNotEqual(initial_bracket, t5.get_scoreboard()) t5.next_game(players[0]) players = t5.opponents t5.next_game(players[0]) players = t5.opponents t5.next_game(players[0]) players = t5.opponents self.assertEqual(0, len(players)) player_list = ["Erik", "Johan", "Fredrik", "Ilda"] t4 = tour.Tournament(player_list) initial_bracket = t4.get_scoreboard() players = t4.opponents self.assertEqual(2, len(players)) self.assertNotEqual(players[0], players[1]) t4.next_game(players[0]) players = t4.opponents self.assertNotEqual(initial_bracket, t4.get_scoreboard()) t4.next_game(players[0]) players = t4.opponents t4.next_game(players[0]) players = t4.opponents self.assertEqual(0, len(players)) player_list = ["Erik", "Johan", "Fredrik"] t3 = tour.Tournament(player_list) initial_bracket = t3.get_scoreboard() players = t3.opponents self.assertEqual(2, len(players)) self.assertNotEqual(players[0], players[1]) t3.next_game(players[0]) players = t3.opponents self.assertNotEqual(initial_bracket, t3.get_scoreboard()) t3.next_game(players[0]) players = t3.opponents self.assertEqual(0, len(players))
players = [] print('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX') print('X Comienza el torneo X') print('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX') if verbose: print('\n\n Simulando...\n\n') for filename in os.listdir(sim_dir): if filename.endswith(".pkl"): p = player.Player.load(sim_dir + '/' +filename) players.append(p) if len(players) > 0: t = tournament.Tournament(players, []) t.all_vs_all(verbose) ranking = t.print_ranking(-1) else: print("No players found.") sys.exit(0) # Para cargar jugadores del directorio load_dir elif sys.argv[1] == '--load': load = True loaded_players = [] for filename in os.listdir(load_dir): if filename.endswith(".pkl"): p = player.Player.load(sim_dir + '/' +filename) players.append(p)
return prevRound def _getRanking(eliminated): pplace = 0 pround = 1 << 64 placements = [] for i, (r, t) in enumerate(reversed(eliminated)): if r < pround: pround = r pplace = i+1 placements.append((pplace, t)) return placements if __name__ == '__main__': # FIXME: remove import tournament import sys import random gen = getGenerator('swiss') t = tournament.Tournament([str(x) for x in range(0, int(sys.argv[1]))], gen) while True: games = gen.generateRound(t) if not games: break print(f'Round {gen.roundNum}') for g in games: v = random.randint(0, 1) g.setScore((v, 1-v)) print(g) print('\n'.join(map(str, gen.getRanking())))