Con paralaje primitivo

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


#La salida es presentada en:
#https://youtu.be/0IK8vHa3g0U


import pygame,time,random,sys
from pygame.locals import *
from math 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)
BLACK = (0, 0, 0)

ENEMY_ODDS=222 #(Sic) Chances of a new enemy
ENEMY_RELOAD=12
LIVES=5

W=SCREENRECT.width
H=SCREENRECT.height

new_x=0
new_y=0
FACING=0

fgrid=open('mundo.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

fgrid.close()

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

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

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

fgrid.close()

#print eve

class Wall(pygame.sprite.Sprite):
    images=[]
    # Constructor function
    def __init__(self,x,y,width,height):
        wall22=pygame.image.load('./DataImgs/brick.png')
        wall2=pygame.transform.scale(wall22,(40,40))
        self.images=[wall2]
        # 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=self.images[0]
        self.rect=self.image.get_rect()
        self.x=x
        self.y=y
        self.rect.bottomleft = (self.x,self.y)


class Enemy(pygame.sprite.Sprite):
    speed = 2
    animcycle = 12
    images = []
    images1= []
    i=0
    up=1
    def __init__(self,init_x,init_y):
        pygame.sprite.Sprite.__init__(self, self.containers)
        beeImgTmp=pygame.image.load('./DataImgs/bee.png').convert_alpha()
        beeImg1=pygame.transform.scale(beeImgTmp,(W/13,H/12))
        beeImg2=pygame.transform.scale(beeImgTmp,(W/14,H/12))
        beeImg3=pygame.transform.scale(beeImgTmp,(W/15,H/12))

        self.images.append(beeImg1)
        self.images.append(beeImg2)
        self.images.append(beeImg3)

        beeImgTmp1=pygame.transform.flip(beeImgTmp,1,0)

        beeImg11=pygame.transform.scale(beeImgTmp1,(W/12,H/11))
        beeImg21=pygame.transform.scale(beeImgTmp1,(W/13,H/11))
        beeImg31=pygame.transform.scale(beeImgTmp1,(W/14,H/11))

        self.images1.append(beeImg11)
        self.images1.append(beeImg21)
        self.images1.append(beeImg31)

        self.image = self.images[0]
        self.rect = self.image.get_rect()
#        self.facing = random.choice((-1,1)) * Enemy.speed
        self.facing = -self.speed
#        self.up=0
#        self.speed=self.speed+random.choice((-1,1))
        self.frame = 0
        if self.facing < 0:
            self.rect.right = SCREENRECT.right+10
         
        self.rect.topleft = (init_x, init_y)

    def update(self):
#        if self.up==1:
        self.i=self.i+1
#        self.rect.move_ip(self.facing, 0)
#        self.rect.move_ip(lista[self.i%(len(lista))], lista2[self.i%len(lista2)])
        (a,b)=(2*listaM)[self.i%len(2*listaM)]
        self.rect.move_ip((a,b))
        if b>=0:
            self.facing=1
        else:
            self.facing=-self.facing
        if self.facing<0:
            self.frame = self.frame + 1
            self.image = self.images[self.frame/self.animcycle%3]
        else:
            self.frame = self.frame + 1
            self.image = self.images1[self.frame/self.animcycle%3]
         
#        print gato.change_x
#        print self.ene_x, self.ene_y #enemy_y
#        self.rect.move_ip(600/self.enemy_x,600/self.enemy_y)

        if not SCREENRECT.contains(self.rect):
            self.facing = -self.facing;
        #     self.rect.top = self.rect.bottom + 1
            self.rect = self.rect.clamp(SCREENRECT)
            if self.rect.right>W-W/9: self.kill()

def vel(n,ls):
   return map(lambda(x):vec(n,x),ls) + map(lambda(x):vec(n,x),ls)

def vec(n,(x,y)):
    return (n*x,n*y)

listaM=vel(random.randint(1,5),
           [(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),
            (1,0),(1,0),(1,0),(1,0),(1,0),(1,0),(1,0),(1,0),(1,0),(1,0),(1,0),(1,0),
            (0,-2),(0,-2),(0,-2),(0,-2),(0,-2),(0,-2),(0,-2),(0,-2),(0,-2),(0,-2),(0,-2),(0,-2),
            (0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),
            (1,0),(1,0),(1,0),(1,0),(1,0),(1,0),(1,0),(1,0),(1,0),(1,0),(1,0),(1,0),
            (0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1),(0,1)])
#lista=[1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,1,1,1,1,1,1]+\
#    [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
l#ista2=lista+lista+lista+map(lambda(n):(-3)*n,lista)
#from scores import *

class Landscape(pygame.sprite.Sprite):
    frame = 1
    inc=1
    dummyx=new_x
    dummyy=new_y
    towards=1
    images=[]
    change_x, change_y=0, 0
    def __init__(self,height,width,x,y):
        pygame.sprite.Sprite.__init__(self,self.containers)
        landImgTmp=pygame.image.load('./DataImgs/nocheFondo.png').\
            convert_alpha()
        landImg=pygame.transform.scale(landImgTmp,(height,width))
        self.image = landImg
        self.images.append(self.image)
        self.rect = self.image.get_rect()

        self.x=x
        self.y=y
        self.rect.topleft = (x, y)

    def update(self):
        self.towards=FACING
        self.oldLand_x=self.rect.topleft[0]
        self.oldLand_y=self.rect.topleft[1]

        if self.towards>0:
#            for i in range(new_x/50):
            self.newLand_x=self.rect.left      
            if self.newLand_x>0:
                self.rect.topleft=(self.oldLand_x,self.oldLand_y)
            else:
                self.rect.move_ip(1, 0)
        if self.towards<0:
            self.newLand_x=self.rect.right      
            if self.newLand_x<SCREENRECT.size[0]:
                self.rect.topleft=(self.oldLand_x,self.oldLand_y)
            else:
                self.rect.move_ip(-1, 0)
        self.newLand_y=self.rect.top  

class Landscape1(pygame.sprite.Sprite):
    frame = 1
    inc=1
    dummyx=new_x
    dummyy=new_y
    towards=1
    images=[]
    def __init__(self,height,width,x,y):
        pygame.sprite.Sprite.__init__(self,self.containers)
        landImgTmp=pygame.image.load('./DataImgs/edificiosFondoIntermedio.png').convert_alpha()
        landImg=pygame.transform.scale(landImgTmp,(height,width))
        self.image = landImg
        self.images.append(self.image)
        self.rect = self.image.get_rect()
        self.x=x
        self.y=y
        self.rect.topleft = (x, y)
    def update(self):
        self.towards=FACING
        self.oldLand_x=self.rect.topleft[0]
        self.oldLand_y=self.rect.topleft[1]

        if self.towards>0:
            self.newLand_x=self.rect.left      
            if self.newLand_x>0:
                self.rect.topleft=(self.oldLand_x,self.oldLand_y)
            else:
                self.rect.move_ip(2, 0)
        if self.towards<0:
            self.newLand_x=self.rect.right      
            if self.newLand_x<SCREENRECT.size[0]:
                self.rect.topleft=(self.oldLand_x,self.oldLand_y)
            else:
                self.rect.move_ip(-2, 0)
        self.newLand_y=self.rect.top  


class SaySomething(pygame.sprite.Sprite):
    def __init__(self,string):
        pygame.sprite.Sprite.__init__(self,self.containers)
        self.fontObj = pygame.font.Font('freesansbold.ttf', H/8)
        self.string=string
        self.textSurfaceObj = self.fontObj.render(self.string, True, \
                                                      Color('yellow'), (0,0,0))
        self.image=self.textSurfaceObj
        self.rect=self.image.get_rect()
        self.x=W/2
        self.y=H/2
        self.rect.center = (self.x,self.y)

class ScoreLives(pygame.sprite.Sprite):
    number=0
    def __init__(self,number,posx,posy):
        pygame.sprite.Sprite.__init__(self)
        self.font = pygame.font.Font(None,H/15)
        self.font.set_italic(1)
        self.color = Color('white')
        self.lastscore=-1
        self.update()
        self.number = number
        self.rect=self.image.get_rect().move(posx,posy)
    def update(self):
        if LIVES != self.lastscore:
            self.lastscore = LIVES
            msg = "Vidas: %d " % LIVES
           # msg = "Número %d: %d " % (self.number,SCORE)
            self.image = self.font.render(msg,0,self.color)

class Place(pygame.sprite.Sprite):
    def __init__(self,height,width,x,y):
        pygame.sprite.Sprite.__init__(self,self.containers)
        exitImgTmp=pygame.image.load('./DataImgs/exit.png')
        exitImg=pygame.transform.scale(exitImgTmp,(height,width))
        self.image = exitImg
        self.rect = self.image.get_rect()
        self.rect.topleft = (x, y)

class Score(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.font = pygame.font.Font(None,H/15)
        self.font.set_italic(1)
        self.color = Color('black')
        self.lastscore=-1
        self.update()
        self.rect=self.image.get_rect().move(30,650)
    def update(self):
        if SCORE != self.lastscore:
            self.lastscore = SCORE
            msg = "Pelotas rasguñadas: %d" % SCORE
            self.image = self.font.render(msg,0,self.color)



class Wall2(pygame.sprite.Sprite):
    images=[]
    def __init__(self,x,y,width,height):
        wall22=pygame.image.load('./DataImgs/brick.png')
        wall2=pygame.transform.scale(wall22,(40,40))
        pygame.sprite.Sprite.__init__(self,self.containers)
        self.images=[wall2]
        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)

        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 Gato(pygame.sprite.Sprite):
    speed = 5
    bounce = 24
    images = []
    frame, i= 0, 0
    animcycle=12
#    posx, posy=110, 200
    change_x, change_y=200, 200
    loop=3
    #Ejemplo de vector patrón de movimiento
    boun=[H/150,-H/150,0,0,0]+[H/150,-H/150,0,0,0]+[H/150,-H/150,0,0,0]
    boun2=map((lambda(x): x*(-3)), [-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5])+\
        map((lambda(x): x*3),[-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5])
 
    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.rect.top=300
        self.rect.left=300
#        self.origtopx=200 #self.rect.top
#        self.origtopy=200 #self.rect.left
    def move(self,horver,direction):
        self.rect = self.rect.clamp(SCREENRECT)
        if horver==1:
            if direction==-1:
                self.i=self.i+1
                self.image=self.images[0]
                self.facing=-1#self.facing
                #Ejemplo de dilación y saltos...
                self.rect.top=self.rect.top-self.boun[self.i%15]
                self.rect.move_ip(direction*self.speed,0)
            if direction==1:
                self.i=self.i+1
                self.image=self.images[1]
                self.rect.top=self.rect.top-self.boun[self.i%15]              
                self.facing=1#-self.facing
#                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)
        if horver==2: #To say...
                self.i=self.i+1
                self.image=self.images[0]
                self.rect.top=self.rect.top-self.boun2[self.i%30]
                self.rect.move_ip(direction*self.speed,direction*self.speed)
#        if horver==3: #To say...
#                self.rect.move_ip(-direction*self.speed,direction*self.speed)
#                self.rect.move_ip(1,1)
        self.change_x=self.rect.left
        self.change_y=self.rect.top
#        print self.change_x,"----",self.change_y

#    def update(self):
#        if random.randint(1,20)==1:
 #               self.rect.move_ip(0,self.speed)
#            self.move(-1,1)
#        self.loop=self.loop-1
#        self.rect.move(300,300)
#        self.rect.center = (self.x,self.y)
#        self.life=self.life-1
#        self.image = self.images[self.loop%2]

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):
     
        ball0=pygame.image.load('./DataImgs/ball.png')
        ball=pygame.transform.scale(ball0,(70,70))
        ball01=pygame.transform.rotate(ball,2)
        ball02=pygame.transform.rotate(ball01,2)
        ball03=pygame.transform.rotate(ball02,2)
        ball04=pygame.transform.rotate(ball03,2)
        self.images=[ball,ball01,ball02,ball03,ball04]

        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[0] #self.life%5]
#        if self.life<=0: self.kill()

class PezEnemigo(pygame.sprite.Sprite):
    images=[]
    frame=0
    animcycle=3
    defaultlife=20
    facing=-1

#    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 move(self,horver,direction):
        if horver==1:
            if direction==-1:
                self.image=self.images[0]
                self.rect.move_ip(direction*self.speed,0)
                self.facing=-1
            if direction==1:
                self.image=self.images[1]
#                self.image=self.images[0]
                self.rect.move_ip(direction*self.speed,0)
                self.facing=1
        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      
     
    def update(self):
#        self.rect.move(300,300)
        if movPE!=[]:
            self.x,self.y=movPE.pop()
            self.rect.center = (self.x,self.y)
            #self.move(self.x,self.y)
        else:
            self.x=self.x+1
            if 0==self.x%350:
                self.x=0
                self.rect.center = (self.x,self.y)
                #self.move(self.x,self.y)
#        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()

movPE=[]
for i in range(1,60):
    for j in range(1,60):
        movPE.append((300*sin(i*0.01)+200,300*cos(j*0.01)+200))

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

    def __init__(self,actor):
        imgExplosion1=pygame.image.load('./DataImgs/frogMio.png')
        imgExplosion=pygame.transform.scale(imgExplosion1,(80,80))

        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.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
    global new_x
    global new_y
    global LIVES
    global FACING
    enemyreload = ENEMY_RELOAD

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

    boom = pygame.mixer.Sound('./DataSounds/cork_pop.wav')
    meow = pygame.mixer.Sound('./DataSounds/meow.wav')
    haha = pygame.mixer.Sound('./DataSounds/haha.wav')
    bus = pygame.mixer.music.load('./DataSounds/grieg.wav')
    laserSound = pygame.mixer.Sound('./DataSounds/wahoo.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,50))

    pezEImg0=pygame.image.load('./DataImgs/pezEnemigo.png')
    pezEImg=pygame.transform.scale(pezEImg0,(30,40))
    pezEImg2=pygame.transform.scale(pezEImg,(30,50))
    pezEImg3=pygame.transform.scale(pezEImg2,(40,50))


 
    bgdtile1=pygame.image.load('./DataImgs/land.png')
    bgdtile=pygame.transform.scale(bgdtile1,(870,290))

    every = pygame.sprite.OrderedUpdates()
#    every = pygame.sprite.RenderUpdates()

    Gato.containers = every

    bombs=pygame.sprite.Group()
    walls2=pygame.sprite.Group()
    walls=pygame.sprite.Group()
    enemies=pygame.sprite.Group()
    places=pygame.sprite.Group()
    landscapes=pygame.sprite.Group()
    landscapes1=pygame.sprite.Group()
    pezEnemigos=pygame.sprite.Group()
    explosions=pygame.sprite.Group()
    sayings=pygame.sprite.Group()

    Ball.containers = bombs, every
    SaySomething.containers=sayings, every
    Landscape.containers=landscapes,every
    Landscape1.containers=landscapes1,every
#    PezEnemigo.containers = pezEnemigos, every
    ScoreLives.containers=every
    Place.containers=places, every
    Wall2.containers = walls2, every
    Wall.containers=walls, every
    Enemy.containers=enemies,every
    Explosion.containers=explosions,every
    Score.containers=every

    if pygame.font:
        H1=H-H/7
        every.add(Score())
#        every.add(ScoreLives(2,10,H1+H/22))
        every.add(ScoreLives(2,40,625))

    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]

    PezEnemigo.images=[pezEImg,pezEImg2,pezEImg3,
                       pezEImg,pezEImg]

    Wall2(0,0,900,500)

    landMain=Landscape(W*2,3*H/5,-W/2,1)
    landscape_list=[]

    landscape_list.append(landMain)

    landscape1_list=[]
    landscape1_list.append(Landscape1(W*2,4*H/7,-W/3,H/2-H/4))

    background.blit(bgdtile,(0,400))
    disp.blit(background,(0,0))

    pygame.display.flip()

    gato = Gato()
#    pezEne1=PezEnemigo(200,300)
    bomb = Ball(100,200)
    bomb1 = Ball(40,300)
    bomb2 = Ball(200,500)


    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

#   #  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))
    places_list=[]
#    for i in range(10):
#        x,y=random.randint(550,600),random.randint(450,500)
    places_list.append(Place(W/8,H/12,W-W/4,H-H/6))

#    enemy1 = Enemy(100,100,100,10)  
    while True:
        old_x=gato.rect.topleft[0]
        old_y=gato.rect.topleft[1]
        print gato.change_x,'   ',gato.change_y
#        print enemy.change_x,'   ',enemy.change_y

        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()
     
        every.clear(disp,background)
        every.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)
        if keystate[K_SPACE]:
            gato.speed=1
            for i in range(1,10):
                gato.move(2,-1)
#            for i in range(1,30):
#                gato.move(3,-1)

#            for i in range(1,100):
#                gato.move(-1,1)
            gato.speed=5
        if keystate[K_a]:
#            gato.move(1,-1)
            a=gato.rect.top
            b=gato.rect.left
            gato.rect.top=a+100
            gato.rect.left=b+100

        if enemyreload:
            enemyreload=enemyreload-1
        elif not int(random.random()*ENEMY_ODDS):
            z=random.randint(1,2)
            if z==1:
                Enemy(W/20,10+H/20)
            else:
                Enemy(W-W/20,10+H/30)
            enemyreload=ENEMY_RELOAD #???????
#E
#        if keystate[K_s]:
#            player.move(-2,-1)
        for enemy in enemies:
            collide3 = pygame.sprite.spritecollide(enemy, wall_list, False)
            if collide3:
                enemy.facing=-enemy.facing


        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
        FACING=gato.facing
        fps_limit=60
        # 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)

        for enemy in pygame.sprite.spritecollide(gato,enemies,True):
            laserSound.play()
            LIVES = LIVES-1
            if LIVES==0:
                gato.kill()
# landscapes.draw(disp)#Landscape(100,100,0,0)
                if pygame.font:
                    every.add(SaySomething("¡Upssss!"))#or option to continue
                    every.clear(disp,background)
                    every.update()
                    dirty=every.draw(disp)
                    pygame.display.update(dirty)

haha.play()
time.sleep(3)
pygame.display.quit()
pygame.quit()
sys.exit()

        for place in pygame.sprite.spritecollide(gato,places,True):
            haha.play()
            if pygame.font:
#                every.add(SaySomething("¡Hasta luego...!"))#or option to continue
                every.add(SaySomething("¿Continuar (s/n)?"))#or option to continue
                every.clear(disp,background)
                every.update()
                dirty=every.draw(disp)
                pygame.display.update(dirty)
                if keystate[K_SPACE]:
                    main()
                else:
                    every.add(SaySomething("¡Hasta luego...!"))#or option to continue
                    time.sleep(3)
                    pygame.display.quit()
                    pygame.quit()
                    sys.exit()

         
#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)
            exists=random.randint(0,1)
            if exists==0:
                Ball(x,y)          
            boom.play()
     
        every.clear(disp,background)
        every.update()
        dirty=every.draw(disp)
        pygame.display.update(dirty)
        clock.tick(fps_limit)

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



if __name__=='__main__': main()