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