class Intro:
def __init__(self):
self.montrer = True
self.__couleur = (180, 180, 180)
self.__timeur = 0
self.__temps = 0
self.__compteur = 0
self.__image = Images().charger_image(
"res/img/interfaces/intro/carryboo.png").convert_alpha()
self.__image.fill((255, 255, 255, 15), None, pygame.BLEND_RGBA_MULT)
Affichage().enregistrer(self)
Maj().enregistrer(self)
def affichage(self, ecran):
if self.montrer:
ecran.fill(self.__couleur)
for i in range(min(30, self.__compteur)):
ecran.blit(self.__image,
(LARGEUR / 2 - 126, HAUTEUR / 2 - 230))
if self.__timeur == 20:
Sons().jouer_son('intro', 'ogg')
if self.__timeur == 550:
self.montrer = False
self.__timeur = 0
MenuPrincipal()
def maj(self, delta):
if self.montrer:
self.__temps += delta
if self.__temps >= 1 / (17 * 2):
self.__temps -= 1 / (17 * 2)
self.__compteur += 1
self.__timeur += 10
def __init__(self):
self.__fleche = Images().charger_image('res/img/fleche.png')
self.__visible = True
self.__temps = 0
self.__delai = 0.5
Affichage().enregistrer(self, 5)
Maj().enregistrer(self)
def __init__(self, i, coord=(0, 0), selectionne=False):
self.surface = Images().charger_image(
'res/img/hud/coeur-rouge.bmp').convert_alpha()
self.surface_transparent = self.surface.copy()
self.surface_transparent.fill((255, 255, 255, 70), None,
pygame.BLEND_RGBA_MULT)
self.selectionne = selectionne
self.coord = coord
self.index = i + 1
def affichage(self, ecran):
nom = self._image
if self.transparent:
image = Images().charger_image(
f'res/img/interfaces/selection/{nom}-desactive.png')
else:
image = Images().charger_image(
f'res/img/interfaces/selection/{nom}.png')
ecran.blit(image, self._coord)
def __init__(self, nom, coord=(0, 0), selectionne=False):
self.surface = Images().charger_image(
f'res/img/interfaces/selection/choix-dino-{nom}.png'
).convert_alpha()
self.surface_transparent = self.surface.copy()
self.surface_transparent.fill((255, 255, 255, 70), None,
pygame.BLEND_RGBA_MULT)
self.selectionne = selectionne
self.coord = coord
self.nom = nom
def __init__(self):
self.montrer = True
self.__couleur = (180, 180, 180)
self.__timeur = 0
self.__temps = 0
self.__compteur = 0
self.__image = Images().charger_image(
"res/img/interfaces/intro/carryboo.png").convert_alpha()
self.__image.fill((255, 255, 255, 15), None, pygame.BLEND_RGBA_MULT)
Affichage().enregistrer(self)
Maj().enregistrer(self)
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 __init__(self, pv, couleur):
self.__max_pv = pv
self.__pv = pv
self.__coeur = Images().charger_image(
f'res/img/hud/coeur-{couleur}.bmp')
self.__coeur_vide = Images().charger_image(
'res/img/hud/coeur_perdu.bmp')
self.__init__position()
HudVie.__compte += 1
Affichage().enregistrer(self, COUCHE_HUD)
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 __init__(self, couleur, y_fin):
self.__texte = Images().charger_image(
f'res/img/interfaces/fin/victoire-{couleur}.png').convert_alpha()
self.__rect_texte = self.__texte.get_rect()
self.__rect_texte.x = LARGEUR / 2 - self.__rect_texte.width / 2
self.__rect_texte.y = -self.__rect_texte.height * 2
self.__vitesse = 500
self.__y_fin = y_fin
self.debut = False
self.fin = False
Affichage().enregistrer(self, 4)
Maj().enregistrer(self)
def __init__(self):
self.montrer = True
self.credits = Credits(self)
self.choix_personnages = ChoixPersonnages(self)
self.reglement = Reglement(self)
self.__background = Images().charger_image("res/img/interfaces/accueil/accueil-background.png")
self.__titre = Images().charger_image("res/img/interfaces/accueil/titre.png")
self.__bouton_jouer = BoutonJouer((350, 400), "bouton-jouer", self)
self.__bouton_reglement = BoutonReglement((350, 500), "bouton-regles", self)
self.__bouton_quitter = BoutonQuitter((350, 600), "bouton-quitter", self)
self.__bouton_credits = BoutonCredits((910, 730), "bouton-credits", self)
self.__konami = []
Affichage().enregistrer(self)
Evenement().enregistrer(pygame.KEYDOWN, self)
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)
def __init__(self, menu):
self.montrer = False
self.__menu = menu
self.__background = Images().charger_image(
"res/img/interfaces/accueil/accueil-background.png")
Affichage().enregistrer(self)
Evenement().enregistrer(pygame.KEYUP, self)
class __Coeur:
def __init__(self, i, coord=(0, 0), selectionne=False):
self.surface = Images().charger_image(
'res/img/hud/coeur-rouge.bmp').convert_alpha()
self.surface_transparent = self.surface.copy()
self.surface_transparent.fill((255, 255, 255, 70), None,
pygame.BLEND_RGBA_MULT)
self.selectionne = selectionne
self.coord = coord
self.index = i + 1
def collision(self, point):
rect = self.surface.get_rect()
rect.x, rect.y = self.coord
return rect.collidepoint(point)
class FinJeu:
def __init__(self, couleur, y_fin):
self.__texte = Images().charger_image(
f'res/img/interfaces/fin/victoire-{couleur}.png').convert_alpha()
self.__rect_texte = self.__texte.get_rect()
self.__rect_texte.x = LARGEUR / 2 - self.__rect_texte.width / 2
self.__rect_texte.y = -self.__rect_texte.height * 2
self.__vitesse = 500
self.__y_fin = y_fin
self.debut = False
self.fin = False
Affichage().enregistrer(self, 4)
Maj().enregistrer(self)
def affichage(self, ecran):
ecran.blit(self.__texte, self.__rect_texte)
def maj(self, delta):
if self.debut:
if self.__rect_texte.y + self.__rect_texte.height < self.__y_fin:
self.__vitesse += 800 * delta
self.__rect_texte = self.__rect_texte.move(
0, delta * self.__vitesse)
else:
self.fin = True
Maj().supprimer(self)
class HudVie:
MARGE_EXTERIEURE = 10
MARGE_INTERIEURE = 2
__compte = 0
def __init__(self, pv, couleur):
self.__max_pv = pv
self.__pv = pv
self.__coeur = Images().charger_image(
f'res/img/hud/coeur-{couleur}.bmp')
self.__coeur_vide = Images().charger_image(
'res/img/hud/coeur_perdu.bmp')
self.__init__position()
HudVie.__compte += 1
Affichage().enregistrer(self, COUCHE_HUD)
def __init__position(self):
self.__x = self.MARGE_EXTERIEURE if self.__compte % 2 == 0 \
else LARGEUR - self.MARGE_EXTERIEURE - self.__max_pv * (self.MARGE_INTERIEURE + self.__coeur.get_width())
self.__y = self.MARGE_EXTERIEURE if self.__compte < 2 else \
HAUTEUR - self.MARGE_EXTERIEURE - self.__coeur.get_height()
def retirer_pv(self):
self.__pv -= 1
def gagner_pv(self):
self.__pv = min((self.__pv + 1, self.__max_pv))
def affichage(self, ecran):
for i in range(1, self.__max_pv + 1):
x = self.__x + (self.__coeur.get_width() +
self.MARGE_INTERIEURE) * (i - 1)
if self.__pv >= i:
ecran.blit_absolu(self.__coeur, (x, self.__y))
else:
ecran.blit_absolu(self.__coeur_vide, (x, self.__y))
def fin(self):
Affichage().supprimer(self)
HudVie.__compte -= 1
def __init__(self, touches, couleur, nb_coeurs):
# Private
Joueur.__count += 1
self.__attente_releve = False
self.__vies = nb_coeurs
self.__sprite = Images().charger_image(
f'{CHEMIN_SPRITE}dino-{couleur}.png')
self.__hud = HudVie(self.__vies, couleur)
self.__rect = self.__sprite.get_rect()
self.__rect.y = HAUTEUR - TAILLE_PERSO[1]
self.__vitesse = 300
self.__deplacement = [0, 0]
self.__boost = 0
self.__velocite_saut, self.vitesse_chute = 2, 4
self.__nb_saut_restant = 1
self._subit_tornade = -1
self.__accroupi = False
self.__anim_attente = Animation(0, 0, TAILLE_PERSO[0], TAILLE_PERSO[1],
4, 0.2)
self.__anim_deplacement = Animation(4, 0, TAILLE_PERSO[0],
TAILLE_PERSO[1], 6, 0.13)
self.__anim_attaque = Animation(10, 0, TAILLE_PERSO[0],
TAILLE_PERSO[1], 3, 0.2)
self.__anim_degat = Animation(13, 0, TAILLE_PERSO[0], TAILLE_PERSO[1],
4, 0.2, False, 0.5)
self.__anim_accroupi = Animation(18, 0, TAILLE_PERSO[0],
TAILLE_PERSO[1], 6, 0.2)
self.__anim_active = self.__anim_attente
# Protected
self._touches = touches
self._couleur = couleur
evenement = Evenement()
evenement.enregistrer(pygame.KEYDOWN, self)
evenement.enregistrer(pygame.KEYUP, self)
Affichage().enregistrer(self, 1)
Maj().enregistrer(self)
class HudFlecheDirection:
def __init__(self):
self.__fleche = Images().charger_image('res/img/fleche.png')
self.__visible = True
self.__temps = 0
self.__delai = 0.5
Affichage().enregistrer(self, 5)
Maj().enregistrer(self)
def maj(self, delta):
self.__temps += delta
if self.__temps >= self.__delai:
self.__temps -= self.__delai
self.__visible = not self.__visible
def affichage(self, ecran):
if self.__visible:
ecran.blit(self.__fleche,
(10, HAUTEUR / 2 - self.__fleche.get_rect().height / 2))
def fin(self):
Affichage().supprimer(self)
Maj().supprimer(self)
def __init__(self, menu):
self.montrer = False
self.__menu = menu
self.__bouton_commencer = BoutonCommencer((750, 380),
"bouton-commencer", self)
self.__selection_joueur_1 = ""
self.__selection_joueur_2 = ""
self.__dino_rouge = self.__Dino("rouge", (0, 70))
self.__dino_bleu = self.__Dino("bleu", (250, 70))
self.__dino_vert = self.__Dino("vert", (500, 70))
self.__dino_jaune = self.__Dino("jaune", (750, 70))
self.__dinos = {
"rouge": self.__dino_rouge,
"bleu": self.__dino_bleu,
"vert": self.__dino_vert,
"jaune": self.__dino_jaune
}
font = pygame.font.Font('res/fonts/Comfortaa-Bold.ttf', 30)
self.__difficulte = font.render('Niveau de difficulté : ', True,
(255, 255, 255))
self.__coeurs = []
for i in range(3):
self.__coeurs.append(
self.__Coeur(i, (LARGEUR / 2 - 50 + i * 40, HAUTEUR / 2 - 30),
True))
for i in range(3, 5):
self.__coeurs.append(
self.__Coeur(i, (LARGEUR / 2 - 50 + i * 40, HAUTEUR / 2 - 30)))
self.__background = Images().charger_image(
"res/img/interfaces/accueil/accueil-background.png")
Affichage().enregistrer(self)
Evenement().enregistrer(pygame.MOUSEBUTTONUP, self)
Evenement().enregistrer(pygame.KEYUP, self)
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 set_sprite(self, nom_fichier):
self.__sprite = Images().charger_image(CHEMIN_SPRITE + nom_fichier)
class Joueur:
NB_SAUT_MAX = 1
RECTANGLE_COLLISION = pygame.Rect(16, 16, 62, 70)
RECTANGLE_COLLISION_ACCROUPI = pygame.Rect(24, 25, 54, 61)
TEMPS_SUBIT_TORNADE = 2 # En seconde
__count = 0
def __init__(self, touches, couleur, nb_coeurs):
# Private
Joueur.__count += 1
self.__attente_releve = False
self.__vies = nb_coeurs
self.__sprite = Images().charger_image(
f'{CHEMIN_SPRITE}dino-{couleur}.png')
self.__hud = HudVie(self.__vies, couleur)
self.__rect = self.__sprite.get_rect()
self.__rect.y = HAUTEUR - TAILLE_PERSO[1]
self.__vitesse = 300
self.__deplacement = [0, 0]
self.__boost = 0
self.__velocite_saut, self.vitesse_chute = 2, 4
self.__nb_saut_restant = 1
self._subit_tornade = -1
self.__accroupi = False
self.__anim_attente = Animation(0, 0, TAILLE_PERSO[0], TAILLE_PERSO[1],
4, 0.2)
self.__anim_deplacement = Animation(4, 0, TAILLE_PERSO[0],
TAILLE_PERSO[1], 6, 0.13)
self.__anim_attaque = Animation(10, 0, TAILLE_PERSO[0],
TAILLE_PERSO[1], 3, 0.2)
self.__anim_degat = Animation(13, 0, TAILLE_PERSO[0], TAILLE_PERSO[1],
4, 0.2, False, 0.5)
self.__anim_accroupi = Animation(18, 0, TAILLE_PERSO[0],
TAILLE_PERSO[1], 6, 0.2)
self.__anim_active = self.__anim_attente
# Protected
self._touches = touches
self._couleur = couleur
evenement = Evenement()
evenement.enregistrer(pygame.KEYDOWN, self)
evenement.enregistrer(pygame.KEYUP, self)
Affichage().enregistrer(self, 1)
Maj().enregistrer(self)
def evenement(self, evenement):
if self.__vies <= 0:
return
if evenement.type == pygame.KEYDOWN:
if evenement.key == self._touches.get('aller_gauche'):
self.__deplacement[0] -= 1
elif evenement.key == self._touches.get('aller_droite'):
self.__deplacement[0] += 1
elif evenement.key == self._touches.get(
'sauter') and self.__nb_saut_restant > 0:
self.__deplacement[1] -= self.__velocite_saut
self.__nb_saut_restant -= 1
Sons().jouer_son('saut')
elif evenement.key == self._touches.get('accroupir'):
self.accroupir()
else: # KEYUP
if evenement.key == self._touches.get('aller_gauche'):
self.__deplacement[0] += 1
elif evenement.key == self._touches.get('aller_droite'):
self.__deplacement[0] -= 1
elif evenement.key == self._touches.get('accroupir'):
self.relever()
if self._subit_tornade <= 0:
self.__maj_animation()
def __maj_animation(self):
if not self.__accroupi:
if self.__deplacement[0] != 0:
self.__anim_active = self.__anim_deplacement
else:
self.__anim_active = self.__anim_attente
def __reset_boost(self):
self.__deplacement[0] -= self.__boost
self.__boost = 0
def __correction_direction(self):
precision = 10
self.__deplacement[0] = round(
self.__deplacement[0] * 10**precision) / 10**precision
self.__deplacement[1] = round(
self.__deplacement[1] * 10**precision) / 10**precision
def __gestion_releve(self):
self.__accroupi = False
if Jeu.Jeu().collisions(self, 0):
self.__accroupi = True
else:
self.__anim_active = self.__anim_attente
self.__vitesse += 100
self.__attente_releve = False
def maj(self, delta):
jeu = Jeu.Jeu()
if self.__vies <= 0:
return
elif Joueur.__count == 1:
jeu.fin(self._couleur)
return
if self.__attente_releve:
self.__gestion_releve()
if self._subit_tornade <= 0:
if self.__deplacement[0] or not self.__accroupi:
self.__anim_active.ajouter_temps(delta)
else:
self.__anim_active.reinitialiser(1)
self.__correction_direction()
ancien_boost = self.__boost
# Mouvement X
self.__rect = self.__rect.move(
self.__vitesse * self.__deplacement[0] * delta, 0)
self.__collisions((self.__deplacement[0], 0),
jeu.collisions(self, delta))
if self.__boost == ancien_boost:
self.__reset_boost()
else:
# gere temps de stun
self._subit_tornade -= delta
self.__anim_active.ajouter_temps(delta)
if self.__anim_active.est_finie():
self.__anim_active.reinitialiser()
if self.__accroupi:
self.__anim_active = self.__anim_accroupi
else:
self.__anim_active = self.__anim_attente
# Mouvement Y
self.__rect = self.__rect.move(
0, self.__vitesse * self.__deplacement[1] * delta)
self.__collisions((0, self.__deplacement[1]),
jeu.collisions(self, delta))
self.__deplacement[1] += self.vitesse_chute * delta
self.__maj_camera(delta)
def __collisions(self, deplacement, collisions):
if collisions:
rect = self.get_rect_collision()
if deplacement[0] > 0:
rect.right = collisions.left
self.__reset_boost()
elif deplacement[0] < 0:
rect.left = collisions.right
self.__reset_boost()
if deplacement[1] < 0:
rect.top = collisions.bottom
self.__deplacement[1] = 0
elif deplacement[1] > 0:
rect.bottom = collisions.top
self.__deplacement[1] = 0
self.ajout_saut(1)
self.set_rect_collision(rect)
def __maj_camera(self, delta):
rect = self.get_rect()
droite = rect.x + self.RECTANGLE_COLLISION.right
haut = rect.y + self.RECTANGLE_COLLISION.top
if Ecran.get_droite() - droite < DISTANCE_DEPLACEMENT:
Ecran.deplacement(droite - Ecran.largeur + DISTANCE_DEPLACEMENT,
Ecran.y)
Parallax().deplacement_joueur(self.__deplacement[0], delta)
if Ecran.x > droite or Ecran.y + Ecran.hauteur < haut:
self.__retirer_vie()
def __retirer_vie(self):
self.__vies -= 1
self.__hud.retirer_pv()
if Jeu.Jeu.konami_actif():
Sons().jouer_son('k-mort')
else:
Sons().jouer_son('mort')
if self.__vies > 0:
self.__revivre()
else:
Joueur.__count -= 1
def __revivre(self):
self.__rect.x = Ecran.x + Ecran.largeur / 2
self.__rect.y = Ecran.y + Ecran.hauteur / 2
def affichage(self, ecran):
if self.__vies <= 0:
return
sous_sprite, sous_sprite_rect = self.__anim_active.recuperer_sous_sprite(
self.__sprite, self.__rect.x, self.__rect.y)
miroir = (self._subit_tornade < 0 and self.__deplacement[0] < 0) or \
(self._subit_tornade > 0 and self._subit_tornade % 0.2 > 0.1)
ecran.blit(pygame.transform.flip(sous_sprite, miroir, False),
sous_sprite_rect)
def get_couleur(self):
return self._couleur
def get_vitesse(self):
return self.__vitesse
def get_sprite(self):
return self.__sprite
def get_rect(self):
return self.__rect
def get_rect_collision(self):
if self.__accroupi:
rect_collision = self.RECTANGLE_COLLISION_ACCROUPI
else:
rect_collision = self.RECTANGLE_COLLISION
rect = self.__rect.copy()
rect.x += rect_collision.x
rect.y += rect_collision.y
rect.width = rect_collision.width
rect.height = rect_collision.height
return rect
def set_rect_collision(self, rect):
if self.__accroupi:
rect_collision = self.RECTANGLE_COLLISION_ACCROUPI
else:
rect_collision = self.RECTANGLE_COLLISION
self.__rect.x = rect.x - rect_collision.x
self.__rect.y = rect.y - rect_collision.y
def get_deplacement(self):
return self.__deplacement
def get_nb_saut_restant(self):
return self.__nb_saut_restant
def get_nb_saut_max(self):
return self.NB_SAUT_MAX
def set_vitesse(self, vitesse):
self.__vitesse = vitesse
def set_deplacement(self, deplacement):
self.__deplacement = deplacement
def ajouter_boost(self, x, y):
self.__boost += x
self.__deplacement[0] += x
self.__deplacement[1] += y
def set_sprite(self, nom_fichier):
self.__sprite = Images().charger_image(CHEMIN_SPRITE + nom_fichier)
def set_rect(self, rect):
self.__rect = rect
def set_velocite_saut(self, velocite_saut):
self.__velocite_saut = velocite_saut
def set_vitesse_chute(self, vitesse_chute):
self.vitesse_chute = vitesse_chute
def ajout_saut(self, nb=1):
self.__nb_saut_restant = min(
[nb + self.__nb_saut_restant, self.NB_SAUT_MAX])
def fin(self):
self.__hud.fin()
Joueur.__count = 0
Evenement().supprimer(self)
Affichage().supprimer(self)
Maj().supprimer(self)
def subit_tornade(self):
self._subit_tornade = self.TEMPS_SUBIT_TORNADE
self.__anim_active = self.__anim_degat
self.__deplacement[1] = -1
def reprendre(self):
key_pressed = pygame.key.get_pressed()
if key_pressed[self._touches.get('aller_droite')]:
self.__deplacement[0] = 1
elif key_pressed[self._touches.get('aller_gauche')]:
self.__deplacement[0] = -1
else:
self.__deplacement[0] = 0
self.__deplacement[0] += self.__boost
self.__maj_animation()
def accroupir(self):
if not self.__accroupi:
self.__accroupi = True
self.__anim_active = self.__anim_accroupi
self.__vitesse -= 100
def relever(self):
self.__attente_releve = True
def affichage(self, ecran):
if self.montrer:
background = Images().charger_image(
"res/img/interfaces/accueil/accueil-background.png")
ecran.blit(background, (0, 0))
if self.equipe and not self.sources:
# Titre
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 80)
texte = font.render("Equipe", True, self.TITRE)
ecran.blit(texte, (LARGEUR / 2 - texte.get_width() / 2, 30))
# Noms
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 36)
ecran.blit(font.render("Baptiste LEDOYEN", True, self.NOM),
(30, 170))
ecran.blit(font.render("Thomas VINCENT", True, self.NOM),
(30, 350))
ecran.blit(font.render("Thibault GROOT", True, self.NOM),
(670, 350))
ecran.blit(font.render("Théo PONCHON", True, self.NOM),
(670, 170))
texte = font.render("Léo LE CORRE", True, self.NOM)
ecran.blit(texte, (LARGEUR / 2 - texte.get_width() / 2, 530))
# Rôles
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 26)
# Baptiste
ecran.blit(
font.render("Chef de projet", True, self.DESCRIPTION),
(90, 220))
ecran.blit(font.render("Développeur", True, self.DESCRIPTION),
(90, 260))
# Thomas
ecran.blit(
font.render("Responsable technique", True,
self.DESCRIPTION), (30, 400))
ecran.blit(font.render("Développeur", True, self.DESCRIPTION),
(90, 440))
# Thibault
ecran.blit(font.render("Développeur", True, self.DESCRIPTION),
(720, 400))
# Théo
ecran.blit(
font.render("Développeur UI", True, self.DESCRIPTION),
(720, 220))
ecran.blit(font.render("Designer", True, self.DESCRIPTION),
(720, 260))
# Léo
texte = font.render("Game Designer", True, self.DESCRIPTION)
ecran.blit(texte,
(LARGEUR / 2 - texte.get_width() / 2 + 30, 580))
# Bouton Sources
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 30)
ecran.blit(font.render("Sources", True, self.TITRE),
(880, 720))
elif self.sources and not self.equipe:
# Titre
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 80)
texte = font.render("Sources", True, self.TITRE)
ecran.blit(texte, (LARGEUR / 2 - texte.get_width() / 2, 30))
# Bouton Equipe
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 30)
ecran.blit(font.render("Equipe", True, self.TITRE), (10, 720))
# Ressources
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 20)
ecran.blit(font.render("Tileset", True, self.NOM),
(self.NOM_X, 150))
ecran.blit(font.render("Parallax", True, self.NOM),
(self.NOM_X, 180))
ecran.blit(font.render("Dinosaures", True, self.NOM),
(self.NOM_X, 210))
ecran.blit(font.render("Coeur HUD", True, self.NOM),
(self.NOM_X, 240))
ecran.blit(font.render("Tornade", True, self.NOM),
(self.NOM_X, 270))
ecran.blit(font.render("Logo CarryBoo", True, self.NOM),
(self.NOM_X, 300))
ecran.blit(font.render("Flèche démarrage", True, self.NOM),
(self.NOM_X, 330))
ecran.blit(font.render("Musique", True, self.NOM),
(self.NOM_X, 370))
ecran.blit(font.render("Musique alternative", True, self.NOM),
(self.NOM_X, 400))
ecran.blit(font.render("Son de tornade", True, self.NOM),
(self.NOM_X, 450))
ecran.blit(font.render("Son de fin", True, self.NOM),
(self.NOM_X, 480))
ecran.blit(
font.render("Son de fin alternatif", True, self.NOM),
(self.NOM_X, 510))
ecran.blit(font.render("Son de mort", True, self.NOM),
(self.NOM_X, 540))
ecran.blit(
font.render("Son de mort alternatif", True, self.NOM),
(self.NOM_X, 570))
ecran.blit(font.render("Son de saut", True, self.NOM),
(self.NOM_X, 600))
ecran.blit(font.render("Son de vent", True, self.NOM),
(self.NOM_X, 630))
ecran.blit(font.render("Son de bouton", True, self.NOM),
(self.NOM_X, 660))
ecran.blit(font.render("Son logo CarryBoo", True, self.NOM),
(self.NOM_X, 690))
# Liens
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 15)
ecran.blit(
font.render(
"https://bigbuckbunny.itch.io/platform-assets-pack",
True, self.DESCRIPTION), (self.DESC_X, 153))
ecran.blit(
font.render("https://mamanezakon.itch.io/forest-tileset",
True, self.DESCRIPTION), (self.DESC_X, 183))
ecran.blit(
font.render("https://arks.itch.io/dino-characters", True,
self.DESCRIPTION), (self.DESC_X, 213))
ecran.blit(
font.render("https://opengameart.org/content/pixel-hearts",
True, self.DESCRIPTION), (self.DESC_X, 243))
ecran.blit(
font.render(
"https://opengameart.org/content/spells-and-company",
True, self.DESCRIPTION), (self.DESC_X, 273))
ecran.blit(
font.render(
"https://www.vecteezy.com/vector-art/153284-free-caribou-vector-collection",
True, self.DESCRIPTION), (self.DESC_X, 303))
ecran.blit(
font.render(
"https://pixabay.com/fr/vectors/droit-arrow-formes-pointage-29247",
True, self.DESCRIPTION), (self.DESC_X, 333))
ecran.blit(
font.render(
"https://www.fesliyanstudios.com/royalty-free-music/download/retro-platforming/454",
True, self.DESCRIPTION), (self.DESC_X, 373))
ecran.blit(
font.render(
"https://freemusicarchive.org/music/sawsquarenoise/Towel_Defence_OST/",
True, self.DESCRIPTION), (self.DESC_X, 403))
ecran.blit(
font.render("Towel_Defence_Ingame", True,
self.DESCRIPTION), (self.DESC_X, 420))
ecran.blit(
font.render(
"https://lasonotheque.org/detail-0595-vent.html", True,
self.DESCRIPTION), (self.DESC_X, 453))
ecran.blit(
font.render(
"https://opengameart.org/content/crash-collision",
True, self.DESCRIPTION), (self.DESC_X, 483))
ecran.blit(
font.render(
"https://opengameart.org/content/15-monster-gruntpaindeath-sounds",
True, self.DESCRIPTION), (self.DESC_X, 513))
ecran.blit(
font.render(
"http://soundbible.com/1569-I-Will-Kill-You.html",
True, self.DESCRIPTION), (self.DESC_X, 543))
ecran.blit(
font.render(
"http://soundbible.com/1459-Psycho-Scream.html", True,
self.DESCRIPTION), (self.DESC_X, 573))
ecran.blit(
font.render(
"https://opengameart.org/content/platformer-jumping-sounds",
True, self.DESCRIPTION), (self.DESC_X, 603))
ecran.blit(
font.render(
"https://freesound.org/people/qubodup/sounds/60009/",
True, self.DESCRIPTION), (self.DESC_X, 633))
ecran.blit(
font.render(
"https://freesound.org/people/volkbutphan/sounds/485486/",
True, self.DESCRIPTION), (self.DESC_X, 663))
ecran.blit(
font.render(
"https://freesound.org/people/luminousfridge/sounds/496199/",
True, self.DESCRIPTION), (self.DESC_X, 693))
# Instruction ESC
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 20)
texte = font.render("ESC pour retourner au menu principal", True,
self.DESCRIPTION)
ecran.blit(texte, (LARGEUR / 2 - texte.get_width() / 2, 740))
def affichage(self, ecran):
if self.montrer:
ecran.blit(self.__background, (0, 0))
# Titre
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 60)
texte = font.render("Règles", True, self.TITRE)
ecran.blit(texte,
(Constantes.LARGEUR / 2 - texte.get_width() / 2, 20))
# Objectif
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 36)
ecran.blit(font.render("Objectif", True, self.SOUS_TITRE),
(50, 110))
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 20)
ecran.blit(
font.render("Soyez le dernier en vie en utilisant les", True,
self.DESCRIPTION), (50, 160))
ecran.blit(
font.render("courants ascendants et descendants", True,
(95, 39, 205)), (455, 160))
ecran.blit(font.render("pour changer", True, self.DESCRIPTION),
(860, 160))
ecran.blit(
font.render("d'étages. Vous disposez également d'une", True,
self.DESCRIPTION), (50, 187))
ecran.blit(font.render("compétence", True, (255, 165, 2)),
(490, 187))
ecran.blit(
font.render("pour rééquilibrer le duel.", True,
self.DESCRIPTION), (625, 187))
ecran.blit(
font.render(
"Evitez les obstacles et courez, la caméra se déplace en fonction du joueur en première",
True, self.DESCRIPTION), (50, 214))
ecran.blit(
font.render(
"position. Si vous sortez de l'écran (à gauche) vous perdez une vie et réapparaissez au",
True, self.DESCRIPTION), (50, 241))
ecran.blit(
font.render("centre de l'écran. Vous possédez jusqu'à", True,
self.DESCRIPTION), (50, 268))
ecran.blit(font.render("5 vies", True, (231, 76, 60)), (485, 268))
ecran.blit(font.render(".", True, self.DESCRIPTION), (550, 268))
# Commandes
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 36)
ecran.blit(font.render("Commandes", True, self.SOUS_TITRE),
(50, 320))
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 26)
ecran.blit(font.render("Joueur 1", True, self.DESCRIPTION),
(350, 370))
ecran.blit(font.render("Joueur 2", True, self.DESCRIPTION),
(750, 370))
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 22)
ecran.blit(font.render("Déplacements", True, self.DESCRIPTION),
(50, 480))
ecran.blit(font.render("Compétence", True, self.DESCRIPTION),
(50, 650))
touche = Images().charger_image(
"res/img/interfaces/regles/touche.png")
font = pygame.font.Font("res/fonts/NotoSansJP-Bold.otf", 45)
# Joueur 1
ecran.blit(touche, (370, 430)) # Haut
ecran.blit(touche, (370, 505)) # Bas
ecran.blit(touche, (290, 505)) # Gauche
ecran.blit(touche, (450, 505)) # Droite
ecran.blit(touche, (370, 630)) # Compétence
ecran.blit(
font.render(self.nom_touche(Constantes.TOUCHES[0]['sauter']),
True, self.TOUCHE), (390, 425)) # Haut
# ecran.blit(font.render(pygame.key.name(Constantes.TOUCHES[0]['']), True, self.TOUCHE), (370, 505)) # Bas
ecran.blit(
font.render(
self.nom_touche(Constantes.TOUCHES[0]['aller_gauche']),
True, self.TOUCHE), (307, 495)) # Gauche
ecran.blit(
font.render(
self.nom_touche(Constantes.TOUCHES[0]['accroupir']), True,
self.TOUCHE), (390, 500)) # Accroupir
ecran.blit(
font.render(
self.nom_touche(Constantes.TOUCHES[0]['aller_droite']),
True, self.TOUCHE), (470, 500)) # Droite
ecran.blit(
font.render(
self.nom_touche(Constantes.TOUCHES[0]['competence']), True,
self.TOUCHE), (377, 630)) # Compétence
# Joueur 2
ecran.blit(touche, (770, 430)) # Haut
ecran.blit(touche, (770, 505)) # Bas
ecran.blit(touche, (690, 505)) # Gauche
ecran.blit(touche, (850, 505)) # Droite
ecran.blit(touche, (770, 630)) # Compétence
ecran.blit(
font.render(self.nom_touche(Constantes.TOUCHES[1]['sauter']),
True, self.TOUCHE), (785, 425)) # Haut
# ecran.blit(font.render(pygame.key.name(Constantes.TOUCHES[0]['']), True, self.TOUCHE), (370, 505)) # Bas
ecran.blit(
font.render(
self.nom_touche(Constantes.TOUCHES[1]['aller_gauche']),
True, self.TOUCHE), (700, 500)) # Gauche
ecran.blit(
font.render(
self.nom_touche(Constantes.TOUCHES[1]['accroupir']), True,
self.TOUCHE), (785, 500)) # Accroupir
ecran.blit(
font.render(
self.nom_touche(Constantes.TOUCHES[1]['aller_droite']),
True, self.TOUCHE), (865, 500)) # Droite
ecran.blit(
font.render(
self.nom_touche(Constantes.TOUCHES[1]['competence']), True,
self.TOUCHE), (773, 627)) # Compétence
font = pygame.font.Font("res/fonts/Comfortaa-Bold.ttf", 20)
texte = font.render("ESC pour retourner au menu principal", True,
self.DESCRIPTION)
ecran.blit(texte,
(Constantes.LARGEUR / 2 - texte.get_width() / 2, 740))
import pygame
import sys
import pygame.time as time
from gestionnaires.Evenement import *
from gestionnaires.Images import Images
from gestionnaires.Maj import *
from interfaces.Intro import Intro
from interfaces.Ecran import Ecran
from utils.Constantes import *
pygame.init()
random.seed()
ecran = pygame.display.set_mode(TAILLE)
pygame.display.set_caption("Dino Tempest")
icon = Images().charger_image("res/img/fenetre/icon2.png")
pygame.display.set_icon(icon)
intro = Intro()
clock = time.Clock()
gestionnaire_evenements = Evenement()
maj = Maj()
affichage = Ecran(ecran)
while 1:
for evenement in pygame.event.get():
if evenement.type == pygame.QUIT:
sys.exit()
else:
gestionnaire_evenements.maj(evenement.type, evenement)
def affichage(self, ecran):
if self._image != "":
image = Images().charger_image(
f'res/img/interfaces/accueil/{self._image}.png')
ecran.blit(image, self._coord)
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()
