Variación rara del gato en carro (II)

# -*- coding: latin-1 -*-

#Este juego instancia algunas ideas de las previas entradas de este blog.
#Se supone que el juego consiste en atrapar letras vocales, deambulando
#no tan libremente con un carrito dentro de un laberinto.

#El video de la ejecución (lo siento, sin editar), está en
#https://youtu.be/BOvuFYqT-sA

import pygame,os,time,random
from pygame.locals import *

H=480
W=640

fgrid=open('grid04.txt','rw')
eve=[]

for line in fgrid:
    line=filter(lambda x: x!='\n',line)
    eve.append(line)

l=[]
j=0
s=0
for i in eve:
    # [k for k in i if k=='1']
    s=0
    for m in i:
        l.append((j,s,m))
        s=s+1
    j=j+1


class Player(pygame.sprite.Sprite):
    speed = 2
    bounce = 24
    images = []
    frame, i= 0, 0
    animcycle=12
    posx, posy=41, 41
    change_x, change_y=41, 41
    #Ejemplo de vector patrón de movimiento
#    boun1=[H/150,-H/150,0,0,0]
 #   boun2=[H/140,-H/150,0,0,0]  
   # boun3=[H/170,-H/170,0,0,0]  

    boun1=[0,0,0,0,0]
    boun2=[0,0,0,0,0]
    boun3=[0,0,0,0,0]

    def __init__(self):
        pygame.sprite.Sprite.__init__(self,self.containers)
        self.image=self.images[0]
        self.rect = self.image.get_rect()
        self.facing=-1
        self.origtopx=self.rect.top+41
        self.origtopy=self.rect.left+41

    def move(self,horver,direction):
        tempo=15
        self.rect = self.rect.clamp((0,0,640,480))
        if horver==1:
            if direction==-1:
                self.i=self.i+1
                if self.i % tempo==1:
                    self.image=self.images[0]
                else:  
                    self.image=self.images[4] #img5
                self.facing=-1#self.facing
                #Ejemplo de dilación y saltos...
                self.rect.top=self.rect.top-self.boun1[self.i%5]
                self.rect.move_ip(direction*self.speed,0)
            if direction==1:
                self.i=self.i+1
                if self.i % tempo==1:
                    self.image=self.images[1]
                else:  
                    self.image=self.images[5] #img5
                self.facing=1#-self.facing
#                self.image=self.images[0]
                self.rect.top=self.rect.top-self.boun2[self.i%5]
                self.rect.move_ip(direction*self.speed,0)
        if horver==-1:
            if direction==-1:
                self.i=self.i+1
                if self.i % tempo==1:
                    self.image=self.images[2]
                else:  
                    self.image=self.images[6] #img5
                self.rect.move_ip(0,direction*self.speed)
            if direction==1:
                self.i=self.i+1
                if self.i % tempo==1:
                    self.image=self.images[3]
                else:  
                    self.image=self.images[7] #img5
                self.rect.move_ip(0,direction*self.speed)
        if horver==2: #To say...
                self.rect.move_ip(direction*self.speed,direction*self.speed)
        self.change_x=self.rect.left      
        self.change_y=self.rect.top      


class Wall(pygame.sprite.Sprite):
    def __init__(self,x,y,height,width):
        pygame.sprite.Sprite.__init__(self,self.containers)
        brickImgTmp=pygame.image.load('./DataImgs/brick.png')
        brickImg=pygame.transform.scale(brickImgTmp,(height,width))
        self.image = brickImg
        self.rect = self.image.get_rect()
        self.rect.topleft = (x, y)

class Wall2(pygame.sprite.Sprite):
    def __init__(self,x,y,height,width,vowel):
        pygame.sprite.Sprite.__init__(self,self.containers)
        if vowel=='a':
            brickImgTmp=pygame.image.load('./DataImgs/brickaGreen.png')
        elif vowel=='e':
            brickImgTmp=pygame.image.load('./DataImgs/bricke.png')
        elif vowel=='i':
            brickImgTmp=pygame.image.load('./DataImgs/bricki.png')
        elif vowel=='o':
            brickImgTmp=pygame.image.load('./DataImgs/brickoRed.png')
        elif vowel=='u':
            brickImgTmp=pygame.image.load('./DataImgs/brickuBlue.png')

        brickImg=pygame.transform.scale(brickImgTmp,(height,width))
        self.image = brickImg
        self.rect = self.image.get_rect()
        self.rect.topleft = (x, y)
    def update(self):
       
        r=random.randint(1,20)
        if r==19:
            self.rect.move_ip(0,1)




def game():
    pygame.init()
    clock=pygame.time.Clock()
    disp=pygame.display.set_mode((640,480),0,32)
    background= pygame.Surface((640,480))
    imgTmp=pygame.image.load('./DataImgs/spriteCamioneta.png').convert_alpha()

    img2Tmp=pygame.image.load('./DataImgs/spriteCamioneta2.png').convert_alpha()
    img=pygame.transform.scale(imgTmp,(W/20,H/20))
    img5=pygame.transform.scale(img2Tmp,(W/20,H/20))
    img2 = pygame.transform.flip(img,1,0)
    img3 = pygame.transform.rotate(img,-90)
    img4 = pygame.transform.rotate(img,90)
    img6 = pygame.transform.flip(img5,1,0)
    img7 = pygame.transform.rotate(img5,-90)
    img8 = pygame.transform.rotate(img5,90)

    Player.images=[img,img2,img3,img4,img5,img6,img7,img8]

    every = pygame.sprite.OrderedUpdates()
    walls=pygame.sprite.Group()
#    wall2s=pygame.sprite.Group()
    Wall.containers=walls,every

    wall2s=pygame.sprite.Group()
    Wall2.containers=wall2s,every

    Player.containers=every
    player=Player()


    final=pygame.Rect(80,40,40,40)


    wall_list=[]
    wall2_list=[]
    emptyList=[]
    for t in l:
        if t[2]=='1':
            wall_list.append(Wall(t[1]*40,t[0]*40,40,40))
        elif t[2]=='2':
            wall2_list.append(Wall2(t[1]*40,t[0]*40,40,40,'o'))
        else:
            emptyList.append(t)
    print emptyList

    wall3_list=[]
    for t in emptyList:
        wall3_list.append(Wall2(t[1]*40,t[0]*40,40,40,random.choice("aeiou")))
#    wall2s=wall2_list      

    while True:
        old_x=player.rect.topleft[0]
        old_y=player.rect.topleft[1]
        if final.contains(player): Wall2(80,120,40,40,'e')
#            pygame.draw.rect(disp,Color('white'),(
#            disp.blit(disp,final)
# Current coordinates (player):

        for event in pygame.event.get():
            if event.type==QUIT or \
                    (event.type==KEYDOWN and event.key==K_ESCAPE):
                return
            keystate=pygame.key.get_pressed()      

        if keystate[K_RIGHT]:
            player.move(1,1)
        if keystate[K_LEFT]:
            player.move(1,-1)
        if keystate[K_UP]:
            player.move(-1,-1)
        if keystate[K_DOWN]:
            player.move(-1,1)


        new_x=player.change_x
        new_y=player.change_y
       
        FACING=player.facing

        # Put the player in the new spot
        player.rect.topleft = (new_x,new_y)
         # Did this update cause us to hit a wall?
        collide = pygame.sprite.spritecollide(player, wall_list, False)
        if collide:
            # Whoops, hit a wall. Go back to the old position
            player.rect.topleft=(old_x,old_y)

        collide1 = pygame.sprite.spritecollide(player, wall2s, True)
        if collide1: pass
            # Whoops, hit a wall. Go back to the old position
#            player.rect.topleft=(old_x,old_y)

        every.clear(disp,background)
        every.update()
        dirty=every.draw(disp)
        pygame.display.update(dirty)
        clock.tick(40)
    pygame.quit()
    fgrid.close()
game()

Variación rara del gato en carro (I)

#Consideremos ahora el siguiente (extremadamente) aburrido
#archivo grid04.txt, con los datos siguientes:

1111011110110111
0000000000110111
1011111110111011
0000000011000000
1111101111011011
0000000011101011
1101111110101011
0000000010110011
1111011121110111
0000000000000100
1011111121101011
0000000011100111
1111102111001011
0000000011101011
1101101110101011
0000000010101011

#Resulta que esta será un mundo preprogramado para la siguiente entrada...

Un gato no tan libre

#Este es un programa ya admitidamente algo largo, pero tenemos ahora la inclusion
#de un "score" para contar el numero de pelotas (temblorosas) y agregando también algunos
#obstáculos para impedir que el gato deambule impunemente. Tambien he agregado
#un ejemplo de musica de fondo; todos estos aditamentos en principio no lesionan
#la eficiencia en general.

#En este estado de desarrollo, existen diversas variantes que originarian juegos interesantes
#con las pertinentes modificaciones.
# Un video correspondiente a la ejecucion de este programa está en:
# VIDEO             https://youtu.be/GJMdnwv2VvI
import pygame,time,random
from pygame.locals import *

SCREENRECT = Rect(0,0,840,680)
SCORE=0
BOMBS=3

WHITE = (255, 255, 255)
GREEN = (0, 255, 0)
BLUE = (0, 0, 128)
BLUER = (0, 255, 128)


class Wall(pygame.sprite.Sprite):
    # Constructor function
    def __init__(self,height,width,x,y):
        # Call the parent's constructor
        pygame.sprite.Sprite.__init__(self,self.containers)
         # Make a blue wall, of the size specified in the parameters
        self.image = pygame.Surface([width, height])
        self.image.fill((BLUER))
         # Make our top-left corner the passed-in location.
        self.rect = self.image.get_rect()
        self.rect.topleft = (x, y)


class Wall2(pygame.sprite.Sprite):
    images=[]
    def __init__(self,x,y,width,height):
        pygame.sprite.Sprite.__init__(self,self.containers)
        self.image=self.images[0]
        self.rect=self.image.get_rect()
        self.x=x
        self.y=y
        self.rect.center = (self.x,self.y)
#    def update(self):
#        self.rect.center = (self.x,self.y)

class Score(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.font = pygame.font.Font(None,60)
        self.font.set_italic(1)
        self.color = Color('white')
        self.lastscore=-1
        self.update()
        self.rect=self.image.get_rect().move(10,550)
    def update(self):
        if SCORE != self.lastscore:
            self.lastscore = SCORE
            msg = "Score: %d" % SCORE
            self.image = self.font.render(msg,0,self.color)



class Gato(pygame.sprite.Sprite):
    speed = 5
    bounce = 24
    images = []
    frame = 0
    animcycle=12
    def __init__(self):
        pygame.sprite.Sprite.__init__(self,self.containers)
        self.image=self.images[0]
        self.rect = self.image.get_rect()
        self.facing=-1
        self.origtop=self.rect.top
        self.change_x=0
        self.change_y=0
       
    def move(self,horver,direction):
        if horver==1:
            if direction==-1:
                self.image=self.images[0]
                self.rect.move_ip(direction*self.speed,0)
            if direction==1:
                self.image=self.images[1]
#                self.image=self.images[0]
                self.rect.move_ip(direction*self.speed,0)
        if horver==-1:
            if direction==-1:
                self.image=self.images[2]
                self.rect.move_ip(0,direction*self.speed)
            if direction==1:
                self.image=self.images[3]
                self.rect.move_ip(0,direction*self.speed)
#    def update(self):
        self.change_x=self.rect.left      
        self.change_y=self.rect.top      

#        self.frame=self.frame+1
#        self.rect.top=self.origtop-(self.rect.left/self.bounce%2)


    def inf(self):
        print self.speed
        print self.bounce
        print self.images

class Ball(pygame.sprite.Sprite):
    images=[]
    images=[]
    frame=0
    animcycle=3
    defaultlife=20

#    x,y=random.randint(1,200),random.randint(1,200)
    def __init__(self,x,y):
        pygame.sprite.Sprite.__init__(self,self.containers)
        self.image=self.images[0]
        self.rect=self.image.get_rect()
        self.x=x
        self.y=y
        self.life=self.defaultlife
       
    def update(self):
#        self.rect.move(300,300)
        self.rect.center = (self.x,self.y)
        self.life=self.life-1
        self.image = self.images[self.life%5]
#        if self.life<=0: self.kill()


class Explosion(pygame.sprite.Sprite):
    images=[]
    frame=0
    animcycle=3
    defaultlife=20

    def __init__(self,actor):
        pygame.sprite.Sprite.__init__(self,self.containers)
        self.image=self.images[0]
        self.rect=self.image.get_rect()
        self.rect.center=actor.rect.center
        self.life=self.defaultlife

    def update(self):
#        self.frame = self.frame+1
        self.life=self.life-1
        self.image = self.images[self.life/self.animcycle%5]
        if self.life<=0: self.kill()

def main():
    global SCORE
    pygame.init()
    clock=pygame.time.Clock()
    windowStyle=0 #FULLSCREEN

    boom = pygame.mixer.Sound('./DataSounds/wahoo.wav')
    meow = pygame.mixer.Sound('./DataSounds/meow.wav')
    bus = pygame.mixer.music.load('./DataSounds/grieg.wav')
    pygame.mixer.music.play(-1,0.0)

    bestDepth=pygame.display.mode_ok(SCREENRECT.size,windowStyle,32)
    disp=pygame.display.set_mode(SCREENRECT.size,windowStyle,bestDepth)
    pygame.display.set_caption("!!!! *** Un GATO de verdad!!!!!... *** ")
    pygame.mouse.set_visible(0)

    background= pygame.Surface(SCREENRECT.size)
    img11=pygame.image.load('./DataImgs/cat.png')
    img=pygame.transform.scale(img11,(90,70))
    ball=pygame.image.load('./DataImgs/ball.png')
    imgExplosion1=pygame.image.load('./DataImgs/frogMio.png')
    imgExplosion=pygame.transform.scale(imgExplosion1,(100,100))
    wall2=pygame.image.load('./DataImgs/brick.png')
    bgdtile=pygame.image.load('./DataImgs/land.png')
 #   for yT in range(0,500,20):
#        for xT in range(0,SCREENRECT.width,bgdtile.get_width()):
#            background.blit(bgdtile,(xT,yT))
    background.blit(bgdtile,(0,400))
    disp.blit(background,(0,0))
   

    all = pygame.sprite.RenderUpdates()
    Gato.containers = all
    bombs=pygame.sprite.Group()
    walls2=pygame.sprite.Group()
    walls=pygame.sprite.Group()
    explosions=pygame.sprite.Group()
    Ball.containers = bombs, all
    Wall2.containers = walls2, all
    Wall.containers=walls,all
    Explosion.containers=explosions,all
    Score.containers=all
    if pygame.font:
        all.add(Score())

    img2 = pygame.transform.flip(img,1,0)
    #...1,0) equiv ...TrueX, FalseY)
    img3 = pygame.transform.rotate(img,-90)
    img4 = pygame.transform.rotate(img,90)
    Gato.images=[img,img2,img3,img4]

    Wall2.images=[wall2]

    ball01=pygame.transform.rotate(ball,2)
    ball02=pygame.transform.rotate(ball01,2)
    ball03=pygame.transform.rotate(ball02,2)
    ball04=pygame.transform.rotate(ball03,2)
    Ball.images=[ball,ball01,ball02,ball03,ball04]

    imE2=pygame.transform.rotate(imgExplosion,15)
    imE3=pygame.transform.rotate(imgExplosion,35)
    imE4=pygame.transform.rotate(imgExplosion,45)
    imE5=pygame.transform.rotate(imgExplosion,95)
    imE6=pygame.transform.rotate(imgExplosion,135)
    Explosion.images=[imgExplosion,imE2,imE3,imE4,imE5]

    pygame.display.flip()

    gato = Gato()

    bomb = Ball(100,200)
    bomb1 = Ball(40,300)
    bomb2 = Ball(200,500)
    wall2 = Wall2(130,180,5000,5000)
    wall_list=[]
#    wall_list.append(Wall(600,10,0,0))
 #   wall_list.append(Wall(10,790,10,0))
    wall_list.append(Wall(10,100,10,100))
    wall_list.append(Wall(30,200,210,300))
    wall_list.append(Wall(20,100,150,220))
    wall_list.append(Wall(100,30,100,350))
    wall_list.append(Wall(100,10,400,350))
    wall_list.append(Wall(10,100,40,400))
    wall_list.append(Wall(15,200,500,210))
    wall_list.append(Wall(120,10,250,320))
    wall_list.append(Wall(14,180,150,300))
    wall_list.append(Wall(160,19,350,200))


    walls3=pygame.sprite.RenderPlain(wall_list)


    gato.inf()

#    disp.blit(img,(100,00))

    while True:
        old_x=gato.rect.topleft[0]
        old_y=gato.rect.topleft[1]

        for event in pygame.event.get():
            if event.type==QUIT or \
                    (event.type==KEYDOWN and event.key==K_ESCAPE):
                return
            keystate=pygame.key.get_pressed()      
#                pygame.quit()
       
        all.clear(disp,background)
        all.update()
        if keystate[K_RIGHT]:
            gato.move(1,1)
        if keystate[K_LEFT]:
            gato.move(1,-1)
        if keystate[K_UP]:
#            for i in range(1,10):
            gato.move(-1,-1)
#            for i in range(1,9):
#                gato.move(-1,1)    
        if keystate[K_DOWN]:
            gato.move(-1,1)

        for wall2 in pygame.sprite.spritecollide(gato,walls2,False):
#            gato.speed=gato.speed+1
#             Wall(30,150,5000,5000)
             gato.move(0,0)
                     
        # Update position according to our speed (vector)
        new_x=gato.change_x
        new_y=gato.change_y
   
        # Put the player in the new spot
        gato.rect.topleft = (new_x,new_y)
         # Did this update cause us to hit a wall?
        collide = pygame.sprite.spritecollide(gato, walls3, False)
        if collide:
            # Whoops, hit a wall. Go back to the old position
            gato.rect.topleft=(old_x,old_y)


           
#True, remover sprite
        for bomb in pygame.sprite.spritecollide(gato,bombs,True):
            Explosion(gato)
            SCORE=SCORE+1
            x,y=random.randint(1,800),random.randint(1,600)
            if (x>1 and y <200) or (x>1 and y>400):
                meow.play()
            exists=random.randint(0,1)
            if exists==0:
                Ball(x,y)          
            boom.play()

        dirty=all.draw(disp)
        pygame.display.update(dirty)
        clock.tick(40)



if __name__=='__main__': main()

Consiguiendo sprites y sonidos (y docs de pygame)

http://www.spriters-resource.com/
http://www.pygame.org/hifi.html
http://www.wavsource.com/animals/animals.htm

El gato con bolas

#El siguiente es un pequeño juego de un gato persiguiendo unas pelotas, y
#encontrando algo curioso en cada ocasión.
#Puedes ver el video en: https://youtu.be/7Ho4JpCNwg0
import pygame,time,random
from pygame.locals import *

SCREENRECT = Rect(0,0,840,680)



class Gato(pygame.sprite.Sprite):
    speed = 5
    bounce = 24
    images = []
    frame = 0
    animcycle=12
    def __init__(self):
        pygame.sprite.Sprite.__init__(self,self.containers)
        self.image=self.images[0]
        self.rect = self.image.get_rect()
        self.facing=-1
        self.origtop=self.rect.top
       
    def move(self,horver,direction):
        if horver==1:
            if direction==-1:
                self.image=self.images[0]
                self.rect.move_ip(direction*self.speed,0)
            if direction==1:
                self.image=self.images[1]
#                self.image=self.images[0]
                self.rect.move_ip(direction*self.speed,0)
        if horver==-1:
            if direction==-1:
                self.image=self.images[2]
                self.rect.move_ip(0,direction*self.speed)
            if direction==1:
                self.image=self.images[3]
                self.rect.move_ip(0,direction*self.speed)
#    def update(self):
#        self.frame=self.frame+1
#        self.rect.top=self.origtop-(self.rect.left/self.bounce%2)


    def inf(self):
        print self.speed
        print self.bounce
        print self.images

class Bomb(pygame.sprite.Sprite):
    images=[]
#    x,y=random.randint(1,200),random.randint(1,200)
    def __init__(self,x,y):
        pygame.sprite.Sprite.__init__(self,self.containers)
        self.image=self.images[0]
        self.rect=self.image.get_rect()
        self.x=x
        self.y=y
       
    def update(self):
#        self.rect.move(300,300)
        self.rect.center = (self.x,self.y)

class Explosion(pygame.sprite.Sprite):
    images=[]
    frame=0
    animcycle=3
    defaultlife=20

    def __init__(self,actor):
        pygame.sprite.Sprite.__init__(self,self.containers)
        self.image=self.images[0]
        self.rect=self.image.get_rect()
        self.rect.center=actor.rect.center
        self.life=self.defaultlife

    def update(self):
#        self.frame = self.frame+1
        self.life=self.life-1
        self.image = self.images[self.life/self.animcycle%5]
        if self.life<=0: self.kill()

def main():
    pygame.init()
    clock=pygame.time.Clock()
    windowStyle=0 #FULLSCREEN

    boom = pygame.mixer.Sound('./DataSounds/wahoo.wav')
    meow = pygame.mixer.Sound('./DataSounds/meow.wav')

    bestDepth=pygame.display.mode_ok(SCREENRECT.size,windowStyle,32)
    disp=pygame.display.set_mode(SCREENRECT.size,windowStyle,bestDepth)
    pygame.display.set_caption("!!!! *** Un GATO de verdad!!!!!... *** ")
    pygame.mouse.set_visible(0)

    background= pygame.Surface(SCREENRECT.size)
    img11=pygame.image.load('./DataImgs/cat.png')
    img=pygame.transform.scale(img11,(90,70))
    sheep=pygame.image.load('./DataImgs/ball.png')
    imgExplosion1=pygame.image.load('./DataImgs/frogMio.png')
    imgExplosion=pygame.transform.scale(imgExplosion1,(100,100))
    bgdtile=pygame.image.load('./DataImgs/land.png')
 #   for yT in range(0,500,20):
#        for xT in range(0,SCREENRECT.width,bgdtile.get_width()):
#            background.blit(bgdtile,(xT,yT))
    background.blit(bgdtile,(0,400))
    disp.blit(background,(0,0))
   

    all = pygame.sprite.RenderUpdates()
    Gato.containers = all
    bombs=pygame.sprite.Group()
    explosions=pygame.sprite.Group()
    Bomb.containers = bombs, all
    Explosion.containers=explosions,all

    img2 = pygame.transform.flip(img,1,0)
    #...1,0) equiv ...TrueX, FalseY)
    img3 = pygame.transform.rotate(img,-90)
    img4 = pygame.transform.rotate(img,90)
    Gato.images=[img,img2,img3,img4]
    Bomb.images=[sheep]

    imE2=pygame.transform.rotate(imgExplosion,15)
    imE3=pygame.transform.rotate(imgExplosion,35)
    imE4=pygame.transform.rotate(imgExplosion,45)
    imE5=pygame.transform.rotate(imgExplosion,95)
    imE6=pygame.transform.rotate(imgExplosion,135)
    Explosion.images=[imgExplosion,imE2,imE3,imE4,imE5]

    pygame.display.flip()

    gato = Gato()

    bomb = Bomb(100,200)
    bomb1 = Bomb(40,300)
    bomb2 = Bomb(200,500)

    gato.inf()

#    disp.blit(img,(100,00))

    while True:
        for event in pygame.event.get():
            if event.type==QUIT or \
                    (event.type==KEYDOWN and event.key==K_ESCAPE):
                return
            keystate=pygame.key.get_pressed()      
#                pygame.quit()
       
        all.clear(disp,background)
        all.update()
        if keystate[K_RIGHT]:
            gato.move(1,1)
        if keystate[K_LEFT]:
            gato.move(1,-1)
        if keystate[K_UP]:
            gato.move(-1,-1)
        if keystate[K_DOWN]:
            gato.move(-1,1)
           
#True, remover sprite
        for bomb in pygame.sprite.spritecollide(gato,bombs,True):
            Explosion(gato)
            x,y=random.randint(1,800),random.randint(1,600)
            if (x>1 and y <200) or (x>1 and y>400):
                meow.play()
            exists=random.randint(0,1)
            if exists==0:
                Bomb(x,y)          
            boom.play()

        dirty=all.draw(disp)
        pygame.display.update(dirty)
        clock.tick(40)



if __name__=='__main__': main()

Un sprite con movimiento mediante teclas de dirección

#Con la siguiente salida asociada:

import pygame,time

from pygame.locals import *

SCREENRECT = Rect(0,0,640,480)

class Gato(pygame.sprite.Sprite):

    speed = 5

    bounce = 24

    images = []

    frame = 0

    animcycle=12

    def __init__(self):

        pygame.sprite.Sprite.__init__(self,self.containers)

        self.image=self.images[0]

        self.rect = self.image.get_rect()

        self.facing=-1

        

    def move(self,horver,direction):

        if horver==1:

            if direction==-1:

                self.image=self.images[0]

                self.rect.move_ip(direction*self.speed,0)

            if direction==1:

                self.image=self.images[1]

                self.image=self.images[0]

                self.rect.move_ip(direction*self.speed,0)

        if horver==-1:

            if direction==-1:

                self.image=self.images[2]

                self.rect.move_ip(0,direction*self.speed)

            if direction==1:

                self.image=self.images[3]

                self.rect.move_ip(0,direction*self.speed)

    def update(self):

        self.frame=self.frame+1

        self.image = self.images[self.frame/self.animcycle%3]

#        self.image=self.images[

    def inf(self):

        print self.speed

        print self.bounce

        print self.images

class Bomb(pygame.sprite.Sprite):

    images=[]

    def __init__(self):

        pygame.sprite.Sprite.__init__(self,self.containers)

        self.image=self.images[0]

        self.rect=self.image.get_rect()

    def update(self):

        self.rect.move(300,300)

def main():

    pygame.init()

    clock=pygame.time.Clock()

    windowStyle=0 #FULLSCREEN

    bestDepth=pygame.display.mode_ok(SCREENRECT.size,windowStyle,32)

    disp=pygame.display.set_mode(SCREENRECT.size,windowStyle,bestDepth)

    background= pygame.Surface(SCREENRECT.size)

    img=pygame.image.load('./DataImgs/car.png')

    sheep=pygame.image.load('./DataImgs/sheep.png')

    all = pygame.sprite.RenderUpdates()

    Gato.containers = all

    bombs=pygame.sprite.Group()

    Bomb.containers = bombs, all

    img2 = pygame.transform.flip(img,1,0)

    img3 = pygame.transform.rotate(img,-90)

    img4 = pygame.transform.rotate(img,90)

    Gato.images=[img,img2,img3,img4]

    Bomb.images=[sheep]

    gato = Gato()

    bomb = Bomb() 

    gato.inf()

#    disp.blit(img,(100,00))

    while True:

        for event in pygame.event.get():

            if event.type==QUIT:

                pygame.quit()

        keystate=pygame.key.get_pressed()        

        all.clear(disp,background)

        all.update()

        if keystate[K_RIGHT]:

            gato.move(1,1)

        if keystate[K_LEFT]:

            gato.move(1,-1)

        if keystate[K_DOWN]:

            gato.move(-1,1)

        if keystate[K_UP]:

            gato.move(-1,-1)

            

#        for bomb in pygame.sprite.spritecollide(gato,bombs,1):

#            print "Explosion!"

        dirty=all.draw(disp)

        pygame.display.update(dirty)

        clock.tick(40)

if __name__=='__main__': main()

Salida gráfica del programa previo