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())))