def do_your_job(self):
        """
        the goal of the explore agent is to move to the 
        target while avoiding blockages on the grid.
        This function is messy and needs to be looked at.
        It currently has a bug in that the backtrack oscillates
        so need a new method of doing this - probably checking if
        previously backtracked in that direction for those coords, ie
        keep track of cells visited and number of times visited?
        """
        y,x = self.get_intended_direction()  # first find out where we should go
        if self.target_x == self.current_x and self.target_y == self.current_y:
            #print(self.name + " : TARGET ACQUIRED")
            if len(self.results) == 0:
                self.results.append("TARGET ACQUIRED")
                self.lg_mv(2, self.name + ": TARGET ACQUIRED" )
            
            return
        
        self.num_steps += 1   
        # first try is to move on the x axis in a simple greedy search
        accessible = ['\\', '-', '|', '/', '.']
        
        # randomly move in Y direction instead of X if all paths clear
        if y != 0 and x != 0 and self.backtrack == [0,0]:
            if random.randint(1,10) > 6:
                if self.grd.get_tile(self.current_y + y, self.current_x) in accessible:
                    self.current_y += y
                    self.lg_mv(3, self.name + ": randomly moving Y axis " + str(self.num_steps)  )
                    return
        if x == 1:
            if self.grd.get_tile(self.current_y, self.current_x + 1) in accessible:
                self.current_x += 1
                self.lg_mv(3, self.name + ": move# " + str(self.num_steps) + " - moving West" )
                return
        elif x == -1:
            if self.grd.get_tile(self.current_y, self.current_x - 1) in accessible:
                self.current_x -= 1
                self.lg_mv(3, self.name + ": move# " + str(self.num_steps) + " - moving East" )
                return
        elif y == 1:
            if self.grd.get_tile(self.current_y + 1, self.current_x) in accessible:
                self.current_y += 1
                self.lg_mv(3, self.name + ": move# " + str(self.num_steps) + " - moving South" )
                return
        elif y == -1:
            if self.grd.get_tile(self.current_y - 1, self.current_x) in accessible:
                self.current_y -= 1
                self.lg_mv(3, self.name + ": move# " + str(self.num_steps) + " - moving North")
                return
        
        self.grd.set_tile(self.start_y, self.start_x, 'A')
        self.grd.save(os.path.join(os.getcwd(), 'agent.txt'))
the goal of the explore agent is to move to the 
        target while avoiding blockages on the grid.
        This function is messy and needs to be looked at.
        It currently has a bug in that the backtrack oscillates
        so need a new method of doing this - probably checking if
        previously backtracked in that direction for those coords, ie
        keep track of cells visited and number of times visited?