Detección de colisiones en PyGame

Prerrequisito: Introducción a pygame

# import required libraries
import pygame
import random
 
# initialize pygame objects
pygame.init()
 
# define the colours
white = (255, 255, 255)
red = (255, 0, 0)
green = (0, 255, 0)
blue = (0, 0, 255)
black = (0, 0, 0)
 
# set the Dimensions
width = 650
height = 700
 
# size of a block
pixel = 64
 
# set Screen
screen = pygame.display.set_mode((width,
                                  height))
 
# set caption
pygame.display.set_caption("CORONA SCARPER")
 
# load the image
gameIcon = pygame.image.load("rectangleBlock.png")
 
# set icon
pygame.display.set_icon(gameIcon)
 
# load the image
backgroundImg = pygame.image.load("wallBackground.jpg")

Este es el código simple básico para crear una pantalla de ventana y configurar el título, el ícono y algunas variables predefinidas que no son tan importantes para profundizar. La variable de píxel es el tamaño de la imagen del bloque, es decir, 64 píxeles.

 Parte

# load the image
playerImage = pygame.image.load("player.png")
 
# set the position
playerXPosition = (width/2) - (pixel/2)
 
# So that the player will be
# at height of 20 above the base
playerYPosition = height - pixel - 10    
 
# set initially 0
playerXPositionChange = 0
 
# define a function for setting
# the image at particular
# coordinates
def player(x, y):
  # paste image on screen object
  screen.blit(playerImage, (x, y))
 
# load the image
blockImage = pygame.image.load("rectangleBlock.png")
 
# set the random position
blockXPosition = random.randint(0,
                                (width - pixel))
 
blockYPosition = 0 - pixel
 
# set the speed of
# the block
blockXPositionChange = 0
blockYPositionChange = 2   
 
# define a function for setting
# the image at particular
# coordinates
def block(x, y):
  # paste image on screen object
  screen.blit(blockImage,
              (x, y))

Aquí mostramos al jugador y al bloque en sus respectivas posiciones X e Y. La posición X del bloque es aleatoria en cada ronda.

Nota: Dondequiera que se use la palabra píxel, se usa para restar 64 píxeles de la posición dada para que se muestre la imagen completa

     Por ejemplo: si el bloque se muestra en la posición de ancho, se dibujará a partir de ese punto y, por lo tanto, se mostrará fuera de la pantalla. Por lo tanto, estamos restando 64 píxeles para ver la imagen completa.

Ahora,

colisión horizontal

Primero, comprobamos si el bloque pasa por la línea horizontal del jugador. Estableceremos el rango de manera que la línea horizontal base del bloque coincida con la línea horizontal del jugador. En la imagen de arriba, los bloques 2 y 3 tienen su línea de base fuera del rango de la línea de superficie superior e inferior del jugador P. Por lo tanto, no están en el rango de colisión. La línea de base del bloque 1 está en el rango de la parte superior e inferior del jugador P. Por lo tanto, vemos además que el bloque entra en el rango del rango vertical del jugador o no.

colisión vertical

Aquí, verificamos el rango de dimensiones de la superficie del lado izquierdo y derecho del jugador con las superficies izquierda y derecha de los bloques. Aquí, los bloques 2 y 3 cuando bajan, chocarán con el jugador y, por lo tanto, el rango del rango del bloque 2 y 3 está entre la posición X del jugador y la posición Y del jugador. 

Por lo tanto, este concepto se utiliza para detectar la colisión.

Parte

# define a function for
# collision detection
def crash():
  # take a global variable
  global blockYPosition
 
  # check conditions
  if playerYPosition < (blockYPosition + pixel):
 
      if ((playerXPosition > blockXPosition
           and playerXPosition < (blockXPosition + pixel))
          or ((playerXPosition + pixel) > blockXPosition
           and (playerXPosition + pixel) < (blockXPosition + pixel))):
 
          blockYPosition = height + 1000

la función de choque define la condición de colisión.

En la primera condición IF , verificamos la colisión horizontal. Aquí, si la posición Y del jugador es menor que la posición Y del bloque, es decir, el bloque se aleja del rango horizontal del jugador, entonces la siguiente condición a verificar es horizontal. El píxel se agrega a blockYPosition porque su posición Y está en la parte superior del bloque y la parte inferior o base del bloque es la posición superior de un bloque + su tamaño de píxel (tamaño de imagen).

La segunda condición IF verifica la colisión vertical. Si el bloque está pasando desde el rango horizontal, solo verifique la vertical, de modo que la colisión del bloque se detecte en sus cuatro lados. Ahora, si la posición X de los jugadores es mayor que la posición X del bloque, es decir, el bloque está a la izquierda del jugador. Aquí, si la posición inicial del bloque es menor que la posición inicial del jugador y la posición final del bloque (posición Y del bloque + píxel) es mayor que la posición inicial del jugador, esto significa que el bloque se superpondrá a la posición inicial del jugador y, por lo tanto, chocará. Esto se muestra en la imagen de colisión vertical anterior para el bloque 2.

De manera similar, el segundo rango se da si la posición inicial de los bloques es menor que la posición final del jugador y la posición final de los bloques es mayor que la posición final del jugador. Esto se muestra para la misma imagen para el bloque 3.

La imagen explica claramente la vista de la colisión.

Por lo tanto, si ocurre una colisión, moveremos el bloque debajo de la pantalla, es decir, a una distancia de más de 1000 debajo para que sea invisible y no aparezca el nuevo bloque.

Parte

running = True
 
while running:
  # set the image on screen object
  screen.blit(backgroundImg, (0, 0))
 
  # loop through all events
  for event in pygame.event.get():
        
      # check the quit condition
       if event.type == pygame.QUIT:
          # quit the game
          pygame.quit()
 
       # movement key control of player
       if event.type == pygame.KEYDOWN:
 
          if event.key == pygame.K_RIGHT:
 
              playerXPositionChange = 3
 
          if event.key == pygame.K_LEFT:
 
              playerXPositionChange = -3
 
       if event.type == pygame.KEYUP:
 
           if event.key == pygame.K_RIGHT or pygame.K_LEFT:
 
               playerXPositionChange = 0

Este es el bucle de juego donde se controla el movimiento del jugador. y se inicia el juego. 

Parte

# Boundaries to the Player
 
# if it comes at right end,
# stay at right end and
# does not exceed
if playerXPosition >= (width - pixel):
  playerXPosition = (width - pixel)
   
# if it comes at left end,
# stay at left end and
# does not exceed
if playerXPosition <= 0:
  playerXPosition = 0

Estos son los límites del jugador, de modo que cuando el jugador se mueve a su posición más a la derecha o más a la izquierda en la pantalla, no debería ir más lejos y rebotar.

Parte

# Multiple Blocks Movement after each other
# and condition used because of game over function
if (blockYPosition >= height - 0 and
    blockYPosition <= (height + 200)):
   
  blockYPosition = 0 - pixel
   
  # randomly assign value in range
  blockXPosition = random.randint(0, (width - pixel))

Cuando el bloque sin colisionar se aleja del jugador, debemos dejarlo volver desde arriba. Por lo tanto, proporcionamos una condición de que si la posición Y del bloque está por debajo de la altura de la pantalla y por debajo de la altura+200 (como por encima de 1000+, el bloque aparece cuando el bloque ha colisionado), luego muévalo nuevamente a la parte superior.

Parte

# movement of Player
playerXPosition += playerXPositionChange
 
# movement of Block
blockYPosition += blockYPositionChange
 
# player Function Call
player(playerXPosition, playerYPosition)
 
# block Function Call
block(blockXPosition, blockYPosition)
 
# crash function call
crash()
 
# update screen
pygame.display.update()

Al final se da el movimiento del jugador y del bloque y se refresca la pantalla

Producción: