Easy pygame!

Una forma más facil de desarrollar juegos con pygame si eres primerizo. Solo requiere saber utilizar clases :

Como se utiliza?

Simplemete se escribe por ejemplo:
______________________________________________
import pygame # Obvio sino como funciona

"""
Aca tiene que ir una copia de la clase boton , de la clase sprite y la clase treadEventosPygame, que estan abajo. Si prefieren pueden hacer otro archivo llamado easy_pygame e importarlo aca
"""


def main(): #Creamos la funcion main() que ejecuta todo el programa


    pantalla = pygame.display.set_mode((400,400)) # creamos la pantalla de 400x400 px




    eventos = treadEventosPygame() #Creamos una clase que admisistra los eventos de mouse y teclado
    eventos.init() # lo inicializamos


    imagen_boton = pygame.image.load("ejemplo.png") # cargamos una imagen del mismo directorio 


    imagen_sprite = pygame.image.load("ejemplo2.png") # cargamos otra imagen ATENCION TIENEN QUE PONERLA EN EL MISMO DIRECTORIO QUE EL PROGRAMA CON EL NOMBRE QUE PONGAN (es obvio pero cualquiera puede confundirse).


   
    boton_1 = boton(imagen_boton, imagen_boton , 200 , 200) # Creamos el boton con la sintaxis   "boton( IMAGEN , IMAGEN DE NUEVO, x ,y)" 


    sprite_1 = sprite(imagen_sprite, 20 , 200) # Creamos el sprite con la sintaxis " sprite(IMAGEN , x , y)
    juego_avanza = True # Creamos la variabnle que permite hacer la actualizacion de la pantalla y el juego
 
    while juego_avanza == True: # Repeticion de la actualizacion del juego
        pantalla.fill((255,255,255)) # Llenamos la pantalla de color blanco
        eventos_actuales = eventos.devolver() #Obtenemos los eventos actuales
       
        mouse = eventos_actuales[0] # El item uno de la lista de eventos es el  estado del mouse
       
       
        presionar = boton_1.actualizar(mouse,pantalla) # Actualizamos y dibujamos en la pantalla el boton 1, si esta presionado presionar vale True y sino vale False


        if presionar == True:


             print "el boton esta presionado" # Imprimimos un mesaje si el boton esta presionado
             sprite_1.x += 20 # subimos 20 poscisiones x al sprite por ejemplo


        sprite_1.pintar(pantalla) # Pintamos el sprite sobre la pantalla
       
        pygame.display.update() #Actualizamos la pantalla del usuario


main() #Iniciamos el programa
#Aca solo faltaria lo que maneje el boton de exit, que sera explicado mas adelante.


LEYENDA:
Inicializacion del juego
Actualizacion del juego
Declaracion y llamada del juego
     
        




__________________________________________________________________
#Clase sprite (PARA INSERTAR IMAGENES Y MOVERLAS)
import pygame
pygame.init()

class sprite(pygame.sprite.Sprite):
    def __init__(self,imagen,x = 0,y = 0,rectangles = False):
     
        self.imagen = imagen
        self.originalImagen = self.imagen
     
        self.rect = self.imagen.get_rect()
        self.rects = [self.rect]
        self.t = self.imagen.get_size()
        self.h , self.w = self.t
        if rectangles != False:
            for x in range(len(rectangles)):
                self.rects.append(pygame.rect.Rect((rectangles[x][0],rectangles[x][1],rectangles[x][2],rectangles[x][3])))
        else:
            self.rects.append(pygame.rect.Rect((0,0,self.h , self.w)))
        self.x = x
        self.y = y
     
        for num in range(len(self.rects)):
            x = self.rects[num].left
            y = self.rects[num].top
            h = self.rects[num].height
            w = self.rects[num].width
            pygame.draw.lines(self.imagen,(200,100,200),True,((x,y),(x+w,y),(x+w,y+h),(x,y+h)),2)
     
     
     
    def cambiarXY(self,x,y):
        self.x = x
        self.y = y
    def moverIP(self,x,y):
        self.x+=x
        self.y+=y
    def aumentarTamanio(self,escala):
        actual1,actual2 = self.t
        self.imagen = pygame.transform.scale(self.imagen,(int(actual1*escala),int(actual2*escala)))
        self.t = self.imagen.get_size()
    def devolverPintadoEscala(self,escala,pantalla):
        actual1,actual2 = self.t
        escalaImage = pygame.transform.scale(self.imagen,(int(actual1*escala),int(actual2*escala)))                                    
        h,w = int(actual1*escala),int(actual2*escala)
        top = self.y -w/2
        left = self.x -h/2
        pantalla.blit(escalaImage,(left,top))
    def setearHW(self,h,w):
        self.imagen = pygame.transform.scale(self.imagen,(int(h),int(w)))
    def devolverRotada(self,angulo,pantalla):
     
        rotadaImage = pygame.transform.rotate(self.originalImagen,angulo)
        actual1,actual2 = rotadaImage.get_size()                    
        h,w = int(actual1),int(actual2)
        top = self.y -w/2
        left = self.x -h/2
        pantalla.blit(rotadaImage,(left,top))
    def pintar(self,pantalla):
        actual1,actual2 = self.t
        self.rect.top = self.y -actual2/2
        self.rect.left = self.x -actual1/2
        pantalla.blit(self.imagen,self.rect)
    def cambiarImagen(self,nuevaImagen):
        self.imagen = nuevaImagen
        self.rect = self.imagen.get_rect()
    def generarRotados(self):
     
        self.rotados = []
        for x in range(-90,90):
            imagen = pygame.transform.rotate(self.originalImagen,x)
            w,h = imagen.get_size()
         
            rectImagen =self.x- w/2,self.y -h/2
         
            self.rotados.append([imagen,rectImagen])
    def actualizarRotador(self,pantalla,rotado):
        pantalla.blit(self.rotados[rotado][0],self.rotados[rotado][1])
    def colicionar(self,objeto):
     
        for x in range(len(self.rects)):
            rectActual = pygame.rect.Rect((self.rects[x].left+self.rect.left,self.rects[x].top+self.rect.top,self.rects[x].width,self.rects[x].height))
            rectActualVecino = pygame.rect.Rect((objeto.rect.left,objeto.rect.top,objeto.rect.width,objeto.rect.height))
         
            if rectActual.colliderect(rectActualVecino) == True:
             
                return True
     
     
        return False
    def getPositionCenter(self):
     
        return self.x,self.y
______________________________________________________________
# Clase boton (PARA INSERTAR BOTONES FACILMENTE)



import pygame
pygame.init()



class boton(pygame.sprite.Sprite):
    def __init__(self,imagen,imagenP,x,y,text = "",color = (0,0,0),imagenPuso = False):
        self.text = text
        if self.text != "":
            font1 = pygame.font.Font(None,20)
            self.texto = font1.render(self.text,0,color)  
        self.imagen = imagen
        self.originalImage = imagen
        if imagenPuso == False:
            self.imagenP = pygame.transform.rotozoom(imagen,0,1.1)
        else:
            self.imagenP = imagenP
        self.rect = self.imagen.get_rect()
        self.y = y
        self.x = x
        self.rectP = self.imagenP.get_rect()
        self.width = int(self.imagenP.get_width())
        self.height =  int(self.imagenP.get_height())
        self.rect.top =  (self.imagenP.get_height()-self.imagen.get_height())/2
        self.rect.left = (self.imagenP.get_width()-self.imagen.get_width())/2
        self.superficie = pygame.Surface((self.width,self.height))
    def mostrar(self,pantalla,tocado):  
        pantalla.blit(self.superficie,(self.x,self.y))
        if tocado == True and self.text != "":
            pantalla.blit(self.texto,(self.x+10,self.y+self.width))
    def actualizar(self,mouse,pantalla,color = (0,0,100),usarCual =False,cual = False):
     
        mouseP = mouse[0]
        mouseX = mouse[1]
     
        mouseY = mouse[2]
     
     
        presionado = False
        tocado = False
        if mouseX > self.x +self.rect.left and mouseX < self.x+self.rect.left+self.width:
            if mouseY > self.y +self.rect.top and mouseY < self.y +self.rect.top+self.height:
                if mouseP == True:
                    presionado = True
                tocado = True
     
         
     
        if tocado == True:
            pantalla.blit(self.imagenP,((self.x+self.rectP.left),(self.y + self.rectP.top)))
        else:
            pantalla.blit(self.imagen,((self.x + self.rect.left),(self.y + self.rect.top)))
        return presionado
     
    def resetearImagen(self):
        self.imagen.blit(self.originalImage,(0,0))
______________________________________________________________

#Clase treadEventosPygame (tal como dice) que admistra los eventos de mouse y de teclado.
import pygame
pygame.init()
import threading
import thread
class eventosPygame:
    def __init__(self):
        self.exit = False
        self.mousePresionado = False
    def devolver(self):
        mouse =[0,0,0,0]
        mouse[0] = False
        key = False
        Down = None
        scroll = 0
        if self.exit == True:
            return ["exit",[0,0,[]]]
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
             
                self.exit = True
                return ["exit",[0,0,[]]]
            if event.type == pygame.MOUSEBUTTONDOWN:
                self.mousePresionado = True
                if event.button == 4:
                    scroll = 1
                elif event.button == 5:
                    scroll = -1
            if event.type == pygame.MOUSEBUTTONUP:
                self.mousePresionado = False
            if event.type == pygame.KEYDOWN:
                key = event.key
                Down = True
             
             
            if event.type == pygame.KEYUP:
                key = event.key
                Down = False
     
        mouse[0] = self.mousePresionado
     
        mouse[1], mouse[2] = pygame.mouse.get_pos()
        mouse[3] = scroll
        keyss = pygame.key.get_pressed()
        keys = []
        for x in range(len(keyss)):
            if keyss[x] == 1:
                keys.append(x)
     
        return [mouse,[key,Down,keys]]
class treadEventosPygame(threading.Thread):
    def init(self):
        self.eventos = [[0,0,0],[None,False,[]]]
        self.start()
    def run(self):
     
        reloj = pygame.time.Clock()
        eventos = eventosPygame()
        self.cont = True
        while self.cont == True:
            self.eventos = eventos.devolver()
            if self.eventos[0] == "exit":
                self.cont = False
         
            reloj.tick(20)
        sys.exit()
    def devolver(self):
     
        return self.eventos
     
        return [[0,0,0],[None,False,[]]]
    def finalizar(self):
        self.cont = False

Otro desarrollo!

Escribo esta entrada para mostrarles otro desarrllo que estoy haciendo en pygame que se trata de un jueguito de tiros libres con una camara unica en 3D! Por ahora solo se patea y no existe ningun tipo de modo de partido o puntuacion, pero en el futuro quien sabe lo que este motor del juego que he creado puede llegar a ser! Les muestro un video que subi ya hace un tiempo sobre este jueguito:

Nuevo proyecto en desarrollo, tux word!

Escribo esta entrada para mostrarles mi nuevo desarrollo, que es un juego en el cual eres el pinguino tux, y debes superar diversos obstaculos en los diferentes niveles. El motor del juego esta casi terminado pero igual me faltaria crear muchos mas niveles, ya que cree clases que sirven para crear niveles facilmente. Si alguien quiere ayudarme con la creacion de niveles contactenme por comentarios y mail, newtonis.penguin@gmail.com, y les explico como funciona y como hacerlo.
Algunas imagenes: