juego de naves en pygame

[elzorro]

Hola comunidad de loserjuegos, la verdad hace poco que empece a meterme al mundo de la programacion en especifico con python y ahora he querido realizar un juego usando pygame pero tengo un par de problemas, la verdad me guie al principio con guias de muchas paginas pero lastimosamente usan clases para los juegos y es un tema del cual soy ajeno, por lo que he decidido hacer el juego solo usando matrices, bueno la verdad despues de mucho trabajo y de conocer algunos codigos de pygame he podido lograr que se muevan las naves y crear limites para que no se salgan ni de la matriz de ni la pantalla de pygame pero me he quedado corto con el tema de los disparos y es por que meti la condicion de disparo dentro de un ciclo y lastimosamente mientras ese ciclo se ejecuta, el juego se congela y cuando termina vuelve a la normalidad, osea que no puedo realizar ningun movimiento mientras la bala esta en curso.

bueno espero que me puedan ayudar y muchas gracias.

el codigo esta a continuacion:

import sys,pygame
from pygame.locals import *

WIDTH = 800
HEIGHT = 600

#==============================================================
# Funcion para crear la matriz.
def matriz(fila,columna):
    i=0
    m=[]
    while i<fila:
        c=0
        M=[]
        while c<columna:
            M+=[0]
            c+=1
        m+=[M]
        i+=1
    return m 



def pytanks ():
    pygame.init()
    # creamos la ventana y le agregamos un titulo:
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("naves py")
    fondo = pygame.image.load("data/fondo.jpg").convert()
    # Indicamos la posicion de las "Surface" sobre la ventana
    jugador1=pygame.image.load("data/comp.png").convert_alpha()
    jugador2=pygame.image.load("data/jugador.png").convert_alpha()
    bala1=pygame.image.load("data/bala1.png").convert_alpha()
    bala2=pygame.image.load("data/bala2.png").convert_alpha()
    x1=1
    y1=250 # estas son las variables iniciales para el jugador 1 (en pixeles)
    
    x2=680
    y2=250 #y estas son las del jugador 2
    MAT=matriz(WIDTH,HEIGHT)# aqui se dibuja la matriz que una lista de lista es
    #igual a un pixel
    screen.blit(fondo,(0,0))
    screen.blit(jugador1,(x1,y1))
    screen.blit(jugador2,(x2,y2))
    pygame.display.update()
    x11=9
    y11=249
    x22=679
    y22=249
    b1=x1
    b2=x2 #esto son las balas que dispararan desde donde se encuentre cualquier
    #nave en el eje X.
    b11=x11
    b22=x22

   



    
               

    while True:
        MAT[x11][y11]=1
        MAT[x22][y22]=2
        
        press=pygame.key.get_pressed()
        #para la nave del primer jugador
        if press[K_w]:
            #movimiento en la pantalla de pygame
        
            y1-=1
            
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
            #movimiento en matriz
        
            y11-=1

            
            
            MAT[x11][y11]=1
            MAT[x11][y11+1]=0
           
            
            
            
            #es necesario poner todos los blits ya que :
            #1. si no ponemos fondo, se verá el rastro de la nave sobre el fondo
            #2. si no ponemos jug..2, con presionar K_UP solo una vez, la nave
            #   de jug..2 desaparecerá de la pantalla.
            #así que es mejor poner los blits de todas las imagenes y update
            #la mayoria de las veces.   
        if press[K_s]:
            y1+=1
           
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
                
            y11+=1
            
            MAT[x11][y11]=1
            MAT[x11][y11-1]=0
            
            
        if press[K_d]:
            x1+=1
            
                
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
                
            x11+=1
            
            MAT[x11][y11]=1
            MAT[x11-1][y11]=0
            
            
        if press[K_a]:
            x1-=1
            
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
                
            x11-=1
            
            MAT[x11][y11]=1
            MAT[x11+1][y11]=0

        if press[K_r]:
            while MAT[b11][y11]!=2 and b11<WIDTH-20:
                b1+=2
                b11+=2
                screen.blit(fondo,(0,0))
                screen.blit(jugador1,(x1,y1))
                screen.blit(jugador2,(x2,y2))
                screen.blit(bala1,(b1,y1))
                pygame.display.update()
                MAT[b11][y11]=3
                MAT[b11-2][y11]=0
                
            

               
                
            if b11>=WIDTH-20:
                b1=x1
                b11=x11
                screen.blit(fondo,(0,0))
                screen.blit(jugador1,(x1,y1))
                screen.blit(jugador2,(x2,y2))
                screen.blit(bala1,(b1,y1))
                pygame.display.update()
                MAT[b11][y11]=3
                MAT[b11-2][y11]=0
                
            elif MAT[b11][y11]==2:
                b1=x1
                b11=x11
                x2=680
                x22=679
                y2=250
                y22=249
                screen.blit(fondo,(0,0))
                screen.blit(jugador1,(x1,y1))
                screen.blit(jugador2,(x2,y2))
                screen.blit(bala1,(b1,y1+15))
                pygame.display.update()
                MAT[b11][y11]=3
                MAT[b11-2][y11]=0

            
        #Condiciones para que la nave no salga de pantalla si en algun evento
        # de movimiento intenta hacerlo.
        

        if x11<=0: # si x11 (posicion en matriz) es menor o igual a 0#
            x1=0   # x1 retorna a la posicion 0
            x11=x11+1 #se suma una unidad a la posicion x11
            screen.blit(fondo,(0,0)) #se actualizan todas las funciones de python
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
        if y11<=0:
            y1=0
            y11=y11+1
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
        if x11>=703:
            x1=703
            x11=x11-1
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
        if y11>=530:
            y1=530
            y11=y11-1
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
            
        
        
        
            
            
            
        #para la nave del segundo jugador
        if press[K_UP]:
            y2-=1
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
            y22-=1
            MAT[x22][y22]=2
            MAT[x22][y22+1]=0
        
        if press[K_DOWN]:
            y2+=1
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
            y22+=1
            MAT[x22][y22]=2
            MAT[x22][y22-1]=0
           
            
            
        if press[K_RIGHT]:
            x2+=1
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
            x22+=1
            MAT[x22][y22]=2
            MAT[x22-1][y22]=0
            
            
            
        if press[K_LEFT]:
            x2-=1
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
            x22-=1
            MAT[x22][y22]=2
            MAT[x22+1][y22]=0
            

        if x22<=0:
            x2=0
            x22=x22+1
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()

        if x22>=699:
            x2=699
            x22=x22-1
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
        
            
        if y22<=0:
            y2=0
            y22=y22+1
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()
        if y22>=533:
            y2=533
            y22=y22-1
            screen.blit(fondo,(0,0))
            screen.blit(jugador1,(x1,y1))
            screen.blit(jugador2,(x2,y2))
            pygame.display.update()

 
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()



if __name__ == "__main__":
    pytanks()

[elzorro]

Me disculpo si he infringido alguna regla del foro pero no encontre el tema de reglas generales, por lo general siempre las reviso por que siempre incumplo algo asi sea pequeño y me borran el tema jeje pero no aqui en otros foros y de otras cosas.

[kaiser]

Hola elzorro!

Aquí en LosersJuegos hay una traducción al español de la API de pygame (http://www.losersjuegos.com.ar/traducciones/pygame).

Además hay un montón de tutoriales sobre el desarrollo de juegos con pygame (http://www.losersjuegos.com.ar/referencia).

Creo que debería ser suficiente para que las "clases para juegos" dejen de ser un tema ajeno.

En cualquier caso deberías tener en cuenta que los juegos suelen estructurarse en tres bloques:

1. Bloque de Inicialización.
(Importación de librerías y módulos, creación de la ventana de juego e inicialización de las variables)

2. Bloque de Lógica y Control.
(Detección de teclas pulsadas, detección de colisiones, actualización de las coordenadas de los sprites y actualización del estado de los diferentes elementos de juego (contadores de puntuación, vida de los personajes, ...))

3. Bloque de Refresco.
(Se redibuja la ventana de juego con los nuevos valores)

Los bloques 2 y 3 van dentro de un bucle while de manera que constantemente detectemos el input, apliquemos la lógica de juego y refresquemos la ventana.

Aplicando ésto a tu código verás que no es necesario que para cada tecla blitees todos los sprites. El tema del bliteado debe ir al final de código y las funciones que detectan las teclas pulsadas deben limitarse a actualizar las coordenadas de los sprites.

En cuanto a lo de las balas... no entiendo por qué le asignas un bucle while propio. Creo que lo haces porque así solo bliteas la bala mientras está en el aire, pero para eso lo mejor es que modifiques la función de tal forma que sea capaz de determinar cuando hay que blitear la bala y cuando no, así como sus coordenadas, y le pase ésta información al bloque de refresco.

Un Saludo!

[elzorro]

Hola muchas gracias por responder mi petición, pues yo use las matrices por que pense en su facilidad de uso y quisiera terminarlo asi, ademas estuve pensando y pense en representar a la nave no como un solo numero si no como una matriz mas pequeña dentro de esa gran matriz pero la verdad intente hacer una funcion y llamarla en una variable pero no he logrado hacer que funcione en la matriz principal, hago esto por que tengo problemas con las colisiones entre naves, al parecer se colisionan a veces pero como representan un unico uno dentro de una matriz es complicado, creo que por eso asi las naves se choquen si no llegan al centro de la nave no se cumplira la condicion de la colision que lo que hace es regresar a la nave golpeada a la posicion inicial. En cuanto a la bala pues pense que para que recorriera la matriz deberia ir aumentando continuamente hasta que golpe la nave o llege a un limite por que si lo hago con un if solo se movera una posicion

[kaiser]

Deja que te de un consejo: si quieres dibujar líneas paralelas no uses una regla porque sea una herramienta fácil de usar, aprende a utilizar la escuadra y el cartabón que son herramientas diseñadas para esa tarea y que por lo tanto, a la larga, te facilitarán la vida.

Como has visto para manejar correctamente la gestión de colisiones entre sprites es necesario utilizar una función. Pygame te ofrece funciones para eso, así que si aprendes a utilizarlas no tendrás que diseñar tú una función para eso (representar la nave como una matriz de puntos).

En cualquier caso, si estás decidido a crear dicha función de detección de colisiones te recomiendo que lo enfoques de la siguiente manera. Puesto que cada casilla de la matriz representa un píxel y sabes el tamaño (en píxeles) que ocupan los sprites de las naves, puedes dejar el funcionamiento de las naves tal y como está, es decir, la nave está representada por un 1 en la matriz, pero añade un función que a partir de ese 1 genere una lista con todas las casillas (píxeles) que están siendo ocupadas por dicho sprite. Además deberás crear otra función que compare las listas de puntos de ambas naves y vea si alguno coincide.

Ten en cuenta que normalmente el centro del sprite (coordenada (0,0)) no coincide con el centro "geográfico" del sprite, sino que normalmente, la mayoría de bibliotecas multimedia, sitúan la coordenada (0,0) en la esquina superior izquierda del sprite.

Te dejo más información sobre eso: http://www.losersjuegos.com.ar/foro/viewtopic.php?f=9&t=965&p=4694#p4694.

En cuanto al tema de las balas tienes que modificar la función de la siguiente manera: por un lado creas una función que al pulsar la R crea una bala, por ejemplo, se pone un flag bala1 = True. Por otro lado creas otra función, por ejemplo, gestionar_bala(), ésta función detectará si existe alguna bala (bala1 = True) y en ese caso caso irá actualizando la posición de la bala (apoyándose en el while externo, no en uno propio), en el momento en que esa bala colisione con la nave contraria o salga de los límites del mapa gestionar_bala() pondrá bala1 = False. Para poder hacer ésto gestionar_bala() deberá asegurase de que la coordenada de la bala sea menor que las coordenadas del límite del mapa y a la vez comparar esa coordenada con la lista de puntos que representa a la nave enemiga.

Un Saludo!

[elzorro]

Gracias en serio, la verdad seguire intentando pero no por hoy creo que me conformo por ahora con tener los movimientos y los limites cosa que al principio no crei que podria.