def build_tree(node):
"""
Builds a tree with all posible boards from the given board
Prediction: chose next move from all posssible
:param node: Node
:return: None
"""
board = node.data
if board.num_free() == 0:
pass
elif board.check_f('x') == "continue":
sing = board.pre_pos[0]
if sing == 'o':
sing = 'x'
elif sing == 'x':
sing = 'o'
free = board.get_free_lst()
pos_r = random.choice(free)
free.remove(pos_r)
if len(free) > 0:
pos_l = random.choice(free)
else:
pos_l = None
right = board.get_same()
left = board.get_same()
right.add_pos(pos_r, sing)
if pos_l is not None:
left.add_pos(pos_l, sing)
node.left = Node(left)
node.right = Node(right)
if node.left:
build_tree(node.left)
build_tree(node.right)
def help(self):
check_result = self.root.data.check_board()
position1 = random.choice(check_result)
check_result.pop(check_result.index(position1))
position2 = random.choice(check_result)
check_result.pop(check_result.index(position2))
right_board = Board([el for el in self.root.data.coors()])
right_board.add(position1, "O")
left_board = Board([el for el in self.root.data.coors()])
left_board.add(position2, "O")
def recur(node):
if node.count != 0:
node.count = node.left.count + node.right.count
return node.count
if type(node.data.check_board()) == int:
node.count = node.data.check_board()
return node.count
else:
check_result = node.data.check_board()
if len(check_result) >= 2:
position1 = random.choice(check_result)
check_result.pop(check_result.index(position1))
pos_against1 = random.choice(check_result)
right_board = Board([el for el in node.data.coors()])
right_board.add(position1, "O")
right_board.add(pos_against1, "X")
position2 = random.choice(check_result)
check_result.pop(check_result.index(position2))
check_result.append(position1)
left_board = Board([el for el in node.data.coors()])
left_board.add(position2, "O")
pos_against2 = random.choice(check_result)
left_board.add(pos_against2, "X")
node.left = Node(left_board)
node.left.parent = node
node.right = Node(right_board)
node.right.parent = node
node.count += recur(node.left) + recur(node.right)
return node.count
else:
position1 = random.choice(check_result)
board = Board([el for el in node.data.coors()])
board.add(position1, "O")
node.left = Node(board)
node.left.parent = node
recur(node.left)
return node.left.data.check_board()
if recur(Node(right_board)) > recur(Node(left_board)):
return position1
else:
return position2
def compute_score(self):
has_winner = self.has_winner()
if has_winner:
winner_scores = {Board.NOUGHT_WINNER: 1, Board.CROSS_WINNER: -1, Board.DRAW: 0}
return winner_scores[has_winner]
board_tree = LinkedBinaryTree(Node(self))
left_board = copy.deepcopy(self)
right_board = copy.deepcopy(self)
moved_left = left_board.make_random_move()
moved_right = right_board.make_random_move()
board_tree.insert_left(Node(moved_left))
board_tree.insert_right(Node(moved_right))
return left_board.compute_score() + right_board.compute_score()
def _insert(self, value, cur_node):
if value < cur_node.value:
if cur_node.left_child == None:
cur_node.left_child = Node(value)
else:
self._insert(value, cur_node.left_child)
elif value > cur_node.value:
if cur_node.right_child == None:
cur_node.right_child = Node(value)
else:
self._insert(value, cur_node.right_child)
else:
print('Value already in tree!')
def build_tree(node):
"""
Builds a tree with all posible boards from the given board
Prediction: chosse next move from two posssible
:param node: Node
:return: None
"""
if node is not None:
board = node.data
if board.num_free() == 0:
pass
elif board.check_f('o') == "continue":
sing = board.pre_pos[0]
if sing == 'o':
sing = 'x'
elif sing == 'x':
sing = 'o'
free = board.get_free_lst()
###########################
for i in range(len(free)):
new = board.get_same()
new.add_pos(free[i], sing)
node.boors[i] = Node(new)
for i in range(len(node.boors)):
build_tree(node.boors[i])
def winning_count(self):
end_of_game = self.check_current_table()
if end_of_game:
if end_of_game == 1:
return 1
else:
return 0
node = Node(self)
tree = BinaryTree(node)
left_board = copy.deepcopy(self)
right_board = copy.deepcopy(self)
left_move = left_board.move_random()
right_move = right_board.move_random()
tree._root.left = Node(left_move)
tree._root.right = Node(right_move)
return left_board.winning_count() + right_board.winning_count()
def compute_score(self):
has_winner = self.has_winner()
if has_winner:
winner_scores = {
Board.NOUGHT_WINNER: 1,
Board.CROSS_WINNER: -1,
Board.DRAW: 0
}
return winner_scores[has_winner]
n1 = Node(self)
board = Tree()
board.root = n1
right_board = left_board = copy.deepcopy(self)
left_move, right_move = left_board.make_random_move(
), right_board.make_random_move()
board.root.left = Node(left_move)
board.root.right = Node(right_move)
return left_board.compute_score() + right_board.compute_score()
def add_root(self, e, mark=None):
"""Place element e at the root of an empty tree and return new Position.
Raise ValueError if tree nonempty.
"""
if self._root is not None:
raise ValueError('Root exists')
self._size = 1
self._root = Node(e, mark=mark)
return self._make_position(self._root)
def count_score(self):
has_winner = self.has_winner()
if has_winner:
scores = {
Board.NOUGHT_WINNER: 1,
Board.CROSS_WINNER: -1,
Board.DRAW: 0
}
return scores[has_winner]
else:
board = Tree()
board.root = Node(self)
board_left = copy.deepcopy(self)
board_right = copy.deepcopy(self)
move_L = board_left.make_random_move()
move_R = board_right.make_random_move()
board.root.left = Node(move_L)
board.root.right = Node(move_R)
result = board_left.count_score() + board_right.count_score()
return result
def add_right(self, p, e, mark=None):
"""Create a new right child for Position p, storing element e.
Return the Position of new node.
Raise ValueError if Position p is invalid or p already has a right child.
"""
node = self._validate(p)
if node._right is not None:
raise ValueError('Right child exists')
self._size += 1
node._right = Node(e, node, mark=mark) # node is its parent
return self._make_position(node._right)
def compute_score(self):
"""
Chooses better move
:return: int
"""
has_winner = self.has_winner()
if has_winner:
winner_scores = {
Board.NOUGHT_WINNER: 1,
Board.CROSS_WINNER: -1,
Board.DRAW: 0
}
return winner_scores[has_winner]
board = Tree()
board.root = Node(self)
left_board = copy.deepcopy(self)
right_board = copy.deepcopy(self)
left_move = left_board.make_random_move()
right_move = right_board.make_random_move()
board.root.left = Node(left_move)
board.root.right = Node(right_move)
return left_board.compute_score() + right_board.compute_score()
def add(root=None, vals=[]) -> 'Node':
# Walk through the tree in a breadth-first fashion to add vals.
#
if not root and vals:
root = Node(vals.pop(0))
q = [root] if root else []
while len(q) > 0:
n = q.pop()
if n.left:
q.insert(0, n.left)
elif vals:
n.left = Node(vals.pop(0))
q.insert(0, n.left)
if n.right:
q.insert(0, n.right)
elif vals:
n.right = Node(vals.pop(0))
q.insert(0, n.right)
return root
def add_left(node, item):
node.left = Node(item)
