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 start(self, date_time): """Summary of start. Args: date_time Returns: list: Description of return value """ rank_p = sorted(self.players, key=lambda x: x.rank) length = len(rank_p) middle_index = length//2 first_half = rank_p[:middle_index] second_half = rank_p[middle_index:] matches = [] for i in range(middle_index): matches.append(Match(first_half[i].first_name + ' ' + first_half[i].last_name, 0, second_half[i].first_name + ' ' + second_half[i].last_name, 0)) first_half_play = next((x for x in self.players if x.first_name + ' ' + x.last_name == first_half[i].first_name + ' ' + first_half[i].last_name), None) second_half_play = next((x for x in self.players if x.first_name + ' ' + x.last_name == second_half[i].first_name + ' ' + second_half[i].last_name), None) first_half_play.opponents.append(second_half_play.first_name + ' ' + second_half_play.last_name) second_half_play.opponents.append(first_half_play.first_name + ' ' + first_half_play.last_name) if length > middle_index*2: matches.append(Match("Pas d'adversaire", 0, second_half[middle_index].first_name + ' ' + second_half[middle_index].last_name, 0)) second_half_play = next((x for x in self.players if x.first_name + ' ' + x.last_name == second_half[middle_index].first_name + ' ' + second_half[middle_index].last_name), None) second_half_play.opponents.append("Pas d'adversaire") for i in range(self.round_count): if i == 0: self.rounds.append(Round("Round {}".format(i + 1), date_time, "", matches)) else: matches = [] self.rounds.append(Round("Round {}".format(i + 1), "", "", matches))
def get_next_round(self, tournament, rounds, players): """Create Round 2, 3 , 4.""" print(f"\n*******************ROUND {len(rounds)+1}******************\n") round = Round( f"Round {len(rounds) + 1}", datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S"), matchs=[], ) players = sorted( sorted( players, key=lambda player: player.rank, ), key=lambda player: player.points, reverse=True, ) print(players) round.get_opponents(players) for player in players: add_point = Input.for_score( f"\n Please enter {player.first_name}'s score : " ) player.add_points(add_point) round.end = str(datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S")) rounds.append(round) print(f"\n{round}") return round
def get_first_round(self, rounds, players): """Create the first round of a tournament.""" print( f"\n*******************ROUND {len(rounds)+1}******************\n") round = Round( f"Round {len(rounds)+ 1}", datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S"), matchs=[], ) players = sorted(players, key=lambda player: player.rank) nb_matchs = 4 for index in range(nb_matchs): print( f"{players[index].first_name} vs {players[index+4].first_name}" ) self.get_first_opponents(players) for player in players: add_point = Input.for_score( f"Please enter {player.first_name}'s score : ") player.add_points(add_point) Round.display_first_matchs(round, players) round.end = str(datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S")) rounds.append(round) print(f"\n{round}") return round
def progress_next_rounds( self, tournament, players, serialized_rounds, nb_rounds, ): """Run the following rounds.""" while nb_rounds > 0: rounds = tournament.rounds round = self.get_next_round(tournament, rounds, players) serialized_round = Round.serialized(round) serialized_rounds.append(serialized_round) tournament.update_round(serialized_rounds) tournament.update_players(players) if nb_rounds > 1: command = self.update(players, tournament) if command == "main menu": return "main menu" players = sorted( sorted( players, key=lambda player: player.rank, ), key=lambda player: player.points, reverse=True, ) nb_rounds = 4 - len(rounds) for player in players: score = player.add_final_score(player.points, player.score) Player.update_score(player, score) View.display_final_score(tournament, players)
def submit_stats(game_id, player, round_id): # get round instance - do we need game_id???? round = Round.get_by_id(round_id) stats_array = [ int(request.form.get('attack-input')), int(request.form.get('hitpoints-input')), int(request.form.get('luck-input')) ] # get round number from round index form or hidden inputs in round show round_num = request.form.get('round_num') if player == '1': round.player_1_stats = stats_array round.player_1_initiative = -1 round.save() else: round.player_2_stats = stats_array round.player_2_initiative = -1 round.save() return redirect( url_for('rounds.show', game_id=game_id, round_id=round_id, round_num=round_num))
def join_existing_game(game: Game, player: Union[User, int]) -> Game: print(f"Player {player} of type {type(player)} is joining game {game}") if isinstance(player, int): print(f"Player {player} is an AI player") player_config = dict( human_player=None, ai_player=player, ) else: print(f"Player {player} is a human player") if game.has_human_player(player): return game game.human_players.add(player) player_config = dict( human_player=player, ai_player=None, ) if game.is_ready(): Round( game=game, round_number=1, ) rack = Rack( game=game, tiles=game.tile_bag.fill_rack(), **player_config, ) commit() print(f"Created rack {rack} for human player {rack.human_player} and ai player {rack.ai_player}") num_racks = len(Rack.select()[:]) print(f"Total number of racks: {num_racks}") return game
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 load_round(self, data): round_list = [ Round(round['name'], [ Match(self.player_controller.get_by_id( match["p1"]["id"]), match["p1"]["score"], self.player_controller.get_by_id(match["p2"]["id"]), match["p2"]["score"]) for match in round["match_list"] ], round["start_time"], round["end_time"]) for round in data ] return round_list
def async_create_round(game_id): # get time delta to sunday midnight ( monday 00:00:00 ) in seconds present_time = datetime.utcnow() sec_per_day = 24 * 60 * 60 delta = ( 7 - present_time.weekday() ) * sec_per_day - present_time.hour * 60 * 60 - present_time.minute * 60 - present_time.second # automatically end currently active round if it exists # can we code logic for loghabit using queries in loghabit functions? # add round to db for game round = Round(game_id=game_id) round.save() # start recursive background task to execute on Monday 00:00:00 - which recalls async_round_create # for development purposes set timedelta = 30s async_create_round.apply_async((game_id, ), countdown=delta)
def progress_first_round( self, tournament, players, serialized_rounds, ): """Run the first round.""" rounds = tournament.rounds round = self.get_first_round(rounds, players) serialized_round = Round.serialized(round) serialized_rounds.append(serialized_round) tournament.update_round(serialized_rounds) tournament.update_players(players) return self.update(players, tournament)
def read_in_db(self, name: str) -> bool: """ Allows to load all the data of the DB of the searched tournament with its name :rtype: True if loading OK | False if loading NOK :param name: str tournament name :return: bool """ try: self.data = self.tournament_table.search(Query().name == name)[0] self.name = self.data['name'] self.location = self.data['location'] self.date = self.data['date'] self.time_control = self.data['time_control'] self.tournament_over = self.data['tournament_over'] self.list_players = list() for player_id in self.data['list_players']: self.player = Player() self.player.load_player(player_id) self.list_players.append(self.player) self.list_rounds_played = list() if self.data['list_round'] != [""]: for self.unique_round_dict in self.data['list_round']: self.round = Round(self.list_players) self.round.read_in_db([ int(self.key) for self.key, self.value in self.unique_round_dict.items() ][0]) self.round_played = { self.round: self.unique_round_dict[self.key] } self.list_rounds_played.append(self.round_played) self.list_match_possible_not_played = self.data[ 'list_match_possible'] self.comment_director = self.data['director_comment'] return True except IndexError: return False
def deserialize(cls, serialized_tournament): name = serialized_tournament['name'] place = serialized_tournament['place'] date = serialized_tournament['date'] time_control = serialized_tournament['time_control'] description = serialized_tournament['description'] rounds_total = serialized_tournament['rounds_total'] tournament = Tournament(name, place, date, time_control, description, rounds_total) tournament.rounds = [ Round.deserialize(serialized_round) for serialized_round in serialized_tournament['rounds'] ] tournament.players = serialized_tournament['players'] return tournament
def create(): #Getting habit_id from the hidden form habit_id = request.form.get('habit-id') current_habit = Habit.get_or_none(Habit.id == habit_id) game_id = current_habit.game_id game = Game.get_or_none(Game.id == game_id) user = User.get_or_none(User.id == current_habit.user_id) username = user.username sender_id = current_habit.user_id if sender_id == game.player_1_id: receiver_id = game.player_2_id else: receiver_id = game.player_1_id # if current_user == user: image_file = request.files[f'image-for-{habit_id}'] output = upload_file_to_s3(image_file, Config.S3_BUCKET) latest_round = Round.select(pw.fn.MAX(Round.id)).where(Round.game_id == game_id).scalar() new_habit_logged = LogHabit(habit_id = habit_id, sender_id = current_habit.user_id, receiver_id = receiver_id, approved = False, image_path = str(output), game_round_id = latest_round) new_habit_logged.save() flash('Habit submitted. Waiting for your opponent\'s approval. Keep up the good work!', 'success') return redirect(url_for('games.show', game_id = game_id, username = username ))
def load_matchs(self, round: dict): """Load matchs for a round from database Args: round (dict): round infos """ matchs: list[dict] = self.database.get_all_matchs_of_round(round['id']) for match in matchs: match_dict = { "id": match["id"], "player1": Player.get_player_by_id(match['player1']), "score_player1": match['score_player1'], "player2": Player.get_player_by_id(match['player2']), "score_player2": match['score_player1'] } match: object = Match().load_match(match_dict) round_obj: object = Round.find_round_by_id(round['id']) round_obj.load_match_to_round(match)
def load_rounds(self, tournament): """Load rounds for a tournament from database Args: tournament (tournament instance): specify a tournament to get his rounds """ rounds: list[dict] = self.database.get_all_rounds_of_tournament( tournament.id) for round in rounds: round_dict = { "id": round['id'], "round_name": round['round_name'], "start_round_datetime": round['start_round_datetime'], "end_round_datetime": round['end_round_datetime'] } round_obj = Round().load_round(round_dict) # import pdb; pdb.set_trace() tournament.add_round(round_obj) self.load_matchs(round)
def pass_round(game: Game, player: Union[User, int]): current_round = game.current_round_as_round_type() RoundAction( human_player=player if isinstance(player, User) else None, ai_player=player if isinstance(player, int) else None, round=current_round, # word="", score_gained=0, clicked_pass=True, ) # If this is the last word placed for this round, create another round if len(current_round.round_actions) == game.total_player_count(): Round( round_number=current_round.round_number + 1, game=game, ) commit()
def get_obj(self, its_name, its_type) -> Union[Player, Tournament]: """Summary of get_obj. Args: its_name its_type Returns: Union[Player, Tournament]: Description of return value """ item = self.get_item(its_name, its_type) if its_type == self.players.item_type: return Player(item['last_name'], item['first_name'], item['birth_date'], Gender(item['gender']), int(item['rank']), int(item['match_score']), int(item['current_score']), item['opponents']) tournament_rounds_objs = [] for rnd in item['rounds']: if isinstance(rnd, str): rnd = json.loads(rnd) tournament_round_matches_objs = [] for mat in rnd['matches']: tournament_round_matches_objs.append( Match(mat['pone_name'], mat['pone_score'], mat['ptwo_name'], mat['ptwo_score'])) tournament_rounds_objs.append( Round(rnd['name'], rnd['start_date_time'], rnd['end_date_time'], tournament_round_matches_objs)) tournament_player_objs = [] for play in item['players']: if isinstance(play, str): play = json.loads(play) tournament_player_objs.append( Player(play['last_name'], play['first_name'], play['birth_date'], play['gender'], play['rank'], play['match_score'], play['current_score'], play['opponents'])) return Tournament(item['name'], item['place'], item['date'], tournament_player_objs, item['time_control'], item['description'], tournament_rounds_objs, item['round_count'])
def build_game(first_player: User, human_player_count: int, ai_player_count: int) -> Game: tile_bag = TileBag.build_bag() new_game = Game( human_players={}, human_player_count=human_player_count, ai_player_count=ai_player_count, board=BoardState().serialize(), tile_bag=tile_bag, has_finished=False, ) tile_bag.game = new_game commit() join_existing_game(new_game, first_player) for ai_player_index in range(1, ai_player_count + 1): join_existing_game(new_game, ai_player_index) if new_game.is_ready(): Round( game=new_game, round_number=1, ) commit() return new_game
def roll_dice(game_id, player, round_id): roll_value = int(request.form.get('roll_value')) roll_index = int(request.form.get('roll_index')) # get round instance - do we need game_id???? round = Round.get_by_id(round_id) # get round number from round index form or hidden inputs in round show round_num = request.form.get('round_num') if player == '1': round.player_1_rolls[roll_index] = roll_value round.save() else: round.player_2_rolls[roll_index] = roll_value round.save() return redirect( url_for('rounds.show', game_id=game_id, round_id=round_id, round_num=round_num))
def get_command(self): "Choose a uncompleted tournament in the database." tournament = None while not tournament: name = Input.for_string("Name of an UNcompleted tournament ? ") tournament = Tournament.get(name) if not tournament: print("The value entered doesn't match any tournament !\n") rounds = tournament.rounds serialized_rounds = [] for round in rounds: serialized_round = Round.serialized(round) serialized_rounds.append(serialized_round) players = tournament.players nb_rounds = 4 - len(rounds) super().progress_next_rounds( tournament, players, serialized_rounds, nb_rounds, ) return "main menu"
def test5GameValidateStartGame(self): lastJoinedGame = {'gameID': 1} self.game_namespace.on("game_started", self.passGetCurrentGame) self.game_namespace.emit("start_game", lastJoinedGame) self.socketIO.wait(seconds=1) print("\n\n") print("****************************************************") print("*Test If start game button work********************") print("(1)*CurrentGame == startGame***********************") print("(2)*Create New Round*******************************") print("(3)*Create New Turn********************************") print("(4)*Assign Roles for Players************************") print("****************************************************") print("\n") # Test joined team player do right join! print("Test(1)*********************************************Pass") self.assertEqual(self.currentGame, lastJoinedGame) print("Test(2)*********************************************Pass") session = Session() turnID = 1 roundID = 1 round = RoundModel.getRoundById(roundID, session) turn = TurnModel.getTurnById(turnID, session) self.assertEqual(self.currentGame["gameID"], round.gameId) print("Test(3)*********************************************Pass") self.assertEqual(self.currentGame["gameID"], turn.gameId) self.assertEqual(round.id, turn.roundId) print("Test(4)********************************************Pass") teller_id = turn.turnTellerId moderator_id = turn.turnModeratorId player_teller = PlayerModel.findPlayerById(session, teller_id) player_moderator = PlayerModel.findPlayerById(session, moderator_id) # Test if teller from turn table has role of teller # Test if moderator from turn table has role of moderator self.assertEqual(player_teller.role, 1) self.assertEqual(player_moderator.role, 2)
def get_command(self): "Choose a uncompleted tournament in the database." tournament = self.tournament if not tournament: name = Input.for_string("Name of an UNcompleted tournament ? ") tournament = Tournament.get(name) if not tournament: return "" rounds = tournament.rounds serialized_rounds = [] for round in rounds: serialized_round = Round.serialized(round) serialized_rounds.append(serialized_round) players = tournament.players nb_rounds = 4 - len(rounds) super().progress_next_rounds( tournament, players, serialized_rounds, nb_rounds, ) return "main menu"
def battle(game_id, player, round_id): game = Game.get_by_id(game_id) # get round instance - do we need game_id???? round = Round.get_by_id(round_id) # get round number from round index form or hidden inputs in round show round_num = request.form.get('round_num') player_initiative = int(request.form.get('initiative_input')) if player == '1': round.player_1_initiative = player_initiative round.save() else: round.player_2_initiative = player_initiative round.save() # algorithm to calculate winner # only execute if both players initiatives have been rolled (therefore both > 0) if (round.player_1_initiative > 0) and (round.player_2_initiative > 0): player_1_initiative = round.player_1_initiative player_2_initiative = round.player_2_initiative if player_1_initiative == player_2_initiative: if random.random() < 0.5: first_attack = 1 else: first_attack = 2 elif player_1_initiative > player_2_initiative: first_attack = 1 else: first_attack = 2 # based on first attacker, increment initiative by 1 # for the case where initiatives are equal # in order to correctly calculate battlescript on client side if first_attack == 1: round.player_1_initiative += 1 round.save() elif first_attack == 2: round.player_2_initiative += 1 round.save() p1_attack = round.player_1_stats[0] p1_hp = round.player_1_stats[1] p1_luck = round.player_1_stats[2] p2_attack = round.player_2_stats[0] p2_hp = round.player_2_stats[1] p2_luck = round.player_2_stats[2] # determine winner of round while (p1_hp > 0 and p2_hp > 0): # if player 1 goes first if first_attack == 1: # check if critical hit if random.random() * 100 < p1_luck: p1_damage = p1_attack * 2 else: p1_damage = p1_attack round.player_1_dmg_array.append(p1_damage) round.save() # check if p2 alive p2_hp = p2_hp - p1_damage if p2_hp <= 0: round.result = User.get_by_id(game.player_1_id) round.save() game.player_1_score += 1 game.save() break # repeat for p2 if random.random() * 100 < p2_luck: p2_damage = p2_attack * 2 else: p2_damage = p2_attack round.player_2_dmg_array.append(p2_damage) round.save() # check if p1 alive p1_hp = p1_hp - p2_damage if p1_hp <= 0: round.result = User.get_by_id(game.player_2_id) round.save() game.player_2_score += 1 game.save() break else: # if player 2 attacks first if random.random() * 100 < p2_luck: p2_damage = p2_attack * 2 else: p2_damage = p2_attack round.player_2_dmg_array.append(p2_damage) round.save() # check if p1 alive p1_hp = p1_hp - p2_damage if p1_hp <= 0: round.result = User.get_by_id(game.player_2_id) round.save() game.player_2_score += 1 game.save() break if random.random() * 100 < p1_luck: p1_damage = p1_attack * 2 else: p1_damage = p1_attack round.player_1_dmg_array.append(p1_damage) round.save() # check if p2 alive p2_hp = p2_hp - p1_damage if p2_hp <= 0: round.result = User.get_by_id(game.player_1_id) round.save() game.player_1_score += 1 game.save() return redirect( url_for('rounds.show', game_id=game_id, round_id=round_id, round_num=round_num))
def show(game_id, round_id): # get game model object game_id = game_id game = Game.get_by_id(game_id) # empty array for number of dice dice_array = [] num_dice = 0 # get round id and round instance round_id = round_id # hardcode for dev purposes round = Round.get_by_id(round_id) # get round number from round index form or hidden inputs in round show round_num = request.args['round_num'] # determine if current_user is p1 or p2 and get roll array game_player_1_id = game.player_1_id if current_user.id == game_player_1_id: # if current_player.id == game_player_1_id: player_variable = 1 roll_array = round.player_1_rolls player_stats = round.player_1_stats opponent_stats = round.player_2_stats player_initiative = round.player_1_initiative opponent_initiative = round.player_2_initiative else: player_variable = 2 roll_array = round.player_2_rolls player_stats = round.player_2_stats opponent_stats = round.player_1_stats player_initiative = round.player_2_initiative opponent_initiative = round.player_1_initiative round_result = round.result winner = User.get_or_none(User.id == round_result) # querydb get habits with user_id==current user AND game_id==game_id # current_user_habit_array = Habit.select().where((Habit.user_id == current_user.id) & (Habit.game_id == game_id)) current_user_habit_array = Habit.select().where( (Habit.user_id == current_user.id) & (Habit.game_id == game_id)) # for each habit, query log_habits table and get number of rows for that habit for current_round that r approved # compare to frequency number of the habit for habit in current_user_habit_array: # query loghabit table for rows belonging to habit/user which are approved # approved_logs = LogHabit.select().where((LogHabit.sender==current_user.id) & (LogHabit.habit_id == habit.id) & (LogHabit.approved==True) & (LogHabit.game_round_id == round_id)) approved_logs = LogHabit.select().where( (LogHabit.sender == current_user.id) & (LogHabit.habit_id == habit.id) & (LogHabit.approved == True) & (LogHabit.game_round_id == round_id)) # get length of list # compare length of list to frequency number if len(approved_logs) >= habit.frequency: # append to dice list dice_array += [1] num_dice += 1 return render_template('rounds/show.html', round=round, round_id=round_id, round_num=round_num, num_dice=num_dice, dice_array=dice_array, player_variable=player_variable, game_id=game_id, roll_array=roll_array, player_stats=player_stats, opponent_stats=opponent_stats, player_initiative=player_initiative, opponent_initiative=opponent_initiative, round_result=round_result, winner=winner)
def create_round(self, params): self.current_round = Round(**params) self.this_round = self.current_round.params
class RoundManager: """ Class of a round manager This class contains methods to create rounds and matches. It contains 4 methods: create_match: creates all the matches for a round by sorting the players from lowest rank to highest rank, separating them in two lists and associating the players with their index, making sure a match has not been already created. ask_score: asks the score of each player and adds it to the previous score. create_round: create a round from the params and puts it in the rounds dict. serialize_round: serialize a round. """ def __init__(self): self.set_matches = set() self.this_round = {} self.current_round = None self.rounds = [] self.utils = Utils() def create_match(self, players_list, nb_round): print("") print(f"Round n°{nb_round+1}") self.rounds.clear() sorted_players = sorted(players_list, key=lambda player: (player[1], player[0]['rank'], player[0]['last_name'])) first_half = sorted_players[0:4] second_half = sorted_players[4:8] for i in range(4): next_player = 0 match = (first_half[0], second_half[0]) current_match = (match[0][0]['identifier'], match[1][0]['identifier']) inverted_current_match = current_match[::-1] if current_match not in self.set_matches and inverted_current_match not in self.set_matches: print(f"{match[0][0]['last_name']} {match[0][0]['first_name']} contre " f"{match[1][0]['first_name']} {match[1][0]['last_name']}") first_half.pop(0) second_half.pop(0) elif len(first_half) == 1 and len(second_half) == 1: pass else: while True: next_player += 1 match = (first_half[0], second_half[next_player]) current_match = (match[0][0]['identifier'], match[1][0]['identifier']) inverted_current_match = current_match[::-1] if current_match not in self.set_matches and inverted_current_match not in self.set_matches: print(f"{match[0][0]['last_name']} {match[0][0]['first_name']} contre " f"{match[1][0]['first_name']} {match[1][0]['last_name']}") first_half.pop(0) second_half.pop(next_player) break else: continue self.set_matches.add(current_match) self.rounds.append(match) def ask_score(self, players_list): new_score = self.utils.ask_float(f"Score de {players_list[0]['last_name']} {players_list[0]['first_name']}: ") players_list[1] += float(new_score) def create_round(self, params): self.current_round = Round(**params) self.this_round = self.current_round.params def serialize_round(self): self.current_round.serialize()
def index(game_id, user_id): rounds = Round.select().where(Round.game_id == game_id) game = Game.get_by_id(game_id) return render_template('/rounds/index.html', rounds=rounds, game=game)
) from controllers.controller import Controller from models.enums import Gender from models.enums import TimeControl from models.tournament import Tournament from models.player import Player from models.round import Round from models.carriers import TournamentCarrier from models.carriers import PlayerCarrier from views.menu import CYSMenu from views.logger import Logger my_matches = [{}] my_rounds = [ Round("round1", "21/21/21", "21/21/21", my_matches), Round("round2", "21/21/21", "21/21/21", my_matches), Round("round3", "21/21/21", "21/21/21", my_matches), Round("round4", "21/21/21", "21/21/21", my_matches) ] my_player = Player("hey", "heythere", "23/12/1992", Gender.FEMALE, 129) my_updated_player = Player("hey", "heythere", "23/11/1800", Gender.OTHER, 100) my_players = [ Player("Carrasco", "Michael", "23/12/1992", Gender.MALE, 299), Player("Myers", "Michael", "25/05/1963", Gender.MALE, 23), Player("Weaver", "Susan", "08/08/1949", Gender.FEMALE, 53), Player("Tobia", "Jacob", "07/06/1991", Gender.OTHER, 156), Player("Kasparof", "Garry", "13/04/1963", Gender.MALE, 2),
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