Develop Reference

TypeError: argument 1 must be pygame.Surface, not str after window.blit() [closed]

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 2 years ago.
Improve this question
I am trying to learn the pygame module and I keep getting 'TypeError: argument 1 must be pygame.Surface, not str' when running it after reorganizing my code and rearranging it into classes, the code below shows the class if it is all that is needed, I have also included the full code if the first bit of code doesn't work.
class player(object):
def __init__(self,x,y,width,height,jH):
self.x= x # x coordinate of the character
self.y = y # y coordinate of the character
self.w = width # width of the character
self.h = height # Height of the character
self.v = 20 # Speed of the character
self.jump = False # Will determine whether the character is jumping
self.jumpC = jH # Jump variable
self.direction = "left"
self.isWalking = 0
def redraw(self,wind):
global number
global previousnumber
global selectedimage
if previousnumber == number:
selectedimage = walkUp[0]
previousnumber = number
window.blit(selectedimage,(self.x,self.y))
Above is the class, the full code is below if it is needed.
import pygame # importing module
pygame.init() # initiates pygame
window = pygame.display.set_mode((500,500)) # creates a 500x500px window
pygame.display.set_caption("PYGAME TEST") # sets caption, self explanatory
class player(object):
def __init__(self,x,y,width,height,jH):
self.x= x # x coordinate of the character
self.y = y # y coordinate of the character
self.w = width # width of the character
self.h = height # Height of the character
self.v = 20 # Speed of the character
self.jump = False # Will determine whether the character is jumping
self.jumpC = jH # Jump variable
self.direction = "left"
self.isWalking = 0
def redraw(self,wind):
global number
global previousnumber
global selectedimage
if previousnumber == number:
selectedimage = walkUp[0]
previousnumber = number
window.blit(selectedimage,(self.x,self.y))
run = True # variable used in a loop, its true if the program is still running.
walkRight = [pygame.image.load('right1.png'), pygame.image.load('right2.png'), pygame.image.load('right3.png')]
walkLeft = [pygame.image.load('left1.png'), pygame.image.load('left2.png'), pygame.image.load('left3.png')]
walkUp = [pygame.image.load('front1.png').convert(), pygame.image.load('front2.png'), pygame.image.load('front3.png')]
walkDown = [pygame.image.load('back1.png'), pygame.image.load('back2.png'), pygame.image.load('back3.png')]
bg = pygame.image.load('bg.jpg')
clock = pygame.time.Clock()
number = 0
selectedimage = walkUp[number]
previousnumber = -2
def spriteupdate(d,a,man):
global number
if man.direction != d:
man.direction = d
changed(0,a,man)
else:
number+= 1
if number>2:
number = 0
changed(number,a)
else:
changed(number,a,troop)
def changed(numb, direction,man):
global number
global selectedimage
number = numb
selectedimage = man.direction[number]
def update(man):
troop.redraw(window)
window.blit(bg,(0,0))
pygame.display.update()
troop = player(250,250,10,10,10)
while run:
clock.tick(15)# FPS
for event in pygame.event.get():
if event.type == pygame.QUIT: # if event quits, presses the x button
run = False # breaks loop
keys = pygame.key.get_pressed() # gets the keys pressed
if keys[pygame.K_LEFT]:# pressed left arrow, x coordinate changes by - speed
#direction, array
spriteupdate("left",walkLeft,troop)
if troop.x <= -10:
pass
else:
troop.x-=troop.v
if keys[pygame.K_RIGHT]: # similar here
spriteupdate("right", walkRight,troop)
if troop.x >= 470:
pass
else:
troop.x+=troop.v
if not(troop.jump): # Only works if the character isn't jumping
if keys[pygame.K_SPACE]: # The character is jumping. changes variable.
troop.jump = True
if keys[pygame.K_UP]: # same here
spriteupdate("down",walkDown,troop)
if troop.y <= -10:
pass
else:
troop.y-=troop.v
if keys[pygame.K_DOWN]: # same here
spriteupdate("up",walkUp,troop)
if troop.y >= 470:
pass
else:
troop.y+=troop.v
else:
if troop.jumpC >= -10: # jumpC is already bigger than -10, this is called
num = 1 # number, will be set to -1 if jumpC becomes a negative number
if troop.jumpC < 0:
num = -1 # there.
troop.y-= (troop.jumpC ** 2) * 0.5 * num # y subtracted (goes up) by the square of jumpC * half * num
troop.jumpC -= 1 # Subtracts 1
else:
troop.jump = False # If Jump c is smaller than -10, jump has finished.
troop.jumpC = 10 # reset variable
update(troop)
pygame.quit()
OUTPUT:
pygame 1.9.6
Hello from the pygame community. https://www.pygame.org/contribute.html
Traceback (most recent call last):
File line 107, in <module>
update(troop)
File line 56, in update
troop.redraw(window)
File , line 25, in redraw
window.blit(selectedimage,(self.x,self.y))
TypeError: argument 1 must be pygame.Surface, not str
This output is above, hope that helps.

On line 53 selectedimage is changed from a surface to a string with :
selectedimage = man.direction[number]

I see one problem right away. In the player.redraw method, wind is the argument passed, but in the body of the method you use window. Try changing the argument:
def redraw(self, window):

Why wont my collision detection or falling images work?

I have recently written this code where fruits and other things fall from the top of the screen and the frog at the bottom has to try and catch them. The collision detection is not working and neither is the falling images as they seem to just fall and get stuck at the top of the screen. This is most of my code as I cannot seem to work out which area the actual error is in:
import pygame, sys, time, random
from pygame.locals import *
######### constants ##########
jumpvel=20
fallingspeed=0.5
running= True
blue= [129,183 ,253]
pink=[255,174,201]
textcolour= [255,255,255]
x=700//2
y=1000//2
score=0
#### fruits and naughty ######
thingylist= ['fruit1.bmp','fruit2.bmp','fruit3.bmp','fruit4.bmp','fruit5.bmp','fruit1.bmp','fruit2.bmp','fruit3.bmp','fruit4.bmp','fruit5.bmp','naughty1.bmp','naughty2.bmp','naughty3.bmp',]
all_things=[]
for i in range (12):
new_thing_image=pygame.image.load(thingylist[(random.randrange(0,12))])
new_thing_image.set_colorkey(pink)
new_thing_rect=new_thing_image.get_rect()
new_thing_rect.x=random.randrange(0,950)
new_thing_rect.y=-random.randrange(50,500)
all_things.append([new_thing_image,new_thing_rect])
################collision###############
def checkCollision (frog_rect,all_things,score):
collides_with=None
for i in range (len(all_things)):
thing_rect=all_things[i][1]
if (frog_rect.colliderect(thing_rect)):
score=score+100
return collides_with
######## initialising screen#########
pygame.init()
gamedisplay=pygame.display.set_mode((1000,600)) #making the screen
pygame.display.set_caption('frog')
clock=pygame.time.Clock()# frames per second
bg=pygame.image.load('actual clouds.bmp').convert()
############ initialising sprites##############
frog= pygame.image.load('actual frog.bmp')
frog.set_colorkey(blue)
frog_rect=frog.get_rect()
frog_rect.centerx=(x)
frog_rect.centery=(y)
####### score###########
pygame.font.init()
font= pygame.font.SysFont ('Dubai MS', 48)
##########drawing things#############
def drawThings (all_things):
for item in all_things:
new_thing_image, new_thing_rect= item
gamedisplay.blit(new_thing_image, (new_thing_rect.x, new_thing_rect.y))
#########update display function###########
def update(x,y,all_things,score):
gamedisplay.blit(bg,[0,0])
gamedisplay.blit(frog,(x,y))
for thing in range (len(all_things)):
new_thing_rect=all_things[i][1]
#thing_rect.y=thing_rect.y+fallingspeed
new_thing_rect.y+= fallingspeed
drawThings(all_things)
label=font.render("score "+ str(score) ,1,textcolour)
gamedisplay.blit(label,(750,10))
pygame.display.update()
pygame.time.delay(50)
#########main game loop ############
while running == True:
gamedisplay.blit(bg,[0,0])
gamedisplay.blit(frog,(x,y))
drawThings(all_things)
label=font.render("score "+ str(score) ,1,textcolour)
gamedisplay.blit(label,(750,10))
pygame.display.flip()
pygame.event.pump()
key=pygame.key.get_pressed()
########### escape ###########
if key [pygame.K_ESCAPE]:
sys.exit()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
########### controls ##############
if key[pygame.K_LEFT]:
x -=2
elif key[pygame.K_RIGHT]:
x +=2
elif key[pygame.K_SPACE]or key[pygame.K_UP]:
for i in range (5):
y -= jumpvel
update(x,y,all_things,score)
for i in range (5):
y += jumpvel
update(x,y,all_things,score)
######## limits ####################
if x < 10:
x = 10
elif (x > (900 - 2)):
x= 900-2
######### falling###########
for item in all_things:
new_thing_image, new_thing_rect= item
#new_thing_rect=all_things[i][1]
#thing_rect.y=thing_rect.y+fallingspeed
new_thing_rect.y+= fallingspeed
############collision detection##########
detect=checkCollision (frog_rect, all_things,score)
if (detect !=None):
score=score+100
update(x,y,all_things,score)
The 'things' are meant to fall to the bottom of the screen for the frog to catch but they are all seemingly getting stuck at the top. When i tested the code for collision detection even when the two images collided it had no effect on the score- meaning something is not working.

Falling images stop because of this
fallingspeed = 0.5
rect uses integer values to keep positon so it will rount 0.5 to integer - int(0.5) == 0.
When you have y = 0 and you add 0.5 - so you could expect y = 0.5 - it will round it to y = 0. In next loop you will add again 0.5 and it will round it to y = 0 again. This way it stops on y = 0
When you have ie y = -5 and you add 0.5 then you could expect -4.5 but it round to -4 (not -5) so it is moving.
Use
fallingspeed = 1
and it will not stop on y = 0
old_y = 0
new_y = int(old_y+0.5)
print(old_y, new_y)
# 0 0
old_y = -5
new_y = int(old_y+0.5)
print(old_y, new_y)
# -5 -4
Sometimes in more complex code it is important to keep position in float values and then you would have to use float variables instead of rect to keep positon and copy it to rect only when you have to draw or check collision
collisions
Inside checkCollision you set collides_with = None but you never change it to `True
def checkCollision (frog_rect,all_things, score):
collides_with = None
for i in range (len(all_things)):
thing_rect = all_things[i][1]
if (frog_rect.colliderect(thing_rect)):
score=score+100
collides_with = True
return collides_with
You could write it shorter
def checkCollision(frog_rect,all_things, score):
collides_with = None
for thing_image, thing_rect in all_things:
if frog_rect.colliderect(thing_rect):
score = score+100
collides_with = True
return collides_with
Now it should change score in line
detect = checkCollision(frog_rect, all_things, score)
if detect:
score = score+100
But if you want to change it inside checkCollision then you have to return value score. Variable score inside checkCollision is local variable and it doesn't change value in global variable score
def checkCollision(frog_rect,all_things, score):
collides_with = None
for thing_image, thing_rect in all_things:
if frog_rect.colliderect(thing_rect):
score = score+100
collides_with = True
return collides_with, score
and then you have to assing to global score
detect, score = checkCollision(frog_rect, all_things, score)

Pyglet game movement lagging behind

So, my snake makes a continuous movement, but if I press any key it goes back in time and lags back and forward. Here is a video: https://youtu.be/KCesu5bGiS8
My guess would be to update the key input faster, but when I do that everything updates faster, so the snake goes faster etc.
Code (as requested in text form) here:
import pyglet
import random
pyglet.resource.path = ["resources"]
pyglet.resource.reindex()
# sets the resource path
class Snake_Window(pyglet.window.Window):
a = 0
dtx = 160
dty = 200
# sets the basic direction and snake body x and y
def __init__(self):
super(Snake_Window, self).__init__(width=1280, height=720)
# sets resolution and inherits
self.key_handler = pyglet.window.key.KeyStateHandler()
self.push_handlers(self.key_handler)
# sets keys
self.set_caption("Wild Snake")
# gives it a name
self.background_image = pyglet.resource.image("background.png")
self.food_image = pyglet.resource.image("food.png")
self.snake_head_image = pyglet.resource.image("snake_head.png")
self.snake_body_image = pyglet.resource.image("snake_body.png")
# makes images usable
self.center_image(self.food_image)
self.center_image(self.snake_head_image)
self.center_image(self.snake_body_image)
# centers the images using center_image
self.snake_head = pyglet.sprite.Sprite(img=self.snake_head_image, x=200, y=200)
self.snake_head.scale = 0.1
self.snake_head.rotation = 270
# sets snake_head as a image on screen
self.snake_body = pyglet.sprite.Sprite(img=self.snake_body_image, x=self.dtx, y=self.dty)
self.snake_body.scale = 0.1
self.snake_body.rotation = 90
# sets snake_body as a image on screen
self.background = pyglet.sprite.Sprite(img=self.background_image, x=0, y=0)
# sets background as a image on screen
self.food = []
# sets food
pyglet.clock.schedule_interval(self.game_tick, 0.1)
def center_image(self, image):
# sets the center of the image to the actual center
image.anchor_x = image.width / 2
image.anchor_y = image.height / 2
def update_snake_head(self):
# makes the snake head go and sets the x and y for the body
if self.a == 0:
self.snake_head.x += 40
self.dtx = self.snake_head.x - 40
self.dty = self.snake_head.y
elif self.a == 1:
self.snake_head.x -= 40
self.dtx = self.snake_head.x + 40
self.dty = self.snake_head.y
elif self.a == 2:
self.snake_head.y += 40
self.dty = self.snake_head.y - 40
self.dtx = self.snake_head.x
elif self.a == 3:
self.snake_head.y -= 40
self.dty = self.snake_head.y + 40
self.dtx = self.snake_head.x
def update_snake_body(self, dtx, dty):
# makes the snakes body go
self.snake_body.x = dtx
self.snake_body.y = dty
def game_tick(self, dt):
# updates snakes head, snakes body, key presses and sets the background
self.update_snake_head()
self.update_snake_body(self.dtx, self.dty)
self.draw_elements()
self.key_press()
print(dt)
def draw_elements(self):
# draws everything in window
self.clear()
self.background.draw()
self.snake_head.draw()
self.snake_body.draw()
def key_press(self):
# sets direction of snake upon key press and rotates his head accordingly
if self.key_handler[pyglet.window.key.RIGHT]:
if self.a == 1:
pass
else:
self.a = 0
self.snake_head.rotation = 270
elif self.key_handler[pyglet.window.key.LEFT]:
if self.a == 0:
pass
else:
self.a = 1
self.snake_head.rotation = 90
elif self.key_handler[pyglet.window.key.UP]:
if self.a == 3:
pass
else:
self.a = 2
self.snake_head.rotation = 180
elif self.key_handler[pyglet.window.key.DOWN]:
if self.a == 2:
pass
else:
self.a = 3
self.snake_head.rotation = 0
game_window = Snake_Window()
pyglet.app.run()

Converting all my comments into a answer instead. It won't solve your problem completely. But due to lack of time, I'll leave something useful at least that almost solves it.
The reason for these are a couple. One of them is that you use a scheduler to render stuff instead of using the built-in on_draw event. Can't say for sure, but a good guess is that the graphical buffer gets updated/flipped automatically in on_draw while you're doing your drawing and stuff in a side-chained render function. So moving all the rendering stuff into on_draw makes sense.
Another issue is that you don't trigger on the actual key press, but instead you need to time the key press to each tick in the scheduler you got going - which you also have mushed into the rendering function. Essentially you're doing eventhandling+rendering+updating+IO in one cluster*** of a function, heh. Instead, you should rely on on_key_press for keyboard events.
Lastly, you're doing math operations all over the place - any of which might be half way done when you're doing the actual rendering. That's why you might get ghosting or odd artifacts (some things aren't completely done updating positions etc).
But here is a almost working example of a few steps taken to get closer to what you want. If no one else (including you) haven't solved this by a few days I'll go ahead and re-write most of your code and point you in a few good directions (batches being one of them).
import pyglet
import random
pyglet.resource.path = ["resources"]
pyglet.resource.reindex()
# sets the resource path
class Snake_Window(pyglet.window.Window):
a = 0
dtx = 160
dty = 200
# sets the basic direction and snake body x and y
def __init__(self):
super(Snake_Window, self).__init__(width=1280, height=720)
# sets resolution and inherits
self.key_handler = pyglet.window.key.KeyStateHandler()
self.push_handlers(self.key_handler)
# sets keys
self.set_caption("Wild Snake")
# gives it a name
self.background_image = pyglet.resource.image("background.png")
self.food_image = pyglet.resource.image("food.png")
self.snake_head_image = pyglet.resource.image("snake_head.png")
self.snake_body_image = pyglet.resource.image("snake_body.png")
# makes images usable
self.center_image(self.food_image)
self.center_image(self.snake_head_image)
self.center_image(self.snake_body_image)
# centers the images using center_image
self.snake_head = pyglet.sprite.Sprite(img=self.snake_head_image, x=200, y=200)
self.snake_head.rotation = 270
# sets snake_head as a image on screen
self.snake_body = pyglet.sprite.Sprite(img=self.snake_body_image, x=self.dtx, y=self.dty)
self.snake_body.scale = 0.1
self.snake_body.rotation = 90
# sets snake_body as a image on screen
self.background = pyglet.sprite.Sprite(img=self.background_image, x=0, y=0)
# sets background as a image on screen
self.food = []
# sets food
pyglet.clock.schedule_interval(self.game_tick, 0.1)
def on_draw(self):
self.draw_elements()
def center_image(self, image):
# sets the center of the image to the actual center
image.anchor_x = image.width / 2
image.anchor_y = image.height / 2
def update_snake_head(self):
# makes the snake head go and sets the x and y for the body
if self.a == 0:
self.snake_head.x += 40
self.dtx = self.snake_head.x - 40
self.dty = self.snake_head.y
elif self.a == 1:
self.snake_head.x -= 40
self.dtx = self.snake_head.x + 40
self.dty = self.snake_head.y
elif self.a == 2:
self.snake_head.y += 40
self.dty = self.snake_head.y - 40
self.dtx = self.snake_head.x
elif self.a == 3:
self.snake_head.y -= 40
self.dty = self.snake_head.y + 40
self.dtx = self.snake_head.x
def update_snake_body(self, dtx, dty):
# makes the snakes body go
self.snake_body.x = dtx
self.snake_body.y = dty
def game_tick(self, dt):
# updates snakes head, snakes body, key presses and sets the background
self.update_snake_head()
self.update_snake_body(self.dtx, self.dty)
def draw_elements(self):
# draws everything in window
self.clear()
self.background.draw()
print('Head:', self.snake_head.x, self.snake_head.y, {0:'Right', 1:'Left', 2: 'Up', 3:'Down'}[self.a])
self.snake_head.draw()
self.snake_body.draw()
self.flip()
def on_key_press(self, symbol, modifier):
# sets direction of snake upon key press and rotates his head accordingly
if symbol == pyglet.window.key.ESCAPE:
pyglet.app.exit()
if symbol == pyglet.window.key.SPACE:
print('Here')
if symbol == pyglet.window.key.RIGHT:
if self.a == 1:
pass
else:
self.a = 0
self.snake_head.rotation = 270
elif symbol == pyglet.window.key.LEFT:
if self.a == 0:
pass
else:
self.a = 1
self.snake_head.rotation = 90
elif symbol == pyglet.window.key.UP:
if self.a == 3:
pass
else:
self.a = 2
self.snake_head.rotation = 180
elif symbol == pyglet.window.key.DOWN:
if self.a == 2:
pass
else:
self.a = 3
self.snake_head.rotation = 0
game_window = Snake_Window()
pyglet.app.run()
I'll leave you not only with this ish-working code, but a good advice.
Stop asking so many questions, and start learn ways to debug why things are happening the way they do. You're shooting in the dark right now, asking questions hoping someone will solve the problems for you so you can focus on the fun stuff - which is the game development itself.
But what you'll have a lot of use for later in life - is finding ways to debug, probe, understand and pinpoint why things are or aren't happening the way you want.
Put some print("moo") here and there, print some values, add logging/debugging all over the place until you get wiser. It's not always efficient, but it got me to this point with your code.

Why does open set never go to 0?

I am trying to create the A Star algorithm and apply to the game Snake. The problem I'm having is that I never get anything drawn on the window because it never reaches that code. It gets stuck when trying to calculate the path in the method run(). Specifically, open set never goes to zero and it adds already existing nodes.
I've tried printing the various lists to the console, but all i've discovered is that "current" repeats tiles at random points, and "openSet and "closedSet" continue to get larger with these repeated tiles. I've also tested my Tile object, my contains method, and my giveNeighbors method and all of these seem to be working and give the expected results. Also as a reference, I am going of the pseudo code found here: https://en.wikipedia.org/wiki/A*_search_algorithm
import Tile
import pygame
class A_star:
def __init__(self):
self.closedSet = []
self.openSet = []
def run(self, start, goal):
self.closedSet = []
self.openSet = [start]
path = []
#THE LENGTH OF OPEN SET NEVER GOES TO ZERO!
while len(self.openSet) > 0:
#Set current to node in openSet with lowest fscore
current = self.openSet[0]
currindex = 0
for i, node in enumerate(self.openSet):
if node.fScore < current.fScore:
current = node
currindex = i
#romove from Open set and add to closed
self.openSet.pop(currindex)
self.closedSet.append(current)
#Reached the end
if current.tileEquals(goal):
print("Done")
while current != None:
path.append(current)
current = current.cameFrom
return path[::-1]
neighbors = self.giveNeighbors(current)
print("Current: " + str(current.posx) + ", " + str(current.posy))
print("Neighbors")
for i in neighbors:
print(str(i.posx) + ", " + str(i.posy))
for i in neighbors:
#if neighbor is already checked, then ignore it.
if not self.contains(self.closedSet, i):
#Distance between start adn neighbor. tenative gscore
tempGScore = current.gScore + 1
#if neighbor is not in openset. Discovered a new node!
if not self.contains(self.openSet, i):
self.openSet.append(i)
elif tempGScore < i.gScore:
i.gScore = tempGScore
i.cameFrom = current
i.fScore = i.gScore + self.heuristicCost(i, goal) #f = g + h
print("Open:")
for i in self.openSet:
print(str(i.posx) + ", " + str(i.posy))
print("Closed")
for i in self.closedSet:
print(str(i.posx) + ", " + str(i.posy))
#Calculates the estimated distance from a given tile to end
def heuristicCost(self, neighbor, goal):
#The snake never goes diagonal, therefore calculate manhatten distance
distance = abs(neighbor.posx - goal.posx) + abs(neighbor.posy - goal.posy)
return distance
def giveNeighbors(self, current):
neighbors = []
if current.posx > 0:
neighbors.append(Tile(current.posx - 10, current.posy))
if current.posx < 200:
neighbors.append(Tile(current.posx + 10, current.posy))
if current.posy > 0:
neighbors.append(Tile(current.posx, current.posy - 10))
if current.posy < 200:
neighbors.append(Tile(current.posx, current.posy + 10))
return neighbors
def contains(self, s, tile):
for i in s:
if i.tileEquals(tile):
return True
else:
return False
def testAStar():
pygame.init()
window = pygame.display.set_mode((200, 200))
pygame.display.set_caption("AStar Test")
window.fill((255,255,255))
clock = pygame.time.Clock()
start = Tile(0, 0)
end = Tile(190, 190)
astar = A_star()
path = astar.run(start, end)
run = True
while run:
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
pygame.draw.rect(window, (0, 255, 0), (start.posx, start.posy, 10, 10))
pygame.draw.rect(window, (255, 0, 0), (end.posx, end.posy, 10, 10))
for i in path:
pygame.draw.rect(window, (0, 0, 255), (i.posx, i.posy, 10, 10))
print("drew stuff")
pygame.display.update()
window.fill((255,255,255))
clock.tick(10)
pygame.quit()
if __name__== "__main__":
testAStar()
class Tile:
def __init__(self, x, y):
self.posx = x
self.posy = y
self.fScore = 0
self.gScore = 0
self.cameFrom = None
def nextTileRight(self):
self.posx = self.posx + 10
def nextTileDown(self):
self.posy = self.posy + 10
def nextTileUp(self):
self.posy = self.posy - 10
def nextTileLeft(self):
self.posx = self.posx - 10
def tileEquals(self, t):
if self.posx == t.posx and self.posy == t.posy:
return True
else:
return False
The expected result should be a non-diagonal path drawn on the window from the start node to the end node. (Also, sorry if my indentation is off. I am still very new to this website)

I'm not sure why you are checking openSets == 0 , you are looking for currentNode = destination or all the neighbours are closed meaning everything has been checked and no path was found.

Can't make walking animations in pygame

I was trying to code a game in pygame, but then when I tried to make a walking animation it only displayed one of the sprites.
def go_left(time):
ness_current = 1
global ness
global is_walking_left
ness_list = [ness_walking,ness_standing]
current_time = pygame.time.get_ticks()
go_left.walking_steps = 1
now = 0
cooldown = 1000
flag = 0
ness = ness_list[ness_current]
print current_time - game_loop.animation_timer
if (current_time - game_loop.animation_timer) > 200:
print 'Changing'
if ness_current == 0:
print 'Changing to sprite 1'
now = pygame.time.get_ticks()
ness_current = 1
current_time = now
elif ness_current == 1:
print 'Changing to sprite 0'
if (current_time - game_loop.animation_timer) > 200:
ness_current = 0
current_time = now
else:
'Changing to sprite 0 because of sprite reset'
ness_current = 0
current_time = now
def stop_it():
global ness
ness = pygame.image.load('nessthekid.png').convert()
ness.set_colorkey(WHITE)
car_list = pygame.sprite.Group()
all_sprites = pygame.sprite.Group()
player_list = pygame.sprite.Group()
When I try to use this it only displays one of the sprites not the other for the character. I want it to swich every 1 or 2 seconds to make it look like its walking. Help is appreciated.

First, I highly suggest using a class, to avoid using global variables.
Second, as you set the current time back to now (0), you will make it so current_time - game_loop.animation_timer will always be negative. This will keep the statement from running.
For now, I suggest completely removing the "if (current_time - game_loop.animation_timer) > 200:" from your code.
Here is an example to get you started (obviously you will have to alter it to make it work for you)
class Ness:
def __init__(self):
self.all_images = [ness_walking,ness_standing]
self.current = 0
self.image = self.all_images[self.current]
def walk_left(self):
# Every 200 clicks
if pygame.time.get_ticks() % 200 == 0:
if self.current == 0:
self.current = 1
else:
self.current = 0
self.image = self.all_images[self.current]

As suggested by #Red Twoon put the stuff separated in class is a very good practice. Another thing that you should do is no rely in get_ticks directly but instead use some kind of time independent movement/animation.
You can achieve this using delta times in your game loop.
Game loop.
while(True):
delta = #Get the delta time.
handle_events();
update(delta);
draw(delta);
#Animation stuff.
time_to_animate_frame = 200;
time_since_last_update = 0;
...
time_since_last_update += delta;
if(time_since_last_update > time_to_animate_frame):
time_since_last_update - time_to_animate_frame;
#Do the animation.....