def setup(self): self.pygame.init() self.pygame.font.init() self.pygame.display.set_caption("TGMastermind!") self.mastermind = Mastermind(self) self.view = View(self) self.playing = True self.carryOn = True
def main(): guess_length_rule = GuessLengthRule() valid_colour_rule = ValidColourRule() rules = [guess_length_rule, valid_colour_rule] input_validator = InputValidator(rules) hint_checker = HintChecker() mastermind = Mastermind(input_validator, hint_checker) mastermind.play()
def __init__(self): self.board = Mastermind(size=4, min_value=1, max_value=3) self.board_size = self.board.size self.min = 1 self.max = 9 self.known = {} self.existed = set() self.cannot = {i: set() for i in range(self.board_size)} self.not_existed = set()
def __init__(self): self.HEIGHT, self.WIDTH = 400, 600 self.BLACK = (0, 0, 0) self.WHITE = (255, 255, 255) self.game = Mastermind() self.size = self.game.size #Initialize the window pygame.init() self.screen = pygame.display.set_mode((self.WIDTH, self.HEIGHT)) pygame.display.set_caption("Mastermind 1.0") self.screen.fill((self.BLACK))
def eval_genomes(genomes, config): solution = [random.randint(1, 4) for i in range(4)] solution_2 = [random.randint(1, 4) for i in range(4)] for genome_id, genome in genomes: genome.fitness = 4.0 net = neat.nn.FeedForwardNetwork.create(genome, config) ## master mind mm = Mastermind(4, 8, solution) mm_2 = Mastermind(4, 8, solution_2) hints_table = mm.play_neat_bot(net, show_board=False) hints_table_2 = mm_2.play_neat_bot(net, show_board=False) genome.fitness += float(fitness_function(hints_table)) genome.fitness += float(fitness_function(hints_table_2))
def launch(self): self.draw_guessing_squares(text="Your test") hist_board = self.draw_scoreboard(0, text1="AI guesses: ", text2="AI past guesses") previous = 0 turn = 0 while True: for event in pygame.event.get(): if event.type == pygame.MOUSEBUTTONDOWN: pos = pygame.mouse.get_pos() #Handling the clicking of the squares for i, square in enumerate(self.buttons): if square.collidepoint(pos): self.draw_outline(self.buttons[previous], self.BLACK) self.draw_outline(square, self.GREEN) previous = i if event.type == pygame.QUIT: pygame.quit() return False #The user enters from a keyboard if event.type == pygame.KEYDOWN: output = self.keyboard_pressed(event) if isinstance(output, int): self.draw_entered_guess(output, self.buttons[previous]) #Handling error #TODO if output > 5: #Do something pass #If the answer is not full, then raise an error self.answer[previous] = output if output == "left": self.draw_outline(self.buttons[previous], self.BLACK) previous -= 1 if previous == -1: previous = self.board_size - 1 self.draw_outline(self.buttons[previous], self.GREEN) if output == "right": self.draw_outline(self.buttons[previous], self.BLACK) previous += 1 if previous == self.board_size: previous = 0 self.draw_outline(self.buttons[previous], self.GREEN) if output == "delete": self.draw_entered_guess(None, self.buttons[previous]) if output == "submit": min_val = min(self.answer) max_val = max(self.answer) size = len(self.answer) board = Mastermind(size=size, min_value=min_val, max_value=max_val, rand=False) board.set_board(self.answer) self.AI.set_board(board) guesses = self.AI.solve() hist_board = self.draw_scoreboard( len(guesses), text1="AI guesses: ", text2="AI past guesses") for i in range(len(guesses)): self.draw_past_guess(guesses[i], i + 1, hist_board) self.winning(text="AI solves it!")
file.close() def open_table(file_name, newline=''): #A function to open a Q-table stored in a csv file file = open(file_name, 'r') q_temp = dict() for row in csv.reader(file, delimiter=';'): q_temp[row[0]] = [float(row[k + 1]) for k in range(1296)] file.close() return (q_temp) if __name__ == "__main__": env = Mastermind() #RL = Sarsa(q_table = open_table(file_name="learnt_table_SARSA_passed.csv"), is_qtable=True) #Remove the comment mode if you want to use an already saved Q-table. RL = Sarsa() n_epochs = 100000 #update(n_epochs) #Remove the comment mode to directly train the agent #save_table(RL.q_table) #Remove the comment mode to save the table perf_episode = n_epochs // 10000 for k in range(perf_episode + 1): t1 = time.time() print('After ', k * 10000, ' epochs') test_perf(10000) update(10000)
def test_check_guess_b(self): code = [1,1,2,2] guess = [2,2,5,5] master = Mastermind(positions=4, colors=6, code=code) self.assertEqual(master.check_guess(guess), (0,2))
def test_check_guess_wrong_all(self): code = [1,1,1,1] guess = [2,2,2,2] master = Mastermind(positions=4, colors=6, code=code) self.assertEqual(master.check_guess(guess), (0,0))
def testGame(guess, solution): a_game = Mastermind() a_game.pegs = Mastermind.pegs[:] + ["EMPTY"] a_game.guess = guess a_game.solution = solution return a_game.checkGuess()
# winner_net = p.run(eval_genomes, 2) solution = [random.randint(1, 8) for i in range(4)] solutions = [[1, 3, 4, 2], [1, 4, 1, 4], [2, 1, 1, 3], [4, 1, 3, 2]] solutions = list(itertools.product([1, 2, 3, 4], repeat=4)) solutions = [list(sol) for sol in solutions] how_many_win = 0 def game_won(hints_table): winner = False winning_round = None # 0, 1, ... for i, row in enumerate(hints_table): if all(hint == 2 for hint in list(row)): winner = True winning_round = i break return winner for s in solutions: mm = Mastermind(4, 8, s) hints_table = mm.play_neat_bot(winner_net, win_show=True, show_board=False) if game_won(hints_table): how_many_win += 1 print("NN won {0} times per {1} possible.".format(how_many_win, 256)) # p = neat.Checkpointer.restore_checkpoint('neat-checkpoint-299') # p.run(eval_genomes, 10)
def test_return_a_list_of_0_and_4_for_all_misplaced_colors(self): self.assertEqual( Mastermind.call(BASIC_SECRET, ['yellow', 'red', 'green', 'blue']), [0, 4])
class MastermindAI(): def __init__(self): self.board = Mastermind(size=4, min_value=1, max_value=3) self.board_size = self.board.size self.min = 1 self.max = 9 self.known = {} self.existed = set() self.cannot = {i: set() for i in range(self.board_size)} self.not_existed = set() def set_board(self, board): self.board = board self.board_size = board.size def make_guess(self): """ Make a guess based on current knowledge """ guess = [0] * self.board_size for i in range(self.board_size): possible_values = [] #If a position is known to be correct: if i in self.known: guess[i] = self.known[i] #If not, check for other conditions else: for value in range(self.min, self.max + 1): if value in self.cannot[i] or value in self.not_existed: pass else: possible_values.append(value) #Make a random choice from the possible values guess[i] = np.random.choice(possible_values) return guess def solve(self): turn = 0 guesses = [] print("The board: ", self.board.board) done = False while not done: guess = self.make_guess() guesses.append(guess) print(f"The AI guesses: {guess}") #Check for results results = self.board.check(guess) print(f"The results the AI gets: {results}") if np.all(results == ([2] * self.board_size)): done = True pass #Append new knowledge for i, result in enumerate(results): if result == 2: self.known[i] = guess[i] self.existed.add(guess[i]) elif result == 1: self.existed.add(guess[i]) self.cannot[i].add(guess[i]) else: self.not_existed.add(guess[i]) return guesses
guess = self.make_guess() guesses.append(guess) print(f"The AI guesses: {guess}") #Check for results results = self.board.check(guess) print(f"The results the AI gets: {results}") if np.all(results == ([2] * self.board_size)): done = True pass #Append new knowledge for i, result in enumerate(results): if result == 2: self.known[i] = guess[i] self.existed.add(guess[i]) elif result == 1: self.existed.add(guess[i]) self.cannot[i].add(guess[i]) else: self.not_existed.add(guess[i]) return guesses if __name__ == "__main__": board = Mastermind(size=4, min_value=1, max_value=4) AI = MastermindAI(board) AI.solve()
from mastermind import Mastermind print("Enter the size of the game:", end=" ") size = int(input()) mm = Mastermind(size) mm.declare_pegs() game = mm.game_over while not game: guess = mm.ask_user() mm.print_matches(guess) game = mm.game_over print("You won")
from builtins import print from util import pretty_name_8_colors, colour_mapping from mastermind import Mastermind from argparser import parser import sys class InvalidStateException(Exception): pass args = parser.parse_args() game_solver = Mastermind(args.k, args.n) print("Welcome to Mastermind interactive solver.") print( "Please think of a code combination containing {} pegs from {} colors ({})." .format(args.n, args.k, ", ".join(list(colour_mapping.values())[:args.k]))) print("\n") # number of red and white pegs from the opponent's response w, r = 0, 0 all_combinations = game_solver.all_possible_combinations possible_combinations = game_solver.all_possible_combinations attempt = game_solver.initial_attempt num_attempts = 0 try: while r != args.n: num_attempts += 1 print("Attempt {} is {}.".format(num_attempts,
def testGame(guess, solution): a_game = Mastermind() a_game.pegs = Mastermind.pegs[:] + ['EMPTY'] a_game.guess = guess a_game.solution = solution return a_game.checkGuess()
from mastermind import Mastermind import random import numpy as np MAX_NUMBER = 6 MAX_ITER = 5000 if __name__ == '__main__': solution = [random.randint(1,MAX_NUMBER) for i in range(4)] mm = Mastermind(4, 8, solution, MAX_NUMBER) mm.play_swaszek() #results = [] #for i in range(MAX_ITER): # solution = [random.randint(1,MAX_NUMBER) for i in range(4)] # mm = Mastermind(4, 8, solution, MAX_NUMBER) # res = mm.play_swaszek(show_board=False, show_win=False) # if res >= 0: # results.append(res) #results.sort() #print("\nPlayed %d rounds" % (MAX_ITER)) #print("Games won: %d" % (len(results))) #print("Games lost: %d" % (MAX_ITER - len(results))) #print("Min round: %d" % (min(results))) #print("Max round: %d" % (max(results))) #print("AVG round: %f" % (sum(results)/len(results)))
def play_game(bots_list): solution = [random.randint(1, 8) for i in range(4)] for bot in bots_list: mm = Mastermind(4, 8, solution) hints_table = mm.play_bot(bot, show_board=False) bot.score = fitness_function(hints_table)
def test_return_a_list_of_0_and_1_for_one_misplaced_color(self): self.assertEqual( Mastermind.call(BASIC_SECRET, ['pink', 'pink', 'pink', 'blue']), [0, 1])
color_names.append( input("Please enter an identifier (string) for color " + str(i + 1) + " : ")) else: number_of_colors = 7 code_length = 4 color_names = [ "Red", "Blue", "Green", "White", "Black", "Orange", "Purple" ] print("Color names are " + ",".join(color_names)) should_use_complex_guessing = args.complex_guessing should_computer_makes_first_guess_randomly = True print("Game is started!") puzzle = Mastermind(color_names, code_length) is_first_action_round = True # Start cracking the code while True: if not is_first_action_round: if should_use_complex_guessing: puzzle.predict_by_complex_algorithm() else: puzzle.make_prediction() else: if should_computer_makes_first_guess_randomly: puzzle.make_prediction() else: t = input("Please enter a guess").split(" ")
def test_return_a_list_of_2_elements(self): self.assertEqual(len(Mastermind.call(BASIC_SECRET, BASIC_SECRET)), 2)
brush.setStyle(QtCore.Qt.SolidPattern) item = QtWidgets.QTableWidgetItem() item.setBackground(brush) self.scoreTable.setItem(self.tries, col, item) def retranslateUi(self, MainWindow): _translate = QtCore.QCoreApplication.translate MainWindow.setWindowTitle(_translate("MainWindow", "Mastermind")) self.submitButton.setText(_translate("MainWindow", "Submit")) __sortingEnabled = self.colorsTable.isSortingEnabled() self.colorsTable.setSortingEnabled(False) self.colorsTable.setSortingEnabled(__sortingEnabled) __sortingEnabled = self.thisGuessTable.isSortingEnabled() self.thisGuessTable.setSortingEnabled(False) self.thisGuessTable.setSortingEnabled(__sortingEnabled) self.resetButton.setText(_translate("MainWindow", "Reset")) if __name__ == "__main__": import sys mastermind = Mastermind([3, 0, 5, 5]) app = QtWidgets.QApplication(sys.argv) MainWindow = QtWidgets.QMainWindow() ui = Ui_MainWindow() ui.setupUi(MainWindow, mastermind) MainWindow.show() sys.exit(app.exec_())
def test_S_creation(): m = Mastermind(weapons=6, gladiators=4)
def test_return_a_list_of_2_integers(self): list_result = Mastermind.call(BASIC_SECRET, BASIC_SECRET) self.assertEqual(type(list_result[0]), int) self.assertEqual(type(list_result[1]), int)
def test_check_guess_correct_all(self): code = [1,2,3,4] guess = [1,2,3,4] master = Mastermind(positions=4, colors=6, code=code) self.assertEqual(master.check_guess(guess), (4,0))
def test_return_a_list_of_4_and_0_for_a_perfect_match(self): self.assertEqual(Mastermind.call(BASIC_SECRET, BASIC_SECRET), [4, 0])
def test_check_guess_a(self): code = [1,2,3,4] guess = [4,3,2,1] master = Mastermind(positions=4, colors=6, code=code) self.assertEqual(master.check_guess(guess), (0,4))
class Controller(object): def __init__(self): self.pygame = pg self.mastermind = None self.view = None self.playing = None self.carryOn = None def setup(self): self.pygame.init() self.pygame.font.init() self.pygame.display.set_caption("TGMastermind!") self.mastermind = Mastermind(self) self.view = View(self) self.playing = True self.carryOn = True def run_game(self): # The clock will be used to control how fast the screen updates clock = self.pygame.time.Clock() # -------- Main Program Loop ----------- while self.carryOn: # --- Main event loop for event in self.pygame.event.get(): # User did something if event.type == self.pygame.QUIT: # If user clicked close self.carryOn = False # Flag that we are done so we exit this loop #print(self.playing) if self.playing: self.view.confirm.handle_event(event) self.view.solve.handle_event(event) if event.type == self.pygame.MOUSEBUTTONUP: pos = self.pygame.mouse.get_pos() # Color selection self.view.color_selected(pos) # entering a colored pin self.view.pin_entered(pos) elif not self.view.restart: self.view.give_restart_option() self.view.confirm = None self.view.restart.handle_event(event) else: self.view.restart.handle_event(event) # if self.view.confirm.collidepoint(pos): # #if self.view.solve.collidepoint(pos): #colors = self.mastermind.solve_mystery() #self.view.solve_mystery(colors) # --- Game logic should go here # --- Drawing code should go here # First, clear the screen to white. if self.view.restart: self.view.restart.update() else: self.view.confirm.update() self.view.solve.update() # --- Go ahead and update the screen with what we've drawn. if self.carryOn: self.pygame.display.flip() # --- Limit to 60 frames per second clock.tick(60) # Once we have exited the main program loop we can stop the game engine: self.pygame.quit() def confirm_guess(self): hints = self.mastermind.check_input(self.view.current_guess) if hints != "WIN": self.view.add_hints(hints) def solve_mystery(self): self.playing = False colors = self.mastermind.solve_mystery() self.view.solve_mystery(colors) def guesser_won(self): self.playing = False self.view.add_hints(['BLACK', 'BLACK', 'BLACK', 'BLACK']) self.view.display_guesser_won(self.mastermind.solve_mystery()) def guesser_lost(self): self.playing = False self.view.display_guesser_lost(self.mastermind.solve_mystery()) def restart(self): self.carryOn = False self.setup() self.view.create_ui() self.run_game()
def test_check_guess_c(self): code = [1,4,4,3] guess = [4,4,3,2] master = Mastermind(positions=4, colors=6, code=code) self.assertEqual(master.check_guess(guess), (1,2))
def test_return_a_list_of_2_and_0_for_two_missing_colors(self): self.assertEqual( Mastermind.call(BASIC_SECRET, ['pink', 'pink', 'red', 'green']), [2, 0])
logger = logging.getLogger('mastermind') logger.propagate = False logger.setLevel(logging.INFO) # create console handler with a higher log level ch = logging.StreamHandler() # create formatter and add it to the handlers formatter = logging.Formatter('%(levelname)s - %(message)s') ch.setFormatter(formatter) logger.addHandler(ch) args = parser.parse_args() game_solver = Mastermind(args.k, args.n, logger=logger, pretty_printer=pretty_name_8_colors) def init_worker(shared_counter): global counter counter = shared_counter # hack to overcome limitation of Pool.map which is unable to execute instance methods def f(x): res = game_solver.batch_solve(x) counter.value += 1 logger.info("{}/{} {}%".format(counter.value, len(game_solver.all_possible_combinations), 100.0 * counter.value / len(game_solver.all_possible_combinations))) return res
def test_return_a_list_of_0_and_0_for_a_completely_wrong_match(self): self.assertEqual( Mastermind.call(BASIC_SECRET, ['pink', 'pink', 'pink', 'pink']), [0, 0])
def test_return_a_list_of_3_and_0_for_one_missing_color(self): self.assertEqual( Mastermind.call(BASIC_SECRET, ['pink', 'yellow', 'red', 'green']), [3, 0])
import numpy as np from ai.bot import Bot from mastermind import Mastermind import copy import random def shake(bot): layers_weights = bot.brain.get_weights() #print(layers_weights) for layer in range(len(layers_weights)): for x in range(len(layers_weights[layer])): for y in range(len(layers_weights[layer][x])): layers_weights[layer][x][y] *= (10 * np.random.randn() + 1) bot.brain.set_weights(layers_weights) #print(bot.brain.get_weights()) if __name__ == "__main__": bot = Bot(4, 8, 8, name="Marek") bot2 = Bot(4, 8, 8, name="Hanka") solution = [random.randint(1, 8) for i in range(4)] mm = Mastermind(4, 8, solution) mm2 = Mastermind(4, 8, solution) score = mm.play_bot(bot) mm2.play_bot(bot2) # print(bot.brain.get_weights()) # print(bot2.brain.get_weights()) shake(bot)