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