La clase sprite

Posted on mayo 15, 2007. Filed under: PyGame, Python |

Leyendo esta excelente guia de ejemplos de pygame, quiero hablar un poco de la clase sprite.

La clase sprite puede ser usada como una clase base para diferentes objetos, y contiene algunas funciones muy útiles para trabajar con grupos de sprites. Por ejemplo podemos tener el grupo de las naves y el grupo de los asteroides y con funciones como groupcollide, controlar cuales naves chocaron con los asteroides. A continuación un ejemplo sencillo de creación de grupos de sprites:

naves=pygame.sprite.Group()
xwing = Xwing()
naves.add(xwing())

asteroides=pygame.sprite.Group()
asteroides.add(Clase_asteroides(200,300))

En el código anterior, creamos un primer grupo de sprites llamado naves, y usando la funcion add vamos agregandole sprites. La linea que dice xwing=Xwing() sirve para crear un objeto de tipo Xwing (que es un sprite).
Luego de esto creamos otro grupo asteroides y agregamos en el grupo de sprites un objeto, pero en este caso lo instanciamos dentro de la función.

Hay 3 grandes tipos de grupos:

  • GroupSingle: solo permite un sprite, si agregamos otro, el que estaba se borraria
  • Group: un grupo de sprites común y corriente
  • RenderUpdates: un grupo que tiene la funcion draw modificada, ya que produce una salida.

Es decir que los grupos tipo Group y RenderUpdates cuando se hace draw() es como si hicieramos un blit() de todos las imagenes que hay en cada sprite, solo que en RenderUpdates la función draw() tiene una respuesta, veamos un ejemplo (modificado de la guia que dejé al principio)

all_sprites=pygame.sprite.Group()       #noten que en el ejemplo se usa RenderPlain, pero esta en desuso
all_sprites.add(player)                           #agregamos el objeto player al grupo all_sprites
all_sprites.add(alien)                             #agregamos el objeto alien

while 1:
       all_sprites.update()                          #actualizamos todos los sprites
       screen.fill((200,200,200))                #pintamos la superfie screen con el color gris
       all_sprites.draw(screen)                  #hacemos un blit en la superficie screen de TODOS los sprites del grupo all_sprites
       pygame.display.flip()                        #mostramos todo lo que hay en el “reverso” de la página

all_sprites.empty()                                   #cuando salimos del while borramos todos los sprites del grupo

Como se puede observar, en cada ciclo del programa se actualizan los sprites, se pinta el fondo de la pantalla (screen) y se dibujan (con la función draw) TODOS los sprites, ya sea que hayan cambiado o no. Esta técnica tiene la desventaja de tener que dibujar TODO siempre, en la actualidad las máquinas son muy rápidas y no tendrían problemas, pero puede ser que el juego tenga una cierta complejidad que no convenga dibujar todo sino una región y en este caso conviene usar otra cosa.

Hay una alternativa que mejoraría el juego y es utilizando el grupo de sprites RenderUpdates, veamos un ejemplo:

all_sprites = pygame.sprite.RenderUpdates()            #creamos un grupo all_sprites
all_sprites.add(player)                                                   #agregamos player al grupo

while 1:
       all_sprites.update()                                                  #actualizamos el grupo
       all_sprites.clear(screen, background)                  #en la superficie screen, pintamos con el background solo en las posiciones de los sprites del grupo.
       pygame.display.update(all_sprite.draw(screen))
all_sprites.empty()

Hay un par de cosas que debemos aclarar de este código. La primer parte es igual solo que creamos un grupo de tipo RenderUpdates. Dentro del while actualizamos los sprites, luego en vez de borrar toda la pantalla (como hacíamos antes pintando de gris todo el fondo), aquí usando la función clear() del grupo, y con esto “pintaremos” solo en aquellas partes donde haya un sprite del grupo all_sprites, la sintaxis es la siguiente:

Group.clear(superficie_destino, superficie_origen) #pintaremos con la superficie_origen solo en los sprites de la superficie_destino.

A continuación de esto hacemos un display.update y un all_sprite.draw, por que? En realidad es muy simple: como había dicho antes la función draw de la clase RenderUpdates esta modificada y devuelve un listado de rectángulos que fueron modificados, es decir devuelve las posiciones de pantalla que cambiaron de un cuadro a otro, esta respuesta le pasamos como parámetro a display.update() que se diferencia de display.flip() por el hecho de que solo actualiza algunas porciones de pantalla.

Al final haremos que nuestro juego de “navecitas” tenga una mejor velocidad de cuadros por segundos, ya que en cada ciclo no se actualizará toda la pantalla sino solo las partes que se necesiten. Hay veces que esta segunda técnica puede ser contraproducente y es cuando hay tantas pero tantas cosas en la pantalla, que directamente conviene dibujarla entera que estar calculando y dibujando porciones.

Quedaría ver otro tipo de grupo, que es OrderedUpdates, este grupo es una modificacion de RenderUpdates por el hecho de que dibuja los sprites que contiene de acuerdo al orden en que fueron siendo agregados y por eso, borrar y agregar sprites es un poco mas lento.

Para mas información visitar la documentación oficial de esta clase.

Powered by ScribeFire.

Make a Comment

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

2 comentarios to “La clase sprite”

RSS Feed for Aprendiendo a Programar en Python con PyGame para hacer Video Juegos Comments RSS Feed

qui ero aprender programar juegos para crear

Felicitaciones por la explicacion, hasta ahora esta parte de los sprites no la tenia muy clara.

Si la intencion es mejorar la velocidad del juego hay otra cosa mas por hacer, existe un modulo de python llamado psyco que es muy facil de encontrar, instalar y usar, y mejora mucho el rendimiento de python en las maquinas intel.

Gracias por el Articulo, esta muy bueno.


Where's The Comment Form?

Liked it here?
Why not try sites on the blogroll...

A %d blogueros les gusta esto: