Videojuegos de pygame

Pygame es un módulo en Python utilizado para el diseño de videojuegos; Estos videojuegos van desde un tic dedo tic simple hasta luchadores espaciales. Ya sea que desee diseñar un juego simple o complicado, debe comenzar con los conceptos básicos de cómo funciona Pygame. En este tutorial, revisaremos los conceptos básicos de Pygame creando un videojuego.

Instalar pygame usando:

PIP install Pygame

Paso 1: Crear la ventana inicial

El primer paso para crear un videojuego es inicializar el pygame usando el método init (). A continuación, establecemos la geometría de la pantalla usando PyGame.mostrar.set_mode (), donde pasamos el ancho y la altura de la pantalla (en ese orden). Estas dos líneas de código crearán una ventana que desaparecerá rápidamente, por lo que necesitamos un mainloop para mantener la ventana en funcionamiento. Dentro de este mainloop, agregaremos una estrategia de salida. La estrategia de salida se crea seleccionando un evento de la lista de eventos (esta lista de eventos se encuentra dentro de Pygame.evento.Get () que alberga todos los eventos disponibles). A continuación, declaramos que si el evento que hemos seleccionado es Pygame.Deja, luego salga. Este último creará un mainloop para la ventana, que mantendrá la ventana en funcionamiento hasta que presione el botón de abandono.

importar pygame
Sys de importación
pygame.en eso()
tamaño = ancho, altura = 800, 600
pantalla = pygame.mostrar.set_mode (tamaño)
Mientras que es cierto:
Para el evento en Pygame.evento.conseguir():
Si el evento.Tipo == Pygame.ABANDONAR:
sys.salida()

Paso 2: Agregar títulos, iconos, colores e imágenes de fondo

En esta sección, agregaremos títulos, colores e imágenes de fondo e íconos a la ventana.

(a) El título se agrega usando:

# Establecer el título de la ventana
pygame.mostrar.set_caption ("videojuego")

(b) Obtuve mi logotipo de https: // icons8.com/icon/set/computer-hardware/doodle. Si está utilizando PyCharm, coloque el icono que descargue en la carpeta apropiada (en mi caso, fue C: \ Users \ Never \ PycharmProjects \ PythonProject2 \ icon.PNG). El logotipo se agrega usando:

# Establecer el icono
imagen = pygame.imagen.Cargar ("icono.png ")
pygame.mostrar.set_icon (imagen)

(c) También puede cambiar el color de retroceso. Para esto, usamos pantalla.llenar () que toma un color RGB. En mi caso, lo he establecido en (0,0,0). Una vez que establece el color, también debe actualizar el PyGame para que el cambio de color surja en vigencia.

# Llena el fondo
pantalla.llenar ((0, 0, 0))
pygame.mostrar.actualizar()

(d) ¿Qué pasa si desea establecer una imagen de fondo en su pantalla?? Eso también es posible. Como desea que la imagen se ejecute todo el tiempo, debe colocarse dentro del bucle While. De hecho, cualquier cosa que deba funcionar constantemente debe colocarse en el mainloop. Usamos pygame.imagen.Load () para seleccionar una imagen que queremos cargar y el método Blit () para colocarla. Aquí, pantalla.Blit () toma dos argumentos: la imagen cargada, la tupla de la ubicación donde se colocará la esquina superior izquierda de la imagen. Además, Pygame.mostrar.Update () debe colocarse al final para actualizar la pantalla! Al diseñar videojuegos, el orden en el que coloca el código importa!!! Por ejemplo, la actualización no puede venir antes de las imágenes!

# Crea la imagen de fondo
bg_image = pygame.imagen.Cargar ("BG_IMAGE.JPG ")
pantalla.Blit (BG_Image, (-15, -25))
pygame.mostrar.actualizar()

Alternativamente, también podemos verlo en una función de fondo (que será útil más adelante), por lo que reescribimos el fondo de la siguiente manera:

# Crea la imagen de fondo
bg_image = pygame.imagen.Load ("BG_IMAGE_3.JPG ")
Fondo de def ()::
pantalla.Blit (BG_Image, (-15, -25))

Tenga en cuenta que hemos colocado el fondo en una función llamada fondo (), que activaremos en el bucle while más tarde.

Paso 3: Agregar imágenes del jugador a la ventana

A continuación, creemos una persona. Esto se hace cargando primero la imagen y luego usando la pantalla.Blit () para colocar la imagen.

# Imagen de persona
image_person = pygame.imagen.Carga ("Persona.png ")
pantalla.Blit (Image_person, (400, 550))

Tenga en cuenta que el pedido en el que coloca el código también importa! Si coloca el código para el fondo después del código para el enemigo, ni la persona ni el enemigo serán visibles!

Sin embargo, una vez más, a los efectos de todo el código, lo colocaremos en una función. Entonces, el código se puede reescribir de la siguiente manera:

# Imagen de persona
Person_x = 400
Person_y = 550
image_person = pygame.imagen.Carga ("Chica.png ")
Def persona (x, y):
pantalla.Blit (Image_person, (x, y))

Esta función se puede activar en el bucle While de la siguiente manera:

persona (persona_x, persona_y)

Paso 4: Mover persona ()

Ahora, se vuelve complicado, así que presta atención. Necesitamos presionar las teclas para mover a la persona correctamente, por lo que las ingresaremos en el bucle While de la siguiente manera:

pressed_keys = pygame.llave.get_pressed ()
Si pressed_keys [Pygame.K_right]:
Person_x += 0.1
Si pressed_keys [Pygame.K_left]:
Person_x += -0.1

Usamos pygame.llave.get_pressed () para obtener la tecla presionada, luego verifíquela. Si la tecla presionada es la tecla de flecha derecha (pygame.K_right), entonces nuestra persona variable_x se incrementa por un valor de 0.1. Si, por otro lado, la tecla presionada es la flecha izquierda (Pygame.K_left), luego disminuimos por 0.1. Lo que estamos haciendo es cambiar la ubicación de la imagen en la consola. Si se presiona la flecha derecha, la tupla inicial de (400, 550) se convertirá (400.1, 550) - y esta es la ubicación de la imagen!

También debemos activar ambas funciones: en segundo plano () y persona (). La función de fondo () borrará la pantalla cada vez que comience el bucle, y sin ella, tendrá un "arrastre".

El código en su conjunto en este punto se vería así:

importar pygame
Sys de importación
# Inicializar
pygame.en eso()
# Establecer la geometría de la pantalla
tamaño = ancho, altura = 800, 600
pantalla = pygame.mostrar.set_mode (tamaño)
# Establecer el título de la ventana
pygame.mostrar.set_caption ("videojuego")
# Establecer el icono
imagen = pygame.imagen.Cargar ("icono.png ")
pygame.mostrar.set_icon (imagen)
# Crea la imagen de fondo
bg_image = pygame.imagen.Load ("BG_IMAGE_3.JPG ")
Fondo de def ()::
pantalla.Blit (BG_Image, (-15, -25))
# Imagen de persona
Person_x = 400
Person_y = 550
image_person = pygame.imagen.Carga ("Chica.png ")
Def persona (x, y):
pantalla.Blit (Image_person, (x, y))
# bucle principal
Mientras que es cierto:
Para el evento en Pygame.evento.conseguir():
Si el evento.Tipo == Pygame.ABANDONAR:
sys.salida()
# Verifique las teclas presionadas
pressed_keys = pygame.llave.get_pressed ()
# Si la tecla presionada es la flecha derecha,
# Luego muévete a la derecha
Si pressed_keys [Pygame.K_right]:
Person_x += 0.1
# Si la tecla presionada es la flecha izquierda,
# Luego muévete a la izquierda
Si pressed_keys [Pygame.K_left]:
Person_x += -0.1
# activar la función de fondo
fondo()
# activar la función de la persona
persona (persona_x, persona_y)
# Actualizar todo
pygame.mostrar.actualizar()

Paso 5: Establezca límites de borde

Cuando presionamos la tecla de flecha derecha o izquierda, en este momento, la persona (o el personaje principal) en nuestro juego seguirá moviéndose y moviéndose fuera de rango o fuera de la ventana de la consola. Entonces, lo siguiente que debemos hacer es establecer límites en el movimiento.

Establecer límites es fácil. Vamos a nuestros pressed_keys [Pygame.K_right] argumento y agregar una condición. Agregamos la condición de que X debe ser menor que nuestro ancho de pantalla: el ancho del personaje.

En mi caso, el ancho del personaje era de 50 píxeles, y el ancho X de mi pantalla era 800. Así que configuré mi lado derecho en 800 - 50 = 750 píxeles. Lo que esto hace es limitar el movimiento de mi personaje. Mi personaje no puede ir más allá de los 750 píxeles y, por lo tanto, permanecerá en la pantalla de la consola en todo momento.

pressed_keys = pygame.llave.get_pressed ()
# Si la tecla presionada es la flecha derecha,
# Luego muévete a la derecha
Si pressed_keys [Pygame.K_right] y persona_x < 750:
Person_x += 0.1
# Si la tecla presionada es la flecha izquierda,
# Luego muévete a la izquierda
Si pressed_keys [Pygame.K_left] y persona_x> 0:
Person_x += -0.1

Paso 6: Creación del enemigo

Crear al enemigo es la parte fácil. Lo hacemos de la misma manera en que creamos el personaje principal. Aquí, nos gustaría aleatorizar la ubicación donde aparece el enemigo, por lo que usaremos el módulo aleatorio para hacerlo. Usamos aleatorios.randint () para establecer una ubicación aleatoria.

importar al azar
# Imagen enemiga
enemy_x = aleatorio.Randint (0, 750)
enemy_y = aleatorio.Randint (0, 300)
image_enemy = pygame.imagen.Cargar ("Enemigo.png ")
Def enemigo (x, y):
pantalla.Blit (Image_enemy, (x, y))

Recuerde actuar al enemigo en el bucle While:

# Activar al enemigo
enemigo (enemy_x, enemy_y)

Paso 7: Mover al enemigo

Mover al enemigo requiere un poco de imaginación. Inicializamos las variables (fuera del bucle While):

#inicializar variables
enemy_diff = 0.6
enemy_x = 0

Y dentro del bucle While, escribimos:

# Mueve al enemigo
enemy_x += enemy_diff
Si enemy_x <= 0:
enemy_x = 0
enemy_diff = 0.6
Si enemy_x> = 730:
enemy_x = 730
enemy_diff = -0.6

Lo que esto hace es que si la imagen del enemigo está dentro de los límites (en este caso, entre 0 y 730), calculará la ecuación enemy_x = enemy_x + enemy_diff y lo moverá. Si, por otro lado, la ubicación del enemigo es superior a 730, entonces establecemos la ubicación enemy_x en 730 e invirtimos la velocidad escribiendo -0.6 en lugar de 0.6. Si la ubicación del enemigo es inferior a 0, entonces establecemos la variable enemy_x en 0 y le decimos que avance por 0.6 píxeles. Debido a que estamos lidiando con un bucle de tiempo, cada vez que comienza el bucle, hace que la variable enemigo_x cambie y, por lo tanto, la ubicación del enemigo cambie. Al final, todo esto hará es mover al enemigo de un lado a otro a la izquierda y a la derecha para siempre.

Paso 8: Crear y disparar múltiples balas

En mi caso, voy a tirar libros a la bola de fuego. Entonces mi bala es un libro o múltiples libros. Primero inicialicemos todas las variables que necesitamos:

#inicializar variables
books_diff = 4
books_y = 520
books_x = 420

Books_x y books_y son su ubicación inicial; Los he colocado cerca del personaje principal. Books_diff es su velocidad. A continuación, inicializamos su estado, que "no se mueve" y cargamos la imagen.

# Imagen de libros
books_state = "no se mueve"
image_books = pygame.imagen.Cargar ("Libros.png ")

Luego creamos una función que toma los books_state. Si colocamos el libro en la cuadrícula, cambiamos su estado a "moverse". Esta función es la función principal que colocará la bala en el mapa/consola. Además, en los libros de funciones (), he escrito x+15 e y+1 para centrar la imagen. Sin este último, los libros miran a un lado.

Libros de Def (x, y):
Global Books_state
books_state = "Moving"
pantalla.Blit (Image_Books, (x + 15, y + 1))

Y dentro del bucle principal, escribiría:

# Movimiento de libros
Si books_y <= 0:
books_y = 420
books_state = "no se mueve"
Si Books_State está "en movimiento":
books_x = Person_x
Libros (books_x, books_y)
books_y -= books_diff
# dispara si se presiona el botón de espacio
Si pressed_keys [Pygame.K_space]:
books_x = Person_x
Libros (books_x, books_y)

Primero definimos qué sucede cuando la bala/libros se mueve de la red o están en la posición y<0. In this case, we change the state back to “not moving” and place the books back on the y-axis at 420. If, on the other hand, the state of the book is “moving”, we say that we want it to move (books_y -= books_diff where books_diff is its speed). Next, we also state that if the key is pressed, we want the books() function to be activated, placing the books' image onto the console grid.

El código en su conjunto en este punto se vería algo así:

importar pygame
Sys de importación
# Inicializar
pygame.en eso()
# Inicializar el reloj
reloj = pygame.tiempo.Reloj()
# Establecer la geometría de la pantalla
tamaño = ancho, altura = 800, 600
pantalla = pygame.mostrar.set_mode (tamaño)
# Establecer el título de la ventana
pygame.mostrar.set_caption ("videojuego")
# Establecer el icono
imagen = pygame.imagen.Cargar ("icono.png ")
pygame.mostrar.set_icon (imagen)
# Crea la imagen de fondo
bg_image = pygame.imagen.Load ("BG_IMAGE_3.JPG ")
Fondo de def ()::
pantalla.Blit (BG_Image, (-15, -25))
# Imagen de persona
Person_x = 400
Person_y = 550
image_person = pygame.imagen.Carga ("Chica.png ")
Def persona (x, y):
pantalla.Blit (Image_person, (x, y))
importar al azar
# Imagen enemiga
enemy_x = aleatorio.Randint (0, 750)
enemy_y = aleatorio.Randint (0, 300)
image_enemy = pygame.imagen.Cargar ("Enemigo.png ")
Def enemigo (x, y):
pantalla.Blit (Image_enemy, (x, y))
#Inicializar variables enemigas
enemy_diff = 0.6
enemy_x = 0
#inicializar variables
books_diff = 4
books_y = 520
books_x = 420
# Imagen de libros
books_state = "no se mueve"
image_books = pygame.imagen.Cargar ("Libros.png ")
Libros de Def (x, y):
Global Books_state
books_state = "Moving"
pantalla.Blit (Image_Books, (x + 15, y + 1))
# bucle principal
Mientras que es cierto:
Para el evento en Pygame.evento.conseguir():
Si el evento.Tipo == Pygame.ABANDONAR:
sys.salida()
# Verifique las teclas presionadas
pressed_keys = pygame.llave.get_pressed ()
# Si la tecla presionada es la flecha derecha,
# Luego muévete a la derecha
Si pressed_keys [Pygame.K_right] y persona_x < 750:
Person_x += 0.8
# Si la tecla presionada es la flecha izquierda,
# Luego muévete a la izquierda
Si pressed_keys [Pygame.K_left] y persona_x> 0:
Person_x += -0.8
# activar la función de fondo
fondo()
# activar la función de la persona
persona (persona_x, persona_y)
# Mueve al enemigo
enemy_x += enemy_diff
Si enemy_x <= 0:
enemy_x = 0
enemy_diff = 0.6
Si enemy_x> = 730:
enemy_x = 730
enemy_diff = -0.6
# Movimiento de libros
Si books_y <= 0:
books_y = 420
books_state = "no se mueve"
Si Books_State está "en movimiento":
books_x = Person_x
Libros (books_x, books_y)
books_y -= books_diff
# dispara si se presiona el botón de espacio
Si pressed_keys [Pygame.K_space]:
books_x = Person_x
Libros (books_x, books_y)
# Activar al enemigo
enemigo (enemy_x, enemy_y)
# Actualizar todo
pygame.mostrar.actualizar()
reloj.Marque (60)

Este código disparará múltiples libros uno tras otro cuando se presione la tecla de espacio.

Paso 9: Detección de colisión

El siguiente paso es detectar una colisión, y esto parece bastante sencillo. Usarías el pygame.Rect (x, y, ancho, altura) para definir un rectángulo. Luego use el método ColliderEd () para detectar la colisión entre dos rectángulos. También decimos que si detecta una colisión, aumentamos el puntaje por 1, reubicamos al enemigo y eliminamos la bala restableciéndola.

# detección de colisiones
enemy_rect = pygame.Rect (enemy_x, enemy_y, 64, 64)
books_rect = pygame.Rect (books_x, books_y, 64, 64)
Si books_rect.COLLIDERECT (enemy_rect):
enemy_x = aleatorio.Randrange (0, 800)
enemy_y = aleatorio.Randrange (0, 300)
puntaje += 1
bullet_state = "no se mueve"
enemigo (enemy_x, enemy_y)
books_y = 0

Paso 10: Mostrar texto

Fuera del mainloop, escribirías:

puntaje = 0
#inicializar fuente
pygame.fuente.en eso()
myFont = pygame.fuente.Sysfont ('Comic Sans MS', 50)
Def text_score (x, y):
text_score = myFont.render ('Score:'+ str (stork), true, (0, 0, 0))
pantalla.Blit (text_score, (x, y))

Dentro del bucle principal, escribirías:

# Activar la puntuación de texto
text_score (6, 6)

Aquí, las fuentes deben inicializarse, así que inicializarla usando PyGame.fuente.en eso(). Entonces eliges tu fuente usando pygame.fuente.Sysfont () donde pasa la fuente y el tamaño. A continuación, definamos una función en la que usamos el método de renderizado para renderizarlo. Aquí, dado que el puntaje es un entero, usamos STR (puntaje). Y luego, los colocamos en la pantalla usando el método Blit ().

En este punto, todo el código se vería así:

importar pygame
Sys de importación
# Inicializar
pygame.en eso()
# Inicializar el reloj
reloj = pygame.tiempo.Reloj()
# Establecer la geometría de la pantalla
tamaño = ancho, altura = 800, 600
pantalla = pygame.mostrar.set_mode (tamaño)
# Establecer el título de la ventana
pygame.mostrar.set_caption ("videojuego")
# Establecer el icono
imagen = pygame.imagen.Cargar ("icono.png ")
pygame.mostrar.set_icon (imagen)
# Crea la imagen de fondo
bg_image = pygame.imagen.Load ("BG_IMAGE_3.JPG ")
Fondo de def ()::
pantalla.Blit (BG_Image, (-15, -25))
# Imagen de persona
Person_x = 400
Person_y = 550
image_person = pygame.imagen.Carga ("Chica.png ")
Def persona (x, y):
pantalla.Blit (Image_person, (x, y))
importar al azar
# Imagen enemiga
enemy_x = aleatorio.Randint (0, 750)
enemy_y = aleatorio.Randint (0, 300)
image_enemy = pygame.imagen.Cargar ("Enemigo.png ")
Def enemigo (x, y):
pantalla.Blit (Image_enemy, (x, y))
#Inicializar variables enemigas
enemy_diff = 0.6
enemy_x = 0
#inicializar variables
books_diff = 4
books_y = 520
books_x = 420
# Imagen de libros
books_state = "no se mueve"
image_books = pygame.imagen.Cargar ("Libros.png ")
Libros de Def (x, y):
Global Books_state
books_state = "Moving"
pantalla.Blit (Image_Books, (x + 15, y + 1))
puntaje = 0
#inicializar fuente
pygame.fuente.en eso()
myFont = pygame.fuente.Sysfont ('Comic Sans MS', 50)
Def text_score (x, y):
text_score = myFont.render ('Score:'+ str (stork), true, (0, 0, 0))
pantalla.Blit (text_score, (x, y))
# bucle principal
Mientras que es cierto:
Para el evento en Pygame.evento.conseguir():
Si el evento.Tipo == Pygame.ABANDONAR:
sys.salida()
# Verifique las teclas presionadas
pressed_keys = pygame.llave.get_pressed ()
# Si la tecla presionada es la flecha derecha,
# Luego muévete a la derecha
Si pressed_keys [Pygame.K_right] y persona_x < 750:
Person_x += 0.8
# Si la tecla presionada es la flecha izquierda,
# Luego muévete a la izquierda
Si pressed_keys [Pygame.K_left] y persona_x> 0:
Person_x += -0.8
# activar la función de fondo
fondo()
# activar la función de la persona
persona (persona_x, persona_y)
# Mueve al enemigo
enemy_x += enemy_diff
Si enemy_x <= 0:
enemy_x = 0
enemy_diff = 0.6
Si enemy_x> = 730:
enemy_x = 730
enemy_diff = -0.6
# Movimiento de libros
Si books_y <= 0:
books_y = 420
books_state = "no se mueve"
Si Books_State está "en movimiento":
books_x = Person_x
Libros (books_x, books_y)
books_y -= books_diff
# dispara si se presiona el botón de espacio
Si pressed_keys [Pygame.K_space]:
books_x = Person_x
Libros (books_x, books_y)
# Activar al enemigo
enemigo (enemy_x, enemy_y)
# detección de colisiones
enemy_rect = pygame.Rect (enemy_x, enemy_y, 64, 64)
books_rect = pygame.Rect (books_x, books_y, 64, 64)
Si books_rect.COLLIDERECT (enemy_rect):
enemy_x = aleatorio.Randrange (0, 800)
enemy_y = aleatorio.Randrange (0, 300)
puntaje += 1
bullet_state = "no se mueve"
enemigo (enemy_x, enemy_y)
books_y = 0
# Activar la puntuación de texto
text_score (6, 6)
# Actualizar todo
pygame.mostrar.actualizar()
reloj.Marque (60)

Paso 11: Agregar sonidos

Agregar sonidos es súper duper fácil!

Fuera del bucle principal, escribiría:

# Inicializar sonidos
pygame.mezclador.en eso()
pygame.mezclador.música.Carga ("Gun-Cocking-01.wav ")

Dentro del mainloop, voy a activar el sonido si hay una colisión! Aquí usamos pygame.mezclador.música.jugar().

# detección de colisiones
enemy_rect = pygame.Rect (enemy_x, enemy_y, 64, 64)
books_rect = pygame.Rect (books_x, books_y, 64, 64)
Si books_rect.COLLIDERECT (enemy_rect):
enemy_x = aleatorio.Randrange (0, 800)
enemy_y = aleatorio.Randrange (0, 300)
puntaje += 1
bullet_state = "no se mueve"
enemigo (enemy_x, enemy_y)
books_y = 0
pygame.mezclador.música.jugar()

Paso 12: finalizando el juego

Voy a poner este juego en una victoria si el puntaje es mayor que 5. Entonces, fuera del bucle principal, escribimos el siguiente código:

text_game_over = pygame.fuente.Sysfont ('Comic Sans MS', 80)
# Juego sobre función
Def Game_over (x, y):
text_game_over_2 = myFont.Render ('ganó', verdadero, (0, 0, 0))
pantalla.Blit (text_game_over_2, (x, y))

Y dentro del bucle principal, escribiría:

# Verifique la ganancia
Si puntaje> 5:
Game_over (400, 300)
pygame.mostrar.voltear()
tiempo.dormir (5)
romper
# Activar la puntuación de texto
text_score (6, 6)
Temporizador (500, 6)

Esto significa que si la puntuación es mayor que 5, entonces la función Game_over () se activará, la pantalla se actualizará y luego decimos, duerme un poco antes de dejar de fumar.

Todo el código se vería así:

importar pygame
Sys de importación
tiempo de importación
# Inicializar
pygame.en eso()
# Inicializar el reloj
reloj = pygame.tiempo.Reloj()
# Establecer la geometría de la pantalla
tamaño = ancho, altura = 800, 600
pantalla = pygame.mostrar.set_mode (tamaño)
# Establecer el título de la ventana
pygame.mostrar.set_caption ("videojuego")
# Establecer el icono
imagen = pygame.imagen.Cargar ("icono.png ")
pygame.mostrar.set_icon (imagen)
# Crea la imagen de fondo
bg_image = pygame.imagen.Load ("BG_IMAGE_3.JPG ")
Fondo de def ()::
pantalla.Blit (BG_Image, (-15, -25))
# Imagen de persona
Person_x = 400
Person_y = 550
image_person = pygame.imagen.Carga ("Chica.png ")
Def persona (x, y):
pantalla.Blit (Image_person, (x, y))
importar al azar
# Imagen enemiga
enemy_x = aleatorio.Randint (0, 750)
enemy_y = aleatorio.Randint (0, 300)
image_enemy = pygame.imagen.Cargar ("Enemigo.png ")
Def enemigo (x, y):
pantalla.Blit (Image_enemy, (x, y))
#Inicializar variables enemigas
enemy_diff = 0.6
enemy_x = 0
#inicializar variables
books_diff = 4
books_y = 520
books_x = 420
# Imagen de libros
books_state = "no se mueve"
image_books = pygame.imagen.Cargar ("Libros.png ")
Libros de Def (x, y):
Global Books_state
books_state = "Moving"
pantalla.Blit (Image_Books, (x + 15, y + 1))
puntaje = 0
#inicializar fuente
pygame.fuente.en eso()
myFont = pygame.fuente.Sysfont ('Comic Sans MS', 50)
Def text_score (x, y):
text_score = myFont.render ('Score:'+ str (stork), true, (0, 0, 0))
pantalla.Blit (text_score, (x, y))
# Inicializar sonidos
pygame.mezclador.en eso()
pygame.mezclador.música.Carga ("Gun-Cocking-01.wav ")
text_game_over = pygame.fuente.Sysfont ('Comic Sans MS', 80)
# Juego sobre función
Def Game_over (x, y):
text_game_over_2 = myFont.Render ('ganó', verdadero, (0, 0, 0))
pantalla.Blit (text_game_over_2, (x, y))
Timer de def (x, y):
text_timer = myFont.Render ('Tiempo:'+ Str (Pygame.tiempo.get_ticks ()), verdadero, (0, 0, 0))
pantalla.Blit (text_timer, (x, y))
# bucle principal
Mientras que es cierto:
Para el evento en Pygame.evento.conseguir():
Si el evento.Tipo == Pygame.ABANDONAR:
sys.salida()
# Verifique las teclas presionadas
pressed_keys = pygame.llave.get_pressed ()
# Si la tecla presionada es la flecha derecha,
# Luego muévete a la derecha
Si pressed_keys [Pygame.K_right] y persona_x < 750:
Person_x += 0.8
# Si la tecla presionada es la flecha izquierda,
# Luego muévete a la izquierda
Si pressed_keys [Pygame.K_left] y persona_x> 0:
Person_x += -0.8
# activar la función de fondo
fondo()
# activar la función de la persona
persona (persona_x, persona_y)
# Mueve al enemigo
enemy_x += enemy_diff
Si enemy_x <= 0:
enemy_x = 0
enemy_diff = 0.6
Si enemy_x> = 730:
enemy_x = 730
enemy_diff = -0.6
# Movimiento de libros
Si books_y <= 0:
books_y = 420
books_state = "no se mueve"
Si Books_State está "en movimiento":
books_x = Person_x
Libros (books_x, books_y)
books_y -= books_diff
# dispara si se presiona el botón de espacio
Si pressed_keys [Pygame.K_space]:
books_x = Person_x
Libros (books_x, books_y)
# Activar al enemigo
enemigo (enemy_x, enemy_y)
# detección de colisiones
enemy_rect = pygame.Rect (enemy_x, enemy_y, 64, 64)
books_rect = pygame.Rect (books_x, books_y, 64, 64)
Si books_rect.COLLIDERECT (enemy_rect):
enemy_x = aleatorio.Randrange (0, 800)
enemy_y = aleatorio.Randrange (0, 300)
puntaje += 1
bullet_state = "no se mueve"
enemigo (enemy_x, enemy_y)
books_y = 0
pygame.mezclador.música.jugar()
# Verifique la ganancia
Si puntaje> 5:
Game_over (400, 300)
pygame.mostrar.voltear()
tiempo.dormir (5)
romper
# Activar la puntuación de texto
text_score (6, 6)
Temporizador (500, 6)
# Actualizar todo
pygame.mostrar.actualizar()
reloj.Marque (60)

Este, por supuesto, es el más simple de todos los juegos que posiblemente puedas crear! Sin embargo, es un comienzo para aquellos que quieren aprender Pygame y diseñar mejores videojuegos.

Games felices!