Creación de juegos 3D con Python y Blender

Preocupados quizás por las dificultades tradicionales en la creación de juegos, y mostrando las capacidades de Python en sus funciones de lenguaje de "scripts" (pequeños programas de alto nivel incrustados dentro de sistemas mayores), nace el concepto de Máquinas de Juegos en Blender
[un programa general de visualización de objetos en tres dimensiones, libre de costo, y descargable desde (www.blender.org)]
Veamos el siguiente código tomado de:

http://blendenzo.com/tutBeginningBGEPython.html

que, a quienes hemos trabajado con agentes durante un tiempo, semeja fielmente el
concepto de agente reactivo, con la simulación convincente visual de un trabajo conjunto de
sensores y actuadores, junto con la máquina de juegos de Blender que aporta el contexto físico
para dar como resultado (ver video en: https://youtu.be/B8P1j2sAAYg) un sorprendente resultado.

(Nuevo video con colorcitos y música: https://youtu.be/1Mq4abDkxzM)

cont = GameLogic.getCurrentController()
own = cont.getOwner()

#Sensors:

forward = cont.getSensor("Up")
backward = cont.getSensor("Down")
turnleft = cont.getSensor("Left")
turnright = cont.getSensor("Right")

#Actuators

motion = cont.getActuator("motion")

#Process

speed = 5
rspeed = 0.02
walk = 0
turn = 0

if forward.isPositive():
    walk = speed
if backward.isPositive():
    walk = -speed
if turnleft.isPositive():
    turn = rspeed
if turnright.isPositive():
    turn = -rspeed

motion.setLinearVelocity(0, walk, 0, 1)
motion.setDRot(0, 0, turn, 1)
GameLogic.addActiveActuator(motion, 1)

Inter: Por qué ciertos lenguajes

Explico sucintamente aquí por qué trabajo con algunos lenguajes en particular:

a) Prolog. Las bases lógicas de este lenguaje, su delicado equilibrio entre teoría y práctica, y sus 

aplicaciones a la inteligencia artificial, a deducciones y reescritura de términos hacen para mí

de Prolog una herramienta ideal en la investigación de la inteligencia humana y sus repercusiones 

en el razonamiento.

b) Haskell. Haskell tiene entre sus virtudes una definición de su semántica completa en un 100%,

con un concepto anexo de mónadas para el tratamiento de características "extra-formales"; la 

sistemática utilización de funciones, dominios y codominios (tipos), y su cercanía con el área de 

matemática de Teoría de categorías hacen de este lenguaje un auténtico paraiso computacional 

con muchas posibilidades aún por explorar.

c) Erlang. Erlang es un lenguaje nacido para tratar con sistemas distribuidos. Erlang, como Prolog

y Haskell, es también de propósito general, con ello implicando que, al dominar este lenguaje, 

seremos capaces de crear nuestros propios programas para resolver problemas específicos, sobre

todo aquellos relacionados con sistemas distribuidos y cómputo distribuido, dos temas fascinantes

de actualidad. 

d) Scheme. Scheme es la versión previa a Haskell, ambos fundamentos teóricamente en el Cálculo 

Lambda. Es una elección natural para los perversos quienes gustamos de pensarnos entre paréntesis.

e) Python. Python es la única elección imperativa que tengo. Tiene lo suficiente de clases para 

propósitos de tipos (con herencia simple, sobrecarga de operadores), contiene una buena cantidad

de construcciones de alto nivel (listas compactas) y de "funciones" de alto orden. Es una elección 

directa para propósitos de enseñanza y transición entre otros lenguajes imperativos y nuevas 

tendencias. 

Ojo: Hay <<miles>> de lenguajes de programación (ok, pongamos, cientos): los lenguajes previos son 

representativos de la lógica, las funciones, y el punto de vista pragmático de solventar con prontitud y

eficiencia (además de corrección) la resolución de problemas <<reales>>.

Madagascar y las vocales

Toma las vocales

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


#Este programa ilustra la idea de "tomar" objetos con un ratón
#(que es una manita), llevándolos de un lugar a otro.

import pygame,os,time,random
from pygame.locals import *
H=600
W=800
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 Hand(pygame.sprite.Sprite):
    posx=0
    posy=0
    def __init__(self,x,y,height,width):
        pygame.sprite.Sprite.__init__(self,self.containers)
        brickImgTmp=pygame.image.load('./DataImgs/hand.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):
        self.rect.topleft = (self.posx, self.posy)

class Wall2(pygame.sprite.Sprite):
    speed=10
    def __init__(self,x,y,height,width,vowel,alea):
        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')
        elif vowel=='x':
            brickImgTmp=pygame.image.load('./DataImgs/basket.png')
        brickImg=pygame.transform.scale(brickImgTmp,(height,width))
        self.image = brickImg
        self.rect = self.image.get_rect()
        self.rect.topleft = (x, y)

def game():
    pygame.init()
    doh=pygame.mixer.Sound('./DataSounds/doh.wav')
    clock=pygame.time.Clock()
    disp=pygame.display.set_mode((640,480),0,32)
    background= pygame.Surface((640,480))
    imgTmp=pygame.image.load('./DataImgs/madagascar.png').convert_alpha()
    imgTmp2=pygame.image.load('./DataImgs/basket.png').convert_alpha()
    img2Tmp=pygame.image.load('./DataImgs/hand.png').convert_alpha()
    img=pygame.transform.scale(imgTmp,(W/12,H/20))
    imgBack=pygame.transform.scale(imgTmp,(W,11*H/14))
    img5=pygame.transform.scale(img2Tmp,(W/20,H/20))

    every = pygame.sprite.OrderedUpdates()
#    every = pygame.sprite.RenderUpdates()
#    every = pygame.sprite.RenderPlain()
    walls=pygame.sprite.Group()
    walls3=pygame.sprite.Group()
    hands=pygame.sprite.Group()
#    wall2s=pygame.sprite.Group()
    Wall.containers=walls,every

    wall2s=pygame.sprite.Group()
    wallAs=pygame.sprite.Group()
    wallEs=pygame.sprite.Group()
    wallIs=pygame.sprite.Group()
    Wall2.containers=wall2s,every
    Hand.containers=every
    final=pygame.Rect(80,40,40,40)
    wall_list=[]
    wall2_list=[]

    wallA_list=[]
    m=Wall2(3,6*50,220,180,'x',10) #basket
    wallIs.add(m)    #Así?
    a=Wall2(3*60,1*40,100,100,'a',10)
    e=Wall2(4*60,1*40,100,100,'e',10)
    i=Wall2(5*60,1*40,100,100,'i',10)
    o=Wall2(6*60,1*40,100,100,'o',10)
    u=Wall2(7*60,1*40,100,100,'u',10)

    wallAs.add(a)
    wallAs.add(e)
    wallAs.add(i)
    wallAs.add(o)
    wallAs.add(u)
    hand=Hand(100,100,50,50)
    pygame.display.set_caption("Hello, World!")

    background = imgBack
    mouse_cursor = img5

    pygame.mouse.set_visible(0)
    M=5
    grab=False
    select=' '
    while True:
        mousex, mousey = pygame.mouse.get_pos()
        mousexx, mouseyy = mousex, mousey
        mousex-= mouse_cursor.get_width() / 2
        mousey-= mouse_cursor.get_height() / 2
        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 event.type==MOUSEBUTTONDOWN:
                grab=True
                if grab and a.rect.contains(hand.rect):
                    a.rect.center=(mousex,mousey)
                    select='a'
                if grab and e.rect.contains(hand.rect):
                    e.rect.center=(mousex,mousey)
                    select='e'
                if grab and i.rect.contains(hand.rect):
                    i.rect.center=(mousex,mousey)
                    select='i'
                if grab and o.rect.contains(hand.rect):
                    o.rect.center=(mousex,mousey)
                    select='o'
                if grab and u.rect.contains(hand.rect):
                    u.rect.center=(mousex,mousey)
                    select='u'
            if event.type==MOUSEMOTION:
                if grab:
                    if select=='a':
                        a.rect.center=(mousex,mousey)
                    elif select=='e':
                        e.rect.center=(mousex,mousey)
                    elif select=='i':
                        i.rect.center=(mousex,mousey)
                    elif select=='o':
                        o.rect.center=(mousex,mousey)
                    elif select=='u':
                        u.rect.center=(mousex,mousey)
            if event.type==MOUSEBUTTONUP:
                for n in wallAs:                  
                    if not m.rect.colliderect(n.rect):
                        print "False"
                        grab=False
                    else:
                        print "True"
                        doh.play()
                        grab = False
                        n.kill()
        for alien in pygame.sprite.spritecollide(hand,wallAs,False):
            pass
        hand.posx,hand.posy=mousex,mousey
        disp.blit(background, (0,0))
        dirty=every.draw(disp)
        pygame.display.update(dirty)
        every.update()
        pygame.display.update()
        clock.tick(40)
    pygame.quit()
    fgrid.close()
game()

Desensamblando Python

%Python es considerado un lenguaje de "alto nivel", y al menos en algunas de sus 

%aplicaciones puede parecerlo sin problemas; no obstante, para aquellos que deseen

%ver los engranajes detrás, vean esta herramienta, dis. 

>>> import dis

>>> def fib(n):

...     if n==0 or n==1: return 1

...     else:

...             return fib(n-1)+fib(n-2)

... 

>>> dis.disassemble(fib.func_code)

  2           0 LOAD_FAST                0 (n)

              3 LOAD_CONST               1 (0)

              6 COMPARE_OP               2 (==)

              9 POP_JUMP_IF_TRUE        24

             12 LOAD_FAST                0 (n)

             15 LOAD_CONST               2 (1)

             18 COMPARE_OP               2 (==)

             21 POP_JUMP_IF_FALSE       28

        >>   24 LOAD_CONST               2 (1)

             27 RETURN_VALUE        

  4     >>   28 LOAD_GLOBAL              0 (fib)

             31 LOAD_FAST                0 (n)

             34 LOAD_CONST               2 (1)

             37 BINARY_SUBTRACT     

             38 CALL_FUNCTION            1

             41 LOAD_GLOBAL              0 (fib)

             44 LOAD_FAST                0 (n)

             47 LOAD_CONST               3 (2)

             50 BINARY_SUBTRACT     

             51 CALL_FUNCTION            1

             54 BINARY_ADD          

             55 RETURN_VALUE        

             56 LOAD_CONST               0 (None)

             59 RETURN_VALUE      

Invitado: Unas esferitas en Haskell

---El siguiente programa muestra algunas posibilidades de trabajo gráfico en 3D
---con Haskell; estas posibilidades son dignas de explorar en la creación de mundos
---virtuales, simulación, graficación de datos, y juegos.
---He puesto un vida de otro programa que seguiría un desarrollo más o menos natural
---al aquí presentado, brindando más experiencia tridimensional e interactiva en
 -------https://youtu.be/Ab7eQdMHF-Q
{-
   Light.hs (adapted from light.c which is (c) Silicon Graphics, Inc.)
   Copyright (c) Sven Panne 2002-2005 <sven.panne@aedion.de>
   This file is part of HOpenGL and distributed under a BSD-style license
   See the file libraries/GLUT/LICENSE

   This program demonstrates the use of the OpenGL lighting model. A sphere
   is drawn using a grey material characteristic. A single light source
   illuminates the object.
-}


---Compilado con
---> ghc -package GLUT Light.hs -o light

---en Fedora, con Haskell tomado de www.haskell.org

import System.Exit ( exitWith, ExitCode(ExitSuccess) )
import Graphics.UI.GLUT

windowWidth=500
windowHeight=500
blackBackground=Color4 0 0 0 0
whiteColor=Color4 1 1 1 1
degreeShininess=50

myInit :: IO ()
myInit = do
   clearColor $= blackBackground
   shadeModel $= Smooth

   materialSpecular Front $= whiteColor
   materialShininess Front $= degreeShininess
   position (Light 0) $= Vertex4 1 1 1 0
   position (Light 1) $= Vertex4 1 1 (-1) 0
   lighting $= Enabled
   light (Light 0) $= Enabled
   light (Light 1) $= Enabled
   depthFunc $= Just Less

-- Sphere(radius,subLat,subLon)

translatef = translate :: Vector3 GLfloat -> IO ()
rotatef = rotate :: GLfloat -> Vector3 GLfloat -> IO ()
rectf = rect :: Vertex2 GLfloat -> Vertex2 GLfloat -> IO ()
normal3f = normal :: Normal3 GLfloat -> IO ()
color3f = color :: Color3 GLfloat -> IO ()
     
display :: DisplayCallback
display = do
   clear [ ColorBuffer, DepthBuffer ]
   rotatef 30 (Vector3 1 0 0)
   normal3f (Normal3 0 0 1)
   color3f (Color3 1 0.1 1)
 --  renderObject (
   translatef (Vector3 0 0 (-2.0))
   rectf (Vertex2 (-20) (-20)) (Vertex2 20 20)
   translatef (Vector3 0 0 (2.0))
   translatef (Vector3 0 0 (1.0))
   renderObject Solid (Sphere' 0.3 20 16)
   translatef (Vector3 0.5 0 0)
   renderObject Solid (Sphere' 0.3 20 16)
   translatef (Vector3 0 0.5 0)
   renderObject Solid (Sphere' 0.3 20 16)
   translatef (Vector3 0.5 0.5 0)
   renderObject Solid (Cube 0.6)

   flush

reshape :: ReshapeCallback
reshape size@(Size w h) = do
   viewport $= (Position 0 0, size)
   matrixMode $= Projection
   loadIdentity
   let wf = fromIntegral w
       hf = fromIntegral h
   if w <= h
      then ortho (-1.5) 1.5 (-1.5 * hf/wf) (1.5 * hf/wf) (-10) 10
      else ortho (-1.5 * wf/hf) (1.5 * wf/hf) (-1.5) 1.5 (-10) 10
   matrixMode $= Modelview 0
   loadIdentity

keyboard :: KeyboardMouseCallback
keyboard (Char '\27') Down _ _ = exitWith ExitSuccess
keyboard _            _    _ _ = return ()

main :: IO ()
main = do
   (progName, _args) <- getArgsAndInitialize
   initialDisplayMode $= [ SingleBuffered, RGBMode, WithDepthBuffer ]
   initialWindowSize $= Size windowWidth windowHeight
   initialWindowPosition $= Position 100 100
   createWindow progName
   myInit
   displayCallback $= display
   reshapeCallback $= Just reshape
   keyboardMouseCallback $= Just keyboard
   mainLoop

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()