Lectores como tú ayudan a apoyar a MUO. Cuando realiza una compra utilizando enlaces en nuestro sitio, podemos ganar una comisión de afiliado. Leer más.

Pygame proporciona varias funciones integradas para detectar colisiones entre objetos del juego. Estos son invaluables porque determinar exactamente cuándo y cómo se superponen los objetos en movimiento puede ser una tarea complicada.

Aprenda a agregar física básica y colisiones en su juego usando el módulo pygame.

Funciones de detección de colisiones integradas de Pygame

La función de detección de colisiones integrada más básica es spritecollide. Toma un sprite, un grupo de sprites y un valor booleano que indica si los sprites deben o no "morir" (eliminarse) cuando chocan. Esta función devuelve una lista de sprites que han colisionado. Aquí hay un ejemplo de cómo usarlo:

colisionaron_sprites = pygame.sprite.spritecollide (sprite1, sprite_group, Verdadero)

Otra función útil de detección de colisiones es groupcollide, que también incluye dos grupos de sprites y un valor booleano. Esta función devuelve un diccionario con los sprites en colisión como claves y los sprites con los que chocaron como valores. Aquí hay un ejemplo de cómo usarlo:

instagram viewer 

colision_dict = pygame.sprite.groupcollide (grupo1, grupo2, Verdadero, Verdadero)

Creación de un juego de plataformas básico con la función spritecollide

Para crear un juego de plataformas básico con Pygame, deberá crear un sprite de jugador que el usuario pueda controlar y un sprite de plataforma para que el jugador se pare. Puede usar la función spritecollide para detectar cuándo el sprite del jugador choca con el sprite de la plataforma y evitar que el jugador caiga a través de la plataforma.

Para comenzar, instalar el módulo pygame usando pip:

pip instalar pygame

Después, crear clases simples para el jugador y la plataforma, los cuales deberían heredar de la clase Sprite de Pygame. La clase Player debe tener un método de actualización para manejar la posición del jugador en función de la velocidad. Además, debe tener una variable y_velocity para aplicar el efecto de gravedad. La clase Platform debe tener un método __init__ que tome las coordenadas de la plataforma y cree una superficie con ese tamaño.

Clase de jugador

Puede crear una clase de jugador usando pygame.sprite. Módulo de sprites. Esta clase inicializará al jugador con unas coordenadas x e y dadas. Luego, el método de actualización actualizará la posición del jugador incrementando el valor de y_velocity.

importar Pygame
claseJugador(pygame.sprite. Duende):
definitivamente__en eso__(yo, x, y):
 super().__init__()
 self.imagen = pygame. Superficie((32, 32))
 self.rect = self.image.get_rect (arriba a la izquierda=(x, y))
 self.y_velocidad = 0
definitivamenteactualizar(ser):
 self.rect.y += self.y_velocity

Clase de plataforma

La clase Platform también usa pygame.sprite. Módulo de sprites. Esta clase inicializará la plataforma con las coordenadas x e y dadas, así como con el ancho y la altura.

clasePlataforma(pygame.sprite. Duende):
definitivamente__en eso__(yo, x, y, ancho, alto):
 super().__init__()
 self.imagen = pygame. Superficie ((ancho, alto))
 self.rect = self.image.get_rect (arriba a la izquierda=(x, y))

El bucle del juego

El bucle del juego te permitirá crear una ventana con un tamaño de 640x480. Luego, ejecutará un ciclo que verificará cualquier evento, como un comando de salida. También comprobará si hay colisiones entre el jugador y la plataforma. Finalmente, llenará la pantalla con un color blanco, dibujará el jugador y la plataforma, y ​​luego girará la pantalla.

jugador = jugador(100, 300)
grupo_jugadores = pygame.sprite. Grupo()
player_group.add (jugador)
plataforma = Plataforma(50, 400, 100, 20)
grupo_plataforma = pygame.sprite. Grupo()
plataforma_grupo.añadir (plataforma)


# Inicializar pygame y crear ventana
pygame.init()
pantalla = pygame.display.set_mode((640, 480))


# Bucle de juego principal
corriendo = Verdadero


mientras correr:
para evento en pygame.event.get():
si evento.tipo == pygame. ABANDONAR:
 corriendo = FALSO

 player_group.update()
 colisionado = pygame.sprite.spritecollide (jugador, grupo_plataforma, FALSO)


si chocó:
 jugador.y_velocidad = 0
 pantalla.llenar((255, 255, 255))
 player_group.draw (pantalla)
 plataforma_grupo.draw (pantalla)
 pygame.display.flip()
pygame.quit()

A continuación se muestra la salida:

Implementación de la gravedad y el comportamiento de salto

Para implementar la gravedad y el comportamiento de salto en su juego de plataformas, deberá agregar una velocidad y a su sprite de jugador y actualizar su posición y en cada cuadro. Para hacer esto, puede usar el método de actualización dentro de la clase Player y agregar el siguiente fragmento de código:

claseJugador(pygame.sprite. Duende):
definitivamente__en eso__(yo, x, y):
 super().__init__()
 self.imagen = pygame. Superficie((32, 32))
 self.rect = self.image.get_rect (arriba a la izquierda=(x, y))
 self.y_velocidad = 0
definitivamenteactualizar(ser):
 self.rect.y += self.y_velocity
 self.y_velocity += GRAVEDAD # Aplicar la gravedad a la velocidad y

Ahora, cada vez que llame al método de actualización, actualizará la posición del jugador de acuerdo con su velocidad y gravedad.

Para hacer que el sprite del jugador salte, puede vincular la acción de salto a una tecla o botón específico y actualizar la velocidad y del jugador con un valor negativo. El siguiente fragmento de código es un ejemplo de cómo saltar cuando un jugador presiona la barra espaciadora.

SALTO_VELOCIDAD = -10
# dentro del ciclo del juego
si evento.tipo == pygame. TECLADO y evento.clave == pygame. ESPACIO_K:
 player.y_velocity = SALTO_VELOCIDAD

Tenga en cuenta que deberá verificar event.type para asegurarse de que el evento sea un evento KEYDOWN antes de verificar el valor de la clave.

Adición de física básica como la fricción y la aceleración

Para agregar física básica como la fricción y la aceleración a su juego de plataformas, deberá actualizar la velocidad x de su sprite de jugador en cada cuadro. Puede agregar la velocidad x a la clase de jugador y actualizarla de la misma manera que la velocidad y. Para implementar la fricción, puede disminuir la velocidad x del sprite del jugador en una pequeña cantidad en cada cuadro. Por ejemplo, puede agregar el siguiente fragmento de código dentro del método de actualización de la clase Player:

FRICCIÓN = 0.9
claseJugador(pygame.sprite. Duende):
definitivamente__en eso__(yo, x, y):
 super().__init__()
 self.imagen = pygame. Superficie((32, 32))
 self.rect = self.image.get_rect (arriba a la izquierda=(x, y))
 self.y_velocidad = 0
 self.x_velocidad = 0
definitivamenteactualizar(ser):
 self.rect.y += self.y_velocity
 self.rect.x += self.x_velocidad
 self.y_velocity += GRAVEDAD # Aplicar la gravedad a la velocidad y
 self.x_velocity *= FRICCIÓN # Aplicar fricción a x velocidad

Para implementar la aceleración, puede establecer una variable, player_movement, para el movimiento horizontal y actualizar la velocidad x del sprite del jugador de acuerdo con el valor de player_movement. Puede hacer esto vinculando el movimiento a teclas o botones específicos y actualizando la velocidad x del jugador en el bucle de eventos, por ejemplo:

ACELERACION = 0.5
jugador_movimiento = 0
si evento.tipo == pygame. TECLADO:
si evento.clave == pygame. K_IZQUIERDA:
 jugador_movimiento = -1
elif evento.clave == pygame. K_DERECHO:
 jugador_movimiento = 1
elif evento.tipo == pygame. TECLA ARRIBA:
si event.key en (pigame. K_LEFT, pygame. K_DERECHA):
 jugador_movimiento = 0

player.x_velocity += player_movement * ACELERACIÓN

Mediante el uso de estas técnicas, puede crear un juego de plataformas simple pero divertido utilizando las funciones de detección de colisiones integradas y la física básica de Pygame. Con un poco de creatividad y experimentación, puede usar estas técnicas para crear una variedad de juegos y mecánicas de juego diferentes.

Puedes encontrar el código completo en el repositorio GitHub.

A continuación se muestra la salida:

Mejore la interacción del usuario con las colisiones

Muchos juegos requieren algún tipo de detección de colisiones. Puede usar colisiones para crear una amplia gama de mecánicas de juego, desde juegos de plataformas simples hasta simulaciones complejas basadas en la física.

La implementación de física básica como la gravedad, la fricción y la aceleración también puede mejorar en gran medida la participación del usuario, agregando realismo y una sensación de peso a los objetos del juego.