Bienvenidos un día más al curso de Python. En este capítulo vamos a tratar el tema de la sincronización en los videojuegos completo, y seguiremos complementando el videojuego que estamos realizando con la librería “Pygame”. En el capítulo anterior ya dejamos hecho el esqueleto de nuestro videojuego y os recomendamos recordar cómo se utiliza el paradigma de programación orientado a objetos. Hoy empezaremos con un poco de teoría, y luego la aplicaremos a nuestro videojuego. Así que pongámonos manos a la obra.

Sincronización en los videojuegos

La forma de sincronizar un videojuego es importante ya que nos permite adaptar nuestro juego a los distintos ordenadores donde lo ejecutemos, de manera que, en todos, el resultado sea el mismo. Siempre y cuando el hardware sea capaz de ejecutar el videojuego. Existen dos maneras de sincronización:

Una manera es la sincronización por “Framerate” o “Frames per Second (FPS)”: Este método se centra en la frecuencia con que se ejecuta el ciclo principal de un videojuego en un segundo (mientras más alto, más fluidez).

Es decir, se va obteniendo el tiempo que ha trascurrido desde el inicio del ciclo, se hacen las acciones del juego y cuando pasen los FPS especificados, se actualiza y/o refresca la pantalla. Así se logra una fluidez constante sin importar en que equipo se ejecute.

Este es uno de los métodos más extendidos (especialmente en juegos en 2D). Claro que este método tiene sus ventajas y desventajas:

• Ventaja: ya que limitamos la cantidad máxima de FPS que puede lograr el juego, éste debería verse de la misma forma en cualquier ordenador en donde se ejecute, ya que si el equipo es muy potente sólo funcionará a los FPS especificados (pese a que puede ir más rápido).
• Desventaja: al usar este método en ordenadores más rápidos (que el que utilicemos para su desarrollo) el juego se verá fluido, pero si lo ejecutamos en un ordenador con un procesador mucho más antiguo del que usamos para desarrollarlo, lo más probable es que se vea bastante lento (por esa razón existen los requerimientos mínimos).

El segundo método es la sincronización por tiempo: En este caso se sincroniza en base al tiempo (por lo que no importan los FPS) moviéndose de igual manera los objetos sin importar en que equipo se ejecute el juego (ya que el movimiento depende del tiempo transcurrido).Ya que lo que se hace es calcular la posición de un objeto en función del tiempo transcurrido.

Este método se usa bastante en videojuegos 3D, ya que el “framerate” varía mucho en cada ciclo.

• Ventajas: Los objetos y/o “sprites” se mueven siempre a la misma velocidad, sin importar cuántos FPS se alcancen (ya que su movimiento es en función del tiempo), por lo cual no hay que preocuparse de controlar el “framerate”.
• Desventajas: Pese a que los objetos se mueven siempre a la misma velocidad, en un ordenador más lento el desplazamiento no se verá fluidamente, por ejemplo en caso de que tarde el juego 1 segundo en cada ciclo, cada vez que se deba mover un objeto este se desplazará grandes distancias (ya que el tiempo entre actualizaciones y/o ciclos en donde se refresca la pantalla es grande), produciéndose un salto muy notorio, siendo este un caso muy exagerado.

Si en el primer método (FPS) queríamos mover un objeto 8 pixeles, haríamos lo siguiente:

x = x + 8

En cambio, si lo hacemos en base al tiempo tendríamos:

x = x + (velocidad) * (tiempo)

Es decir, física básica, en donde por ejemplo si se desplaza el objeto a una velocidad de 0.008, y el ciclo demora 1 segundo en ejecutarse (1000ms), el nuevo incremento será de:

x = x + 0.008 * 1000

x = x + 8

Después de esto continuemos con el desarrollo de nuestro videojuego.

Moviendo la pelota (y creando un reloj)

En el juego utilizaremos el método de sincronización de “FPS”. Entonces vamos a crear dentro de la clase Pelota una función de actualización, que se encargará de hacer avanzar la bola y que haga que rebote cuando haya llegado a los límites de la pantalla.

#!/usr/bin/env python 
 # -*- coding: utf-8 -*- 
  
 # --------------------------- 
 # Importacion de los módulos 
 # --------------------------- 
  
 import pygame 
 from pygame.locals import * 
 import os 
 import sys 
  
 # ----------- 
 # Constantes 
 # ----------- 
  
 SCREEN_WIDTH = 640 
 SCREEN_HEIGHT = 480 
 IMG_DIR = "imagenes" 
  
 # ------------------------------ 
 # Clases y Funciones utilizadas 
 # ------------------------------ 
  
  
 def load_image(nombre, dir_imagen, alpha=False): 
     # Encontramos la ruta completa de la imagen 
     ruta = os.path.join(dir_imagen, nombre) 
     try: 
         image = pygame.image.load(ruta) 
     except: 
         print("Error, no se puede cargar la imagen: " + ruta) 
         sys.exit(1) 
     # Comprobar si la imagen tiene "canal alpha" (como los png) 
     if alpha is True: 
         image = image.convert_alpha() 
     else: 
         image = image.convert() 
     return image 
  
  
 # ----------------------------------------------- 
 # Creamos los sprites (clases) de los objetos del juego: 
  
  
 class Pelota(pygame.sprite.Sprite): 
     "La bola y su comportamiento en la pantalla" 
  
     def __init__(self): 
         pygame.sprite.Sprite.__init__(self) 
         self.image = load_image("bola.png", IMG_DIR, alpha=True) 
         self.rect = self.image.get_rect() 
         self.rect.centerx = SCREEN_WIDTH / 2 
         self.rect.centery = SCREEN_HEIGHT / 2 
         self.speed = [3, 3] 
  
     def update(self): 
         if self.rect.left < 0 or self.rect.right > SCREEN_WIDTH: 
             self.speed[0] = -self.speed[0] 
         if self.rect.top < 0 or self.rect.bottom > SCREEN_HEIGHT: 
             self.speed[1] = -self.speed[1] 
         self.rect.move_ip((self.speed[0], self.speed[1])) 
  
 # ------------------------------ 
 # Funcion principal del juego 
 # ------------------------------ 
  
  
 def main(): 
     pygame.init() 
     # creamos la ventana y le indicamos un titulo: 
     screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) 
     pygame.display.set_caption("Pong") 
  
     # cargamos los objetos 
     fondo = load_image("fondo.jpg", IMG_DIR, alpha=False) 
     bola = Pelota() 
  
     clock = pygame.time.Clock() 
  
     # el bucle principal del juego 
     while True: 
         clock.tick(60) 
         bola.update() 
  
         # actualizamos la pantalla 
         screen.blit(fondo, (0, 0)) 
         screen.blit(bola.image, bola.rect) 
         pygame.display.flip() 
  
         # Posibles entradas del teclado y mouse 
         for event in pygame.event.get(): 
             if event.type == pygame.QUIT: 
                 sys.exit() 
  
  
 if __name__ == "__main__": 
     main()