class Dino:
def __init__(self, couleur, position, deplacement):
self.__sprite = Images().charger_image(f'{CHEMIN_SPRITE}dino-{couleur}.png')
self.__rect = self.__sprite.get_rect()
self.__rect.x, self.__rect.y = position
self.vitesse = 300
self.deplacement = deplacement
self.anim = Animation(18, 0, TAILLE_PERSO[0], TAILLE_PERSO[1], 6, 0.2)
Maj().enregistrer(self)
Affichage().enregistrer(self, 3)
def maj(self, delta):
self.anim.ajouter_temps(delta)
self.__rect = self.__rect.move(self.vitesse * self.deplacement[0] * delta,
self.vitesse * self.deplacement[1] * delta)
def affichage(self, ecran):
sous_sprite, sous_sprite_rect = self.anim.recuperer_sous_sprite(self.__sprite, self.__rect.x, self.__rect.y)
ecran.blit(pygame.transform.flip(sous_sprite, self.deplacement[0] < 0, False), sous_sprite_rect)
def get_pos(self):
return self.__rect.x, self.__rect.y
def fin(self):
Affichage().supprimer(self)
Maj().supprimer(self)
class Bloc:
DESSINS = {}
def __init__(self, nom_json, x, y, taille):
fichier_json = open(f'res/blocs/{nom_json}.json')
self.__donnees = json.load(fichier_json)
self.__sprite = Images().charger_image('res/img/Tileset.png')
self._x = x
self._y = y
self.__z = self.__donnees['z'] if 'z' in self.__donnees.keys() else 0
self.__taille = taille
self._dessin = None
self.__animation = None
if all(cle in self.__donnees for cle in ['animation', 'temps-animation']):
self.__animation = Animation(self.__donnees['x'], self.__donnees['y'], self.__donnees['largeur'],
self.__donnees['hauteur'], self.__donnees['animation'],
self.__donnees['temps-animation'])
direction = self.__donnees['direction']
if direction == 'x':
self.__direction = [1, 0]
self.__largeur = self.__donnees['largeur'] * taille
self.__hauteur = self.__donnees['hauteur']
else:
self.__direction = [0, 1]
self.__largeur = self.__donnees['largeur']
self.__hauteur = self.__donnees['hauteur'] * taille
Maj().enregistrer(self)
else:
fin_debut = 0
fin_milieu = 0
taille_milieu = 0
if self.__donnees['direction'] == 'x':
largeur = 0
for debut in self.__donnees['debut']:
largeur += debut['largeur']
fin_debut = largeur
for milieu in self.__donnees['milieu']:
taille_milieu += milieu['largeur']
largeur += taille_milieu * self.__taille
fin_milieu = largeur
for fin in self.__donnees['fin']:
largeur += fin['largeur']
hauteur = self.__donnees['debut'][0]['hauteur']
elif self.__donnees['direction'] == 'y':
largeur = self.__donnees['debut'][0]['largeur']
hauteur = 0
for debut in self.__donnees['debut']:
hauteur += debut['hauteur']
fin_debut = largeur
for milieu in self.__donnees['milieu']:
taille_milieu += milieu['hauteur']
hauteur += taille_milieu * self.__taille
fin_milieu = largeur
for fin in self.__donnees['fin']:
hauteur += fin['hauteur']
else:
largeur = self.__donnees['debut'][0]['largeur']
hauteur = self.__donnees['debut'][0]['hauteur']
self.__taille = taille
nom_cache = f'{nom_json}|{taille}'
if nom_cache not in Bloc.DESSINS:
self.__init_dessin(largeur, hauteur, fin_debut, fin_milieu, taille_milieu)
Bloc.DESSINS[nom_cache] = self._dessin
else:
self._dessin = Bloc.DESSINS[nom_cache]
self.__largeur = self._dessin.get_width()
Affichage().enregistrer(self, self.__z)
def dessiner_partie(self, direction, decalage, partie):
for element in partie:
sprite = self.__sprite.subsurface(
pygame.Rect(element['x'], element['y'], element['largeur'], element['hauteur']))
x_element = element['dx'] + direction[0] * decalage
y_element = element['dy'] + direction[1] * decalage
self._dessin.blit(sprite, (x_element, y_element))
def __init_dessin(self, largeur, hauteur, fin_debut, fin_milieu, taille_milieu):
self._dessin = pygame.Surface((largeur, hauteur)).convert_alpha()
self._dessin.fill((0, 0, 0, 0))
direction = [0, 0]
if self.__donnees['direction'] == 'x':
direction[0] = 1
elif self.__donnees['direction'] == 'y':
direction[1] = 1
self.dessiner_partie(direction, 0, self.__donnees['debut'])
for i in range(0, self.__taille):
self.dessiner_partie(direction, fin_debut + taille_milieu * i, self.__donnees['milieu'])
self.dessiner_partie(direction, fin_milieu, self.__donnees['fin'])
def maj(self, delta):
self.__animation.ajouter_temps(delta)
def affichage(self, ecran):
if self.__animation:
for i in range(self.__taille):
x = self._x + (self.__donnees['largeur'] * i) * self.__direction[0]
y = self._y + (self.__donnees['hauteur'] * i) * self.__direction[1]
sous_sprite, sous_sprite_rect = self.__animation.recuperer_sous_sprite(self.__sprite, x, y)
ecran.blit(sous_sprite, sous_sprite_rect)
else:
ecran.blit(self._dessin, (self._x, self._y))
def set_x(self, x):
self._x = x
def set_y(self, y):
self._y = y
def get_largeur(self):
return self.__largeur
def get_rect(self):
if self._dessin:
return self._dessin.get_rect()
else:
return pygame.rect.Rect(self._x, self._y, self.__largeur, self.__hauteur)
def collisions(self, joueur, delta):
return None
class Tornade:
TAILLE_IMAGE = [64, 64]
CHEMIN_SPRITE = 'res/img/competences/'
RECTANGLE_COLLISION = pygame.Rect(9, 0, 45, 60)
def __init__(self, positions, deplacement, couleur_joueur, vitesse=400, duree=3):
self.__couleur_joueur = couleur_joueur
self.__sprite = Images().charger_image(self.CHEMIN_SPRITE + 'Tornade.png')
self.__rect = self.__sprite.get_rect()
self.__rect.x, self.__rect.y = positions
self.__deplacement = deplacement
self.__vitesse = vitesse
self.__animation = Animation(0, 0, Tornade.TAILLE_IMAGE[0], Tornade.TAILLE_IMAGE[1], 4, duree / 12)
self.__temps_restant = duree
Sons().jouer_son('Tornade', 'wav', math.ceil(duree/3) - 1, duree) # Avec 3 la duree du sons
Affichage().enregistrer(self, 1)
Maj().enregistrer(self)
def maj(self, delta):
self.gerer_collisions()
if self.__temps_restant > 0:
self.__animation.ajouter_temps(delta)
self.__rect = self.__rect.move(self.__vitesse * self.__deplacement[0] * delta,
self.__vitesse * self.__deplacement[1] * delta)
self.__temps_restant -= delta
else:
Maj().supprimer(self)
def affichage(self, ecran):
if self.__temps_restant > 0:
sous_sprite = self.__sprite.subsurface(self.__animation.recuperer_image())
sous_sprite_rect = sous_sprite.get_rect()
sous_sprite_rect.x, sous_sprite_rect.y = self.__rect.x, self.__rect.y
ecran.blit(pygame.transform.flip(sous_sprite, self.__deplacement[0] < 0, False), sous_sprite_rect)
else:
Affichage().supprimer(self)
def set_deplacement(self, deplacement):
self.__deplacement = deplacement
def get_rect(self):
return self.__rect
def get_couleur_joueur(self):
return self.__couleur_joueur
def get_rect_collision(self):
rect = self.__rect.copy()
rect.x += self.RECTANGLE_COLLISION.x
rect.y += self.RECTANGLE_COLLISION.y
rect.width = self.RECTANGLE_COLLISION.width
rect.height = self.RECTANGLE_COLLISION.height
return rect
def gerer_collisions(self):
joueurs = Jeu.Jeu().get_joueurs()
if joueurs:
for joueur in joueurs:
if joueur.get_rect_collision().colliderect(self.get_rect_collision()) and self.get_couleur_joueur() != joueur.get_couleur():
joueur.subit_tornade()