def main2():
# my_node = Node(Grid(),0)
# my_node.grid.setCellValue((3,3), 1)
# my_node.print_grid()
grid1 = Grid()
grid1.setCellValue((0, 0), 1)
grid2 = grid1.clone()
grid2.setCellValue((0, 1), 1) # child of node1
grid3 = grid1.clone()
grid3.setCellValue((0, 1), 2) # child of node1
grid4 = grid2.clone()
grid4.setCellValue((0, 2), 1) # child of node2
grid5 = grid3.clone()
grid5.setCellValue((0, 2), 1) # child of node3
node1 = Node(grid1, 0)
node2 = Node(grid2, 0)
node3 = Node(grid3, 0)
node4 = Node(grid4, 0)
node5 = Node(grid5, 0)
node1.push_children(node2)
node1.push_children(node3)
node2.push_children(node4)
node3.push_children(node5)
my_tree = SearchTree(node1)
my_tree.print_tree()
def main():
player = PlayerAI()
testGrid = Grid()
displayer = Displayer()
displayer.display(testGrid)
print(player.findPairs(testGrid))
testGrid.setCellValue([0, 0], 3)
displayer.display(testGrid)
print(player.findPairs(testGrid))
testGrid.setCellValue([0, 3], 3)
displayer.display(testGrid)
print(player.findPairs(testGrid))
testGrid.setCellValue([2, 3], 3)
displayer.display(testGrid)
print(player.findPairs(testGrid))
testGrid.setCellValue([0, 1], 3)
displayer.display(testGrid)
print(player.findPairs(testGrid))
testGrid.setCellValue([0, 2], 3)
displayer.display(testGrid)
print(player.findPairs(testGrid))
testGrid.setCellValue([1, 1], 3)
displayer.display(testGrid)
print(player.findPairs(testGrid))
#main()
def __init__(self, size = 4):
self.grid = Grid(size)
self.possibleNewTiles = [2, 4]
self.probability = defaultProbability
self.initTiles = defaultInitialTiles
self.computerAI = None
self.playerAI = None
self.displayer = None
self.over = False
def __init__(self, size=4):
self.grid = Grid(size)
self.possibleNewTiles = [2, 4]
self.probability = defaultProbability
self.initTiles = defaultInitialTiles
self.computerAI = None
self.playerAI = None
self.displayer = None
self.over = False
# Load the DNN model
self.model_NN = load_model("all_2048_8000games.h5")
def __init__(self, size=4, playerAI=None, computerAI=None, displayer=None):
self.grid = Grid(size)
self.possibleNewTiles = [2, 4]
self.probability = defaultProbability
self.initTiles = defaultInitialTiles
self.over = False
# Initialize the AI players
self.computerAI = computerAI or ComputerAI()
self.playerAI = playerAI or PlayerAI()
self.displayer = displayer or Displayer()
def __init__(self, size=4):
self.grid = Grid(size)
self.possibleNewTiles = [2, 4]
self.probability = defaultProbability
self.initTiles = defaultInitialTiles
self.computerAI = None
self.playerAI = None
self.displayer = None
self.over = False
self.max_time_for_get_move = 0
self.next_move_counter = 0
self.MAX_NEXT_MOVE_COUNTER = 10000
def main():
grid1 = Grid()
node1 = Node(grid1, 0)
grid1.map[0][0] = 64
grid1.map[1][0] = 2
grid1.map[3][0] = 4
grid1.map[0][1] = 0
grid1.map[1][1] = 0
grid1.map[3][1] = 0
grid1.map[2][1] = 0
grid1.map[2][2] = 0
strategy = MiniMax(node1)
alpha_beta = strategy.alpha_beta(5)
print("\nMiniMax: ", node1.h_value, "\nDirection: ", alpha_beta)
def main4():
grid1 = Grid()
node1 = Node(grid1, 0)
grid1.map[0][0] = 64
grid1.map[1][0] = 2
grid1.map[3][0] = 4
grid1.map[0][1] = 0
grid1.map[1][1] = 0
grid1.map[3][1] = 0
grid1.map[2][1] = 0
grid1.map[2][2] = 0
my_tree = SearchTree(node1)
my_tree.build_tree(4)
strategy = MiniMax(node1)
alpha_beta = strategy.alpha_beta(5)
print("\nMiniMax: ", node1.h_value, "\nDirection: ", alpha_beta)
def main3():
grid1 = Grid()
node1 = Node(grid1, 0)
grid1.map[0][0] = 2
grid1.map[1][0] = 2
grid1.map[3][0] = 4
grid1.map[0][1] = 0
grid1.map[1][1] = 0
grid1.map[3][1] = 0
grid1.map[2][1] = 0
grid1.map[2][2] = 0
my_tree = SearchTree(node1)
my_tree.build_tree(4)
my_tree.print_tree()
strategy = MiniMax(node1)
alpha_beta = strategy.alpha_beta(4)
print("\nMiniMax: {0:.4f}".format(alpha_beta))
print("---------> ", node1.h_value)
def create_slowgrid_from(self, val) -> Grid:
sut = Grid()
for row in range(4):
for col in range(4):
sut.setCellValue((row, col), val[row][col])
return sut
def __init__(self):
self.grid = Grid()
self.game_manager = GameManager()
self.playerAI = PlayerAI()
self.computerAI = ComputerAI()
self.displayer = BaseDisplayer()
def create_slowgrid_from_list(self, l, size=4) -> FastGrid:
sut = Grid()
sut.map = l
sut.size = size
return sut
def test_can_create_grid_to_design(self):
sut = Grid()
self.assertIsNotNone(sut)
self.assertEqual(4, sut.size)
sut.setCellValue((0, 0), 2)
self.assertEqual(sut.getCellValue((0, 0)), 2)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Jun 11 16:36:48 2018
@author: jinzhao
"""
from Grid_3 import Grid
g = Grid()
g.map[0][0] = 2
g.map[1][0] = 2
g.map[3][0] = 4
empty = g.getAvailableCells()
print(empty)
def test_fun():
return 1, 2
b = test_fun()[1]
print(b)
class test_class():
def __init__(self):
self.val = 100
neighbours = self.get_neighbours(pos)
for n in neighbours:
if pos_value == grid.getCellValue(n):
merges += 1
return merges
def grid_eval(self, grid):
gradients = [[[3, 2, 1, 0], [2, 1, 0, -1], [1, 0, -1, -2],
[0, -1, -2, -3]],
[[0, 1, 2, 3], [-1, 0, 1, 2], [-2, -1, 0, 1],
[-3, -2, -1, -0]],
[[0, -1, -2, -3], [1, 0, -1, -2], [2, 1, 0, -1],
[3, 2, 1, 0]],
[[-3, -2, -1, 0], [-2, -1, 0, 1], [-1, 0, 1, 2],
[0, 1, 2, 3]]]
values = [0, 0, 0, 0]
for i in range(4):
for x in range(4):
for y in range(4):
values[i] += gradients[i][x][y] * grid.map[x][y]
return max(values)
if __name__ == "__main__":
grid = Grid()
a = grid.getAvailableCells()
print(len(a))
def to_slowgrid(self):
g = Grid()
g.map = Util.array_to_2dlist(self.board)
return g
def make(self):
self.grid = Grid(self.size)
for i in range(self.init_tiles):
self.insert_random_tile()