Ejemplo n.º 1
0
def depthLimitedSearch(pegSolitaireObject, maxDepth):
    #Check if the current state is goal state or not
    if pegSolitaireUtils.isGoalState(pegSolitaireObject.gameState):
        return True
    
    #If current state is already explored, it will not explore it furthur and return
    if pegSolitaireUtils.isAlreadyExplored(pegSolitaireObject.gameState): 
        return
    
    #if depth reached is zero, goal can't be find with these moves and it backtracks
    if maxDepth == 0:
        return
    
    #Check for all pegs in the peg board in all direction for next game state
    for i in xrange(7):
        for j in xrange(7):
            if pegSolitaireObject.gameState[i][j] == 1: 
                for direction in all_directions:
                    #check valid move
                    if pegSolitaireObject.is_validMove((i,j),direction):
                        #Save game state in another state variable, so that we can backtrack if our next move eventually fails
                        parentObject = pegSolitaireUtils.game("game.txt")
                        parentObject.gameState = pegSolitaireUtils.copyGameState(pegSolitaireObject)
                        #Get next valid move state
                        pegSolitaireObject.getNextState((i,j),direction)
    
                        #Recursively call function with next valid move and depth-1
                        result = depthLimitedSearch(pegSolitaireObject, maxDepth-1)
                        
                        #If the above exploration fails it will return to its initial game state (backtrack)
                        if result == None:
                            pegSolitaireUtils.restoreInitialState(pegSolitaireObject,parentObject.gameState)
                        #If Goal state is reached, it computes the trace and return true
                        if result == True:
                            #Get next move position for computing trace
                            newpos = pegSolitaireObject.getNextPosition((i,j), direction)
                            pegSolitaireObject.trace.insert(0,newpos)
                            pegSolitaireObject.trace.insert(0,(i,j))
                            return True

    return
Ejemplo n.º 2
0
def aStarOne(pegSolitaireObject):
    #################################################
        # Must use functions:
        # getNextState(self,oldPos, direction)
        # 
        # we are using this function to count,
        # number of nodes expanded, If you'll not
        # use this grading will automatically turned to 0
        #################################################
        #
        # using other utility functions from pegSolitaireUtility.py
        # is not necessary but they can reduce your work if you 
        # use them.
        # In this function you'll start from initial gameState
        # and will keep searching and expanding tree until you 
	# reach goal using A-Star searching with first Heuristic
	# you used.
        # you must save the trace of the execution in pegSolitaireObject.trace
        # SEE example in the PDF to see what to return
        #
        #################################################
    
    
    intialStartingState = pegSolitaireUtils.copyGameState(pegSolitaireObject)
    #This Queue would keep elements in increasing order of priority. This priority is decided by heuristic value.
    heapQueue = Queue.PriorityQueue()
    #Keep a hash of all explored states to prevent exploration of repeated states.
    pegSolitaireUtils.executedStates = set()
    #ParentStates would include a dictionary to map children nodes to its parent node along with the direction it arrived from.
    #This would help us to compute trace.
    parentStates = {}

    #Insert the first element in the Priority Queue and run a loop until either
    #1. Goal is reached.
    #2. All states are explored.
    heapQueue.put((0,pegSolitaireObject.gameState))
    parentStates[pegSolitaireUtils.stateToString(pegSolitaireObject.gameState)] = (None,None)

    while not heapQueue.empty():
        currentNodeState = (heapQueue.get())[1]
        #If current state is already explored, get the next state from the Queue.
        if pegSolitaireUtils.isAlreadyExplored(currentNodeState): 
            if heapQueue.empty():
                return False;
            currentNodeState = (heapQueue.get())[1]
        
        #If the current state is goal state, compute the trace and return True.
        if pegSolitaireUtils.isGoalState(currentNodeState):
            pegSolitaireUtils.computeTrace(parentStates,pegSolitaireUtils.stateToString(currentNodeState),pegSolitaireObject)
            return True

        #Back up of the parent node.
        initialState = copy.deepcopy(currentNodeState)
        pegSolitaireObject.gameState = currentNodeState
        #Get list of valid moves from the current game state.
        nextValidMoves = pegSolitaireUtils.setValidMoves(pegSolitaireObject)

        for nextMove in nextValidMoves:
            #Get next state of the game based on the position of current node and direction.
            pegSolitaireObject.getNextState((nextMove[0],nextMove[1]),nextMove[2])
            #Set parent for the current state.
            parentStates[pegSolitaireUtils.stateToString(pegSolitaireObject.gameState)] = (pegSolitaireUtils.stateToString(initialState),nextMove)
            #Put the node and the its f(n) value in the queue [f(n) = g(n) + h(n)]
            heapQueue.put((pegSolitaireUtils.funcFforAStarOne(intialStartingState,pegSolitaireObject),pegSolitaireUtils.copyGameState(pegSolitaireObject)))
            #Restore original state for next iteration.
            pegSolitaireUtils.restoreInitialState(pegSolitaireObject,initialState)
          
             
    pegSolitaireObject.trace.append("GOAL NOT FOUND")        

    return False