def __init__(self):
# charger font
self.font = pygame.font.Font(None, 40)
# charger images
self.images = {
"stars": load_image("stars.png"),
"earth": load_image("earth.png")
}
def __init__(self,x0,y0, angle0):
Projectile.__init__(self,x0,y0,angle0)
self.vit=10
self.cpt=1000
self.im1 = load_image('reddragon1.png')[0].convert()
self.im2 = load_image('reddragon2.png')[0].convert()
self.im3 = load_image('reddragon3.png')[0].convert()
self.im4 = load_image('reddragon4.png')[0].convert()
self.image=self.im1
self.image.set_colorkey((255,255,255))
def __init__(self, image_path, position, max_life, atk, max_speed) :
pg.sprite.Sprite.__init__(self)
if image_path == None:
self.image = None
else:
try:
print(load_image)
self.image_all = load_image(image_path, -1)[0] #sprite sheet
except:
print("Impossible de charger l'image du personnage")
rect_tab = [[pg.Rect(32*i, 48*j, 32, 48) for j in range(4)] for i in range(4)]
self.images = [[self.image_all.subsurface(rect_tab[i][j]) for i in range(4)] for j in range(4)]
self.image = self.images[0][0]
self.position = position
self.rect = pg.rect.Rect(position[0], position[1], 32, 48)
self.speed = max_speed
self.life = max_life
self.atk = atk #attaque de l'entité
self.state = 0 #Défini l'état de l'entité (0 : immobile, 1: mouvement, 2: attaque, 3: touché)
self.aim = 0 #"angle" de visé de l'entité
self.cpt = 1000
self.i_image = 0
self.j_image = 0
def __init__(self,x0,y0,height = 48, width = 64, lifeMax = 1000, period = 120):
Building.__init__(self,x0,y0,height,width,lifeMax = 1000)
self.image = load_image('Cochon.png')
self.image.set_colorkey((255,255,255))
self.period = period
self.gene_time = period
self.gene_pos = (x0 + 20, y0 + 65)
def __init__(self, x0, y0, angle0):
Projectile.__init__(self, x0, y0, angle0)
self.vit = 6
self.cpt = 1000
self.nb_sprites = 4 # temp
self.spritesheet = load_image("baseballs_demo.png", colorkey=-1)
clip_rect_tab = [pygame.Rect(6 * i, 0, 6, 6) for i in range(self.nb_sprites)]
self.sprites = [self.spritesheet.subsurface(clip_rect) for clip_rect in clip_rect_tab]
self.image = self.sprites[0]
self.sprite_index = 0 # désigne le numéro du sprite en cours
def __init__(self, spritesheet_name, sprite_width, sprite_height, animation_info_hash, init_animation_name):
"""
Initialise un sprite animé depuis le spritesheet 'spritesheet_name' avec des sprites de dimension (sprite_width, sprite_height)
Le sprite animé est composé de différentes 'animations' basées sur le spritesheet suivant le paramètre 'animation_info_hash'.
'animation_info_hash' est un hash dont chaque entrée correspond aux infos d'une animation. Chaque entrée est décrite comme suit :
- une clé donnant le nom de l'animation (marche haut, immobile droite...)
- une valeur sous forme de hash donnant :
- 'start' : le numéro du sprite de départ (les sprites sont comptés de gauche à droite et de haut en bas sur la spritesheet et sont de dimension connue)
- 'end' : le numéro du sprites final (les sprites sont supposés consécutifs sur la spritesheet)
- 'duration' : la durée de chaque sprite (pour l'instant, la durée est la même pour tous les sprites)
(ou simplement un tuple)
Puis on en déduit 'animation_hash' qui contient véritablement les animations, sous le format suivant :
- en clé, le nom de l'animation
- en valeur, un tuple (liste des sprites de l'animation, durée de chaque sprite)
On pourrait aussi se contenter de garder 'animation_info_hash' en attribut et retrouver les sprites voulus dans la spritesheet
à partir de ces données à chaque fois qu'un update est nécessaire (on s'arrêterait après la définition de sprite_list)
"""
sprite.Sprite.__init__(self)
# pour l'instant, si le chargement échoue, on exit...
# pas très correct, mieux vaut faire un raise dans load_image()
# et le récupérer dans une clause try ici
self.spritesheet = load_image(spritesheet_name, colorkey=-1)
nb_sprites_i = self.spritesheet.get_width() / sprite_width
nb_sprites_j = self.spritesheet.get_height() / sprite_height
# on travaille avec un tableau 2D de sprites : une ligne par état
clip_rect_list = [
Rect(sprite_width * i, sprite_height * j, sprite_width, sprite_height)
for j in range(nb_sprites_j)
for i in range(nb_sprites_i)
]
sprite_list = [self.spritesheet.subsurface(clip_rect) for clip_rect in clip_rect_list]
self.animation_dict = {
animation_name: (
sprite_list[animation_info["start"] : animation_info["end"] + 1],
animation_info["duration"],
)
for animation_name, animation_info in animation_info_hash.iteritems()
}
self.change_animation(init_animation_name) # animation en cours (marche haut, attaque droite...)
self.sprite_index = 0 # numéro du sprite en cours dans cette animation
self.image = self.animation[0][
self.sprite_index
] # le premier élement du couple self.animation est la liste de sprites en jeu
self.time = self.animation[1] # on lance le décompte avec la durée, le deuxième élément du couple
def __init__(self,x0,y0,height = 48, width = 32, lifeMax = 100):
Building.__init__(self,x0,y0,height,width,lifeMax = 1000)
self.image = load_image('pitching_machine_demo.png')
self.image.set_colorkey((255,255,255))
def __init__(self,x0,y0,height = 48, width = 64, lifeMax = 1000):
Building.__init__(self,x0,y0,height,width,lifeMax = 1000)
self.image = load_image('Cochon.png').convert()
self.image.set_colorkey((255,255,255))