def make_move():
"""
looks at the board after each possible move and then chooses the move that leaves the most options for the next move
seems to work fine
"""
list_of_length = []
current_board = solit_random.board.copy()
valid_m = solit_random.find_valid_moves()
if len(valid_m) == 0: # return 0 if there is no valid move
return 0
for element in range(
len(valid_m)
): # perform valid moves, then add length of the now possible moves to list
next_move = valid_m[element]
solit_random.move(next_move[0], next_move[1])
list_after = solit_random.find_valid_moves()
list_of_length.append(len(list_after))
solit_random.board = current_board.copy()
m = max(
list_of_length
) # look for the move that leaves the most possibilities and execute it
list_of_max_options = [
index for index, element in enumerate(list_of_length) if element == m
]
favoured_move_index = random.randint(0, len(list_of_max_options) - 1)
favoured_move = valid_m[favoured_move_index]
solit_random.move(favoured_move[0], favoured_move[1])
return 1
def play_move_to_victory():
"""
Plays moves created by solve_solitaer() backtracking algorithm
"""
if len(moves_to_victory) == 0:
return 0
move = moves_to_victory[0]
solit_random.move(move[0], move[1])
moves_to_victory.pop(0)
return 1
def policy_move_2():
"""
looks two moves ahead and then chooses the move that leaves the most options for the next move
"""
list_of_scored_moves = []
current_board = solit_random.board.copy()
valid_m = solit_random.find_valid_moves()
if len(valid_m) == 0: # return 0 if there is no valid move
return 0
for element in range(len(valid_m)): # make each possible move
next_move = valid_m[element]
solit_random.move(next_move[0], next_move[1])
list_after = solit_random.find_valid_moves()
if len(
list_after
) == 0: # if there are no more possible moves, look ahead with depth 1 and make a move
solit_random.board = current_board.copy()
return policy_move()
for element2 in range(len(list_after)): # make a possible move, then
next_move_2 = list_after[element2]
solit_random.move(next_move_2[0], next_move_2[1])
list_after_2 = solit_random.find_valid_moves(
) # append index + valuescore
list_of_scored_moves.append(
[element, evaluate_bord(solit_random.board)])
solit_random.board = current_board.copy()
indices, list_of_values = zip(*list_of_scored_moves)
m = max(list_of_values)
favoured_move_index = indices[list_of_values.index(m)]
favoured_move = valid_m[favoured_move_index]
solit_random.move(favoured_move[0], favoured_move[1])
solit_random.move(favoured_move[0], favoured_move[1])
return 1
def positions_n_jumps(depth, board):
for n in range(depth):
posb_moves = solit_random.find_valid_moves()
for i in range(len(posb_moves)):
previous_board = solit_random.board.copy()
current_move = posb_moves[i]
solit_random.move(current_move[0], current_move[1])
board_in_list = False
for element in range(len(list_of_states)):
if compare_boards(list_of_states[element].copy(),
solit_random.board.copy()):
board_in_list = True
break
if (board_in_list is True):
if i < len(posb_moves) - 1:
solit_random.board = previous_board.copy()
else:
list_of_states.append(solit_random.board.copy())
positions_n_jumps(depth - n - 1, solit_random.board.copy())
solit_random.board = previous_board.copy()
def policy_move():
"""
looks at the board after each possible move and then chooses the move that leaves the most options for the next move
seems to work fine
"""
list_of_values = []
current_board = solit_random.board.copy()
valid_m = solit_random.find_valid_moves()
if len(valid_m) == 0: # return 0 if there is no valid move
return 0
for element in range(
len(valid_m)
): # perform valid moves, then add length of the now possible moves to list
next_move = valid_m[element]
solit_random.move(next_move[0], next_move[1])
list_of_values.append(evaluate_bord(solit_random.board))
solit_random.board = current_board.copy()
m = max(list_of_values)
favoured_move_index = list_of_values.index(m)
favoured_move = valid_m[favoured_move_index]
solit_random.move(favoured_move[0], favoured_move[1])
return 1
def solve_solitaer():
"""
uses Backtracking to get a solution for the solitaer puzzle and saves the necessary moves in moves_to_victory
"""
# Analog zu N-Damen Problem https://www.geeksforgeeks.org/python-program-for-n-queen-problem-backtracking-3/
# https://www.youtube.com/watch?v=0DeznFqrgAI
if (solit_random.board == 2).sum() == 1 and solit_random.board[5][5] == 2:
return True
else:
posb_moves = solit_random.find_valid_moves()
for i in range(31):
if len(posb_moves) == 0:
return False
previous_board = solit_random.board.copy()
current_move = posb_moves[0]
moves_to_victory.append(current_move)
solit_random.move(current_move[0], current_move[1])
if solve_solitaer() is True:
return True
posb_moves.pop(
0
) # pops first element of list, for higher performance look at collections.deque
moves_to_victory.pop() # pops last element
solit_random.board = previous_board.copy()
def make_move_2():
"""
looks two moves ahead and then chooses the move that leaves the most options for the next move
still in beta
"""
list_of_length = []
current_board = solit_random.board.copy()
valid_m = solit_random.find_valid_moves()
if len(valid_m) == 0: # return 0 if there is no valid move
return 0
for element in range(len(valid_m)): # make each possible move
next_move = valid_m[element]
solit_random.move(next_move[0], next_move[1])
list_after = solit_random.find_valid_moves()
if len(
list_after
) == 0: # if there are no more possible moves, look ahead with depth 1 and make a move
solit_random.board = current_board.copy()
return make_move()
for element2 in range(len(list_after)): # make a possible move, then
next_move_2 = list_after[element2]
solit_random.move(next_move_2[0], next_move_2[1])
list_after_2 = solit_random.find_valid_moves(
) # append index + amount of possible moves after the move
list_of_length.append([element, len(list_after_2)])
solit_random.board = current_board.copy()
indices, lengths = zip(*list_of_length)
m = max(
lengths
) # look for the move that leaves the most possibilities and execute it
list_of_max_options = [
index for index, element in enumerate(lengths) if element == m
]
favoured_move_index = random.randint(0, len(list_of_max_options) - 1)
favoured_move = valid_m[indices[favoured_move_index]]
solit_random.move(favoured_move[0], favoured_move[1])
return 1