def valueOfMove(self, board, move):
board = self.game.preRotate(move, board)
testGame = GameState()
testGame.setBoard(board)
testGame.setBoard(testGame.copyArr())
value = 0
# store previous information
oldScore = testGame.getScore()
oldMaxTile = testGame.getMaxTile()
testGame.executeMove(Move.down)
newScore = testGame.getScore()
value += newScore - oldScore
# check if the largest tile is in a corner after the move
newMaxTile = testGame.getMaxTile()
for corner in self.fourCorners:
if testGame.gameArray[corner[0]][corner[1]] == newMaxTile:
value *= self.maxInCornerMultiplier
value += self.cornerBonusScaledByMax * newMaxTile
value += self.enterCorner
# penalty for moving down
if move == Move.down:
value -= self.moveDownPenalty * newMaxTile
board = self.game.postRotate(move, board)
return value
def estimateValue(self, depth, board, move):
ev2 = [[0 for x in range(4)] for x in range(4)]
ev4 = [[0 for x in range(4)] for x in range(4)]
ev = 0
numOptions = 0
# go through all options
if(self.game.isValid(move)):
baseGameUp = GameState()
baseGameUp.setBoard(board)
baseGameUp.executeMove(move)
for x in range (0, 4):
for y in range (0, 4):
if(baseGameUp.gameArray[x][y] == 0):
numOptions += 2
# per cell ev expecting 4
pretendBoard2 = baseGameUp.copyArr()
pretendGame2 = GameState()
pretendBoard2[x][y] = 2
pretendGame2.setBoard(pretendBoard2)
searchEv = self.startSearch(pretendGame2.copyArr(), depth - 1)
ev2[x][y] = searchEv[1]
pretendGame4 = None
# per cell ev expecting 4
pretendBoard4 = baseGameUp.copyArr()
pretendGame4 = GameState()
pretendBoard4[x][y] = 4
pretendGame4.setBoard(pretendBoard4)
searchEv = self.startSearch(pretendGame4.copyArr(), depth - 1)
ev4[x][y] = searchEv[1]
pretendGame4 = None
pass
return ev
def searchDirection(self, board, depth, move):
testGame = GameState()
testGame.setBoard(board)
testGame.setBoard(testGame.copyArr())
# if the move isn't valid, don't consider it
if (not testGame.isValid(move)):
return -1
# determine the value for making the move at this level
ourValue = self.valueOfMove(testGame.gameArray, move)
# if we have reached bottom depth, stop searching and return the heuristic value
if depth == 1:
return ourValue
# using that as the starting board, check a lot of possibilities
afterMove = testGame.executeMove(move)
testGame.setBoard(afterMove)
ev2 = [[0 for x in range(4)] for x in range(4)]
ev4 = [[0 for x in range(4)] for x in range(4)]
options = 0
searchValue = 0
# determine the value of each cell
for x in range (0, 4):
for y in range (0, 4):
trialBoard = testGame.copyArr()
if (trialBoard[x][y] == 0):
options += 1
trialBoard[x][y] = 2
ev2[x][y] = self.search(trialBoard, depth - 1)[1]
trialBoard[x][y] = 4
ev4[x][y] = self.search(trialBoard, depth - 1)[1]
trialBoard[x][y] = 0
# adjust those cells for their likelihood
for x in range (0, 4):
for y in range (0, 4):
searchValue += (ev2[x][y] * 0.9) / options
searchValue += (ev4[x][y] * 0.1) / options
return ourValue + searchValue
def searchDirection(self, board, depth, move):
testGame = GameState()
testGame.setBoard(board)
testGame.setBoard(testGame.copyArr())
# if the move isn't valid, don't consider it
if (not testGame.isValid(move)):
return -1
# determine the value for making the move at this level
ourValue = self.valueOfMove(testGame.gameArray, move)
# using that as the starting board, check the child's options
afterMove = testGame.executeMove(move)
searchValue = self.search(afterMove, depth - 1)[1]
return ourValue + searchValue
def searchDirection(self, board, likelihood, move, depth):
testGame = GameState()
testGame.setBoard(board)
testGame.setBoard(testGame.copyArr())
# if the move isn't valid, don't consider it
if (not testGame.isValid(move)):
return -1
#determine the value for making the move at this level
ourValue = self.valueOfMove(testGame.gameArray, move)
#'using that as the starting board, check a lot of possibilities'
afterMove = testGame.executeMove(move)
testGame.setBoard(afterMove)
ev2 = [[0 for x in range(4)] for x in range(4)]
ev4 = [[0 for x in range(4)] for x in range(4)]
options = 0
searchValue = 0
# determine which cells can have a new tile
trialBoard = testGame.copyArr()
for x in range (0, 4):
for y in range (0, 4):
if (trialBoard[x][y] == 0):
options += 1
# determine the value of each cell
for x in range (0, 4):
for y in range (0, 4):
trialBoard = testGame.copyArr()
if (trialBoard[x][y] == 0):
cellChance = likelihood / options
trialBoard[x][y] = 2
ev2[x][y] = cellChance * 0.9 * self.search(trialBoard, likelihood * cellChance * 0.9, depth)[1]
trialBoard[x][y] = 0
trialBoard[x][y] = 4
ev4[x][y] = cellChance * 0.9 * self.search(trialBoard, likelihood * cellChance * 0.1, depth)[1]
trialBoard[x][y] = 0
return ourValue + searchValue
def searchDirection(self, board, depth, move):
testGame = GameState()
testGame.setBoard(board)
testGame.setBoard(testGame.copyArr())
# if the move isn't valid, don't consider it
if not testGame.isValid(move):
return -1
# determine the value for making the move at this level
ourValue = self.valueOfMove(testGame.gameArray, move)
#'using that as the starting board, check a lot of possibilities'
afterMove = testGame.executeMove(move)
testGame.setBoard(afterMove)
options = 0
searchValue = 0
# arrays
ev2 = [[0 for x in range(2)] for x in range(2)]
ev4 = [[0 for x in range(2)] for x in range(2)]
optionsInRegion = [[0 for x in range(2)] for x in range(2)]
# determine value of the region
for x in range(0, 2): # location of region
for y in range(0, 2):
trialBoard = testGame.copyArr()
validLocs = []
for rx in range(0, 2): # location within region
for ry in range(0, 2):
locX = (x * 2) + rx
locY = (y * 2) + ry
# take all 0s into account for likelihood
if trialBoard[locX][locY] == 0:
optionsInRegion[x][y] += 1
options += 1
validLocs += [(locX, locY)]
# find a cell in the region to test
possibilities = optionsInRegion[x][y]
for loc in validLocs:
rand = randrange(0, 100)
# randomly select one cell in the region to care about
if rand < ((1 / possibilities) * 100): # test whether or not this is the cell we care about
trialBoard[loc[0]][loc[1]] = 2
ev2[x][y] = self.search(trialBoard, depth - 1)[1]
trialBoard[loc[0]][loc[1]] = 4
ev4[x][y] = self.search(trialBoard, depth - 1)[1]
trialBoard[loc[0]][loc[1]] = 0
break
possibilities -= 1
# reset our locations for the next region
validLocs.clear()
# adjust those region evs for their likelihood
for x in range(0, 2):
for y in range(0, 2):
searchValue += (ev2[x][y] * 0.9) * (optionsInRegion[x][y] / options)
searchValue += (ev4[x][y] * 0.1) * (optionsInRegion[x][y] / options)
return ourValue + searchValue
