Razón Artificial

La ciencia y el arte de crear videojuegos

Arkanoid II – Gestionando escenas

Escrito por adrigm el 28 de septiembre de 2010 en Desarrollo Videojuegos, Noticias, Programación | 3 Comentarios.

Una vez listo nuestro directorio de trabajo y nuestro archivo de configuración es hora de implementar el sistema de escenas que ya mencionamos en el artículo anterior. Vuelvo a recomendar encarecidamente leer y entender el artículo de gestión de escenas, pues no voy a volver a explicarlo.

El archivo director.py

Es el archivo que contiene el objeto director que es en última estancia el que llevará el bucle de nuestro juego y que gestionará las diferentes escenas.

# -*- encoding: utf-8 -*-

# Módulos
import pygame
import config

class Director:
    """Representa el objeto principal del juego.

    El objeto Director mantiene en funcionamiento el juego, se
    encarga de actualizar, dibuja y propagar eventos.

    Tiene que utilizar este objeto en conjunto con objetos
    derivados de Scene."""

    def __init__(self):
        self.screen = pygame.display.set_mode((config.width, config.height))
        pygame.display.set_caption(config.name)
        self.scene = None
        self.quit_flag = False
        self.clock = pygame.time.Clock()

    def loop(self):
        "Pone en funcionamiento el juego."

        while not self.quit_flag:
            self.time = self.clock.tick(60)

            # Eventos de Salida
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.quit()

            # detecta eventos
            self.scene.on_event()

            # actualiza la escena
            self.scene.on_update()

            # dibuja la pantalla
            self.scene.on_draw(self.screen)
            pygame.display.flip()

    def change_scene(self, scene):
        "Altera la escena actual."
        self.scene = scene

    def quit(self):
        self.quit_flag = True

A destacar ver como importamos el archivo config y lo usamos para cargar la resolución o el nombre del juego. Lo demás viene explicado en el artículo de la gestión de escenas.

El archivo scene.py

Representará una escena abstracta del juego y será heredada por las escenas de nuestro juego.

# -*- encoding: utf-8 -*-

class Scene:
    """Representa un escena abstracta del videojuego.

    Una escena es una parte visible del juego, como una pantalla
    de presentación o menú de opciones. Tiene que crear un objeto
    derivado de esta clase para crear una escena utilizable."""

    def __init__(self, director):
        self.director = director

    def on_update(self):
        "Actualización lógica que se llama automáticamente desde el director."
        raise NotImplemented("Tiene que implementar el método on_update.")

    def on_event(self, event):
        "Se llama cuando llega un evento especifico al bucle."
        raise NotImplemented("Tiene que implementar el método on_event.")

    def on_draw(self, screen):
        "Se llama cuando se quiere dibujar la pantalla."
        raise NotImplemented("Tiene que implementar el método on_draw.")

SceneGame

Aunque cuando nuestro juego esté acabado la escena inicial será SceneHome en un principio vamos a crear y a cargar SceneGame mientras desarrollamos el juego ya que el menú principal lo desarrollaremos más adelante. Esto solo afecta a la escena que cargaremos en primer lugar y luego cambiar a SceneHome será tan fácil como sustituirla en el archivo main.

La clase que representan a las escena he decidido llamarlas SceneName donde Name es el nombre de la escena y el archivo que las contiene se llamará scene_name donde otra vez name es el nombre de la escena.

Por tanto creamos un archivo llamado scene_game.py y dentro creamos nuestra escena SceneGame:

# -*- encoding: utf-8 -*-

import scene
import config

class SceneGame(scene.Scene):
    """Escena inicial del juego, esta es la primera que se carga cuando inicia"""

    def __init__(self, director):
        scene.Scene.__init__(self, director)


    def on_update(self):
        pass

    def on_event(self):
        pass

    def on_draw(self, screen):
        pass

Como vemos creamos la clase SceneGame como se explica en el tutorial, con el método init llamando al init de Scene y creando los tres métodos de actualizar, eventos y dibuhar de rigor. Que, de momento, estñan vacíos.

El archivo principal

Por último debemos crear el archivo main.py que será el encargado de ejecutar el juego. Por ahora main.py cargará SceneGame, pero cuando nuestro juego este listo pasará a cargar SceneHome.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import pygame
import director
import scene_game

def main():
    dir = director.Director()
    scene = scene_game.SceneGame(dir)
    dir.change_scene(scene)
    dir.loop()

if __name__ == '__main__':
    pygame.init()
    main()

Con esto ya debemos poder ejecutar nuestro juego y tener una ventana en negro que en realidad es más que eso, pues está lista para ejecutar las ordenes dadas en SceneGame.

3 Comentarios en "Arkanoid II – Gestionando escenas"

  1. Emilianox64 dice:

    En director.py, linea 27: “time = self.clock.tick(60)”, debería ser self.time ;)

    Grácias por los tutos, están geniales! :)

  2. adrigm dice:

    Emilianox64, si cierto, me di cuenta cuando lo tuve que usar en tutoriales posteriores, pero se me olvido corregirlo en este tutorial.

    Gracias por el aviso.

  3. Xfred dice:

    Los tutoriales son muy buenos y te agradezco el interés y el tiempo que le dedicas. Solo quería hacerte notar que el link de “gestión de escenas” se encuentra caído. Gracias.

Deja un comentario