def __init__(self) -> None:
self.score = ScoreView()
self.tournament_view = TournamentView()
self.menu_view = MenuView()
self.utilities_view = UtilitiesView()
self.player_view = PlayerView()
self.match_view = MatchView()
def __init__(self) -> None:
self.view_controller = ViewsController()
self.menu_view = MenuView()
self.player_view = PlayerView()
self.round_view = RoundView()
self.score = ScoreView()
self.utilities_view = UtilitiesView()
self.tournois_view = TournamentView()
self.players: List = []
def __init__(self) -> None:
self.model_controller = ModelsController()
self.view_controller = ViewsController()
self.db_controller = DBController()
self.player_view = PlayerView()
self.menu_view = MenuView()
self.tournament_view = TournamentView()
self.utilities_view = UtilitiesView()
self.score_view = ScoreView()
class PlayerController (Controller):
def __init__(self):
super(PlayerController, self).__init__()
self.model = PlayerModel()
self.view = PlayerView()
self.deck = None
self.hand = None
self.sections = []
self.mana = None
self.resource = 0
def notify(self, event):
super(Controller, self).notify(event)
if isinstance(event, events.StartTurn):
self.resource += 2
#TODO Check if it is the active player
def setVisibility(self, visible):
self.hand.setVisibility(visible)
self.view.updateAll()
def takeDamage(self, section, damage):
self.sections[section].takeDamage(damage)
if self.sections[section].model.curHealth <= 0:
g.event_manager.post(events.GameOver(self))
def expendMana(self, amount):
if amount > self.mana.model.curHealth:
raise ValueError("Too little mana!")
self.mana.take(amount)
def hasEnoughMana(self, amountNeeded):
return amountNeeded <= self.mana.model.curHealth
def gainMana(self):
if self.mana.model.curHealth >= self.mana.model.maxHealth:
self.mana.gain(1)
else:
self.mana.gain(2)
def drawCard(self):
card = self.deck.drawCard()
self.hand.addCard(card)
self.view.updateAll()
def __init__(self):
super(PlayerController, self).__init__()
self.model = PlayerModel()
self.view = PlayerView()
self.deck = None
self.hand = None
self.sections = []
self.mana = None
self.resource = 0
def main():
deck = Deck()
active_view = PlayerView()
passive_views = (active_view, BroadcastView(), InternetStreamingView())
views = Views(active_view, passive_views)
checker = CheckerRankAndSuitIndex()
game = Controller(deck, views, checker)
game.run()
class ModelsController:
def __init__(self) -> None:
self.view_controller = ViewsController()
self.menu_view = MenuView()
self.player_view = PlayerView()
self.round_view = RoundView()
self.score = ScoreView()
self.utilities_view = UtilitiesView()
self.tournois_view = TournamentView()
self.players: List = []
def end_of_round(self, tournament):
"""End a round :
- set an end time to round
- update score
- generate new round
Args:
tournament (tournament instance): tournament instance
"""
try:
round = tournament.round_list[-1]
if round.end_round_datetime == 'Round en cours':
round.stop_round()
self.round_view.display_stop_time(round)
self.update_score_round(round)
self.generate_next_round(round, tournament)
else:
self.utilities_view.display_tournament_is_finished()
except AttributeError:
self.view_controller.display_error()
def update_score_round(self, round):
"""Update player's score at the end of a round.
Keyword arguments:
round : Round -- instance of Round
"""
for match in round.matchs:
# On demande : qui est le vainqueur
winner = self.score.update_score(match)
# passer le score en variable de config
if winner == 0:
# match null
match.score_player1 += SCORE_FOR_NULL
match.score_player2 += SCORE_FOR_NULL
elif winner == 1:
# player 1 gagne
match.score_player1 += SCORE_FOR_WINNER
elif winner == 2:
# player 2 gagne
match.score_player2 += SCORE_FOR_WINNER
def DEMO_import_auto_tournament(self):
"""Create random info for a tournament
"""
tournament_infos = {'tournament_name': f"tournament_name {random.randint(0, 1000)}",
'location': "Strasbourg",
'tour_number': '4',
'start_date': (
f'''{random.randint(10, 20)}/{random.randint(10, 12)}/'''
f'''{random.randint(1990, 2000)}'''
),
'time_controller': random.randint(1, 3),
'number_of_players': '8',
'description': 'Description du tournois',
'id': str(uuid1())}
tournament_infos['end_date'] = tournament_infos['start_date']
tournament_obj = Tournament()
tournament_obj.add_tournament(tournament_infos)
self.add_multiple_players(int(tournament_obj.number_of_players), tournament_obj)
self.generate_first_round(tournament_obj)
def DEMO_import_auto_players(self, players_number: int, tournois_obj: object):
"""DEMO : import players auto for a tournament
Args:
players_number (int): players number in the tournament
tournois_obj (tournament instance): tournament instance
"""
self.players = []
for num_player in range(int(players_number)):
player_infos = {
"last_name": f'Nom {str(num_player+1)}',
"first_name": f'Prénom {str(num_player+1)}',
"date_of_birth": f'{random.randint(10, 28)}/{random.randint(10, 12)}/{random.randint(1950, 2021)}',
"sex": 'M' if random.randint(0, 1) else 'F',
"ranking": random.randint(300, 2000),
"id": str(uuid1())}
player_obj = Player()
player_obj.add_player(player_infos)
self.players.append(player_obj)
self.bind_multiple_players_to_tournament(tournois_obj, self.players)
self.players = []
# ______________________________________________________________________
def create_multiple_player(self, player_info: dict):
"""Create player instance, add to players list
Args:
player_info (dict): player informations from user
"""
player_obj = Player()
player_obj.add_player(player_info)
self.players.append(player_obj)
def create_new_player(self, player_info):
"""Create a player instance
Args:
player_info (dict): player informations from user
Returns:
player instance
"""
player_obj = Player()
player_obj.add_player(player_info)
return player_obj
def ask_player_info(self, num_player: int) -> dict:
"""Input player informations, ask to user
Args:
num_player (int): player number to show
- it can be number in the turnament
- or count of all players
Returns:
dict: player info
"""
player_info: dict = self.player_view.get_player_info(num_player + 1)
id = str(uuid1())
player_info['id'] = str(id)
return player_info
def check_players_list(self, tournament_obj):
"""Get a list of players without player already in the tournament
Args:
tournament_obj (tournament instance): tournament instance
Returns:
List : List of all players, without players already in the tournament
"""
check_list = list(Player.LIST_PLAYERS)
for player in tournament_obj.players_list:
if player in check_list:
check_list.remove(player)
return check_list
def import_players_manuel(self, players_number, tournament_obj):
"""Import player to a tournament
- already saved player
- Input new player
Args:
players_number (int): player number for this tournament
tournament_obj (tournament instance): tournament instance where we wants to imports players
"""
for num_player in range(int(players_number)):
# check_list is a list of all players without players already binded with tournament
check_list = self.check_players_list(tournament_obj)
# Display menu if
if len(check_list) != 0:
while True:
selected_menu = self.menu_view.display_menu_add_player()
# Player already saved
if selected_menu == '1':
self.player_view.display_players_list(check_list)
player_id = int(self.menu_view.select_item('joueur'))
try:
player = check_list[player_id]
except IndexError:
self.utilities_view.display_error_with_message('Index non trouvé !!')
if player in tournament_obj.players_list:
self.utilities_view.display_error_with_message('Joueur déjà enregistré dans ce tournoi !!')
else:
self.bind_player_to_tournament(tournament_obj, player)
break
# input new player
elif selected_menu == '2':
player_info = self.ask_player_info(num_player)
player = self.create_new_player(player_info)
self.bind_player_to_tournament(tournament_obj, player)
break
else:
self.utilities_view.display_error()
# input new player
else:
player_info = self.ask_player_info(num_player)
player = self.create_new_player(player_info)
self.bind_player_to_tournament(tournament_obj, player)
def add_multiple_players(self, players_number: int, tournament_obj: object):
"""Add players to a tournament.
Keyword arguments:
players_number : int -- number of players to add
"""
selected_menu = self.menu_view.import_auto_or_manuel_menu()
self.player_import_type(selected_menu, players_number, tournament_obj)
def player_import_type(self, selected_menu, players_number, tournois_obj):
"""Select a way to import players :
- auto
- manuel
Args:
selected_menu (int): selection by user
players_number (int): number for a player
tournois_obj (tournament instance): instance du tournoi.
"""
# import auto
if selected_menu == '1':
self.DEMO_import_auto_players(players_number, tournois_obj)
# import manuel
elif selected_menu == '2':
self.import_players_manuel(players_number, tournois_obj)
else:
self.view_controller.display_error()
def bind_player_to_tournament(self, tournament_obj, player_obj):
"""Bind player to a tournament :
Add player instance to a list in the tournament instance.
Args:
tournament_obj (Tournament instance): tournament where we want to link players
player_obj (Player instance): player we want to link
"""
tournament_obj.bind_player(player_obj)
def bind_multiple_players_to_tournament(self, tournament_obj: object, players: List[Player]):
"""Add players lists to tournament.
Keyword arguments:
tournois_obj : Tournament -- Instance of Tournament
players : [Player] -- List of Player's instance
"""
tournament_obj.bind_multiple_players(players)
def generate_first_round(self, tournois_obj):
"""Create first round.
Keyword arguments:
tournois_obj : Tournament -- Instance de class Tournament
"""
# generate_first_round renvoi une liste de tuple
# => pair de joueur [(player1, player2), (player1, player2), ...]
first_round_list = Suisse().generate_first_round(tournois_obj.players_list)
self.round = Round().create_round('Round 1')
for players in first_round_list:
# Create match instance - init score
match = Match().create_match(players[0], 0, players[1], 0)
self.round.add_match_to_round(match)
# Création du match suivant, et affichage des prochains matchs
tournois_obj.add_round(self.round)
RoundView().start_new_round(self.round)
self.view_controller.display_match_of_round(self.round)
def generate_next_round(self, previous_round, tournois_obj):
"""Create the next round.
Keyword arguments:
previous_round : Round -- round instance that has just ended
tournois_obj : Tournament -- Instance of Tournament
"""
# Check tour number
if len(tournois_obj.round_list) < DEFAULT_TOUR_NUMBER:
match_list = Suisse().generate_next_round(previous_round, tournois_obj)
self.round = Round().create_round(f'Round {len(tournois_obj.round_list)+1}')
RoundView().start_new_round(self.round)
for match in match_list:
formated_match = Match().create_match(match[0][0], match[0][1], match[1][0], match[1][1])
self.round.add_match_to_round(formated_match)
tournois_obj.add_round(self.round)
self.view_controller.display_match_of_round(self.round)
# end of tournament => display final score
else:
# récupérer la liste triée:
players = Suisse().get_players_list_with_score(tournois_obj.round_list[-1])
sorted_list = Suisse().sort_list_by_score(players)
self.score.display_final_score(sorted_list)
tournois_obj.set_final_score(sorted_list)
print("Fin du tournois")
def create_tournament(self):
"""Create tournament instance with user informations."""
tournament_infos = self.tournois_view.get_tournament_info()
tournament_infos['id'] = str(uuid1())
tournois_obj = Tournament()
tournois_obj.add_tournament(tournament_infos)
self.add_multiple_players(int(tournois_obj.number_of_players), tournois_obj)
self.generate_first_round(tournois_obj)
def get_ended_tournament(seld):
ended_tournament = []
for tournament in Tournament.TOURNAMENT_LIST:
if ((tournament.round_list[-1].end_round_datetime != 'Round en cours') and
(len(tournament.round_list) == int(tournament.tour_number))):
ended_tournament.append(tournament)
return ended_tournament
class Router:
def __init__(self) -> None:
self.model_controller = ModelsController()
self.view_controller = ViewsController()
self.db_controller = DBController()
self.player_view = PlayerView()
self.menu_view = MenuView()
self.tournament_view = TournamentView()
self.utilities_view = UtilitiesView()
self.score_view = ScoreView()
def main_menu(self, selected_menu):
"""Main Menu:
- 1 : Create tournament
- 2 : Create new player
- 3 : Edit tournament
- 4 : Edit player
- 5 : Rapports
- 6 : Load data from database
- 7 : Save to database
- 8 : DEMO generate auto tournament
- 9 : Stop
Args:
selected_menu (str): input user
Returns:
False : to Stop the loop with [9]
"""
# Create new tournament
if selected_menu == '1':
self.model_controller.create_tournament()
# Create new player
if selected_menu == '2':
player_info = self.model_controller.ask_player_info(
len(Player.LIST_PLAYERS))
self.model_controller.create_new_player(player_info)
# Edit tournament
elif selected_menu == '3':
if len(Tournament.TOURNAMENT_LIST) >= 1:
selected_tournament = self.view_controller.select_tournament()
if selected_tournament:
try:
self.edit_tournament_menu(selected_tournament)
except IndexError:
self.utilities_view.display_error_with_message(
'Pas de tournois à cet index !')
else:
pass
else:
self.utilities_view.display_error_with_message(
'Pas de tournois enregistré pour le moment !')
# Edit player
elif selected_menu == '4':
if Player.get_all_players() is not None:
self.player_view.display_players_list(Player.get_all_players())
player_id = self.menu_view.select_item('joueur')
try:
selected_player: object = Player.get_all_players()[int(
player_id)]
self.edit_player_menu(selected_player)
except IndexError:
self.utilities_view.display_error_with_message(
'Pas de joueur à cet index !')
except ValueError:
self.utilities_view.display_error_with_message(
"Ce n'est un numéro d'index !")
# Rapports
elif selected_menu == '5':
self.reports_menu()
# Load data from database
elif selected_menu == '6':
self.db_controller.load_players()
self.db_controller.load_tournaments()
# Save
elif selected_menu == '7':
self.db_controller.save_to_tinydb(Player().LIST_PLAYERS,
Tournament().TOURNAMENT_LIST)
# DEMO generate tournament auto
elif selected_menu == '8':
self.model_controller.DEMO_import_auto_tournament()
# stop
elif selected_menu == '9':
return False
else:
self.utilities_view.display_error_with_message('Valeur non trouvé')
def edit_tournament_menu(self, tournament: object):
"""Tournament edition menu
1 : End of a round
2 : Change Name
3 : Change Description
4 : Change time controller
5 : Change Location
6 : Change Sart date
7 : Change End Date
8 : Return to main menu
Args:
tournament (object): Instance of tournament, we want to edit.
"""
selected_menu = self.menu_view.display_menu_edit_tournament(tournament)
# end of the round -> update score
if selected_menu == '1':
self.model_controller.end_of_round(tournament)
# change name of tournament
elif selected_menu == '2':
new_tournament_name = self.tournament_view.update_tournament_name(
tournament)
tournament.update_name(new_tournament_name)
# change description
elif selected_menu == '3':
new_description = self.tournament_view.update_tournament_description(
tournament)
tournament.update_description(new_description)
# change time controller
elif selected_menu == '4':
new_time_controller = self.tournament_view.update_time_controller(
tournament)
tournament.update_time_controller(new_time_controller)
# change tournament's location
elif selected_menu == '5':
new_location = self.tournament_view.update_tournament_location(
tournament)
tournament.update_location(new_location)
# change start_date
elif selected_menu == '6':
new_start_date = self.tournament_view.update_tournament_start_date(
tournament)
tournament.update_start_date(new_start_date)
# change end_date
elif selected_menu == '7':
new_end_date = self.tournament_view.update_tournament_end_date(
tournament)
tournament.update_end_date(new_end_date)
# return to main menu
elif selected_menu == '8':
pass
# error : value not found
else:
self.utilities_view.display_error()
def edit_player_menu(self, player: object):
"""Menu player edition
Args:
player (object): Player instance we want to edit
"""
selected_menu = self.menu_view.display_menu_edit_player()
# Editer the ranking
if selected_menu == '1':
new_ranking = self.player_view.update_ranking(player)
player.update_ranking(new_ranking)
# Edit first name and last name
elif selected_menu == '2':
new_first_name, new_last_name = self.player_view.update_name(
player)
player.update_name(new_first_name, new_last_name)
# Edit date of birth
elif selected_menu == '3':
new_date_of_birth = self.player_view.update_birthday(player)
player.update_birthday(new_date_of_birth)
# Edit sex
elif selected_menu == '4':
new_sex = self.player_view.update_sex(player)
player.update_sex(new_sex)
# Return to main menu
elif selected_menu == '5':
pass
else:
self.utilities_view.display_error()
def reports_menu(self):
"""Choice - Menu reports."""
selected_menu = self.menu_view.display_report_menu()
# display all players
if selected_menu == '1':
if len(Player.LIST_PLAYERS) >= 1:
self.view_controller.display_all_players_sorted()
else:
self.utilities_view.display_error_with_message(
'Pas de joueur enregistré pour le moment !')
# Players of a tournament
elif selected_menu == '2':
if len(Tournament.TOURNAMENT_LIST) >= 1:
self.view_controller.display_players_of_tournament()
else:
self.utilities_view.display_error_with_message(
'Pas de tournois enregistré pour le moment !')
# Display a tournament
elif selected_menu == '3':
if len(Tournament.TOURNAMENT_LIST) >= 1:
self.tournament_view.display_tournament_list(
Tournament.TOURNAMENT_LIST)
else:
self.utilities_view.display_error_with_message(
'Pas de tournois enregistré pour le moment !')
# Rounds of a tournament
elif selected_menu == '4':
if len(Tournament.TOURNAMENT_LIST) >= 1:
self.view_controller.display_round_of_tournament()
else:
self.utilities_view.display_error_with_message(
'Pas de tournois enregistré pour le moment !')
# Matchs list of a tournament
elif selected_menu == '5':
if len(Tournament.TOURNAMENT_LIST) >= 1:
self.view_controller.display_match_of_tournament()
else:
self.utilities_view.display_error_with_message(
'Pas de tournois enregistré pour le moment !')
# Final score
elif selected_menu == '6':
ended_tournaments = self.model_controller.get_ended_tournament()
if ended_tournaments != []:
self.tournament_view.display_tournament_list(ended_tournaments)
try:
selected_tournoi = ended_tournaments[int(
self.menu_view.select_item('tournoi'))]
player_with_score = Suisse().get_players_list_with_score(
selected_tournoi.round_list[-1])
sorted_player_list = Suisse().sort_list_by_score(
player_with_score)
self.score_view.display_final_score(sorted_player_list)
except IndexError:
self.utilities_view.display_error_with_message(
'Pas de tournoi à cet index')
except ValueError:
self.utilities_view.display_error_with_message(
"Ce n'est pas un numéro d'index")
else:
self.utilities_view.display_error_with_message(
"Pas de tournoi terminé pour l'instant")
# retrun to main menu
elif selected_menu == '7':
pass
# Le choix n'est pas dans les propositions du menu
else:
UtilitiesView().display_error()
class ViewsController:
def __init__(self) -> None:
self.score = ScoreView()
self.tournament_view = TournamentView()
self.menu_view = MenuView()
self.utilities_view = UtilitiesView()
self.player_view = PlayerView()
self.match_view = MatchView()
def display_match_of_tournament(self):
"""Select the tournament and call the view to display match of a tournament."""
selected_tournament = self.select_tournament()
if selected_tournament is not None:
RoundView().display_round(selected_tournament, True)
else:
pass
def display_round_of_tournament(self):
"""Call the view to display round of tournament."""
selected_tournament = self.select_tournament()
if selected_tournament is not None:
RoundView().display_round(selected_tournament)
else:
pass
def select_tournament(self) -> object:
"""Allow the user to choose the turnament.
Returns:
instance of Tournament
"""
# Selectionner un tournoi -> afficher les tournois
self.tournament_view.display_tournament_list(
Tournament().TOURNAMENT_LIST)
# choisir l'ordre d'affichage
number_item = self.menu_view.select_item('tournois')
if number_item.isdigit():
try:
selected_tournament = Tournament().TOURNAMENT_LIST[int(
number_item)]
return selected_tournament
except IndexError:
self.utilities_view.display_error_with_message(
'Pas de tournoi à cet index !')
else:
self.utilities_view.display_error_with_message(
"L'index que vous avez saisi n'est pas un")
return None
def display_players_of_tournament(self):
"""Display players of a tournament."""
# affiche les tournois - et choix
selected_tournament = self.select_tournament()
if selected_tournament is not None:
# les joueurs du tournoi
players = selected_tournament.players_list
# Ranger la liste par ordre alphabetique ou par classement
sort_by = self.menu_view.select_sorting()
sorted_list = sort_list_by(players, sort_by)
# afficher les joueurs par ordre souhaité
self.player_view.display_players_list(sorted_list)
else:
pass
def display_all_players_from_model(self):
"""Display all players."""
self.all_players = Player.get_all_players()
self.player_view.display_players_list(self.all_players)
def display_all_players_sorted(self):
# Tous les joueurs
players = Player.LIST_PLAYERS
# sort choice
sort_by = self.menu_view.select_sorting()
sorted_list = sort_list_by(players, sort_by)
self.player_view.display_players_list(sorted_list)
def display_match_of_round(self, round):
"""Display all matchs of a round
Keyword arguments:
round : Round -- Instance of Round
"""
for match in round.matchs:
self.match_view.display_match(match)
# TODO a supprimer
def display_error(self):
self.utilities_view.display_error()
