def new_tournament(self):
tournaments = Query()
name = self.get_and_check_name()
place = self.get_and_check_place()
date = set_date()
time_control = self.get_and_check_time_control()
details = get_tournament_details()
self.tournament = Tournament(name, place, date, time_control, details)
self.tournament.status = "En cours"
self.tournament.players = list()
self.tournament_data.insert(tournament_serializer(self.tournament))
tournament_get = self.tournament_data.get(
(tournaments.name == self.tournament.name)
& (tournaments.place == self.tournament.place))
tournament_id = tournament_get.doc_id
for i in range(1, 9):
playerController = PlayerController()
print_text(f"Joueur {i} : ")
player = playerController.handle_players_choice()
self.tournament.add_player(player)
self.tournament_data.update(tournament_serializer(self.tournament),
doc_ids=[tournament_id])
self.run_first_round()
self.tournament_data.update(tournament_serializer(self.tournament),
doc_ids=[tournament_id])
quit = self.get_and_check_continue_or_quit()
if quit == "q":
return
else:
pass
for round_number in range(2, 5):
self.run_round(round_number)
self.tournament_data.update(tournament_serializer(self.tournament),
doc_ids=[tournament_id])
quit = self.get_and_check_continue_or_quit()
if quit == "q":
return
else:
pass
self.tournament.status = "Terminé"
self.tournament_data.update(tournament_serializer(self.tournament),
doc_ids=[tournament_id])
update_elo = self.check_update_player_elo()
while True:
if update_elo == "o":
PlayerController.update_player_elo()
update_elo = self.check_update_player_elo()
else:
return
def is_tournament_already_exist(tournament_name_response):
list_tournament = Tournament.get_tournament_name(
TinyDB("db.json").table("tournament")
)
new_tournament_name = tournament_name_response
if list_tournament == []:
return True
for tournament_name in list_tournament:
if (
Tournament.check_tournament_duplicate(new_tournament_name, tournament_name)
is True
):
print(" Tournament already exists")
else:
return True
def tournament_deserializer(object):
tournament_list = []
for tournament in object:
this_tournament = Tournament(tournament["name"],
tournament["place"],
tournament["date"],
tournament["tours"],
DataHandler.player_deserializer(
tournament["players"]),
tournament["timing_style"],
tournament["description"],
tournament["round_number"])
this_tournament.rounds = DataHandler.round_deserializer(
tournament["rounds"])
tournament_list.append(this_tournament)
return tournament_list
def instanciation_tournament(self, tournament_table, tournament_name):
""" Fonction qui instancie le tournoi à partir du .json """
liste_tournament = tournament_table.search(
where("Name") == tournament_name)
data = liste_tournament[0]
self.tournament_progress = Tournament(
data["Name"],
data["Place"],
data["Date"],
data["Numbers of rounds"],
data["Rounds"],
[],
data["Players"],
data["Type"],
data["Description"],
)
def get(self, user_id):
args = tournamentParser.parse_args()
tournamentID = args['tournamentID']
tournament = Tournament.objects(id=tournamentID).first()
if tournament is None:
raise InvalidUsage('Tournament Not Found',404)
return tournament_serialize(tournament)
def new_tournament_created(self, db):
self.tournament_progress = Tournament(
vt.get_tournament_name(),
vt.get_tournament_place(),
str(vt.get_tournament_date()),
4,
[],
[],
[],
vt.get_tournament_time_control(),
vt.get_tournament_description(),
)
tournament_table = db.table(f"{self.tournament_progress.name}")
serialized_tournament = self.tournament_progress.serialize()
tournament_table.insert(serialized_tournament)
return tournament_table
def get(self, user_id):
args = tournamentParser.parse_args()
page = args['page']
if page is None:
page = 0
profile = Profile.objects(user=user_id).first()
tournaments = Tournament.objects(creator=profile).only('id','creator','isEnded','createTime','rounds','isFull')
return tournament_search_serialize(tournaments[5*page:5*(page+1)])
def create_tournament(self):
name = AskInfos.tournament_name()
while not name.replace(" ", "").isalpha():
print("Le nom du tournoi ne peut être composé que de lettres")
name = AskInfos.tournament_name()
place = AskInfos.tournament_place()
while not place.replace(" ", "").isalpha():
print("La ville ne peut être composé que de lettres")
place = AskInfos.tournament_place()
date_ok = False
date = AskInfos.tournament_date()
while not date_ok:
try:
strptime(date, '%d/%m/%Y')
date_ok = True
except ValueError:
print("La date doit être au format JJ/MM/AAAA")
date = AskInfos.tournament_date()
player_number = AskInfos.tournament_player_number()
while not player_number.isnumeric():
print("Le nombre de joueur doit être un chiffre ou un ensemble"
"de chiffres")
player_number = AskInfos.tournament_player_number()
while not 2 <= int(player_number) <= 1000:
print("Le nombre de joueur doit être compris entre 2 et 1000")
player_number = AskInfos.tournament_player_number()
timing_style = AskInfos.tournament_timing_style().capitalize()
while timing_style != "Blitz" and timing_style != "Bullet" and \
timing_style != "Coup rapide":
print("Le contrôle du temps doit être Bullet, Blitz ou "
"Coup rapide")
timing_style = AskInfos.tournament_timing_style().capitalize()
description = AskInfos.tournament_description()
round_number = AskInfos.tournament_round_number()
while not 1 <= int(round_number) <= 20:
print("Le nombre de round doit être compris entre 1 et 20")
round_number = AskInfos.tournament_round_number()
players_list = []
x = 1
tours = "rien"
for i in range(int(player_number)):
print("Joueur " + str(x))
players_list.append(Menu.create_player())
x += 1
self.actual_tournament = Tournament(name, place, date, tours,
players_list, timing_style,
description, round_number)
Menu.start(self)
def manage_tournament(self):
"""
Allow to create tournament if not already exist and first and other rounds
"""
if (
Tournament.tournament_table_is_empty(self.tournament_table) is True
or Tournament.status_tournament_is_finished(self.tournament_table) is True
):
new_tournament = Tournament.create_tournament()
serialized_tournament = vars(new_tournament)
self.tournament_table.insert(serialized_tournament)
self.add_players_to_tournament()
self.choice_create_next_round()
elif (
Tournament.tournament_table_is_empty(self.tournament_table) is not True
and self.round_table.all() == []
) or self.round_table.all()[-1]["status_round"] == "finished":
self.choice_create_next_round()
else:
self.choice_end_round()
def tournament_deserializer(reloaded_tournament):
tournament = Tournament(reloaded_tournament["name"],
reloaded_tournament["place"],
reloaded_tournament["date"],
reloaded_tournament["time_control"],
reloaded_tournament["details"])
tournament.status = reloaded_tournament["status"]
tournament.players = list()
tournament.rounds = list()
for player in reloaded_tournament["players"]:
player = player_deserializer(player)
tournament.add_player(player)
for round in reloaded_tournament["rounds"]:
reload_round = round_deserializer(round)
tournament.add_round(reload_round)
return tournament
def post(self, user_id):
args = tournamentParser.parse_args()
tournamentName = args['tournamentName']
isSchool = args['isSchool']
school = args['school']
descriptions = args['descriptions']
entryFee = args['entryFee']
size = args['size']
try:
rounds = request.json['rounds']
except:
raise InvalidUsage('Round information is not valid')
teamSize = args['teamSize']
#group_stage = args['group_stage']
map = args['map']
pick = args['pick']
roundNumber = int(math.log(size,2))
totalPrize = args['totalPrize']
profile = Profile.objects(user=user_id).first()
if roundNumber != math.log(size,2):
return {'status' : 'error', 'message' : 'size not acceptable'}
tournament = Tournament(tournamentName=tournamentName,isSchool=isSchool,descriptions=descriptions,entryFee=entryFee,size=size,school=school,creator=profile,totalPrize=totalPrize)
for i in range(roundNumber):
round = Round(roundName=str(Fraction(2*(i+1)/size))+' Final', startTime=rounds[i]['startTime'], bestOfN=rounds[i]['bestOfN'])
round.save()
tournament.rounds.append(round)
for i in range(roundNumber-1):
tournament.rounds[i].next = tournament.rounds[i+1]
tournament.rounds[roundNumber-1].next = None
try:
tournament.save()
except ValidationError,e:
raise InvalidUsage(e.message)
def get(self, user_id):
args = tournamentParser.parse_args()
tournamentName = args['tournamentName']
page = args['page']
if tournamentName is None:
tournamentName = ''
if page is None:
page = 0
tournaments = Tournament.objects(tournamentName__icontains=tournamentName).only('id','creator','isEnded','createTime','rounds','isFull')
tournaments = tournaments.filter(isEnded=False).order_by('-createTime')[10*page:10*(page+1)]
return tournament_search_serialize(tournaments)
def propose_to_load_tour():
'''propose the user to enter the name of the tournament he wants to load
and loads the proper tournament from the db'''
while True:
tournament_table = db.table('tournaments')
all_tournaments = tournament_table.all()
tour_name = input('Tournament name: ')
for tournament in all_tournaments:
if tournament['name'] == tour_name:
user_answer = Tournament.load_tournament(tournament)
print('---------------------------------------')
print('Tournament loaded')
print('---------------------------------------')
return user_answer
else:
print('-------------')
print('wrong entries')
def test_02_create_tournament(self):
"""
Method that tests creation of a tournament in
database
"""
tournament_handler = TournamentHandler()
tournament = Tournament('CSGO Major - One Vs One 2017',
datetime.datetime.now(),
datetime.datetime.now())
tournament_handler.create_tournament(tournament)
self.assertTrue(tournament_handler.get_tournament() is not None,
"The tournament were not created.")
print "Created tournament: [" + tournament.name[0] + "]"
print "-----------------------------------------"
def delete(self, user_id):
args = tournamentParser.parse_args()
tournamentID = args['tournamentID']
if tournamentID is None:
raise InvalidUsage('Provide tournament id please')
profile = Profile.objects(user=user_id).first()
tournament = Tournament.objects(id=tournamentID).first()
if tournament is None:
raise InvalidUsage('Tournament not found',404)
if tournament.creator != profile:
raise InvalidUsage('Unauthorized',401)
# More deletions need to be added
rule = Rule.objects(tournament=tournament).first()
if rule is not None:
rule.delete()
for round in tournament.rounds:
round.delete()
tournament.delete()
return {'status':'success'}
def post(self, user_id):
args = tournamentParser.parse_args()
tournamentID = args['tournamentID']
tournament = Tournament.objects(id=tournamentID).first()
if tournament is None:
raise InvalidUsage('Tournament not found',404)
if tournament.isEnded is True or tournament.isFull is True:
raise InvalidUsage('Tournament full or has ended',403)
profile = Profile.objects(user=user_id).first()
team = profile.LOLTeam
if team is None or team.captain != profile:
raise InvalidUsage('Only captain can join tournament',401)
if team.inGame is True:
raise InvalidUsage('One team can only join one tournament at the same time',403)
# join the first round
round = tournament.rounds[0]
round.checkInNumber += 1
if round.checkInNumber == tournament.size:
tournament.isFull = True
tournament.save()
if len(round.readyTeam) is 0:
round.update(add_to_set__readyTeam=team)
else:
opponent = round.readyTeam[0]
round.update(pull__readyTeam=opponent)
match = MatchHistory(tournament=tournament,tournamentName=tournament.tournamentName,round=round,teams=[opponent,team])
match.save()
team.update(add_to_set__matchHistory=match)
opponent.update(add_to_set__matchHistory=match)
round.update(add_to_set__matches=match)
team.inGame = True
team.save()
return {'status' : 'success'}
def create_tournament():
""" Fonction Permetant de creer un tournoi"""
data = view.create_tournament_view()
tournament = Tournament(data['name'], data['place'], data['description'],
data['turn_number'])
return tournament
def is_valid_id_tournament(response):
list_tournaments = Tournament.get_tournaments(TinyDB("db.json").table("tournament"))
if response not in list_tournaments:
print(" Invalid tournamanet Id")
else:
return True
class TournamentControler:
""" Classe qui lance et fait fonctionner le tournoi """
def __init__(self):
self.tournament_progress = ""
def new_tournament_created(self, db):
self.tournament_progress = Tournament(
vt.get_tournament_name(),
vt.get_tournament_place(),
str(vt.get_tournament_date()),
4,
[],
[],
[],
vt.get_tournament_time_control(),
vt.get_tournament_description(),
)
tournament_table = db.table(f"{self.tournament_progress.name}")
serialized_tournament = self.tournament_progress.serialize()
tournament_table.insert(serialized_tournament)
return tournament_table
def init_players(self, tournament_table, actors_db):
""" Fonction qui instancie les joueurs du tournoi """
for i in range(8):
input(f"\nEnter player{i+1} informations [ENTER]\n")
name = vp.get_player_name()
surname = vp.get_player_surname()
birthday = vp.get_player_birthday()
sexe = vp.get_player_sexe()
elo = vp.get_player_elo()
score = 0
player = Player(name, surname, birthday, sexe, elo, score)
self.tournament_progress.add_player(player)
serialized_player = player.serialize()
actor_table = actors_db.table(f"{name}")
User = Query()
actor_table.upsert(serialized_player, User.name == name)
self.tournament_progress.serialized_players.append(
serialized_player)
self.tournament_progress.serialized_tournament = (
self.tournament_progress.serialize())
tournament_table.truncate()
tournament_table.insert(self.tournament_progress.serialized_tournament)
def print_all_players(self):
""" Fonction qui imprime les joueurs d'un tournoi"""
print(self.tournament_progress.players)
def handle_score(self, match):
""" Fonction qui calcule le score d'un match """
score = vr.enter_score(match)
while score != "1" and score != "2" and score != "3":
score = vr.enter_score(match)
if score == "1":
return 1, 0
elif score == "2":
return 0, 1
elif score == "3":
return 0.5, 0.5
def get_players(self):
""" Fonction qui tri les players par elo et par score """
players = []
for player in self.tournament_progress.players:
players.append(player)
players.sort(key=lambda x: x.elo)
players.sort(key=lambda x: x.score, reverse=True)
return players
def make_pairing(self, players, current_round):
""" Algorithme qui crée les paires de match """
i = 0
while len(players) != 0:
player1 = players[i]
player1_index = i
player2 = players[i + 1]
player2_index = i + 1
player2_id = player2.surname + player2.elo
while player2_id in player1.opponents:
try:
i += 1
player2 = players[i + 1]
player2_index = i + 1
player2_id = player2.surname + player2.elo
except IndexError:
player2 = players[i]
player2_index = i
player2_id = player2.surname + player2
break
current_round.add_match(player1, player2)
del players[player2_index]
del players[player1_index]
i = 0
def run_first_round(self, tournament_table, actors_db):
""" Fonction qui fait tourner le premier round """
round_name = "Round 1"
round_date = str(vr.get_round_date())
round_starttime = str(vr.get_round_starttime())
round1 = Round(round_name, round_date, round_starttime)
serialized_round1 = round1.serialize()
self.tournament_progress.serialized_rounds.append(serialized_round1)
self.tournament_progress.serialized_rounds = (
self.tournament_progress.serialized_rounds)
vt.print_info(
f"{self.tournament_progress.name} begins !\n--------------------------------------\n"
)
vt.print_info(f"{round_name} launchment...")
self.tournament_progress.players.sort(key=lambda x: x.elo)
for i in range(4):
round1.add_match(
self.tournament_progress.players[i],
self.tournament_progress.players[4 + i],
)
self.tournament_progress.add_round(round1)
i = 0
for match in self.tournament_progress.rounds[0].matchs:
vt.print_info("\n...\n")
vt.print_info(
f"{match.player1.name} and {match.player2.name} play against each other !"
)
match.score1, match.score2 = self.handle_score(match)
i += 1
vr.print_match_result(match)
serialized_match = match.serialize()
round1.serialized_matchs.append(serialized_match)
match.player1.add_opponent(match.player2)
match.player2.add_opponent(match.player1)
match.player1.add_score(match.score1)
match.player2.add_score(match.score2)
tournament_table.truncate()
tournament_table.insert(
self.tournament_progress.serialized_tournament)
round1.endtime = str(vr.get_round_endtime())
serialized_round1 = {
"Round end-time": round1.endtime,
"Round Matchs": round1.serialized_matchs,
}
self.tournament_progress.serialized_tournament = (
self.tournament_progress.serialize())
tournament_table.truncate()
tournament_table.insert(self.tournament_progress.serialized_tournament)
vt.print_info(f"End of the Round1 at {round1.endtime}.")
vt.print_info("\n--------------------------------------\n")
def run_rounds(self, tournament_table, actors_db, next_round_number=2):
""" Fonction qui fait tourner les rounds suivants """
for i in range(next_round_number, 5):
players = self.get_players()
round_name = f"Round {i}"
round_date = vr.get_round_date()
round_starttime = vr.get_round_starttime()
round_endtime = " "
next_round = Round(round_name, round_date, round_starttime,
round_endtime)
self.tournament_progress.add_round(next_round)
serialized_next_round = next_round.serialize()
self.tournament_progress.serialized_rounds.append(
serialized_next_round)
self.tournament_progress.serialized_rounds = (
self.tournament_progress.serialized_rounds)
self.serialized_tournament = self.tournament_progress.serialize()
vt.print_info(f"{round_name} launchment...")
self.make_pairing(players, next_round)
self.tournament_progress.serialized_players.clear()
for match in self.tournament_progress.rounds[i - 1].matchs:
vt.print_info("\n...\n")
vt.print_info(
f"{match.player1.name} and {match.player2.name} play against each other !"
)
match.score1, match.score2 = self.handle_score(match)
vr.print_match_result(match)
serialized_match = match.serialize()
next_round.serialized_matchs.append(serialized_match)
match.player1.add_opponent(match.player2)
match.player2.add_opponent(match.player1)
match.player1.add_score(match.score1)
match.player2.add_score(match.score2)
serialized_player1 = match.player1.serialize()
self.tournament_progress.serialized_players.append(
serialized_player1)
serialized_player2 = match.player2.serialize()
self.tournament_progress.serialized_players.append(
serialized_player2)
self.tournament_progress.serialized_tournament = (
self.tournament_progress.serialize())
tournament_table.update(
self.tournament_progress.serialized_tournament)
next_round.endtime = vr.get_round_endtime()
endtime = next_round.serialize_endtime()
tournament_table.update(
self.tournament_progress.serialized_tournament)
vt.print_info(f"End of the {round_name} at {next_round.endtime}.")
vt.print_info("\n--------------------------------------\n")
i += 1
self.tournament_progress.serialized_tournament = (
self.tournament_progress.serialize())
vt.print_info(
f"{self.tournament_progress.name} is over !\n--------------------------------------\n"
)
vt.print_players_scores(self.tournament_progress.players)
return tournament_table, actors_db
def run_ungoing_tournament(self, db, tournament_name, actors_db):
""" Fonction qui reprends un tournoi existant non terminé """
tournament_table = db.table(f"{tournament_name}")
self.instanciation_tournament(tournament_table, tournament_name)
self.instanciation_players()
self.instanciation_rounds()
last_round_index = 0
for i in range(len(self.tournament_progress.rounds) - 1):
self.instanciation_matchs(i)
last_round_index += 1
r = len(self.tournament_progress.rounds)
m = len(self.tournament_progress.rounds[last_round_index].matchs)
if r == 0 and m < 3:
self.run_first_round(tournament_table, actors_db)
elif r == 1 and m < 3:
self.run_rounds(tournament_table, actors_db, next_round_number=2)
elif r == 2 and m < 3:
self.run_rounds(tournament_table, actors_db, next_round_number=3)
elif r == 3 and m < 3:
self.run_rounds(tournament_table, actors_db, next_round_number=4)
def instanciation_tournament(self, tournament_table, tournament_name):
""" Fonction qui instancie le tournoi à partir du .json """
liste_tournament = tournament_table.search(
where("Name") == tournament_name)
data = liste_tournament[0]
self.tournament_progress = Tournament(
data["Name"],
data["Place"],
data["Date"],
data["Numbers of rounds"],
data["Rounds"],
[],
data["Players"],
data["Type"],
data["Description"],
)
def instanciation_players(self):
""" Fonction qui instancie les joueurs du tournoi à partir du .json """
for serialized_player in self.tournament_progress.serialized_players:
p = Player(
serialized_player["Name"],
serialized_player["Surname"],
serialized_player["Birthday"],
serialized_player["Sexe"],
serialized_player["ELO"],
)
self.tournament_progress.add_player(p)
def instanciation_rounds(self):
""" Fonction qui instancie les rounds du tournoi à partir du .json """
for serialized_round in self.tournament_progress.serialized_rounds:
r = Round(
serialized_round["Name"],
serialized_round["Date"],
serialized_round["Round start-time"],
[],
)
self.tournament_progress.add_round(r)
def instanciation_matchs(self, i):
""" Fonction qui instancie les matchs du tournoi à partir du .json """
round_table = self.tournament_progress.serialized_rounds[i]
round_matchs = round_table["Round Matchs"]
for s_match in round_matchs:
print(s_match)
m = Match(
player1=s_match["Player1"],
player2=s_match["Player2"],
score1=s_match["Score1"],
score2=s_match["Score2"],
)
self.tournament_progress.rounds[i].add_match(m.player1, m.player2)
def run_new_tournament(self, db, actors_db):
""" Fonction qui lance un nouveau tournoi """
tournament_table = self.new_tournament_created(db)
self.init_players(tournament_table, actors_db)
self.run_first_round(tournament_table, actors_db)
self.run_rounds(tournament_table, actors_db)
#!/usr/bin/env python # -*- coding: utf-8 -*- from model.tournament import Tournament current_tournament = Tournament() players = [] result_list = [] number_of_player = 8
def create_new_tournament():
'''allows the use to create a new tournament'''
tournament = Tournament(name=input('name: '),
place=input('place: '),
date=input('date: '))
return tournament
class TournamentController:
def __init__(self):
self.tournament = None
self.db = TinyDB("tournament_data.json", indent=4)
self.tournament_data = self.db.table("tournament_data")
def new_tournament(self):
tournaments = Query()
name = self.get_and_check_name()
place = self.get_and_check_place()
date = set_date()
time_control = self.get_and_check_time_control()
details = get_tournament_details()
self.tournament = Tournament(name, place, date, time_control, details)
self.tournament.status = "En cours"
self.tournament.players = list()
self.tournament_data.insert(tournament_serializer(self.tournament))
tournament_get = self.tournament_data.get(
(tournaments.name == self.tournament.name)
& (tournaments.place == self.tournament.place))
tournament_id = tournament_get.doc_id
for i in range(1, 9):
playerController = PlayerController()
print_text(f"Joueur {i} : ")
player = playerController.handle_players_choice()
self.tournament.add_player(player)
self.tournament_data.update(tournament_serializer(self.tournament),
doc_ids=[tournament_id])
self.run_first_round()
self.tournament_data.update(tournament_serializer(self.tournament),
doc_ids=[tournament_id])
quit = self.get_and_check_continue_or_quit()
if quit == "q":
return
else:
pass
for round_number in range(2, 5):
self.run_round(round_number)
self.tournament_data.update(tournament_serializer(self.tournament),
doc_ids=[tournament_id])
quit = self.get_and_check_continue_or_quit()
if quit == "q":
return
else:
pass
self.tournament.status = "Terminé"
self.tournament_data.update(tournament_serializer(self.tournament),
doc_ids=[tournament_id])
update_elo = self.check_update_player_elo()
while True:
if update_elo == "o":
PlayerController.update_player_elo()
update_elo = self.check_update_player_elo()
else:
return
def reload_tournament(self):
self.db = TinyDB("tournament_data.json", indent=4)
tournaments = Query()
self.tournament_data = self.db.table("tournament_data")
db_tournament = self.tournament_data.search(
tournaments.status == "En cours")
while is_query_empty(db_tournament):
error_message("Aucun tournoi en cours")
return
print_current_tournaments()
for db_tour in db_tournament:
number_round_to_run = 4 - len(db_tour["rounds"])
print_existing_tournaments(db_tour)
print_number_round_to_run(number_round_to_run)
choice = tournament_choice()
reloaded_tournament = self.tournament_data.get(doc_id=choice)
self.tournament = None
self.tournament = tournament_deserializer(reloaded_tournament)
self.tournament.date = set_date()
nb_of_players = len(self.tournament.players)
if nb_of_players < 8:
for i in range(1, (9 - nb_of_players)):
playerController = PlayerController()
print_text(f"Joueur {i + nb_of_players} : ")
player = playerController.handle_players_choice()
self.tournament.add_player(player)
self.tournament_data.update(tournament_serializer(
self.tournament),
doc_ids=[choice])
number_round_to_run = 4 - len(self.tournament.rounds)
if number_round_to_run == 4:
self.run_first_round()
self.tournament_data.update(tournament_serializer(self.tournament),
doc_ids=[choice])
quit = self.get_and_check_continue_or_quit()
if quit == "q":
return
else:
pass
for i in range(2, 5):
self.run_round(i)
self.tournament_data.update(tournament_serializer(
self.tournament),
doc_ids=[choice])
quit = self.get_and_check_continue_or_quit()
if quit == "q":
return
else:
pass
else:
for i in range(len(self.tournament.rounds) + 1, 5):
self.run_round(i)
self.tournament_data.update(tournament_serializer(
self.tournament),
doc_ids=[choice])
quit = self.get_and_check_continue_or_quit()
if quit == "q":
return
else:
pass
self.tournament.status = "Terminé"
self.tournament_data.update(tournament_serializer(self.tournament),
doc_ids=[choice])
update_elo = self.check_update_player_elo()
while True:
if update_elo == "o":
PlayerController.update_player_elo()
update_elo = self.check_update_player_elo()
else:
return
def run_first_round(self):
# algorithme pour créer les premiers rounds
match_number = 1
start_time = set_round_time()
end_time = None
round1 = Round("1", start_time, end_time)
self.tournament.add_round(round1)
player_for_round = self.get_players()
print_player(player_for_round)
for i in range(4):
round1.add_match(player_for_round[i], player_for_round[i + 4])
for match in round1.matches:
match.player1.opponent.append(match.player2.elo)
match.player2.opponent.append(match.player1.elo)
for match in self.tournament.rounds[0].matches:
print_text(f"\nROUND #1 - MATCH #{match_number}")
print_match(match)
match.score_player1, match.score_player2 = self.handle_score()
print_text(f"\nRÉSULTAT DU MATCH #{match_number}")
match_number += 1
print_match_result(match)
self.update_tournament_score(match)
self.tournament.players.sort(key=lambda x: x.elo, reverse=True)
self.tournament.players.sort(key=lambda x: x.score, reverse=True)
print_final_score(self.tournament.players, round1.round_number)
round1.end_time = set_round_time()
def run_round(self, round_number):
match_number = 1
start_time = set_round_time()
end_time = None
round = Round(str(round_number), start_time, end_time)
self.tournament.add_round(round)
player_for_round = self.get_players()
print_player(player_for_round)
index_player = 0
while len(player_for_round) != 0:
player1 = player_for_round[index_player]
player1_index = index_player
player2 = player_for_round[index_player + 1]
player2_index = index_player + 1
while player2.elo in player1.opponent:
index_player += 1
player2 = player_for_round[index_player + 1]
player2_index = index_player + 1
round.add_match(player1, player2)
del player_for_round[player1_index]
del player_for_round[player2_index - 1]
index_player = 0
for match in round.matches:
match.player1.opponent.append(match.player2.elo)
match.player2.opponent.append(match.player1.elo)
for i in range(1, 2):
for match in self.tournament.rounds[round_number - 1].matches:
print_text(f"\nROUND #{round_number} - MATCH #{match_number}")
print_match(match)
match.score_player1, match.score_player2 = self.handle_score()
print_text(f"\nRÉSULTAT DU MATCH #{match_number}")
match_number += 1
print_match_result(match)
self.update_tournament_score(match)
self.tournament.players.sort(key=lambda x: x.elo, reverse=True)
self.tournament.players.sort(key=lambda x: x.score, reverse=True)
print_final_score(self.tournament.players, round.round_number)
round.end_time = set_round_time()
def get_players(self):
player_for_round = list()
for player in self.tournament.players:
player_for_round.append(player)
player_for_round.sort(key=lambda x: x.elo, reverse=True)
player_for_round.sort(key=lambda x: x.score, reverse=True)
return player_for_round
def handle_score(self):
score = enter_score()
if (score == "1"):
return 1, 0
elif (score == "2"):
return 0, 1
else:
return 0.5, 0.5
def get_and_check_name(self):
name = get_tournament_name()
name = name.strip().capitalize()
while not is_tournament_name_valid(name):
error_message("Le format du nom est incorrect")
name = get_tournament_name()
name = name.strip().capitalize()
return name
def get_and_check_place(self):
place = get_tournament_place()
place = place.strip().capitalize()
while not is_place_valid(place):
error_message("Le format du lieu est incorrect")
place = get_tournament_place()
place = place.strip().capitalize()
return place
def get_and_check_time_control(self):
time_control = get_tournament_time_control()
time_control = time_control.lower()
while is_time_control_valid(time_control):
error_message("Le format du contrôle du temps est incorrect")
time_control = get_tournament_time_control()
time_control = time_control.lower()
else:
time_control = time_control_def(time_control)
return time_control
def get_and_check_continue_or_quit(self):
quit = get_continue_or_quit()
quit = quit.lower()
while not is_continue_or_quit(quit):
error_message("Aucune commande correspondante")
quit = get_continue_or_quit()
quit = quit.lower()
return quit
def update_tournament_score(self, match):
match.player1.score += match.score_player1
match.player2.score += match.score_player2
def check_update_player_elo(self):
update_elo = print_update_player_elo()
update_elo = update_elo.lower()
while not is_update_player_elo_valid(update_elo):
error_message("Entrez uniquement " "O" " ou " "N" "")
update_elo = print_update_player_elo()
update_elo = update_elo.lower()
return update_elo