def start_game(player1, player2, player3, player4, player1color, player2color, player3color, player4color): screen = Screen(900, 900, 90) screen.start_board_display() player1 = Player(player1, player1color) player1.initialize_pieces(screen) player2 = Player(player2, player2color) player2.initialize_pieces(screen) player3 = Player(player3, player3color) player3.initialize_pieces(screen) player4 = Player(player4, player4color) player4.initialize_pieces(screen) board = Board(screen) # board.draw() running = True while running: board.draw() player1.L5.draw() screen.display_update(board.board_rectangle) pygame.display.update(board.board_rectangle) for event in pygame.event.get(): if event.type == pygame.QUIT: running = False
def process(): global root_path, output_path, shape, matrix matrix = cut_matrix(matrix) # cut matrix by empty rows matrix = cut_matrix(transpose(matrix)) # cut matrix by empty columns board = Board(matrix) out_file = open(root_path + output_path, "w") out_file.write(str(board.run())) out_file.close()
def main(): # print("Kiwi") game_gestion = Board() try: ### A supprimer ### # test_board = Board() # test_board.new(30) # test_board.board[14][18] = 2 # test_board.board[15][15] = 1 # test_board.board[18][18] = 1 # test_board.board[13][14] = 1 # test_board.show() # print(bk.IA_decision(test_board)) while (True): cmd = input() # print(game_gestion.Board.board) # game_gestion.Board = Board(2,2) # print(game_gestion.Board.board) code = parse(cmd, game_gestion) # print(game_gestion.Board.board) if (code == 84): return 84 if (code == 1): break # game_gestion.show() except KeyboardInterrupt: return 0 return 0
def select_best_move(board, dice, player_main, player_opponent, n_iter=10000): _moves_and_games_cnt, _moves_and_wins_cnt = {}, {} for i in range(n_iter): _board, pieces_position = Board(given_board=board).initialize() piece, new_position = player_main.choose_piece_and_position( pieces_position, _board, given_dice=dice) _moves_and_games_cnt[(piece, new_position)] = _moves_and_games_cnt.get( (piece, new_position), 0) + 1 player_main.play(_board, pieces_position, given_piece_and_position=(piece, new_position)) while True: if player_main.won: _moves_and_wins_cnt[(piece, new_position)] = _moves_and_wins_cnt.get( (piece, new_position), 0) + 1 break player_opponent.play(_board, pieces_position) if player_opponent.won: break player_main.play(_board, pieces_position) player_main.won, player_opponent.won = False, False try: _moves_and_probabilities_of_win = {} for k, v in _moves_and_wins_cnt.items(): probability = v / _moves_and_games_cnt[k] _moves_and_probabilities_of_win[k] = probability (best_piece, best_position), win_probability = sorted( _moves_and_probabilities_of_win.items(), key=lambda x: x[1], reverse=True)[0] except: best_piece, best_position, win_probability = piece, new_position, 0 return (best_piece, best_position, win_probability)
def readInBoard(): print( "Please enter each row of letters (one row at a time) in the format \"a b c d\"" ) inputLetters = [] for i in range(4): while (True): letters = input("Row %d of letters:\t" % (i + 1)) letters = letters.lower() lettersSplit = letters.split() allSingleChar = True for l in lettersSplit: if len(l) > 1: allSingleChar = False if allSingleChar: if len(lettersSplit) == 4: # if exactly 4 single letters entered break print("Invalid input. Please type that row again.") for letter in lettersSplit: inputLetters.append(letter) letterObjs = [] for i in range(len(inputLetters)): letterObjs.append(Letter(inputLetters[i], i)) board = Board(letterObjs) return board
def get_available_center_point(self, board: Board): x = board.rows // 2 y = board.cols // 2 if board.get(x, y) == 0: return x, y else: return x+1, y+1
def parse_moves_coords(board, piece, coords_new): _, pieces_position = Board(given_board=board).initialize() coords_until_now = pieces_position[piece] _str = '' _str += chr(-coords_until_now[1] + 101) _str += chr(-coords_until_now[0] + 101) _str += chr(-coords_new[1] + 101) _str += chr(-coords_new[0] + 101) return _str
def run(self) -> None: pygame.init() self.canvas = pygame.display.set_mode(self.screenSize.as_tuple()) pygame.display.set_caption('Conway Game of Life') self.clock = pygame.time.Clock() self.board = Board(self.boardSize) self.gameLoop() pygame.quit()
def initialize_game(pl1, pl2, winning_points): pl1_human = pl1['type'] == 'human' pl2_human = pl2['type'] == 'human' board = Board( pl1_human, pl2_human, winning_points, pl1_params=pl1.get('parameters'), pl2_params=pl2.get('parameters') ) return board
def create_next_grid(row_rand, col_rand, val): """ Function to add a new Board object to the list Grid_List, and update the new Board with the random choice value """ Grid_List.append(Board(grid=copy.deepcopy(Grid_List[-1].value))) for col in xrange(0, 9): Grid_List[-1].Cols[col].get_cells() Grid_List[-1].get_cell_ranges() Grid_List[-1].update(row=row_rand, col=col_rand, val=val)
def initBoard(): # Object Game Board try: del Program.board except: pass Program.board = Board(Program.screen.frameBoard) Program.board.drawBoard() Program.canvas = Program.board.canvas Program.movesCounter = 1 Program.definePlayerTurnsAndPlayers() Program.gameFlow()
def solve_puzzles(puzzles, solver): """ Solves an array of sudoku puzzles, recording runtime. :param puzzles: an array of 2D array boards :param solver: the CSP solver to be used :return: none """ fail_count = 0 start_time = datetime.now() # start timer (for runtime) for puzzle in puzzles: # initialize Board b = Board(puzzle) sudoku = Problem(solver) # initialize CSP with custom solver # add variables for each square, indexed 1...size^2 for index in range(b.board_size ** 2): value = b.get_value(index) if value == 0: sudoku.addVariable(index, range(1, b.board_size + 1)) else: sudoku.addVariable(index, [value]) # add uniqueness constraints to each row, column, and subsquare for i in range(b.board_size): sudoku.addConstraint(AllDifferentConstraint(), [el[0] for el in b.row(i)]) sudoku.addConstraint(AllDifferentConstraint(), [el[0] for el in b.col(i)]) sudoku.addConstraint(AllDifferentConstraint(), [el[0] for el in b.subsquare(i)]) sln = sudoku.getSolution() # solve CSP if sln: # assign solved values for index, value in sln.items(): b.set_value(index, value) else: fail_count += 1 # perform/display runtime calculation runtime = datetime.now() - start_time print("Runtime: {} seconds ({} failed)".format(runtime.total_seconds(), fail_count))
def create_specimen(offsprings=None, intelligent=False): global current_specimen_num global board_pieces global board_width global board_height global num_collisions global best_specimen global worst_specimen global score clear() for x in range(0, board_height): column = [] for y in range(0, board_width): column.append(Tile(board, x, y)) empty_spaces.append([x, y]) board_pieces.append(column) place_barriers(barrier_placement) place_queens(locations=offsprings, intelligent=intelligent) for queen in queen_locations: num_collisions += len( board_pieces[queen[0]][queen[1]].get_total_queen_path()) if queen_count == 0: score = -9999 else: score = queen_count - num_collisions current_specimen = Board.Board(current_specimen_num, queen_count, num_collisions, score, board_pieces, queen_locations, barrier_locations, empty_spaces) current_generation.append(current_specimen) if best_specimen is None or best_specimen.get_score( ) < current_specimen.get_score(): best_specimen = current_specimen if worst_specimen is None or worst_specimen.get_score( ) > current_specimen.get_score(): worst_specimen = current_specimen current_specimen_num += 1
def get_free_point_around(self, board: Board, x: int, y: int): while True: if board.get(x, y) == 0: return x, y
from classes import Board from backtracking import backtracking #https://dlbeer.co.nz/articles/sudoku.html def board_loader(board): with open(board) as f: board = csv.reader(f) board = [i for i in board] return board if __name__ == "__main__": board = sys.argv[1] board = board_loader(board) board = Board(board) sol = backtracking(board, 0) if sol: total = sol[0] moves = sol[1:] for i in moves: board.board[i[0]][i[1]] = i[2] print("success") else: print("fail")
current_turn = 2 elif current_turn == 2: position = player2.ask_for_input() board.fill(position, player2.symbol) current_turn = 1 board.print_board() winner = board.check_for_winner() if winner != "": if winner == "X": print("The winner is {}".format(player1.name)) elif winner == "O": print("The winner is {}".format(player2.name)) break def ask_for_names(): name1 = str(input("Enter the name of the first player.(X): ")) name2 = str(input("Enter the name of the second player.(O): ")) return [name1, name2] if __name__ == "__main__": names = ask_for_names() player1 = Player(names[0], "X") player2 = Player(names[1], "O") board = Board(player1.name, player2.name) start_game(board, player1, player2)
pygame.init() score = 0 cells = 70 y_pos = 40 x_pos = 40 route = 2 count = 0 pause = False v = 100 screen = pygame.display.set_mode((cells * size + 20, cells * size + 20)) pygame.display.flip() board = Board(cells) ball = Ball(x_pos, y_pos) status = Status(screen) clock = pygame.time.Clock() running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False elif status.game not in start_or_stop and event.type == pygame.MOUSEBUTTONDOWN: if event.button == 1: if board.get_coord( event.pos) is not None and board.get_coord( event.pos) not in board.walls:
from classes import Board from models import Products, Substitutes from constants import CATEGORIES_ARRAY, INTRO_TEXT import random # class instanciation intro = Board() # first display of console intro.display(INTRO_TEXT, "Choisissez ce que vous voulez faire") # Select a new food or browse your replaced food list if intro.get_input("number") == str(1): intro.display(CATEGORIES_ARRAY, "Les categories sont :") else: substitute_list = Products.select().join(Substitutes).where( Products.id == Substitutes.food_id) intro.display(substitute_list, "Vos aliments dejà substitués sont : ", True) # select a category answer = "0" if answer.isdigit() is False: print("Ce n'est pas un chiffre, veuillez selectionner un chiffre") answer = intro.get_input("category") else: answer = intro.get_input("category") # make db requests cat_foods = Products.select().where(Products.category_id == int(answer),
def initUI(self): self.setWindowTitle(self.title) self.setGeometry(self.left, self.top, self.width, self.height) #number to place self.selected_num = 0 #background white self.setAutoFillBackground(True) p = self.palette() p.setColor(self.backgroundRole(), Qt.white) self.setPalette(p) #empty grid self.grid_label = QLabel(self) self.grid_size = 400 self.num_size = 400 / 9 #para el tamaño de los numeros self.grid_pixmap = QPixmap('Assets/background6.png').scaled( self.grid_size, self.grid_size) self.grid_label.setPixmap(self.grid_pixmap) self.resize(self.grid_size + 200, self.grid_size) self.num_img = {i: f'Assets/nums4/{i}.png' for i in range(0, 10)} self.num_img2 = {i: f'Assets/nums3/{i}.png' for i in range(0, 10)} #buttons self.buttons = {} for i in range(9): self.buttons[i] = QPushButton("", self) self.buttons[i].setCheckable(True) self.buttons[i].clicked[bool].connect(self.make_selected(i + 1)) self.buttons[i].setIcon(QIcon(self.num_img2[i + 1])) #self.buttons[i]1.setIconSize(QSize(24,24)) self.buttons[i].setGeometry(420, 20 + 41 * i, 60, 30) self.buttons[i].show() #initialize board self.board = Board(board) self.cells = {} for i in range(9): for j in range(9): num = self.board.board[i][j] #si no viene en el original se puede cambiar if num == 0: self.cells[(i, j)] = ClickLabel(self) self.cells[(i, j)].clicked.connect(self.on_product_clicked) else: # label = QLabel(self) # label.move(self.num_size*0.9*i+25, self.num_size*0.9*j+22) # pixmap2 = QPixmap("Assets/color.png").scaled(self.num_size*0.7,self.num_size*0.7) # label.setPixmap(pixmap2) # label.show() self.cells[(i, j)] = QLabel(self) # x width y altura self.cells[(i, j)].move(self.num_size * 0.9 * i + 25, self.num_size * 0.9 * j + 23) pixmap = QPixmap(self.num_img[num]).scaled( self.num_size * 0.7, self.num_size * 0.7) self.cells[(i, j)].setPixmap(pixmap) self.cells[(i, j)].show() self.show()
def main(): game_running = True # обрабатывает двойные нажатия clock = pg.time.Clock() timer = 0 dt = 0 # Доска | RC - количество клеток в рэндзю cell_size = HEIGHT // (RC + 1) board = Board(RC, RC) board.set_view(cell_size // 2, cell_size // 2, (HEIGHT - cell_size) // RC) board.set_screen(renju_screen) # для заднего фона bg = BackgroundBlink(STARS) pg.time.set_timer(CHANGE_BACKGROUND, 12000) pg.time.set_timer(DARKNESS_TICK, 6000 // 200) while game_running: if board.time >= 5000 // 150 or not board.win: pg.time.set_timer(WINNER_CONGRATULATIONS, 0) # изображение на заднем фоне renju_screen.blit(background, (0, 0)) for event in pg.event.get(): if event.type == pg.QUIT: game_running = False if event.type == pg.MOUSEBUTTONDOWN and event.button == 1: board.button_click(event.pos, 'down') # Надо обработать двойное нажатие левой кнопки if event.type == pg.MOUSEBUTTONUP and event.button == 1: if timer == 0: timer = 0.001 elif timer < 0.3: if not board.win: board.get_click(event.pos) timer = 0 board.button_click(event.pos, 'up') if board.win: pg.time.set_timer(WINNER_CONGRATULATIONS, 150) elif event.type == pg.MOUSEMOTION: board.button_check(event.pos) elif event.type == CHANGE_BACKGROUND: bg.update() elif event.type == DARKNESS_TICK: bg.change_darkness() elif event.type == WINNER_CONGRATULATIONS: board.congrats_wnr() if timer != 0: timer += dt if timer >= 0.3: timer = 0 bg.show_stars(renju_screen) board.render(renju_screen) dt = clock.tick() / 1000 pg.display.flip() pg.quit()
import pygame from config import Cfg as cfg from classes import Area, BlitList, MenuButton, Board # Game Init, Screen/Display, and Clock pygame.init() pygame.display.set_caption(cfg.APPLICATION_TITLE) screen = pygame.display.set_mode((cfg.WIDTH, cfg.HEIGHT)) clock = pygame.time.Clock() # Game Blit Objects menu = Area(size=cfg.MENU_SIZE, coords=cfg.MENU_COORDS, color=cfg.SILVER) board = Board(size=cfg.BOARD_SIZE, coords=cfg.BOARD_COORDS, color=cfg.WHITE) play_btn = MenuButton(parent=menu, img_loc="./img/play.png", nth_pos=1) pause_btn = MenuButton(parent=menu, img_loc="./img/pause.png", nth_pos=2) trash_bin = MenuButton(parent=menu, img_loc="./img/trash-bin.png", nth_pos=3) menu_btns = [play_btn, pause_btn, trash_bin] blit_list = BlitList(objs=[ menu.main_blit, board.main_blit, play_btn.main_blit, pause_btn.main_blit, trash_bin.main_blit, ]) def main(): app_running = True sim_running = False sim_rate = 5
class Game: """ Contains the Game Playing Logic """ def __init__(self): self.board = Board() self.human = HumanPlayer(self.board) self.computer = ComputerPlayer(self.board) self.next_player = None self.winner = None def select_player_counter(self): """ Let the player select their counter """ counter = '' while not (counter == 'X' or counter == 'O'): print('Do you want to be X or O?') counter = input().upper() if counter != 'X' and counter != 'O': print('Input must be X or O') if counter == 'X': self.human.counter = X self.computer.counter = O else: self.human.counter = O self.computer.counter = X def select_player_to_go_first(self): """ Randomly selects who will play first - the human or the computer.""" if random.randint(0, 1) == 0: self.next_player = self.human else: self.next_player = self.computer def play(self): """ Main game playing loop """ print('Welcome to TicTacToe') self.select_player_counter() self.select_player_to_go_first() print(self.next_player, 'will play first first') while self.winner is None: # Human players move if self.next_player == self.human: print(self.board) print('Your move') move = self.human.get_move() self.board.add_move(move) if self.board.check_for_winner(self.human): self.winner = self.human else: self.next_player = self.computer # Computers move else: print('Computers move') move = self.computer.get_move() self.board.add_move(move) if self.board.check_for_winner(self.computer): self.winner = self.computer else: self.next_player = self.human # Check for a winner or a draw if self.winner is not None: print('The Winner is the ' + str(self.winner)) elif self.board.is_full(): print('Game is a Tie') break print(self.board)
def main(): board = Board() player_turn = False choice = True turn_choice = '' move = '' player_kings = 2 npc_kings = 2 game_over = False while(not game_over): while(choice): turn_choice = input("Please select your turn (1 or 2): ") if(turn_choice == '1'): player_turn = True choice = False elif(turn_choice == '2'): player_turn = False choice = False else: print('Your input is not an integer 1 or 2. Please try again.\n') # Call move Generator board.print_board() # Players take turns if(player_turn): # Print Legal Player Moves legal_moves = board.generate_moves(player_turn) # Opponent wins of no playable moves if not legal_moves: game_over = True board.print_board() print('-----------------------------------') print(' GAME OVER') print(' NO PLAYER LEGAL MOVES REMAINING') print(' OPPONENT WINS') print('-----------------------------------') break print(legal_moves) # Player makes move move = input('Enter your move: ') while(move not in legal_moves): move = input('Please enter a valid move: ') print('Your move: %s\n' % move) board.make_move(move) npc_kings = board.update_kings(player_turn) if(npc_kings == 0): game_over = True board.print_board() print('-------------------------------') print(' GAME OVER') print(' ALL OPPONENT KINGS CAPTURED') print(' PLAYER WINS') print('-------------------------------') break player_turn = False else: # NPC Move Generator (returns list of legal moves) legal_moves = board.generate_moves(player_turn) # Player wins if no playable moves if not legal_moves: game_over = True board.print_board() print('-------------------------------------') print(' GAME OVER') print(' NO OPPONENT LEGAL MOVES REMAINING') print(' PLAYER WINS') print('-------------------------------------') break print(legal_moves) # NPC Evaluates Moves # val = board.eval() # NPC makes move """ # Optional Player 2 Input move = input('Enter your move: ') while(move not in legal_moves): move = input('Please enter a valid move: ') """ # move = random.choice(legal_moves) RANDOM MOVES best_move = board.minimax(player_kings, npc_kings, player_turn) print(legal_moves) print('Best Move:') print(best_move) if best_move: best_move_trans = board.translate_move(best_move) print('Computer move: %s (%s)\n' % (best_move, best_move_trans)) # board.make_move(best_move) player_kings = board.update_kings(player_turn) if(player_kings == 0): game_over = True board.print_board() print('-----------------------------') print(' GAME OVER') print(' ALL PLAYER KINGS CAPTURED') print(' OPPONENT WINS') print('-----------------------------') break else: game_over = True board.print_board() print('-------------------------------------') print(' GAME OVER') print(' NO OPPONENT LEGAL MOVES REMAINING') print(' PLAYER WINS') print('-------------------------------------') break player_turn = True # Check legality of move # Compare list of legal moves to user input if(move == 'stop'): game_over = True
def __init__(self): self.board = Board() self.human = HumanPlayer(self.board) self.computer = ComputerPlayer(self.board) self.next_player = None self.winner = None
class Game: def __init__(self, player_amount, field_amount): self.field_amount = field_amount self.player_amount = player_amount self.game_board = Board(player_amount, field_amount) def roll(self): """ method to roll the dice, returns the dice eye """ return random.randint(1, 6) def start_game(self): no_winner = True players = [] for i in range(self.player_amount): player = Player("Player-{}".format(i), "Color-{}".format(i)) self.game_board.register_player(player) players.append(player) # game loop logger.info("Starting new game") while no_winner: for player in players: # increment player turns player.turns += 1 logger.info("Player {}, Turn {}:".format( player.name, player.turns)) logger.debug( "Player data before turn: start figures: {}, finished figures: {}" .format(reveal_name(player.start_figures), reveal_name(player.finished_figures))) # grab players figures from cemetery player.grab_figures_from_cemetery(self.game_board) # check for player's figures on board if player.has_figures_on_board(self.game_board): if self.roll() == 6 and len(player.start_figures) != 0: player.place_figure(self.game_board) player.move_figure(self.game_board, self.roll()) # player has no figure on board else: # three chances to roll a 6 for i in range(3): if self.roll() == 6: # place new figure player.place_figure(self.game_board) # move figure player.move_figure(self.game_board, self.roll()) break # count finished figures to evaluate win condition finished_figures = [ figure for figure in player.finished_figures if hasattr(figure, "name") ] if len(finished_figures) == 4: no_winner = False logger.info( "Player {} won the game after {} turns!".format( player.name, player.turns)) break logger.debug( "Player data after turn: start figures: {}, finished figures: {}" .format(reveal_name(player.start_figures), reveal_name(player.finished_figures))) # debug output of board fields logger.debug("Board fields after turn: {}".format( self.game_board.display_board()))
def __init__(self, player_amount, field_amount): self.field_amount = field_amount self.player_amount = player_amount self.game_board = Board(player_amount, field_amount)
test_dir = os.path.join('D:\\', 'GitHub', 'Sudoku-Solver', 'Tests') code_dir = os.path.join('D:\\', 'GitHub', 'Sudoku-Solver') os.chdir(test_dir) test_inputs = iter((filename, filename.split('incomplete')[1]) for filename in os.listdir(os.curdir) if 'incomplete' in filename) counter = 0 time_base = time.time() for filename in test_inputs: with open(filename[0]) as f: counter += 1 reader = csv.reader(f, delimiter=' ') grid_init = [list(map(int, num)) for num in reader] Grid_List = [] Grid = Board(grid=grid_init) for col in xrange(0, 9): Grid.Cols[col].get_cells() Grid.get_cell_ranges() record_random = [] Grid_List = [Grid] os.chdir(code_dir) solved = solve() if solved[1][-1].is_valid() and solved[1][-1].is_complete(): print "Test {} PASSED. Time taken so far: {}. {} random inserts. Final random insert depth: {}".format( counter, time.time() - time_base, solved[2], len(solved[1]) - 1) else:
for event in pygame.event.get(): if event.type == pygame.QUIT: self.quit() if event.type == pygame.MOUSEBUTTONDOWN: if event.button == LEFT: pass elif event.button == RIGHT: pass def draw_menu(self): pass # --------------------------------------------------------------------------- board = Board(10, 10) # -------- Main Program Loop ----------- # Loop until the user clicks the close button. done = False first_click = True while not done: # --- Main event loop ''' Detecting double clicks: at a guess, instead of processing each click immediately, apply a 50ms delay and see if you get another click event in that time. The user probably won't notice the 50ms delay. ''' for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user clicked close done = True # Flag that we are done so we exit this loop
from classes import Board from classes import Player from classes import Computer movenum = 0 winner = "" b = Board() p = Player(b.board_values) c = Player(b.board_values) bv = b.board_values computer = Computer(c, b, bv) print("Welcome to Ben's AI tic tac toe game.") print("You are X and the computer is O.") print( "You will enter a move number from 1-9 starting at the top left of the board" ) start = "0" while start != "1": start = input("Press 1 to start:") if start == '1': while movenum < 9 and winner == "": p.playermove() print("") print("Your move") b.drawboard() movenum += 1 if computer.testwin('x') == 'yes': winner = 'human'
def simulate_game(player_amount, figure_amount, field_amount, roll_duration, move_duration): # game init no_winner = True game_board = Board(player_amount, field_amount) players = [] for i in range(player_amount): player = Player("Player-{}".format(i), "Color-{}".format(i), figure_amount) game_board.register_player(player) players.append(player) # game loop logger.info("Starting new game simulation..") while no_winner: for player in players: # increment player turns player.turns += 1 logger.info("Player {}, Turn {}:".format(player.name, player.turns)) logger.debug( "Player data before turn: start figures: {}, finished figures: {}" .format(reveal_name(player.start_figures), reveal_name(player.finished_figures))) # grab players figures from cemetery player.grab_figures_from_cemetery(game_board) # check for player's figures on board if player.has_figures_on_board(game_board): if player.roll(roll_duration) == 6 and len( player.start_figures) != 0: player.place_figure(game_board) player.move_figure(game_board, player.roll(roll_duration), move_duration) # player has no figure on board else: # three chances to roll a 6 for i in range(3): if player.roll(roll_duration) == 6: # place new figure player.place_figure(game_board) # move figure player.move_figure(game_board, player.roll(roll_duration), move_duration) break # count finished figures to evaluate win condition finished_figures = [ figure for figure in player.finished_figures if hasattr(figure, "name") ] if len(finished_figures) == player.figure_amount: no_winner = False total_real_playtime = sum( [player.real_playtime for player in players]) / 60 total_real_playtime = round(total_real_playtime, 2) amount_of_six_stats = [ player.amount_of_six for player in players ] total_dice_eye_stats = [ player.total_roll for player in players ] player_names = [player.name for player in players] aos = pd.DataFrame(amount_of_six_stats, index=player_names, columns=["amount"]) tde = pd.DataFrame(total_dice_eye_stats, index=player_names, columns=["sum"]) logger.info("Player {} won the game after {} turns!".format( player.name, player.turns)) st.success( "Player {} won the game after {} turns and {} rolls!". format(player.name, player.turns, player.roll_turns)) st.info( "By using this simulator you saved {} minutes of your life avoiding playing senseless games! :)" .format(total_real_playtime)) st.subheader("Sum of dice eyes per player") st.bar_chart(tde) st.subheader("Total amount of dice eye 6 rolls per player") st.bar_chart(aos) break logger.debug( "Player data after turn: start figures: {}, finished figures: {}" .format(reveal_name(player.start_figures), reveal_name(player.finished_figures))) # debug output of board fields logger.debug("Board fields after turn: {}".format( reveal_name(game_board.fields)))