def swipeRandom(board):
directions = ["up", "down", "left", "right"]
generatedInput = {}
validResults = []
for direction in directions:
boardCopy = copyBoard(board)
generatedInput["board"] = boardCopy
generatedInput["direction"] = direction
swipeResult = deterministicSwipe(generatedInput)
if ("error" not in swipeResult["gameStatus"]):
validResults.append(swipeResult)
numberValidResults = len(validResults)
if (numberValidResults == 0):
return {'gameStatus': "error: Cannot swipe in any direction"}
#pickIndex = random.randint(1, numberValidResults) - 1
result = random.choice(validResults)
operationSuccess = placeTile(result["board"]["grid"])
if (not operationSuccess):
raise RuntimeError(
"There was no empty space to put a new tile. This exception should never occur."
)
return result
def swipeRecommend(board, moves):
directions = ["up", "down", "left", "right"]
boardCopy = {}
scores = [0] * 4
for index in range(4):
boardCopy = copyBoard(board)
scores[index] = searchSwipePaths(boardCopy, moves - 1,
directions[index])["maxScore"]
highestScore = max(scores)
bestDirections = []
for index in range(4):
if (scores[index] == highestScore):
bestDirections.append(directions[index])
if (len(bestDirections) == 0):
return {"gameStatus": "error: Cannot swipe in any direction. "}
bestDirection = random.choice(bestDirections)
generatedInput = {}
generatedInput["board"] = copyBoard(board)
generatedInput["direction"] = bestDirection
output = deterministicSwipe(generatedInput)
assert (placeTile(output["board"]["grid"]))
return output
def checkBoardStatus(tile, board):
def prepareInputPackage(direction):
inputPackage = {}
inputPackage["direction"] = direction
inputPackage["board"] = dict(board)
inputPackage["board"]["grid"] = list(board["grid"])
return inputPackage
output = ""
for element in board["grid"]:
if (
2**element >= tile
): #Conditional modified to account for spec change to how tile works
output = "win"
return output
swipeResults = [0] * 4
upInput = prepareInputPackage("up")
swipeResults[0] = deterministicSwipe(upInput)
downInput = prepareInputPackage("down")
swipeResults[1] = deterministicSwipe(downInput)
leftInput = prepareInputPackage("left")
swipeResults[2] = deterministicSwipe(leftInput)
rightInput = prepareInputPackage("right")
swipeResults[3] = deterministicSwipe(rightInput)
for result in swipeResults:
if ("error" not in result["gameStatus"]):
return "underway"
return "lose"
return output
def test_swipe_FunctionalTest04(self):
columnCount = 4
rowCount = 2
grid = [1, 2, 3, 0, 1, 2, 0, 0]
direction = "right"
board = {
"columnCount": columnCount,
"rowCount": rowCount,
"grid": grid
}
input = {"board": board, "direction": direction}
output = deterministicSwipe(input)
self.assertEqual([0, 1, 2, 3, 0, 0, 1, 2], output["board"]["grid"])
def test_swipe_Score02(self):
columnCount = 4
rowCount = 2
grid = [1, 3, 3, 0, 2, 2, 0, 0]
direction = "right"
board = {
"columnCount": columnCount,
"rowCount": rowCount,
"grid": grid
}
input = {"board": board, "direction": direction}
output = deterministicSwipe(input)
self.assertEqual(2**4 + 2**3, output["score"])
def test_swipe_Score01(self):
columnCount = 4
rowCount = 2
grid = [0, 1, 1, 1, 1, 1, 0, 0]
direction = "down"
board = {
"columnCount": columnCount,
"rowCount": rowCount,
"grid": grid
}
input = {"board": board, "direction": direction}
output = deterministicSwipe(input)
self.assertEqual(4, output["score"])
def test_swipe_FunctionalTest02(self):
columnCount = 2
rowCount = 2
grid = [0, 1, 0, 0]
direction = "left"
board = {
"columnCount": columnCount,
"rowCount": rowCount,
"grid": grid
}
input = {"board": board, "direction": direction}
output = deterministicSwipe(input)
grid = output["board"]["grid"]
self.assertEqual(1, grid[0])
def searchSwipePaths(board, movesleft, direction, timeStart=0):
#perform swipe on board in direction
#store score from swipe
#if move is invalid return -1
#if moves left > 0 and if swipe is valid then
# call search swipe paths for each direction with moves - 1, and a copy of board
# pick path with greatest score
# add greatest score to score
#if greatest score is -1
# return -1
#return score
if (timeStart != 0):
elapsed = time.clock() - timeStart
if (elapsed > 0.5):
raise RuntimeError
errorMessage = ""
outputPackage = {}
outputPackage["isInvalid"] = False
outputPackage["errorMessage"] = errorMessage
outputPackage["maxScore"] = -1
outputPackage["minScore"] = -1
outputPackage["avgScore"] = -1
outputPackage["scoreWeight"] = 1
inputPackage = {}
inputPackage["board"] = board
inputPackage["direction"] = direction
myResults = deterministicSwipe(inputPackage)
if ("error" in myResults["gameStatus"]):
outputPackage["isInvalid"] = True
errorMessage = " swipe could not be performed"
return outputPackage
myScore = myResults["score"]
outputPackage["maxScore"] = myScore
outputPackage["minScore"] = myScore
outputPackage["avgScore"] = myScore
if (movesleft == 0):
return outputPackage
directions = ["up", "down", "left", "right"]
maxScores = []
minScores = []
avgScores = []
avgScoreWeights = []
for index in range(4):
boardCopy = copyBoard(board)
directionalSearchResult = searchSwipePaths(boardCopy, movesleft - 1,
directions[index],
timeStart)
if directionalSearchResult["isInvalid"] == False:
maxScores.append(directionalSearchResult["maxScore"])
minScores.append(directionalSearchResult["minScore"])
avgScores.append(directionalSearchResult["avgScore"])
avgScoreWeights.append(directionalSearchResult["scoreWeight"])
if (len(maxScores) == 0):
outputPackage["isInvalid"] = True
return outputPackage
outputPackage["maxScore"] += max(maxScores)
outputPackage["minScore"] += min(minScores)
average = 0.0
for index in range(len(avgScores)):
average += float(avgScores[index]) * float(avgScoreWeights[index])
average /= float(sum(avgScoreWeights))
outputPackage["avgScore"] += average
return outputPackage
def swipe(input):
#-----------------------------------------------------#
#HELPER FUNCTIONS
#Function checks for invalid inputs and returns a dictionary with keys "isError" and "errorMessage"
def isInputValid(input):
resultPackage = {}
errorMessage = "error: "
resultPackage["errorMessage"] = errorMessage
resultPackage["isError"] = False
#Check that everything is in the dictionary
if ("direction" not in input):
resultPackage["isError"] = True
errorMessage += "direction not given. "
if ("board" not in input):
resultPackage["isError"] = True
errorMessage += "board not in dictionary. "
if (resultPackage["isError"]):
return resultPackage
#check that everything within the dictionary is valid
direction = input["direction"]
if (type(direction) is unicode):
direction = direction.encode('ascii', 'ignore')
if (type(direction) is not str):
errorMessage += "Direction must be string. "
resultPackage["isError"] = True
return resultPackage
direction = direction.lower()
input["direction"] = direction
if (direction != 'up' and direction != 'down' and direction != 'left' and direction != 'right'):
errorMessage += "Direction not recognized. "
resultPackage["isError"] = True
board = input["board"]
boardValidity = isBoardValid(board)
if (boardValidity["isInvalid"]):
resultPackage["isError"] = True
errorMessage += resultPackage["errorMessage"]
return resultPackage
#END HELPER FUNCTIONS
#-----------------------------------------------------#
validationResults = isInputValid(input)
if (validationResults["isError"] == True):
return {"gameStatus": validationResults["errorMessage"]}
results = deterministicSwipe(input)
if ("error" in results["gameStatus"]):
return results
operationSuccess = placeTile(input["board"]["grid"])
if (operationSuccess == False):
return {"gameStatus": "error A new tile could not be placed after swiping."}
return results
