Esta obra de Oriol Boix está licenciada bajo una licencia no importada Creative Commons Reconocimiento-NoComercial-SinObraDerivada 3.0.
Hem vist com crear un programa amb un únic sprite, però en aquest teníem al bucle principal les instruccions que en controlaven el moviment i el canvi d'aspecte. Si, amb el mateix mètode, volguéssim tenir dos sprites caldria repetir els conjunts d'instruccions; però, imaginem que volem tenir vint sprites. Està clar que aquesta metodologia no és pràctica si n'hi ha més d'un o dos.
La forma més eficient serà crear un objecte per als nostres sprites i fer-ne tantes instàncies com siguin necessàries. En aquest objecte definirem els mètodes que permeten fer les funcions necessàries sobre l'sprite, en el nostre cas la inicialització i el comportament (moviment i canvi d'aspecte). Així, les accions del programa principal seran només crides a aquests mètodes.
També farem servir vectors; que ens permetran treballar sobre diversos sprites emprant bucles, en lloc de repetir les instruccions.
Comencem, doncs, per la definició de l'objecte i els seus mètodes:
class Bloc(stage.Sprite):
def __init__(self, x, y):
super().__init__(banc, 1, x, y)
self.incx = 2
self.incy = 2
def update(self):
super().update()
self.set_frame(self.frame % 4 + 1)
self.move(self.x + self.incx, self.y + self.incy)
if not 0 < self.x < 144: # 160 - 16 = 144
self.incx = -self.incx
if not 0 < self.y < 112: # 128 - 16 = 112
self.incy = -self.incy
Els objectes ja tenen, per definició, un mètode d'inicialització i un altre d'actualització; per aquest motiu hem creat els nostres dos mètodes amb els mateixos noms, __init__ i update. A cada un d'ells, però, cridem als mètodes originals per assegurar-nos que les tasques es fan correctament i no se'ns passa res per alt; un cop executat el mètode original, hi afegim les accions que ens interessen. Les següents línies marcades en color són les que criden als mètodes originals:
def __init__(self, x, y):
super().__init__(banc, 1, x, y)
...
def update(self):
super().update()
...
A banda del comentat, en la inicialització només definim quin és l'increment de cada una de les dues coordenades.
def __init__(self, x, y):
super().__init__(banc, 1, x, y)
self.incx = 2
self.incy = 2
En el mètode d'actualització hi posem aquelles accions sobre l'sprite que en el programa amb un únic sprite fèiem al bucle principal.
def update(self):
super().update()
self.set_frame(self.frame % 4 + 1)
self.move(self.x + self.incx, self.y + self.incy)
if not 0 < self.x < 144: # 160 - 16 = 144
self.incx = -self.incx
if not 0 < self.y < 112: # 128 - 16 = 112
self.incy = -self.incy
Un cop definit l'objecte, anem a veure com serà el programa complet. Després comentarem la resta de línies.
import ugame import stage
class Bloc(stage.Sprite):
def __init__(self, x, y):
super().__init__(banc, 1, x, y)
self.incx = 2
self.incy = 2
def update(self):
super().update()
self.set_frame(self.frame % 4 + 1)
self.move(self.x + self.incx, self.y + self.incy)
if not 0 < self.x < 144: # 160 - 16 = 144
self.incx = -self.incx
if not 0 < self.y < 112: # 128 - 16 = 112
self.incy = -self.incy
banc = stage.Bank.from_bmp16("bloc.bmp")
fons = stage.Grid(banc, 10, 8)
bloc1 = Bloc(32, 40)
bloc2 = Bloc(64, 0)
bloc3 = Bloc(96, 80)
joc = stage.Stage(ugame.display, 12)
blocs = [bloc1, bloc2, bloc3]
joc.layers = [bloc1, bloc2, bloc3, fons]
joc.render_block()
while True:
for element in blocs:
element.update()
joc.render_sprites(blocs)
joc.tick()
La majoria de les línies ja les coneixem. Potser en cal comentar unes poques.
Definim tres blocs o elements i els inicialitzem, cada un, en una posició diferent de la pantalla.
bloc1 = Bloc(32, 40) bloc2 = Bloc(64, 0) bloc3 = Bloc(96, 80)
També creem un vector amb tots els blocs creats.
blocs = [bloc1, bloc2, bloc3]
I, a cada passada pel bucle principal, fem un bucle que recorri el vector i actualitzi tots els elements.
for element in blocs:
element.update()
Esta obra de Oriol Boix está licenciada bajo una licencia no importada Creative Commons Reconocimiento-NoComercial-SinObraDerivada 3.0.