This code keeps giving a TypeError:

$"""$

Motion planning on a rectangular grid using A$*$ search

$"""$

from random import random

from random import seed

from queue import PriorityQueue

from copy import deepcopy

class State$($object$)$:

def $\_\_$init$\_\_($self$,$ start$\_$position, goal$\_$position, start$\_$grid$)$:

self.position $=$ start$\_$position

self.goal $=$ goal$\_$position

self.grid $=$ start$\_$grid

self.total$\_$moves $=0$

#$---$ Fill in the rest of the class...

def manhattan$\_$distance$($self$)$:

$"""$Calculates the Manhattan distance to the goal."""

return abs$($self$.$goal$[0]-$ self.position$[0])+$ abs$($self$.$goal$[1]-$ self.position$[1])$

def get$\_$successors$($self$)$:

$"""$Generates possible successor states."""

successors $=[]$

for i$,$ j in $[(0,1),(0,-1),(1,0),(-1,0)]$:

new$\_$position $=($self$.$position$[0]+$ i$,$ self.position$[1]+$ j$)$

if $0<=$ new$\_$position$[0]<$ len$($self$.$grid$)$ and $0<=$ new$\_$position$[1]<$ len$($self$.$grid$[0])$:

if self.grid$[$new$\_$position$[0]][$new$\_$position$[1]]==0$:

new$\_$grid $=$ deepcopy$($self$.$grid$)$

new$\_$grid$[$new$\_$position$[0]][$new$\_$position$[1]]=\text{'}*\text{'}$

successors.append$($State$($new$\_$position, self.goal, new$\_$grid$))$

return successors

def create$\_$grid$()$:

$"""$

Create and return a randomized grid

$0\text{'}$s in the grid indcate free squares

$1\text{'}$s indicate obstacles

DON'T MODIFY THIS ROUTINE.

DON'T MODIFY THIS ROUTINE.

DON'T MODIFY THIS ROUTINE.

DON'T MODIFY THIS ROUTINE.

ARE YOU MODIFYING THIS ROUTINE?

IF SO$,$ STOP IT$.$

$"""$

# Start with a num$\_$rows by num$\_$cols grid of all zeros

grid $=[[0$ for c in range$($num$\_$cols$)]$ for r in range$($num$\_$rows$)]$

# Put ones around the boundary

grid$[0]=[1$ for c in range$($num$\_$cols$)]$

grid$[$num$\_$rows $-1]=[1$ for c in range$($num$\_$cols$)]$

for r in range$($num$\_$rows$)$:

grid$[$r$][0]=1$

grid$[$r$][$num$\_$cols $-1]=1$

# Sprinkle in obstacles randomly

for r in range$(1,$ num$\_$rows $-1)$:

for c in range$(2,$ num$\_$cols $-2)$:

if random$()<$ obstacle$\_$prob:

grid$[$r$][$c$]=1$;

# Make sure the goal and start spaces are clear

grid$[1][1]=0$

grid$[$num$\_$rows $-2][$num$\_$cols $-2]=0$

return grid

def print$\_$grid$($grid$)$:

$"""$

Print a grid, putting spaces in place of zeros for readability

DON'T MODIFY THIS ROUTINE.

DON'T MODIFY THIS ROUTINE.

DON'T MODIFY THIS ROUTINE.

DON'T MODIFY THIS ROUTINE.

ARE YOU MODIFYING THIS ROUTINE?

IF SO$,$ STOP IT$.$

$"""$

for r in range$($num$\_$rows$)$:

for c in range$($num$\_$cols$)$:

if grid$[$r$][$c$]==0$:

print$(\text{'}\text{'},$ end$=\text{'}\text{'})$

else:

print$($grid$[$r$][$c$],$ end$=\text{'}\text{'})$

print$(\text{'}\text{'})$

print$(\text{'}\text{'})$

return

def main$()$:

$"""$

Use A$*$ search to find a path from the upper left to the lower right

of the puzzle grid

Complete this method to implement the search

At the end, print the solution state

Each State object has a copy of the grid

When you make a move by generating a new State, put a $*$ on its grid

to show the solution path

$"""$

# Setup the randomized grid

grid $=$ create$\_$grid$()$

print$\_$grid$($grid$)$

# Initialize the starting state and priority queue

start$\_$position $=(1,1)$

goal$\_$position $=($num$\_$rows $-2,$ num$\_$cols $-2)$

start$\_$state $=$ State$($start$\_$position, goal$\_$position, grid$)$

start$\_$state.grid$[1][1]=$ ord$(\text{'}*\text{'})$

# A$*$ priority: implement the Manhattan distance in the State class

priority $=$ start$\_$state.total$\_$moves $+$ start$\_$state.manhattan$\_$distance$()$

queue $=$ PriorityQueue$()$

# Insert as a tuple

# The queue orders elements by the first tuple value

# A call to queue.get$()$ returns the tuple with the minimum first value

queue.put$(($priority$,$ start$\_$state$))$

# Maybe you should use a dictionary to keep track of visited positions?

#$---$ Fill in the rest of the search...

visited $=$ set$()$ # Keep track of visited positions

while not queue.empty$()$:

priority, current$\_$state $=$ queue.get$()$

current$\_$position $=$ current$\_$state.position

if current$\_$position $==$ goal$\_$position:

print$\_$grid$($current$\_$state.grid$)$ # Print the solution path

return

visited.add$($current$\_$position$)$

for successor in current$\_$state.get$\_$successors$()$:

if successor.position not in visited:

successor.total$\_$moves $=$ current$\_$state.total$\_$moves $+1$

priority $=$ successor.total$\_$moves $+$ successor.manhattan$\_$distance$()$

queue.put$(($priority$,$ successor$))$

# No solution found

print$("$No path found"$)$

if $\_\_$name$\_\_==\text{'}\_\_$main$\_\_\text{'}$:

seed$(0)$

#$---$ Easy mode

# Global variables

# Saves us the trouble of continually passing them as parameters

num$\_$rows $=8$

num$\_$cols $=16$

obstacle$\_$prob $=\mathrm{.}20$

for trial in range$(5)$:

print$(\text{'}$

$-----$Easy trial $\text{'}+$ str$($trial $+1)+\text{'}-----\text{'})$

ma