class TestFirstDart(unittest.TestCase): def setUp(self): self.round = Round() @data(('S10', 10), # test single ('D10', 20), # test double ('T10', 30), # test triple ('s10', 10) # test lower case ) @unpack def test_hit(self, throw, total): # 1st dart hit => set the marker, # add the score to total, # missed_first remains unchanged dart_throw = DartThrow(throw) self.round.dart1(dart_throw) self.assertEqual(total, self.round.total) self.assertFalse(self.round.missed_first) self.assertEqual(int(throw[1:]), self.round.marker) def test_miss(self): # 1st dart missed => don't set the marker, # don't add the score to total, # missed_first is set to true dart_throw = DartThrow('M') self.round.dart1(dart_throw) self.assertEqual(-50, self.round.total) self.assertTrue(self.round.missed_first) self.assertEqual(-1, self.round.marker)
class Main(ShowBase): def __init__(self): ShowBase.__init__(self) self.login = Login(self) def startMainmenu(self): self.login.hide() self.mainmenu = MainMenu(self) self.pregame = Pregame(self) self.mainmenu.show() def startPregame(self): self.mainmenu.hide() self.pregame.reset() self.pregame.show() def returnToMenu(self): self.pregame.hide() self.mainmenu.show() def startRound(self): self.pregame.hide() self.round = Round(self) def endRound(self): self.round.destroy() del self.round self.pregame.show() def hostGame(self, params): pid = Popen(["python", "server.py", params]).pid print 'Server Process ID:', pid def quit(self): sys.exit()
class TestSecondDart(unittest.TestCase): def setUp(self): self.round = Round() @data(('S10', 20), ('s10', 20), ('D10', 30), ('T10', 40), ('M', -40), ('S5', 5)) @unpack def test_first_dart_hit(self, throw, total): self.round.missed_first = False self.round.marker = 10 self.round.total = 10 self.round.dart2_and_3(DartThrow(throw)) self.assertEqual(total, self.round.total) @data(('S10', 20), ('M', -50)) @unpack def test_first_dart_miss(self, throw, total): self.round.missed_first = True self.round.total = 0 self.round.dart2_and_3(DartThrow('S10')) self.assertEqual(-10, self.round.total)
class Game: """ Represents a Word Guess Game """ def __init__(self, id): """ Initialize the Game """ self.id = id self.currentRound = Round() self.points = 0 def guess(self, guesses): """ Return the results of the guess against the current Round """ self.currentRound.guess(guesses) self.tryToAwardPoints() def startNextRound(self): """ Start the Next Round """ nextWordLength = GetNextLength(self.currentRound.wordLength) self.currentRound = Round(wordLength=nextWordLength) def tryToAwardPoints(self): """ Award Poitns if the Round was finished """ if self.currentRound.completed: self.points += points[self.currentRound.triesLeft] def hasNextRound(self): """ Return if there is a round to play after the current round """ return HasNextLength(self.currentRound.wordLength)
def play_game(self): """ Play a game. - Start score as game_score (usually 0) - New rounds while no player reaches max_score - If winner on round, winner's score is updated - History of game is updated with each round's result (winner and score of round) Return game winner and list of rounds results """ score = self.game_score() while max(score.values()) < self.n_points: new_round = Round(self.players, self.n_tiles, self.max_number) winner, score, _ = new_round.play_round() try: winner.update_score(score) except AttributeError: pass self.history.append({'winner': str(winner), 'score': score}) score = self.game_score() print self.str_game_score() print winner = [str(player) for player in self.players if player.get_score() == max(score.values())][0] return winner, self.history
def start_round(self): names = self.__get_names() lists = self.__get_selected_lists() interface = RoundInterface(names) words_per_round = properties.WORDS_PER_ROUND word_time_interval = properties.WORD_TIME_INTERVAL img_from_wiki = properties.LOAD_IMAGES_FROM_WIKIPEDIA round = Round(words_per_round, word_time_interval, names, lists, interface, img_from_wiki) round.start()
def game_view(request): if 'context' in request.session: ctx = request.session['context'] else: ctx = UserContext() request.session['context'] = ctx request.session['round'] = Round.get_round(ctx.round) return render(request, 'game.html', {}, content_type="html")
def run(self, round_num): # initialize round pool self.config.log("Generating Initial Seating Arrangement") cur_round = Round(players=self.config.PLAYERS) cur_round.pair_players( list(self.config.PLAYERS), self.config.SEATS_PER_TABLE, self.config.MIN_SEATS_PER_TABLE) should_converge = cur_round.should_converge(round_num, self.config) # iterate some number of times for i in range(0, self.config.MAX_ITERATIONS): iter_stats = self.stats.create_iteration() self.stats.record_round(cur_round) # if any are 0, then done. self.config.log("Checking for Global Minimum.") if self.stats.did_converge(self.config.NUM_PLAYERS): return cur_round self.config.log("Checking for early exit.") if not should_converge and self.check_early_exit(): return cur_round self.config.log("Improving Seating Assignments") new_round = cur_round.improve(self.config) if new_round.score() <= cur_round.score(): cur_round = new_round # else: # pool = [cur_round.improve(self.config) for i in range(0, self.config.CLASH_MUTATION_SIZE)] # pool.sort(key=lambda x: x.score()) # best_round = pool[0] # # if best_round.score() < cur_round.score(): # cur_round = best_round self.stats.finish_iteration() if self.config.DEBUG: iter_stats.print_iteration_report() cur_round.validate() return cur_round
def set_up_test_data(): stephen = Player('Stephen Muller') stephen_first_round = Round(stephen) first_round_misses = [21] stephen_first_round.singles_round.missed_target(first_round_misses) stephen_first_round.print_score() stephen_second_round = Round(stephen) second_round_misses = [6, 14, 24] stephen_second_round.singles_round.missed_target(second_round_misses) stephen_second_round.print_score()
def play(self): for _ in xrange(1, self.rounds + 1): self.current_round += 1 self.print_score() for pKey, pVal in self.players.iteritems(): start_msg = "Player {p}'s turn. Starting score = {s}" print start_msg.format(p=pKey, s=pVal.score) rnd = Round() dart = get_throw(1) rnd.dart1(DartThrow(dart)) dart = get_throw(2) rnd.dart2_and_3(DartThrow(dart)) dart = get_throw(3) rnd.dart2_and_3(DartThrow(dart)) pVal.score += rnd.total self.game_in_progress = False
def create_rounds(tournament_list): """ Use the tournament_list object list, that was returned from the create_tournaments function, which contains 15 Tournament objects with the following instance variables: tourn_id, tourn_name, golf_course_id, start_date, num_rounds, num_golfers, golfers... Create num_rounds Round objects from every Tournament object element in tournament_list: Add in the following as instance variables values round_id, tourn_id, day A list is returned, where each element is a Round object """ print("\nThe Round object list\n") # Create an empty list that will be filled with Round objects whose data comes from the parameter tournament_list rounds_list = [] # Initialize round_id round_id = 1 # Create an outer looper to traverse the input tournament_list, where the loop variable "tourn" will contain # one of the Tournament objects in tournament_list at each loop iteration for tourn in tournament_list: # Get the number_rounds and tourn_id from Tournament object, tourn, and initialize num_rounds to number_rounds - # this will be decremented below to find the correct day for the Round object being built tourn_id = tourn.get_tourn_id() number_rounds = tourn.get_num_rounds() num_rounds = int(number_rounds) # Create an inner loop to run number_round times using the range function, where the loop variable 'r' keeps # the number of Rounds being created for r in range(int(number_rounds)): # Check the value of num_rounds to determine the day value of this Round object. if int(num_rounds) == 4: day = "Thu" elif int(num_rounds) == 3: day = "Fri" elif int(num_rounds) == 2: day = "Sat" elif int(num_rounds) == 1: day = "Sun" # Decrement the num_rounds counter num_rounds -= 1 # Create a Round object call it round passing in round_id, tourn_id, and day round = Round(round_id, tourn_id, day) # Append the Round object to the rounds_list rounds_list.append(round) # Increment the round_id round_id += 1 # Print the round objects to the console for item in rounds_list: print(item) return rounds_list
def test_serialize_no_movie(self): round1 = Round(TestRound.room1, 1) ser = {'judge': '', 'movie': '', 'number': 1} self.assertEqual(round1.serialize(), ser)
def test_eq_equal(self): round1 = Round(TestRound.room1, 1) round2 = Round(TestRound.room1, 1) self.assertEqual(round1, round2)
def fire_round(ai_settings, window, ship, rounds): if len(rounds) < ai_settings.num_rounds_on_screen: new_round = Round(ai_settings, window, ship) rounds.add(new_round)
def startRound(self): self.pregame.hide() self.round = Round(self)
def test_standard_moves(self): r = Round(SingleWordCollection(), [0, 1, 2]) self.assertFalse(r.timer) r.timer = 25 self.assertEqual(r.timer, 25) r.timer = 30 self.assertEqual(r.timer, 30) r.timer = None self.assertFalse(r.timer) self.assertEqual(r.start_game(), (0, 1)) self.assertEqual(r.start_move(0), "one") self.assertEqual(r.guessed(0), "one") self.assertEqual(r.time_ran_out(0), (1, 2)) self.assertEqual(r.start_move(1), "one") self.assertEqual(r.failed(1), (2, 0)) self.assertEqual(r.start_move(2), "one") self.assertEqual(r.guessed(2), "one") self.assertEqual(r.guessed(2), "one") self.assertEqual(r.guessed(2), "one") self.assertEqual(r.guessed(2), "one") self.assertEqual(r.pretty_scores(), [[0, 5, 1, 4], [2, 4, 4, 0], [1, 1, 0, 1]])
def start_round(self, task): self.preround.hide() self.round = Round(self) return task.done
def round_sm(): """Generates a small round.""" return Round(0, 0, 0, 1)
def round_bg(): """Generates a bigger round.""" return Round(0, 0, 0, 2)
def startRound(self): self.lobby.hide() self.round = Round(self)
def onpick(event): ind = event.ind for i in ind: stroke2print = lookup_basedon_type_str_gain(round1, np.take(x, i), np.take(y, i)) stroke2print.stroke_print() if __name__ == '__main__': #run only once on a round of data unless comment out save_round() data_import = pd.read_csv( 'rounds\\Uploaded\\121418_LaurelCreek_Palmer.csv', names=['Club', 'Loc Start', 'Dist Start']) round1 = Round('12/14/18', 'LaurelCreek', 'Palmer', '18') for idx, row in data_import.iterrows(): a = Stroke((idx + 1), row["Club"], row["Loc Start"], row["Dist Start"]) round1.add_stroke(a) round1.calculate_strokes_gained() round1.strokes = round1.strokes_to_pandas() round1.calculate_strokes_to_hole() round1.build_scorecard() round1.single_round_plot() #round1.save_round('rounds\Taillie_History.csv') # fig2 = round1.plot_strgain_type_bar() # #
def main(): pygame.init() done = False fps_counter = 0 game_speed = 60 display_scale = 1 clock = pygame.time.Clock() retlange_height = 50 retlange_width = 500 screen_height = 1080//display_scale screen_width = 1920//display_scale screen = pygame.display.set_mode((0, 0), pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN) # screen = pygame.display.set_mode((400, 400), pygame.HWSURFACE | pygame.DOUBLEBUF) x = 100 y = screen_height//10*9 moving_speed = 15 round_finished = False paddle_power = 0 print(1) # pygame.display.set_caption("Arkanoid Wiktorii") icon = pygame.image.load('graphics/background.jpg').convert_alpha() # pygame.display.set_icon(icon) start_time = time.time() pygame.font.init() # you have to call this at the start, # if you want to use this module. myfont = pygame.font.SysFont('Comic Sans MS', 30) # print(start_time) pygame.font.init() stage = Round(1) print(2) while not done: print(3) fps_counter += 1 pressed = pygame.key.get_pressed() # if pressed[pygame.K_UP] and y > 0 : # y = y - moving_speed # if pressed[pygame.K_DOWN] and y < 500 - retlange_height: # y = y + moving_speed if pressed[pygame.K_RIGHT] and x < screen_width - retlange_width : x = x + moving_speed * paddle_power // 100 if paddle_power < 100: paddle_power = paddle_power + 4 if pressed[pygame.K_LEFT] and x > 0 : x = x - moving_speed * paddle_power // 100 if paddle_power < 100: paddle_power = paddle_power + 4 if not pressed [pygame.K_RIGHT] and not pressed [pygame.K_LEFT]: paddle_power = 0 for event in pygame.event.get(): if event.type == pygame.QUIT: done = True if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE: done = True # pygame.draw.rect(object, (object_colour), pygame.Rect(x, y, object_width, object_height)) #pygame.draw.rect(screen, (91, 44, 111), pygame.Rect(x, y, retlange_width, retlange_height)) stage.draw(screen, x, y, retlange_width) pygame.draw.polygon(screen, (91, 44, 111), [[x, y + retlange_height], [x + retlange_width, y + retlange_height], [x + retlange_width // 2, y]]) fps_per_sec = fps_counter / (time.time() - start_time) textsurface = myfont.render(str(round(fps_per_sec)), False, (0, 0, 0)) screen.blit(textsurface, (20, 20)) if stage.round_finished: textsurface = myfont.render("Level 1 finished", False, (0, 0, 0)) screen.blit(textsurface, (500, 500)) time.sleep(1) stage = Round(2) #pygame.draw.rect(screen, tuple(ball_colour), pygame.Rect(ball_position[0], ball_position[1], ball_diameter, ball_diameter)) pygame.display.flip() clock.tick(120)
def work(self): # TODO: change one round to multiround with Round(self.client, self.dealer) as round: result = round.work()
def create_rounds(tournament_list): # Use the tournament_list object list, that was # returned from the create_tournaments function, which # contains 15 Tournament objects with the following # instance variables: # tourn_id, tourn_name, golf_course_id, start_date, # num_rounds, num_golfers, golfers... # Create num_rounds Round objects from every # Tournament object element in tournament_list: # Add in the following as instance variables values # round_id, tourn_id, day # A list is returned, where each element is a Round object # print("\nThe Round object list:\n") # 1. Create an empty list called rounds_list # that will be filled in with Round objects # whose data comes from the parameter - tournament_list rounds_list = [] # 2. Initialize the round_id round_id = 1 # 3. Create an outer loop to traverse the input # tournament_list, where the loop variable 'tourn' # will contain one of the Tournament objects in # tournament_list at each loop iteration for tourn in tournament_list: # a. Get the number_rounds and tourn_id from the # Tournament object, tourn, and initialize # num_rounds to number_rounds - this will be # decremented below to find the correct day # for the Round object being built number_rounds = Tournament.get_num_rounds(tourn) tourn_id = Tournament.get_tourn_id(tourn) # b. Create an inner loop to run number_rounds times # using the range function, where the loop # variable 'r' keeps the count for the # number of Rounds being created r = number_rounds for item in range(number_rounds): # 1. Check the value of num_rounds to determine # the day value of this Round object. # Use an if/elif/else structure to set the # day instance variable if r == 4: day = "Thu" elif r == 3: day = "Fri" elif r == 2: day = "Sat" elif r == 1: day = "Sun" # 2. Decrement the num_rounds counter r = r - 1 # 3. Create a Round object call it round passing # in round_id, tourn_id, and day round = Round(round_id, tourn_id, day) # 4. Append the Round object to the rounds_list rounds_list.append(round) # 5. Increment the round_id round_id = round_id + 1 # 4. Print the round objects to the console for rounds in rounds_list: print(rounds) #return rounds_list to console return rounds_list
def generate_round(self): new_round = Round(self.team_one, self.team_two) new_round.round_actions() self.rounds.append(new_round)
def setUp(self): self.a_round = Round() self.players = [Player(i) for i in range(5)] # exercise for reader: understand how generators and iterators work; learn their # benefits and drawbacks self.cards = (Card(suit, rank) for rank, suit in islice(product(Rank, Suit), 10))
def blackjack(): """Manages the blackjack game""" print_menu() menu_choice = input("What would you like to do (1/2)? ") while menu_choice == "1": current_round = Round() current_round.print_header() current_round.deal() # Ends the game if the player gets blackjack if current_round.round_winner: print_menu() menu_choice = input("What would you like to do (1/2)? ") continue current_round.print_hands() move = input("What is your move (Hit/Stay)? ") while move == "Hit" and current_round.round_winner == False: current_round.player_hit() if current_round.round_winner == False: move = input("What is your move (Hit/Stay)? ") # Only plays the dealer if the player doesn't bust if not current_round.round_winner: current_round.play_for_dealer() print_menu() menu_choice = input("What would you like to do (1/2)? ")
def start_new_round(self): self.curr_round = Round(self) self.curr_frame = self.curr_round self.main_menu.close()
def test_more_words(self): r = Round(ManyWordCollection(), [0, 1, 2]) self.assertEqual(r.start_game(), (0, 1)) got = set() got.add(r.start_move(0)) got.add(r.guessed(0)) got.add(r.guessed(0)) self.assertEqual(r.time_ran_out(0), (1, 2)) self.assertEqual(r.guessed(0), texts.not_your_turn_message) got.add(r.start_move(1)) got.add(r.guessed(1)) self.assertEqual(r.time_ran_out(1), (2, 0)) self.assertEqual(r.start_move(1), texts.not_your_turn_message) got.add(r.start_move(2)) self.assertEqual(r.time_ran_out(2), (0, 2)) self.assertEqual(r.time_ran_out(2), texts.not_your_turn_message) got.add(r.start_move(0)) got.add(r.guessed(0)) self.assertEqual(r.time_ran_out(0), (1, 0)) got.add(r.start_move(1)) got.add(r.guessed(1)) self.assertEqual(r.time_ran_out(1), (2, 1)) got.add(r.start_move(2)) self.assertEqual(r.failed(2), (0, 1)) self.assertEqual(r.failed(2), texts.not_your_turn_message) self.assertEqual(r.guessed(2), texts.not_your_turn_message) self.assertEqual(r.start_move(0), texts.no_more_words_message) self.assertSetEqual( got, {"два", "двенадцать", "восемьдесят", "пять", "ноль", "шесть"}) self.assertEqual(r.points[0], 4) self.assertEqual(r.points[1], 4) self.assertEqual(r.points[2], 2)
def play(self): self.start() # First 7 rounds (starting at 7, 1 less card each round until 1 card per person) for i in range(7): r = Round(7 - i, self.playerList) # Gets the round initialized print() r.bets() sleep(1) # One iteration for each trick for k in range(7 - i): self.updateDisplay(self.roundNumber, r.topCard.getSuit(), r.dealer) r.trick() sleep(1) # self.roundNumber += 1 r.end() self.pointsDisplay(self.roundNumber, r.dealer) self.roundNumber += 1 # Remaining 9 rounds (starting with 1 card, 1 more per round until 10) for i in range(9): r = Round(i + 2, self.playerList) # Gets the round initialized r.bets() sleep(1) for k in range(i + 2): self.updateDisplay(self.roundNumber, r.topCard.getSuit(), r.dealer) r.trick() sleep(1) # self.roundNumber += 1 r.end() self.pointsDisplay(self.roundNumber, r.dealer) self.roundNumber += 1 self.endGame()
def shoot_round(ai_settings, win, plane, rounds): """shoot a round if !limit""" if len(rounds) < ai_settings.num_rounds_on_screen: new_round = Round(ai_settings, win, plane) rounds.add(new_round)
def play_game(Players, main_player): all_rounds = [] for i in range(1, 14): table = [] if all_rounds == []: current_round = Round(i) if not computer: roundWinner.score = "" else: if len(all_rounds[-1].leaders) > 1: current_round = Round(i, all_rounds[-1]) else: current_round = Round(i) if not computer: roundWinner.score = "" moves = dict() for player in Players: if player.type == 0: print("Player %d" % player.id) print(player.getCards()) played = -1 while played == -1: for event in pygame.event.get(): pos = pygame.mouse.get_pos() if event.type == pygame.QUIT: played = -2 pygame.quit() exit() if event.type == pygame.MOUSEBUTTONDOWN: if playButton.isOver(pos): played = None for card in player.hand.values(): if card.selected: played = card.value continue if played: table.append(player.hand[played]) else: played = -1 # del player.hand[played] for card in player.hand.values(): if card.isOver(pos): card.selected = True else: card.selected = False # choice = (int)(input("Enter Move: ")) # played = player.play(choice) redrawWindow(main_player.hand.values(), table, win) played = player.play(played) redrawWindow(main_player.hand.values(), table, win) c.send("%d,%d" % (main_player.id, played.value)) info = c.recv().split(",") for i in range(len(Players) - 1): moves[int(info[2 * i])] = int(info[2 * i + 1]) elif player.type == 2: played = player.play(random.choice(list(player.getCards()))) # table.append(played) c.send("%d,%d" % (main_player.id, played)) info = c.recv().split(",") for i in range(len(Players) - 1): moves[int(info[2 * i])] = int(info[2 * i + 1]) else: played = player.play(moves[player.id]) if not computer: table.append(played) # print("Player %d played: %d" %(player.id, played)) if not computer: redrawWindow(main_player.hand.values(), table, win) current_round.update(player.id, played.value) else: current_round.update(player.id, played) all_rounds.append(current_round) current_round.status() if len(current_round.leaders) == 1: print("Round won by: Player %d" % current_round.leaders[0]) if not computer: if current_round.leaders[0] == main_player_id: roundWinner.score = "You" else: roundWinner.score = "Player %d" % current_round.leaders[0] else: if not computer: roundWinner.score = "Tie" for player in Players: player.update(current_round) if not computer: score_board[player.id].score = str(player.points) if not computer: redrawWindow(main_player.hand.values(), table, win) sleep(2)
from ball import Ball from paddle import Paddle from round import Round from game import Game if __name__ == '__main__': paddle = Paddle() ball = Ball() this_round = Round() game = Game() game.run(this_round, paddle, ball)
def test_eq_diff_rooms(self): round1 = Round(TestRound.room1, 1) round2 = Round(TestRound.room2, 1) self.assertNotEqual(round1, round2)
class Game(object): def __init__(self, id, players): """ init the game! once player threshold is met :param id: int :param players: Player[] """ self.id = id self.players = players self.words_used = set() self.round = None self.board = Board() self.player_draw_ind = 0 self.round_count = 1 self.start_new_round() def start_new_round(self): """ Starts a new round with a new word :return: None """ try: round_word = self.get_word() self.round = Round(round_word, self.players[self.player_draw_ind], self) self.round_count += 1 if self.player_draw_ind >= len(self.players): self.round_ended() self.end_game() self.player_draw_ind += 1 except Exception as e: self.end_game() def player_guess(self, player, guess): """ Makes the player guess the word :param player: Player :param guess: str :return: bool """ return self.round.guess(player, guess) def player_disconnected(self, player): """ Call to clean up objects when player disconnects :param player: Player :raises: Exception() """ # todo check this if player in self.players: self.players.remove(player) self.round.player_left(player) self.round.chat.update_chat( f"Player {player.get_name()} disconnected.") else: raise Exception("Player not in game") if len(self.players) <= 2: self.end_game() def get_player_scores(self): """ give a dict of player scores. :return: dict """ scores = {player.name: player.get_score() for player in self.players} return scores def skip(self, player): """ Increments the round skips, if skips are greater than threshold, starts new round. :return: None """ if self.round: new_round = self.round.skip(player) if new_round: self.round.chat.update_chat(f"Round has been skipped.") self.round_ended() return True return False else: raise Exception("No round started yet!") def round_ended(self): """ If the round ends call thiss :return: None """ self.round.chat.update_chat(f"Round {self.round_count} has ended.") self.start_new_round() self.board.clear() def update_board(self, x, y, color): """ calls update method on board. :param x: int :param y: int :param color: 0-8 :return: None """ if not self.board: raise Exception("No board created") self.board.update(x, y, color) def end_game(self): """ ends the game :return: """ print(f"[GAME] Game {self.id} ended") for player in self.players: player.game = None def get_word(self): """ gives a word that has not yet been used :return: str """ with open("words.txt", "r") as f: words = [] for line in f: wrd = line.strip() if wrd not in self.words_used: words.append(wrd) self.words_used.add(wrd) r = random.randint(0, len(words) - 1) return words[r].strip()
def setUp(self): self.round = Round()
class Game(object): def __init__(self, id, players): """ lancez le jeu! une fois que le seuil de joueur est atteint """ self.id = id self.players = players self.words_used = set() self.round = None self.board = Board() self.player_draw_ind = 0 self.round_count = 1 self.start_new_round() def start_new_round(self): """ Commence un nouveau tour avec un nouveau mot """ try: round_word = self.get_word() self.round = Round(round_word, self.players[self.player_draw_ind], self) self.round_count += 1 if self.player_draw_ind >= len(self.players): self.round_ended() self.end_game() self.player_draw_ind += 1 except Exception as e: self.end_game() def player_guess(self, player, guess): """ Fait deviner le mot au joueur """ return self.round.guess(player, guess) def player_disconnected(self, player): """ Appel pour nettoyer les objets lorsque le joueur se déconnecte """ # todo check this if player in self.players: player_ind = self.players.index(player) if player_ind >= self.player_draw_ind: self.player_draw_ind -= 1 self.players.remove(player) self.round.player_left(player) self.round.chat.update_chat( f"Player {player.get_name()} disconnected.") else: raise Exception("Player not in game") if len(self.players) <= 2: self.end_game() def get_player_scores(self): """ donnez un dict des scores des joueurs.. """ scores = {player.name: player.get_score() for player in self.players} return scores def skip(self): """ Incrémente les sauts de ronde, si les sauts sont supérieurs à seuil, commence un nouveau tour. """ if self.round: new_round = self.round.skip() self.round.chat.update_chat( f"Player has votes to skip ({self.round.skips}/{len(self.players) -2})" ) if new_round: self.round.chat.update_chat(f"Round has been skipped.") self.round_ended() return True return False else: raise Exception("No round started yet!") def round_ended(self): """ Si le tour se termine, appelez-le """ self.round.chat.update_chat(f"Round {self.round_count} has ended.") self.start_new_round() self.board.clear() def update_board(self, x, y, color): """ appelle la méthode de mise à jour à bord. """ if not self.board: raise Exception("No board created") self.board.update(x, y, color) def end_game(self): """ arreter le jeu :return: """ print(f"[GAME] Game {self.id} ended") for player in self.players: player.game = None def get_word(self): """ donne un mot qui n'a pas encore été utilisé :return: str """ with open("words.txt", "r") as f: words = [] for line in f: wrd = line.strip() if wrd not in self.words_used: words.append(wrd) self.words_used.add(wrd) r = random.randint(0, len(words) - 1) return words[r].strip()
def __init__(self, id): """ Initialize the Game """ self.id = id self.currentRound = Round() self.points = 0
def test_repr(self): round1 = Round(TestRound.room1, 1) self.assertEqual(repr(round1), '1')
def round(self): r = Round(self.set_dealer()) cards = list(self.cards) r.deal_cards(cards, self.players) # While loop continues until all players are out of cards or player wants to quit game while not r.check_end(self.players): # the.play() returns -1 when player wants to quit game if r.the_play() == -1: return -1 r.change_player(self.players) r.calculate_points(self.players) r.empty_players_decks(self.players)
def test_eq_diff_types(self): round1 = Round(TestRound.room1, 1) round2 = 'I am a string' self.assertNotEqual(round1, round2)
def test_methods(self): game = Game() game.initialize_cards() game.players = [ Player("Mike"), Player("Tim"), Player("Jack"), Player("Nick") ] # Points for Mike game.players[0].cards_deck = game.cards[0:26] # Points for Tim game.players[1].cards_deck = game.cards[26:37] # Points for Jack game.players[2].cards_deck = game.cards[37:49] # Points for Nick game.players[3].cards_deck = game.cards[49:52] rnd = Round(game.players[0]) game.players[1].mokki = 2 rnd.calculate_points(game.players) # Check that the points of each player is correct self.assertEqual(4, game.players[0].points, "Wrong amount of points!") self.assertEqual(3, game.players[1].points, "Wrong amount of points!") self.assertEqual(1, game.players[2].points, "Wrong amount of points!") self.assertEqual(3, game.players[3].points, "Wrong amount of points!") # Check that the validation algorithm works properly self.assertEqual( True, Round.check_validity( self, Card("Pata-7", 7, 7), [Card("Ruutu-3", 3, 3), Card("Hertta-4", 4, 4)]), "Validation failed") self.assertNotEqual( True, Round.check_validity( self, Card("Pata-8", 8, 8), [Card("Ruutu-3", 3, 3), Card("Hertta-4", 4, 4)]), "Validation failed") self.assertEqual( True, Round.check_validity( self, Card("Pata-2", 2, 15), [Card("Pata-8", 8, 8), Card("Hertta-7", 7, 7)]), "Validation failed") self.assertNotEqual( True, Round.check_validity(self, Card("Pata-10", 10, 10), [ Card("Ruutu-5", 5, 5), Card("Hertta-5", 5, 5), Card("Pata-5", 5, 5) ]), "Validation failed") # Check that the dealer changes correctly after each round game.set_dealer() self.assertEqual(game.players[0], game.dealer, "Wrong dealer!") game.set_dealer() self.assertEqual(game.players[1], game.dealer, "Wrong dealer!") game.set_dealer() game.set_dealer() game.set_dealer() self.assertEqual(game.players[0], game.dealer, "Wrong dealer!")
def test_eq_diff_numbers(self): round1 = Round(TestRound.room1, 1) round2 = Round(TestRound.room1, 2) self.assertNotEqual(round1, round2)
def startNextRound(self): """ Start the Next Round """ nextWordLength = GetNextLength(self.currentRound.wordLength) self.currentRound = Round(wordLength=nextWordLength)