¿Cómo manejar colisiones de Pong en Python?

¿Has visto scripts de Python que integren el método de las colisiones? Si los has hecho, pero aún no sabes cómo funciona, debes seguir leyendo este post, ya que, aquí, podrás aprender cómo manejar colisiones de Pong en Python.

Este tipo de ejercicios serán importantes si quieres realizar otros videojuegos en formato 2D, similares a Pong, con la librería de Pygame, pues presenta una serie de dinámicas muy parecidas a otros juegos y con funciones que también se pueden utilizar allí. Por esto, a continuación, te presentamos cómo manejar colisiones de Pong en Python.

Pasos para manejar colisiones de Pong en Python

Lanzar la bola de Pong en Python

En un pasado post de KeepCoding, hablamos de cómo mover una bola de Pong en Python. Allí se establece cómo mover y lanzar una bola en Pong con el método “muévete”. Sin embargo, aún no se había ordenado una función o método para que fuera funcional en Pong, pues aún nos faltaba integrar la colisiones que sucedían entre la bola y los bordes superior e inferior, además de la colisión contra las dos paletas del juego.

En este post, por tanto, te explicaremos el proceso de los dos últimos pasos que establecimos para que el juego fuera más funcional: en primer lugar, que la bola debe rebotar en el borde superior e inferior y, por último, que la bola debe rebotar en las paletas. 

Colisiones de Pong en Python

Las colisiones de Pong en Python actúan a tráves del movimiento de las dos paletas de cada jugador y de la bola o pelota del mismo juego. En este caso, en la siguiente imagen representamos la forma en la que actuaría una bola en la pantalla de un programa de Pong. Esto servirá para definir la acción para que la bola rebote en el borde superior e inferior, así como que la bola debe rebotar en las paletas.

La bola debe rebotar en el borde superior e inferior

Para cumplir con este paso, debemos establecer los puntos de referencias de nuestra pantalla y además entender cómo actuará la bola, según las distancias establecidas desde la dimensión de las pantalla. Esto nos ayudará a comprobar las posiciones que puede tener la bola mientras hay un movimiento. Esto proceso lo puedes observar en la imagen anterior.

En un primer momento, deberás definir un método, al que llamaremos colisión, en el constructor de la clase Pong. Si quieres saber, antes de esto, cómo construir una clase Pong, puedes visitar el siguiente post sobre cómo hacer una clase Pong.

Después, para comprobar que la bola esté cada vez que las posiciones cambian, deberemos instanciarla en el bucle principal de la misma clase. Allí empezaremos a utilizar lo que representamos en la imagen que hemos establecido en un paso anterior.

Para la colisión del borde inferior, utilizaremos la función de if self.y >= self._ALTO y, para el borde superior, la función self.y <= 0. De esta manera, se imprimirá un rebote. En el caso de los bordes laterales, utilizaremos las funciones if self.x < 0 para la izquierda o y self.x > self._ANCHO – self.w para el borde de la derecha.

En este caso, si la bola pasa por estos bordes, le dará un punto al jugador que la haya lanzado. Aquí ya habremos representado la función, pero no ha sido practicable para términos de Pong. Por eso, el siguiente paso es cambiar los sentidos y las velocidades de la clase bola. Una vez hecho esto, deberás integrarlo también en la definición en el constructor de los bordes:

import Pygame
#definición de la clase Pong

class Pong

#definición del constructor de la clase Pong

def __init__ (self, ancho, alto):

def colision_bordes (self):

       if self.y >= self._ALTO - self.h or self.y <= 0: 

          print  ("rebote")

#Aquí deberás cambiar el sentido vertical, después de encontrar el sentido de la bola

         self.bola.vel_v = -self.bola.vel_v

       if self.x < 0 or self.x > self._ANCHO - self.w

        print ("punto")

         self.bola.vel_h = -self.bola.vel_h

#definición del método en el bucle principal

self.jugador1.muevete ()

self.jugador2.muevete ()

self.bola.muevete ()

self.colisiones

#en la definición de la clase bola

#definición de la clase

class Bola (pygame.React)

def __init__ (self, velocidad, *args, **kwargs)

supper (Bola, self).init (*args, **kwargs)

self.velocidad = velocidad

self.vel_h = velocidad

self.vel_v = velocidad

#definición del método muévete

def muevete (self),

#cambiar el sentido de la x horizontal

self.x += self.vel_h

#cambiar el sentido de la y vertical

self.y += self.vel_y

En resumen, el proceso es el siguiente: cada vez que el programa pase por el bucle, estarás comprobando si hay una colisión con un borde. En la definición de las colisiones, comprueba que la bola está (en el caso de la y) en un punto mayor que la parte inferior de la pantalla y, a su vez, estaremos comprobando que sea mayor que la parte de arriba.

Así, la bola rebotará si cumple o no cumple estas condiciones. Entonces, lo que estarás haciendo en la colisión es cambiar los signos si está rebotando en la vertical o en la horizontal, según corresponda.

Aunque saber manejar colisiones de Pong en Python llega a ser mucho más funcional si estás creando un juego, debes recordar que hemos establecido una igual velocidad para los bordes verticales y horizontales, por lo que no tendría sentido en términos de perder o ganar en un juego. Así pues, deberás trabajar con los ángulos en la velocidad de cada borde.

Ahora que sabes cómo manejar colisiones de Pong en Python, la bola de tu videojuego Pong estará lista para interactuar con la paletas de cada uno de los jugadores y la misma pantalla.

Si quieres saber más acerca de Pygame, de desarrollo de videojuegos y del mundillo de IT, te recomendamos echarle un vistazo al programa que ofrece nuestro Bootcamp de Programación. ¡Apúntate!