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:

Nuevo juego: Pong Dexule

He dessarrollado un nuevo juego con python-pygame, que se llama pong deluxe.

Se trata del clasico Pong pero, con modo multijugador en lan e internet

Algunas imagenes:

Si quieren descargarlo para windows ve a http://newtonis.deviantart.com/art/Pong-multiplayer-online-no-testeado-aun-289796105

Si alguien desarrolla juegos en python-pygame y tiene alguna duda con  respecto a esto solo comenten.

Newtonis

Previa siguiente proyecto

Que será? Nada más simple que un juego de damas en linea con pygame (Es un poco dificil desarrollar IA), pero, no es tan facil como parece, por, ejemplo, para el movimiento de la dama tuve que desarrollar un algoritmo de movimiento que solo permitia moverla para cualquier lado en diagonal siempre y cuando solo comiera una ficha contraria.
También se me ocurrió una forma de lograr permitir facilmente comer doble (Simplemente, al comer una ficha se tiene derecho a mover otra vez siempre y cuando sea para comer otra ficha.


Les muestro fotos del juego (si quieren codigo fuente y/o explicación, pidamenlo en un comentario):

Para que vean que la dama funciona como corresponde:
Aqui si puede moverse:

Aqui no:

Aqui dos damas de cada equipo!!:

Y se van comiendo de a poco:

Y finalmente victoria blanca

Proximamente link de descarga...

Newtonis

HANGMAN

Este juego se trata de un simple juego de ahorcado multiplayer por internet de a dos (uno elige la palabra y el otro adivina).

Solo requiere la introducción de la IP de la maquina con la que quieres jugar (en caso de ser cliente) o tu misma IP (en caso de ser servidor). Utiliza algo llamado sockets, que sirve para la conección (igual viene con el python, no hay que instalar nada adicional)

Utiliza colores de terminal 8bit.

Todo el script fue hecho por mi excepto en una parte de la version para Windows, que la encontre en internet y me ayudo a hacer colores en la terminal de windows

FOTOS (click para aumentar zoom):


Inicio del juego:

Victoria del adversario:

Victoria del jugador local:

Descargar version para Windows (incluye python, por si no lo tienen):
http://newtonis.deviantart.com/art/Hangman-2-player-279645040
Escriban sus preguntas, dudas, etc en comentarios.

Newtonis

Bienvenidos a Newtonis Python Projets

En este blog les dare el link de descarga de algunos de mis proyectos y, de paso, les respondere preguntas, y les explicaré la base de dichos proyectos.

Yo conozco todo lo basico de python y, también algunas cositas más avenzadas, por lo cual, si son principiantes o intermedios en python puedo explicarles lo que quieran. 

Si no lo se , bueno, seguro será algo muy dificil.

Primer proyecto:

HANGMAN (ahorcado)

Descripción:

juego de ahorcado en linea con python en una terminal con colores 8 bit. Funciona en cualquier sistema operativo siempre y cuando tenga el python correspondiente a su SO instalado.