def __init__(self, marbleExplosion):
""" constructeur
Entrées : marbleExplosion : instance d'une classe MarbleExplosion
"""
self.marbleExplosion = marbleExplosion
explosionType = marbleExplosion.explosionType
if explosionType == EXPLOS_MARBLE_ON_BORDER:
# Récupération de la direction de déplacement de la bille avant qu'elle n'explose.
marbleMoveDir = marbleExplosion.listMarbleExploded[0].moveDir
# Récupération des informations sur l'explosion de la bille.
explosionInfo = DICT_INFO_FROM_EXPLOS_ON_BORDER_DIR[marbleMoveDir]
self.waitLimit, self.offsetPos, listImgInfo = explosionInfo
# Détermination de la position de l'explosion, en fonction de la position de la bille,
# et des infos sur l'explosion.
marblePos = marbleExplosion.listMarbleExploded[0].pos
marblePosScreen = posScreenFromPosArenaMarble(marblePos)
posScreen = marblePosScreen.move(self.offsetPos)
# Création du SimpleSprite représentant l'explosion, qu'il faudra afficher
# dans l'arène le moment venu. (C'est à dire après self.waitLimit cycles d'anim).
self.simpleSprExplosion = SimpleSprite(posScreen, listImgInfo)
else:
print "autres types d'explosion pas encore fait"
assert False
def initAnimation(self):
"""
Initialise un début d'animation, qui décrira le passage d'un état de jeu à un autre
(c'est à dire un cycle de jeu).
Cette fonction consulte les infos qu'il y a dans self.arena, et en déduit les mouvements
de bille, les explosions, etc. qu'il faut afficher et animer.
"""
# Réinitialisation d'un tas de trucs
self.listMovMarbleInfo = []
self.listPosTileToRefresh = []
self.listMarbleHidden = []
self.listSimpleSprite = []
self.animationCounter = 0
#On parcourt toutes les marbles de l'arena, on s'intéresse à celles qui sont en mouvement.
for marble in self.arena.listMarble:
if marble.moveDir != NO_MOVE:
# On déduit les informations décrivant le mouvement de la marble
posScreen = posScreenFromPosArenaMarble(marble.pos)
movMarbleInfo = (marble,
posScreen,
DICT_OFFSET_FROM_DIR[marble.moveDir],
DICT_ANIM_PERIOD_FROM_DIR[marble.moveDir])
# Et on ajoute ces infos déduites dans self.listMovMarbleInfo.
self.listMovMarbleInfo.append(movMarbleInfo)
# Au passage, on complète la liste des Components qui devront être réaffichés
# lors de l'animation du mouvement de la marble. (Y'a le component de départ
# de la marble, et le component d'arrivée).
# TRODO : si plusieurs marbles proches, on risque d'ajouter plusieurs fois
# les mêmes positions de Component. C'est crétin. A optimiser.
self.listPosTileToRefresh.append(marble.pos)
self.listPosTileToRefresh.append(marble.posFuture)
# Détermination des marbleExplosionDisplayer, à partir de la liste des marbleExplosion
# actuellement présentes dans l'arène.
self.listMarbleExplosionDisplayer = [
# Les objets marbleExplosionDisplayer ainsi créés contiennent un simpleSprite,
# représentant l'animation de l'explosion. Mais ce simpleSprite n'est pas affiché
# ni animé tout de suite. Il ne le sera pas tant qu'il ne sera pas placé dans la
# liste self.listSimpleSprite. Cette action est faite plus tard
# (voir advanceAnimationCounter)
MarbleExplosionDisplayer(marbleExplosion)
for marbleExplosion in self.arena.listMarbleExplosion ]
def refreshAllScreen(self):
"""
Réactualise tout le contenu de la grande image de l'arène.
Attention ! Cette fonction ne doit pas être appelée pendant qu'on est en train
de dérouler des cycles d'animation. Car ça n'afficherait pas tout comme il faut.
On ne doit l'appeler que pendant la résolution d'un cycle de jeu.
La fonction réaffiche tous les Components, et toutes les marbles.
"""
# On parcourt tous les Component de l'arène
# TRODO : need a crawler, pour parcourir plus classieusement ?
for y in xrange(self.arena.height):
for x in xrange(self.arena.width):
posArena = pyRect(x, y)
posScreen = posScreenFromPosArenaTile(posArena)
component = self.arena.getComponent(posArena)
# Détermination de l'image correspondant au Component en cours à afficher.
# not TRODO : on pourrait garder ces images en mémoire, quelque part. Pour
# ne pas avoir à redéterminer l'image à chaque fois. On va pas le faire, car ça
# ralentit pas trop (on est en mode texte !). De plus, certaines images de
# Components pourront changer au cours du jeu. (ex : switch, reset, ...)
img = self.componentDisplayer.imgFromComponent(component)
# Blit de l'image du Component sur l'image principale de l'arène.
self.blitImg(posScreen, img)
# On parcourt toutes les marbles de l'arène, et on les affiche.
# On tient pas compte des marble hidden, ni des marble en mouvement. Il est pas
# censé y avoir ce genre de trucs lorsqu'on n'est pas en train de dérouler une anim.
for marble in self.arena.listMarble:
posScreen = posScreenFromPosArenaMarble(marble.pos)
self.blitImg(posScreen, IMG_MARBLE)
# On parcourt tous les SimpleSprite, et on les affiche.
# En fait ça sert à rien mais pour l'instant. Car pas de SimpleSprite si pas pendant
# une anim. Mais peut-être pour plus tard.
for simpleSprite in self.listSimpleSprite:
self.blitImg(simpleSprite.posScreen, simpleSprite.getCurrentImg())
