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