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