BFS function not returning path right

Hey guys, what's up ya'll. For this, I have to create a BFS function that finds shortest path between a destination and source for the game called Quoridor, I'm sure some of ya'll played this before. When I r开发者_高级运维un it, no errors were found but I want the shortest path function to return the path as one I did in searchBFS function. Also, sorry for the sloppy post, it's my first one.

Here's the code....

from interface import *
import engine

#public routines

def init(gameFile, playerId, numPlayers, playerHomes, wallsRemaining):

"""
    For all parts the engine calls this method so the player can initialize their data.
        gameFile - a string which is the file containing the initial board state.
        playerId - the numeric Id of the player (0-4).
        numPlayers - the number of players (2 or 4).
        playerHomes - a list of coordinates for each players starting cell (PO-P4).
        wallsRemaining - the number of walls remaining (same for all players at start)."""

    # log any message string to standard output and the current log file
    engine.log_msg("player.init called for player " + str(playerId) + " File=" + gameFile +
                   ', playerId=' + str(playerId) + ', numPlayers=' + str(numPlayers) + ', playerHomes=' +
                   str(playerHomes) + ', wallsRemaining=' + str(wallsRemaining))

    playerData = None

    # initialize your data structure here, and then return it.  It will be
    # passed back to you as 'playerData' in the shortest_path function.

    return playerData

def shortest_path(playerData, source, dest):

"""Returns a list of coordinates representing the shortest path on the
    board between the start and finish coordinates.
        playerData - The player's data
        source - the start coordinate
        dest - the end coordinate"""

    engine.log_msg("player.shortest_path called.  Source: " + str(source) + 
                   ", Dest: " + str(dest))

    path = []

def searchBFS(graph, source, dest):

"""Performs a BFS search between source and destination nodes using a queue.
    It returns the path as a list of graph nodes (or an empty list if no path exists)."""

    dispenser = myQueue.Queue()
    myQueue.enqueue(source, dispenser)

    #construct the visited list.

    visited = set()
    visited.add(source)

    #loop untill either the destination is found or the dispenser
    #is empty (no path)

    while not myQueue.empty(dispenser):
        current = myQueue.front(dispenser)
        myQueue.dequeue(dispenser)
        if current == dest:
            break
        # loop over all neighbors of current
        for neighbor in current.neighbors:
            # process unvisited neighbors
            if neighbor not in visited:
                neighbor.previous = current
                visited.add(neighbor)
                myQueue.enqueue(neighbor, dispenser)
    return constructPath(visited, source, dest)

def constructPath(visited, source, dest):

"""Returns the path as a list of nodes from source to destination"""

    #construct the path using a stack and traversing from the destination
    #node back to the source node using Node's previous
    stack = myStack.Stack()
    if dest in visited:
        temp = dest
        while tmp != source:
            myStack.push(tmp, stack)
            tmp = tmp.previous
        myStack.push(source, stack)

    path = []
    while not myStack.empty(stack):
        path.append(myStack.top(stack))
        myStack.pop(stack)
    return path

---

stack = myStack.Stack()
if dest in visited:
    temp = dest
    while tmp != source:
        myStack.push(tmp, stack)
        tmp = tmp.previous

I think the tmp and temp variables here should be the same? Although I would expect an error since tmp isn't assigned before you use it.