def __init__(self): #variables self.nbrParties = 0 #nombre de parties jouees self.aPlacer = None #objet a placer sur la map self.aPlacerVue = None #objet visuel a placer self.tourSelect = None self.leJoueur = Joueur() self.lesTours = [] #liste des tours existantes self.lesToursVue = [] #liste des representations graphiques des tours self.lesCreeps = [] #liste des creeps existants self.lesCreepsVue = [] #liste des affichages de creeps existants #les ids self.idCreep = 0 #id a donner a chaque creep, incremente self.idTour = 0 #meme chose pour les tours self.nbrCreepsTues = 0 #map self.nomMap = "" #fichier contenant la map self.laMap = None #objet Map self.generateurCreep = None #entite qui controle d'ou les creeps arrivent et a quel rythme #interface self.interface = Vue(leController=self) #scores self.lesScores = Score(leController=self) #actions a faire en ouvrant le jeu self.interface.chargerMenu() self.interface.root.mainloop() #derniere fonction du constructeur
class Map: """ Représentation de la carte. Utilisation d'une liste à 2 dimensions pour représenter la map. """ def __init__(self, map_str): self._representation_map = self._convert(map_str) """Représentation interne de la map : liste 2D""" self._joueur = Joueur(self._representation_map) """Joueur qui va manipuler la Map en se déplaçant""" def __repr__(self): """ Concatène tous les éléments de la liste 2D pour afficher le labyrinthe """ str_ = "" for line in self._representation_map: for colonne in line: str_ += colonne str_ += "\n" return str_.rstrip() def _convert(self, map_str): """ Convertit la string provenant du fichier texte en une liste à 2 dimensions. La map est considérée intègre. """ map_ = list() # On sépare les lignes map_str = map_str.rstrip().split("\n") # Pour chacune des lignes... for i, ligne in enumerate(map_str): # ...on crée une liste de caractères ligne = list(ligne) # ...et on crée une un liste dans la 1ère dimension map_.append(list()) # Pour chacun des caractères... for car in ligne: # ...on l'ajoute dans la 2nde dimension map_[i].append(car) return map_ def deplacement(self, type_, longueur): """ En fonction du type de déplacement, on réévalue la map. Si un déplacement renvoie un IndexError, on l'ignore. """ for i in range(0, longueur): try: self._representation_map = self._joueur.se_deplacer(self._representation_map, type_) except IndexError: break finally: print(self) return self._etat_jeu(self._representation_map) def _etat_jeu(self, map_): """ Retourne False si le jeu n'est pas gagné et True s'il est gagné. Le robot doit remplacer la sortie lors de son dernier mouvement pour que cette méthode fonctionne correctement. """ # Pour chacune des lignes... for row, i in enumerate(map_): # ...on cherche l'indice de la colonne... try: column = i.index(representation['sortie']) # ...si on trouve la sortie, le joueur n'a pas encore gagné return False # ...si la sortie n'est pas encore trouvé, on continue la recherche... except ValueError: continue # ...si on arrive ici, c'est que la sortie n'a pas été trouvée et que le joueur a gagné return True
def __init__(self, map_str): self._representation_map = self._convert(map_str) """Représentation interne de la map : liste 2D""" self._joueur = Joueur(self._representation_map) """Joueur qui va manipuler la Map en se déplaçant"""
# Avancer : joueur x cdb -> cdb # description : avance toutes les cartes du joueur sur le champ de bataille se trouvant à l'arrière et que le front devant eux est vide. def Avancer(joueur, cdb): return 0 #### Programme Principal : # Realise par: # - ARNAUD Paul # - RANARIMAHEFA Mitantsoa Michel # Création des joueurs print('Création des joueurs') joueur1 = Joueur() joueur1.creerJoueur() joueur2 = Joueur() joueur2.creerJoueur() joueurCourant = joueur1 joueurAdverse = joueur2 # Création du champ de bataille print('Création du champ de bataille') cdb = CDB() cdb.creerCDB() #### Mise en place :
from Protocole import * from Joueur import * import socket import io #initialisation de la partie nb_joueurs = 4 personages = ["Loup garou", "Villageois"] players = [Joueur("no one", personages) for i in xrange(0,nb_joueurs)] cptJoueurs = 0 #ouverture de la communication comSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) comSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) comSocket.bind(('',8000)) comSocket.listen(nb_joueurs) #ecoute des clients try: newSocket, address = comSocket.accept() p = Protocole(newSocket, '$') print "Connecte a ", address p.envoi("nb_Joueurs",str(nb_joueurs)) p.rec("val") p.envoiListe("persos",personages) nomJoueur1 = p.rec("nom")
from tkinter import * from tkinter.messagebox import * from random import * import time from threading import * import Decor import Joueur if __name__ == "__main__": Joueur.Fenêtre = Tk() Decor.initialisation_incassables(10) Couleur = "grey" Zone = Canvas(Joueur.Fenêtre, width=Decor.Largeur, height=Decor.Hauteur, background=Couleur) grille = Decor.grille(Zone, 2, 'black') Decor.dessine_incassables(Zone) Joueur.Player = Joueur.Personnage(Zone, 'grey') Joueur.Player2 = Joueur.Personnage2(Zone, 'blue') #grille(2, "black") #bombe = Bombe(Zone, Joueur) Joueur.Fenêtre.mainloop()
import Jeu import Joueur j = Jeu.cree() print('fenetre=' + str(Jeu.fenetre(j))) print('pile=' + str(Jeu.pile(j))) print('joueurs=' + str(Jeu.joueurs(j))) print('indiceJoueur=' + str(Jeu.indiceJoueur(j))) print('joueurCourant=' + Joueur.nom(Jeu.joueurCourant(j))) for i in range(2): Jeu.passeJoueurSuivant(j) print('indiceJoueur=' + str(Jeu.indiceJoueur(j))) print('joueurCourant=' + Joueur.nom(Jeu.joueurCourant(j)))
def main(): j1 = Joueur() j2 = Joueur() joueurs = [j1, j2] tailles = [1, 2, 3, 3, 4] # On fixe les tailles des bateaux à créer k = 0 # Compteur pour le nombre de bateau à créer (ici 5) ''' Saisie des bateaux pour les 2 joueurs ''' for i in range(0, 2): # Alterner du joueur 1 au joueur2 while (k != 5): x1, y1, x2, y2 = -1, -1, -1, -1 if (tailles[k] == 1 ): # Si la taille est de 1 on saisie une seule coordonnee while (x1 < 0 or x1 > 20): x1 = int( input("Entrez un x de depart pour bateau de taille " + str(tailles[k]) + " : ")) while (y1 < 0 or y1 > 20): y1 = int( input("Entrez un y de depart pour bateau de taille " + str(tailles[k]) + ": ")) x2 = x1 y2 = y1 b = Bateau(x1, y1, x2, y2) valideAjoutBateau = joueurs[i].ajoutBateau(b) if (valideAjoutBateau): k = k + 1 else: print("Entrez un bateau de taille : " + str(tailles[k])) valideAjoutBateau = False while (not (valideAjoutBateau)): x1, y1, x2, y2 = -1, -1, -1, -1 while (x1 < 0 or x1 > 20): x1 = int( input( "Entrez un x de depart pour bateau de taille " + str(tailles[k]) + ": ")) while (y1 < 0 or y1 > 20): y1 = int( input( "Entrez un y de depart pour bateau de taille " + str(tailles[k]) + ": ")) while (x2 < 0 or x2 > 20): x2 = int( input("Entrez un x de fin pour bateau de taille " + str(tailles[k]) + ": ")) while (y2 < 0 or y2 > 20): y2 = int( input("Entrez un y de fin pour bateau de taille " + str(tailles[k]) + ": ")) if ( x1 == x2 and (abs(y1 - y2) + 1) == tailles[k] ): # Verifier que les coordonnees rentrees sont coherentes avec la taille souhaite b = Bateau(x1, y1, x2, y2) valideAjoutBateau = joueurs[i].ajoutBateau( b ) # si la position n'est pas occupée valideAjoutBateau = true if ( valideAjoutBateau ): # Si l'ajout est reussie on passe au bateau suivant à placer k = k + 1 else: print( "La case est déjà occupée par un autre bateau") elif (y1 == y2 and (abs(x1 - x2) + 1) == tailles[k]): b = Bateau(x1, y1, x2, y2) valideAjoutBateau = joueurs[i].ajoutBateau( b ) # si la position n'est pas occupée valideAjoutBateau = true if ( valideAjoutBateau ): # Si l'ajout est reussie on passe au bateau suivant à placer k = k + 1 else: print( "La case est déjà occupée par un autre bateau") else: print( "Les coordonnées entrées ne correspondent pas à la taille " + str(tailles[k]) + " souhaitée !") estFini = False courant = 0 suivant = 1 ''' Debut de la partie avec alternance des 2 joueurs ''' while (not (estFini)): coordonnee = viser() retour = joueurs[suivant].seFaitTirer(coordonnee[0], coordonnee[1]) if (retour == 0): print("Touché !") elif (retour == 1): print("En vue !") elif (retour == 2): print("A l'eau ") estFini = joueurs[suivant].aPerdu( ) # On vérifie que le joueur adverse sur lequel on a tiré a perdu courant, suivant = suivant, courant # On permute les joueurs
def jeuDebut(self): #actions a faire en debut de jeu self.leJoueur = Joueur() self.leJoueur.vivant = True self.nbrCreepsTues = 0 self.interface.actualiserVieArgent()
def main(): #Affichage du menu principal nettoyer() afficherTitre() start = raw_input("Commencer le jeu ? (o/n) ") if start != "o": return nettoyer() #Placement des bateaux (la fonction creerBateau est appelee a l interieur de entrerBateau avec les informations entrees par l utilisateur) valider = "n" while valider == "n": nettoyer() print("Joueur 1") S1 = getEmptyGrid() afficher(S1) b11 = entrerBateau(1) ajoutMatrice(b11, S1) nettoyer() print("Joueur 1") afficher(S1) b12 = entrerBateau(2) ajoutMatrice(b12, S1) nettoyer() print("Joueur 1") afficher(S1) b13 = entrerBateau(3) ajoutMatrice(b13, S1) nettoyer() print("Joueur 1") afficher(S1) b14 = entrerBateau(3) ajoutMatrice(b14, S1) nettoyer() print("Joueur 1") afficher(S1) b15 = entrerBateau(4) ajoutMatrice(b15, S1) nettoyer() afficher(S1) valider = raw_input("valider? (o/n) ") valider = "n" nettoyer() while valider == "n": print("Joueur 2") S2 = getEmptyGrid() afficher(S2) b21 = entrerBateau(1) ajoutMatrice(b21, S2) nettoyer() print("Joueur 2") afficher(S2) b22 = entrerBateau(2) ajoutMatrice(b22, S2) nettoyer() print("Joueur 2") afficher(S2) b23 = entrerBateau(3) ajoutMatrice(b23, S2) nettoyer() print("Joueur 2") afficher(S2) b24 = entrerBateau(3) ajoutMatrice(b24, S2) nettoyer() print("Joueur 2") afficher(S2) b25 = entrerBateau(4) ajoutMatrice(b25, S2) nettoyer() afficher(S2) valider = raw_input("valider? (o/n) ") #Creation des joueurs batJ1 = [b11, b12, b13, b14, b15] batJ2 = [b21, b22, b23, b24, b25] j1 = Joueur(batJ1) j2 = Joueur(batJ2) tour = int(1) #tour du joueur x = int(0) y = int(0) G1 = getEmptyGrid() G2 = getEmptyGrid() G = [G1, G2] #Boucle de jeu while (j1.nbBateauxRestants() != 0) and (j2.nbBateauxRestants() != 0): nettoyer() print("Joueur " + str(tour) + " " + " choisit une position de tir") afficher(G[tour - 1]) x = input("Coordonnee x : ") y = input("Coordonnee y : ") if tour == 1: tir = Tir(x, y, j2) else: tir = Tir(x, y, j1) result = tir.resultatTir() if result == "touché" or result == "coulé": G[tour - 1][x][y] = 1 nettoyer() afficher(G[tour - 1]) print(result) time.sleep(1) #Dans resultatTir on appelle les fonctions verifierEnVue, etatPosition et nbBateauxRestants if tour == 1: tour += 1 else: tour -= 1 nettoyer() if (j1.nbBateauxRestants == 0): felicitation(2) else: felicitation(2)
class Controller: def __init__(self): #variables self.nbrParties = 0 #nombre de parties jouees self.aPlacer = None #objet a placer sur la map self.aPlacerVue = None #objet visuel a placer self.tourSelect = None self.leJoueur = Joueur() self.lesTours = [] #liste des tours existantes self.lesToursVue = [] #liste des representations graphiques des tours self.lesCreeps = [] #liste des creeps existants self.lesCreepsVue = [] #liste des affichages de creeps existants #les ids self.idCreep = 0 #id a donner a chaque creep, incremente self.idTour = 0 #meme chose pour les tours self.nbrCreepsTues = 0 #map self.nomMap = "" #fichier contenant la map self.laMap = None #objet Map self.generateurCreep = None #entite qui controle d'ou les creeps arrivent et a quel rythme #interface self.interface = Vue(leController=self) #scores self.lesScores = Score(leController=self) #actions a faire en ouvrant le jeu self.interface.chargerMenu() self.interface.root.mainloop() #derniere fonction du constructeur def chargerMap(self): #init la map self.laMap = Map(nomMap="Maps/"+self.nomMap) xGen, yGen = self.laMap.getPosGenerateur() self.generateurCreep = Generateur(x=xGen, y=yGen, leController=self) def jeuDebut(self): #actions a faire en debut de jeu self.leJoueur = Joueur() self.leJoueur.vivant = True self.nbrCreepsTues = 0 self.interface.actualiserVieArgent() def reset(self): #a chaque fois qu'on clique sur "nouvelle partie" #variables self.aPlacer = None #objet a placer sur la map self.aPlacerVue = None #objet visuel a placer self.tourSelect = None self.lesTours = [] #liste des tours existantes self.lesToursVue = [] #liste des representations graphiques des tours self.lesCreeps = [] #liste des creeps existants self.lesCreepsVue = [] #liste des affichages de creeps existants #les ids self.idCreep = 0 #id a donner a chaque creep, incremente self.idTour = 0 #meme chose pour les tours self.nbrCreepsTues = 0 #map self.nomMap = "" self.laMap = None self.generateurCreep = None self.jeuDebut() def getMap(self): #retourne l'objet Map pour avoir acces a ses donnees return self.laMap def getInfoJoueur(self): #retourne l'objet Joueur pour avoir acces a ses donnees return self.leJoueur def getInfoTour(self, id): #retourne la tour associee a cet id for i in self.lesTours: if i.idTour == id: return i def getInfoTourVue(self, id): #retourne la vue de la tour associee a cet id for i in self.lesToursVue: if i.idTour == id: return i def getInfoRange(self, id): #retourne la tour associee a cet id for i in self.lesRangesVue: if i.idTour == id: return i def getInfoCreep(self, id): #retourne le creep associe a cet id for i in self.lesCreeps: if i.idCreep == id: return i def getInfoCreepVue(self, id): #retourne le creep associe a cet id for i in self.lesCreepsVue: if i.idCreep == id:# #print i.idCreep return i def boucleJeu(self): if self.leJoueur.vivant == True: for i in self.lesCreeps: #print i.idCreep #debug self.getInfoCreepVue(i.idCreep).affichage() i.deplacement() for i in self.lesToursVue: i.leRange.detection() #on cherche des cibles self.interface.root.after(200, self.boucleJeu) #"boucle" else: #si le joueur est mort self.generateurCreep.jouer=False #arretter de generer des creeps pour une periode indefinie self.interface.dechargerJeu() self.leJoueur.points = self.nbrCreepsTues*2 + self.leJoueur.argent #on calcule le score self.interface.unPopup = PopupEntreNom(leController=self) #on veut enregistrer le score def creerCreep(self): #ajouter un nouveau creep a la liste des creeps, lui associer une vue et un id self.lesCreeps.append(Creep(x=self.generateurCreep.x, y=self.generateurCreep.y, idCreep=self.idCreep, leController=self, pv=100+100*self.generateurCreep.nbrVagues/2)) self.lesCreepsVue.append(VueCreep(leCanvas=self.interface.zoneJeu, leController=self, idCreep=self.idCreep)) self.idCreep = self.idCreep + 1 #incremente l'id du prochain creep def detruireCreep(self, id, auChateau=True): if auChateau == False: #un creep a ete tue, on donne des points self.nbrCreepsTues = self.nbrCreepsTues +1 self.leJoueur.argent = self.leJoueur.argent + 10 self.interface.actualiserVieArgent() for i in self.lesCreeps: #enlever le creep de la liste if i.idCreep == id: self.lesCreeps.remove(i) #print "creep removed" for j in self.lesCreepsVue: #enlever la vue associee a ce creep if j.idCreep == id: j.cacher() self.lesCreepsVue.remove(j) #print "creepVue removed" def choisirLevelTour(self, type): #on a clique sur un bouton de tour if self.aPlacer == None: #aucune tour selectionnee, on choisis ce qu'on veut self.interface.unPopup = PopupChoixTour(leCanvas=self.interface.zoneJeu, x=350, y=100, leController=self, typeTour=type) #popup pour choisir le level de la tour et le prix else: self.annulerTour() #on a deja selectionne une tour, on la deselectionne def creerTour(self, type=None, level=1): #creer un objet tour, tourVue..., les associer, retourner l'objet vue a afficher self.aPlacer = type(lvl=level, idTour=self.idTour, leController=self) rangeTemp = VueRange(leCanvas=self.interface.zoneJeu, leController=self, idTour=self.idTour) self.aPlacerVue = VueTour(leCanvas=self.interface.zoneJeu, leController=self, idTour=self.idTour, leRange=rangeTemp) #ajouter aux listes self.lesTours.append(self.aPlacer) self.lesToursVue.append(self.aPlacerVue) self.idTour = self.idTour + 1 def listeTypesTours(self): #retourne tous les types de tours existants pour avoir assez de boutons et les associer aux bonnes cmd return (TourStandard,) def appliquerTour(self):#, skip=False): if self.empVal == True: self.laMap.changerEmplacement(self.aPlacer.x, self.aPlacer.y) self.aPlacerVue.leRange.cacher() #on cache le range car on construit la tour self.leJoueur.enleverArgent(self.aPlacer.cout*self.aPlacer.lvl)#enlever de l'argent au joueur self.interface.actualiserVieArgent() self.aPlacer = None #on efface les objets temporaires self.aPlacerVue = None self.interface.zoneJeu.config(cursor="") #on reset le curseur def annulerTour(self): #on cache la tour et son range self.aPlacerVue.cacher() self.aPlacerVue.leRange.cacher() #on cache le range car on construit la tour self.aPlacer = None #on efface les objets temporaires self.aPlacerVue = None self.interface.zoneJeu.config(cursor="") #on reset le curseur #enlever les objets temporaires de la liste self.lesTours = self.lesTours[:-1] self.lesToursVue = self.lesToursVue[:-1] #on recule d'un id self.idTour = self.idTour - 1 def deplacerObjets(self, event): #deplacer les objets temporaire (quand la tour flotte sous la souris pour la construire) self.interface.zoneJeu.config(cursor="cross") self.aPlacer.x = event.x self.aPlacer.y = event.y self.aPlacerVue.leRange.cacher() #pour bouger/actualiser self.aPlacerVue.leRange.affichage() self.aPlacerVue.cacher() self.empVal = self.laMap.emplacementValide(event.x, event.y) #est-ce un emplacement valide sur la map? self.aPlacerVue.affichage(valide=self.empVal) def selectionTour(self,event): lesObjets = self.interface.zoneJeu.find_overlapping(event.x-10, event.y-10, event.x+10, event.y+10) #liste des objets sous la souris found = False #est-ce qu'on a clique sur une tour? for i in lesObjets: lesTags = self.interface.zoneJeu.gettags(i) if len(lesTags) > 0: #protection contre objet none if lesTags[0] == "Tour": #on regarde si l'objet en cours est une tour if self.tourSelect != None: #on doit deselectionner la tour actuelle ou popper le menu d'upgrade si c'est la meme tour if int(lesTags[1]) == self.tourSelect.idTour: #si tour deja selectionnee, on ouvre le menu d'upgrade self.interface.unPopup = PopupUpgradeTour(leCanvas=self.interface.zoneJeu, x=350, y=100, leController=self, idTour = self.tourSelect.idTour) #popper fenetre else: #si une autre tour, on deselectionne self.getInfoTourVue(self.tourSelect.idTour).leRange.cacher() #cacher range de l'ancienne tour self.tourSelect = self.getInfoTour(int(lesTags[1])) #afficher autre tour self.getInfoTourVue(self.tourSelect.idTour).leRange.affichage() self.getInfoTourVue(self.tourSelect.idTour).affichage(True) #pour pas etre cache par le range else: #si aucune tour selectionnee auparavant, on en selectionne une self.tourSelect = self.getInfoTour(int(lesTags[1])) #la tour cliquee devient la tour selectionnee self.getInfoTourVue(self.tourSelect.idTour).leRange.affichage() self.getInfoTourVue(self.tourSelect.idTour).affichage(True) #pour pas etre cache par le range found = True #on a clique sur une tour elif lesTags[0] == "Creep": #on choisi une cible if self.tourSelect != None: self.tourSelect.cible = self.getInfoCreep(int(lesTags[1])) #donner la priorite a ce creep #print self.tourSelect.cible.idCreep #debug found = True if found == False: #pas clique sur une tour ou creep = deselectionner tour if self.tourSelect != None: self.getInfoTourVue(self.tourSelect.idTour).leRange.cacher() self.tourSelect = None self.interface.zoneJeu.config(cursor="") else: #si on a selectionne quelque chose self.interface.zoneJeu.config(cursor="cross")
def test_ancienne_position(): joueur_de_test = Joueur.joueur("toto", 12, 189) joueur_de_test.deplacer(1, 1) assert joueur_de_test.ancienne_position() == (12, 189)
def test_position(): joueur_de_test = Joueur.joueur("toto", 12, 189) assert joueur_de_test.position() == (12, 189)
def test_sauver_etat(): joueur_de_test = Joueur.joueur("toto", 12, 189) joueur_de_test.sauver_etat() assert joueur_de_test.old_X == 12 assert joueur_de_test.old_Y == 189
def __init__(self,niveau,difficulté,mode_affichage): self.mode_affichage = mode_affichage if self.mode_affichage == voir_tout : self.LARGEUR_CASE = 20 self.LARGEUR_MUR = 1 elif self.mode_affichage == aveugle : self.LARGEUR_CASE = 45 self.LARGEUR_MUR = 5 elif self.mode_affichage == parcours_en_profondeur : self.LARGEUR_CASE = 20 self.LARGEUR_MUR = 1 elif self.mode_affichage == distance_max : self.LARGEUR_CASE = 20 self.LARGEUR_MUR = 1 if niveau == 0: if difficulté == BEGINNER : self.CASES_X = 20 self.CASES_Y = 20 res = True self.salles=[Patern((8,8),10,10,self.LARGEUR_CASE,self.LARGEUR_MUR)] elif difficulté == EASY : self.CASES_X = 20 self.CASES_Y = 20 res = False self.salles=[Patern((14,14),5,5,self.LARGEUR_CASE,self.LARGEUR_MUR)] elif difficulté == AVERAGE : self.CASES_X = 40 self.CASES_Y = 40 res = False self.salles=[Patern((17,17),5,5,self.LARGEUR_CASE,self.LARGEUR_MUR)] elif difficulté == HARD : self.CASES_X = 60 self.CASES_Y = 60 res = False self.salles=[Patern((10,29),40,2,self.LARGEUR_CASE,self.LARGEUR_MUR,[])] #on génère les entrées de manière a avoir un espace ouvert self.salles[0].pre_gen_entrees_x(0,0,39) self.salles[0].pre_gen_entrees_x(1,0,39) elif difficulté == INSANE : self.CASES_X = 100 self.CASES_Y = 100 res = False self.salles=[Patern((49,30),2,40,self.LARGEUR_CASE,self.LARGEUR_MUR)] elif difficulté == IMPOSSIBLE : self.CASES_X = 1000 self.CASES_Y = 1000 res = False self.salles=[] #variables correspondants a la largeur et la hauteur du zoom self.zoom_largeur=11 self.zoom_hauteur=11 self.force_joueur = 5 self.hp_joueur = 100 inventaire_joueur = Inventaire() pygame.init() #poids permettants de manipuler l'aléatoire self.poids=[6,2,1,2] #salle pour exp monstres self.salles.append(Patern((0,0),5,5,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,3]])) #génération du labyrinthe self.lab=Labyrinthe(self.CASES_X,self.CASES_Y,self.CASES_X-1,self.CASES_Y-1,self.LARGEUR_CASE,self.LARGEUR_MUR,self.poids,self.salles) self.lab.generation() self.lab.casser_X_murs(0.1) #exp avec les portes mat_lab=self.lab.getMatrice_cases() mat_lab[4][2].murs[DROITE]=Porte(self.LARGEUR_MUR,"goodooKey") self.lab.matrice_cases=mat_lab if res : self.lab.resolution(self.CASES_X-1,self.CASES_Y-1,0,0,"Largeur") pygame.display.set_caption("test") self.screen = pygame.display.set_mode((FENETRE_X,FENETRE_Y),pygame.RESIZABLE) self.screen.fill((0,0,0)) #entitées self.joueur=Joueur(inventaire_joueur,self.hp_joueur,self.force_joueur,2,self.zoom_largeur,self.zoom_hauteur) self.monstres=[Fatti([5,10],10,10,100,5,1,5,(0,0,100))]#,Fatti([10,10],10,10,100,5,1,5,(0,0,100))] self.entitees=[self.joueur,Clee((3,3),"goodooKey")] elif niveau == 1: #niveau labyrinthique sans monstres pour apprendre à se déplacer self.CASES_X = 40 self.CASES_Y = 40 res = False self.salles=[] #variables correspondants a la largeur et la hauteur du zoom self.zoom_largeur=13 self.zoom_hauteur=13 self.force_joueur = 10 self.hp_joueur = 200 inventaire_joueur = Inventaire() pygame.init() #poids permettants de manipuler l'aléatoire self.poids=[6,2,1,2] #salle pour exp monstres self.salles.append(Patern((0,0),11,3,self.LARGEUR_CASE,self.LARGEUR_MUR,[[10,1],[8,2]])) #génération du labyrinthe self.lab=Labyrinthe(self.CASES_X,self.CASES_Y,self.CASES_X-1,self.CASES_Y-1,self.LARGEUR_CASE,self.LARGEUR_MUR,self.poids,self.salles) self.lab.generation() self.lab.casser_X_murs(0.2) mat_lab=self.lab.getMatrice_cases() self.lab.matrice_cases=mat_lab if res : self.lab.resolution(self.CASES_X-1,self.CASES_Y-1,0,0,"Largeur") pygame.display.set_caption("test") self.screen = pygame.display.set_mode((FENETRE_X,FENETRE_Y),pygame.RESIZABLE) self.screen.fill((0,0,0)) #entitées self.joueur=Joueur(inventaire_joueur,self.hp_joueur,self.force_joueur,2,self.zoom_largeur,self.zoom_hauteur) self.monstres=[]#Fatti([25,25],10,10,100,5,1,5,(0,0,100)),Fatti([25,30],10,10,100,5,1,5,(0,0,100)),Fatti([30,25],10,10,100,5,1,5,(0,0,100)),Fatti([30,30],10,10,100,5,1,5,(0,0,100))] self.entitees=[self.joueur] elif niveau == 2: #niveau monstrueux sans labyrinthe pour apprendre à se battre self.CASES_X = 10 self.CASES_Y = 60 res = False self.salles=[Patern((1,13),8,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1],[5,7]]),Patern((1,25),6,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1],[5,7]]),Patern((2,40),8,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1],[5,7]]),Patern((4,52),5,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1]])] #variables correspondants a la largeur et la hauteur du zoom self.zoom_largeur=13 self.zoom_hauteur=13 self.force_joueur = 10 self.hp_joueur = 200 inventaire_joueur = Inventaire() pygame.init() #poids permettants de manipuler l'aléatoire self.poids=[6,2,1,2] #salle pour exp monstres self.salles.append(Patern((4,0),2,10,self.LARGEUR_CASE,self.LARGEUR_MUR,[[0,9],[1,9]])) #génération du labyrinthe self.lab=Labyrinthe(self.CASES_X,self.CASES_Y,5,59,self.LARGEUR_CASE,self.LARGEUR_MUR,self.poids,self.salles) self.lab.generation() self.lab.casser_X_murs(0.2) mat_lab=self.lab.getMatrice_cases() self.lab.matrice_cases=mat_lab if res : self.lab.resolution(5,59,4,0,"Largeur") pygame.display.set_caption("test") self.screen = pygame.display.set_mode((FENETRE_X,FENETRE_Y),pygame.RESIZABLE) self.screen.fill((0,0,0)) #entitées self.joueur=Joueur(inventaire_joueur,self.hp_joueur,self.force_joueur,2,self.zoom_largeur,self.zoom_hauteur,(4,0)) self.monstres=[Fatti([5,17],10,10,100,5,1,0,(0,0,100)),Fatti([8,25],10,10,100,5,1,1,(0,0,100)),Fatti([3,48],10,10,100,5,1,2,(0,0,100)),Fatti([5,59],10,10,100,5,1,3,(0,0,100))] self.entitees=[self.joueur] elif niveau == 3: #niveau monstrueux sans labyrinthe pour apprendre à se battre self.CASES_X = 10 self.CASES_Y = 60 res = False self.salles=[Patern((1,13),8,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1],[5,7]]),Patern((1,25),6,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1],[5,7]]),Patern((2,40),8,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1],[5,7]]),Patern((4,52),5,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1]])] #variables correspondants a la largeur et la hauteur du zoom self.zoom_largeur=13 self.zoom_hauteur=13 self.force_joueur = 10 self.hp_joueur = 200 inventaire_joueur = Inventaire() pygame.init() #poids permettants de manipuler l'aléatoire self.poids=[6,2,1,2] #salle pour exp monstres self.salles.append(Patern((4,0),2,10,self.LARGEUR_CASE,self.LARGEUR_MUR,[[0,9],[1,9]])) #génération du labyrinthe self.lab=Labyrinthe(self.CASES_X,self.CASES_Y,5,59,self.LARGEUR_CASE,self.LARGEUR_MUR,self.poids,self.salles) self.lab.generation() self.lab.casser_X_murs(0.2) mat_lab=self.lab.getMatrice_cases() self.lab.matrice_cases=mat_lab if res : self.lab.resolution(5,59,4,0,"Largeur") pygame.display.set_caption("test") self.screen = pygame.display.set_mode((FENETRE_X,FENETRE_Y),pygame.RESIZABLE) self.screen.fill((0,0,0)) #entitées self.joueur=Joueur(inventaire_joueur,self.hp_joueur,self.force_joueur,2,self.zoom_largeur,self.zoom_hauteur,(4,0)) self.monstres=[Slime([5,17],10,10,100,5,1,0,(0,0,100)),Fatti([8,25],10,10,100,5,1,1,(0,0,100)),Runner(self.lab.getMatrice_cases(),5,59,[3,48],10,10,100,5,1,2,(0,0,100)),Fatti([5,59],10,10,100,5,1,3,(0,0,100))] self.entitees=[self.joueur] elif niveau == 4: #niveau monstrueux sans labyrinthe pour apprendre à se battre self.CASES_X = 15 self.CASES_Y = 15 res = False self.salles=[Patern((3,0),3,15,self.LARGEUR_CASE,self.LARGEUR_MUR,[[0,13],[2,1]]),Patern((6,0),3,15,self.LARGEUR_CASE,self.LARGEUR_MUR,[[0,1],[2,13]]),Patern((9,0),3,15,self.LARGEUR_CASE,self.LARGEUR_MUR,[[0,13],[2,1]]),Patern((12,0),3,15,self.LARGEUR_CASE,self.LARGEUR_MUR,[[0,1]])] #variables correspondants a la largeur et la hauteur du zoom self.zoom_largeur=13 self.zoom_hauteur=13 self.force_joueur = 10 self.hp_joueur = 200 inventaire_joueur = Inventaire() pygame.init() #poids permettants de manipuler l'aléatoire self.poids=[6,2,1,2] #salle pour exp monstres self.salles.append(Patern((0,0),3,15,self.LARGEUR_CASE,self.LARGEUR_MUR,[[2,13]])) #génération du labyrinthe self.lab=Labyrinthe(self.CASES_X,self.CASES_Y,self.CASES_X-1,self.CASES_Y-1,self.LARGEUR_CASE,self.LARGEUR_MUR,self.poids,self.salles) self.lab.generation() self.lab.casser_X_murs(0.0) mat_lab=self.lab.getMatrice_cases() self.lab.matrice_cases=mat_lab if res : self.lab.resolution(self.CASES_X-1,self.CASES_Y-1,0,0,"Largeur") pygame.display.set_caption("test") self.screen = pygame.display.set_mode((FENETRE_X,FENETRE_Y),pygame.RESIZABLE) self.screen.fill((0,0,0)) #entitées self.joueur=Joueur(inventaire_joueur,self.hp_joueur,self.force_joueur,2,self.zoom_largeur,self.zoom_hauteur) self.monstres=[Slime([1,5],10,10,100,5,1,1,(0,0,100)),Slime([2,12],10,10,100,5,1,1,(0,0,100)),Slime([0,12],10,10,100,5,1,1,(0,0,100)),Slime([1,13],10,10,100,5,1,1,(0,0,100)),Slime([2,8],10,10,100,5,1,1,(0,0,100)),Slime([0,8],10,10,100,5,1,1,(0,0,100)),Slime([1,9],10,10,100,5,1,1,(0,0,100)),Slime([2,10],10,10,100,5,1,1,(0,0,100)),Slime([0,10],10,10,100,5,1,1,(0,0,100)),Slime([1,11],10,10,100,5,1,1,(0,0,100)),Slime([7,5],10,10,100,5,1,2,(0,0,100)),Slime([8,12],10,10,100,5,1,2,(0,0,100)),Slime([6,12],10,10,100,5,1,2,(0,0,100)),Slime([7,13],10,10,100,5,1,2,(0,0,100)),Slime([8,8],10,10,100,5,1,2,(0,0,100)),Slime([6,8],10,10,100,5,1,2,(0,0,100)),Slime([7,9],10,10,100,5,1,2,(0,0,100)),Slime([8,10],10,10,100,5,1,2,(0,0,100)),Slime([6,10],10,10,100,5,1,2,(0,0,100)),Slime([7,11],10,10,100,5,1,2,(0,0,100))] self.entitees=[self.joueur] for i in range(0,len(self.monstres)): self.entitees.append(self.monstres[i]) #objet qui traite les collisions self.collision=Collision() #événements self.evenements=[] #objet d'affichage self.affichage=Affichage(self.screen,self.mode_affichage,self.LARGEUR_CASE,self.LARGEUR_MUR) #texte de fin font = pygame.font.SysFont(None, 72) self.textWin = font.render("Vous avez gagné!! \(^o^)/", True, (128, 0, 0)) self.textLose = font.render("Vous avez perdu!! ;o;", True, (0, 128, 128)) self.position_screen=(0,0)
class Niveau: def __init__(self,niveau,difficulté,mode_affichage): self.mode_affichage = mode_affichage if self.mode_affichage == voir_tout : self.LARGEUR_CASE = 20 self.LARGEUR_MUR = 1 elif self.mode_affichage == aveugle : self.LARGEUR_CASE = 45 self.LARGEUR_MUR = 5 elif self.mode_affichage == parcours_en_profondeur : self.LARGEUR_CASE = 20 self.LARGEUR_MUR = 1 elif self.mode_affichage == distance_max : self.LARGEUR_CASE = 20 self.LARGEUR_MUR = 1 if niveau == 0: if difficulté == BEGINNER : self.CASES_X = 20 self.CASES_Y = 20 res = True self.salles=[Patern((8,8),10,10,self.LARGEUR_CASE,self.LARGEUR_MUR)] elif difficulté == EASY : self.CASES_X = 20 self.CASES_Y = 20 res = False self.salles=[Patern((14,14),5,5,self.LARGEUR_CASE,self.LARGEUR_MUR)] elif difficulté == AVERAGE : self.CASES_X = 40 self.CASES_Y = 40 res = False self.salles=[Patern((17,17),5,5,self.LARGEUR_CASE,self.LARGEUR_MUR)] elif difficulté == HARD : self.CASES_X = 60 self.CASES_Y = 60 res = False self.salles=[Patern((10,29),40,2,self.LARGEUR_CASE,self.LARGEUR_MUR,[])] #on génère les entrées de manière a avoir un espace ouvert self.salles[0].pre_gen_entrees_x(0,0,39) self.salles[0].pre_gen_entrees_x(1,0,39) elif difficulté == INSANE : self.CASES_X = 100 self.CASES_Y = 100 res = False self.salles=[Patern((49,30),2,40,self.LARGEUR_CASE,self.LARGEUR_MUR)] elif difficulté == IMPOSSIBLE : self.CASES_X = 1000 self.CASES_Y = 1000 res = False self.salles=[] #variables correspondants a la largeur et la hauteur du zoom self.zoom_largeur=11 self.zoom_hauteur=11 self.force_joueur = 5 self.hp_joueur = 100 inventaire_joueur = Inventaire() pygame.init() #poids permettants de manipuler l'aléatoire self.poids=[6,2,1,2] #salle pour exp monstres self.salles.append(Patern((0,0),5,5,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,3]])) #génération du labyrinthe self.lab=Labyrinthe(self.CASES_X,self.CASES_Y,self.CASES_X-1,self.CASES_Y-1,self.LARGEUR_CASE,self.LARGEUR_MUR,self.poids,self.salles) self.lab.generation() self.lab.casser_X_murs(0.1) #exp avec les portes mat_lab=self.lab.getMatrice_cases() mat_lab[4][2].murs[DROITE]=Porte(self.LARGEUR_MUR,"goodooKey") self.lab.matrice_cases=mat_lab if res : self.lab.resolution(self.CASES_X-1,self.CASES_Y-1,0,0,"Largeur") pygame.display.set_caption("test") self.screen = pygame.display.set_mode((FENETRE_X,FENETRE_Y),pygame.RESIZABLE) self.screen.fill((0,0,0)) #entitées self.joueur=Joueur(inventaire_joueur,self.hp_joueur,self.force_joueur,2,self.zoom_largeur,self.zoom_hauteur) self.monstres=[Fatti([5,10],10,10,100,5,1,5,(0,0,100))]#,Fatti([10,10],10,10,100,5,1,5,(0,0,100))] self.entitees=[self.joueur,Clee((3,3),"goodooKey")] elif niveau == 1: #niveau labyrinthique sans monstres pour apprendre à se déplacer self.CASES_X = 40 self.CASES_Y = 40 res = False self.salles=[] #variables correspondants a la largeur et la hauteur du zoom self.zoom_largeur=13 self.zoom_hauteur=13 self.force_joueur = 10 self.hp_joueur = 200 inventaire_joueur = Inventaire() pygame.init() #poids permettants de manipuler l'aléatoire self.poids=[6,2,1,2] #salle pour exp monstres self.salles.append(Patern((0,0),11,3,self.LARGEUR_CASE,self.LARGEUR_MUR,[[10,1],[8,2]])) #génération du labyrinthe self.lab=Labyrinthe(self.CASES_X,self.CASES_Y,self.CASES_X-1,self.CASES_Y-1,self.LARGEUR_CASE,self.LARGEUR_MUR,self.poids,self.salles) self.lab.generation() self.lab.casser_X_murs(0.2) mat_lab=self.lab.getMatrice_cases() self.lab.matrice_cases=mat_lab if res : self.lab.resolution(self.CASES_X-1,self.CASES_Y-1,0,0,"Largeur") pygame.display.set_caption("test") self.screen = pygame.display.set_mode((FENETRE_X,FENETRE_Y),pygame.RESIZABLE) self.screen.fill((0,0,0)) #entitées self.joueur=Joueur(inventaire_joueur,self.hp_joueur,self.force_joueur,2,self.zoom_largeur,self.zoom_hauteur) self.monstres=[]#Fatti([25,25],10,10,100,5,1,5,(0,0,100)),Fatti([25,30],10,10,100,5,1,5,(0,0,100)),Fatti([30,25],10,10,100,5,1,5,(0,0,100)),Fatti([30,30],10,10,100,5,1,5,(0,0,100))] self.entitees=[self.joueur] elif niveau == 2: #niveau monstrueux sans labyrinthe pour apprendre à se battre self.CASES_X = 10 self.CASES_Y = 60 res = False self.salles=[Patern((1,13),8,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1],[5,7]]),Patern((1,25),6,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1],[5,7]]),Patern((2,40),8,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1],[5,7]]),Patern((4,52),5,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1]])] #variables correspondants a la largeur et la hauteur du zoom self.zoom_largeur=13 self.zoom_hauteur=13 self.force_joueur = 10 self.hp_joueur = 200 inventaire_joueur = Inventaire() pygame.init() #poids permettants de manipuler l'aléatoire self.poids=[6,2,1,2] #salle pour exp monstres self.salles.append(Patern((4,0),2,10,self.LARGEUR_CASE,self.LARGEUR_MUR,[[0,9],[1,9]])) #génération du labyrinthe self.lab=Labyrinthe(self.CASES_X,self.CASES_Y,5,59,self.LARGEUR_CASE,self.LARGEUR_MUR,self.poids,self.salles) self.lab.generation() self.lab.casser_X_murs(0.2) mat_lab=self.lab.getMatrice_cases() self.lab.matrice_cases=mat_lab if res : self.lab.resolution(5,59,4,0,"Largeur") pygame.display.set_caption("test") self.screen = pygame.display.set_mode((FENETRE_X,FENETRE_Y),pygame.RESIZABLE) self.screen.fill((0,0,0)) #entitées self.joueur=Joueur(inventaire_joueur,self.hp_joueur,self.force_joueur,2,self.zoom_largeur,self.zoom_hauteur,(4,0)) self.monstres=[Fatti([5,17],10,10,100,5,1,0,(0,0,100)),Fatti([8,25],10,10,100,5,1,1,(0,0,100)),Fatti([3,48],10,10,100,5,1,2,(0,0,100)),Fatti([5,59],10,10,100,5,1,3,(0,0,100))] self.entitees=[self.joueur] elif niveau == 3: #niveau monstrueux sans labyrinthe pour apprendre à se battre self.CASES_X = 10 self.CASES_Y = 60 res = False self.salles=[Patern((1,13),8,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1],[5,7]]),Patern((1,25),6,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1],[5,7]]),Patern((2,40),8,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1],[5,7]]),Patern((4,52),5,8,self.LARGEUR_CASE,self.LARGEUR_MUR,[[4,-1]])] #variables correspondants a la largeur et la hauteur du zoom self.zoom_largeur=13 self.zoom_hauteur=13 self.force_joueur = 10 self.hp_joueur = 200 inventaire_joueur = Inventaire() pygame.init() #poids permettants de manipuler l'aléatoire self.poids=[6,2,1,2] #salle pour exp monstres self.salles.append(Patern((4,0),2,10,self.LARGEUR_CASE,self.LARGEUR_MUR,[[0,9],[1,9]])) #génération du labyrinthe self.lab=Labyrinthe(self.CASES_X,self.CASES_Y,5,59,self.LARGEUR_CASE,self.LARGEUR_MUR,self.poids,self.salles) self.lab.generation() self.lab.casser_X_murs(0.2) mat_lab=self.lab.getMatrice_cases() self.lab.matrice_cases=mat_lab if res : self.lab.resolution(5,59,4,0,"Largeur") pygame.display.set_caption("test") self.screen = pygame.display.set_mode((FENETRE_X,FENETRE_Y),pygame.RESIZABLE) self.screen.fill((0,0,0)) #entitées self.joueur=Joueur(inventaire_joueur,self.hp_joueur,self.force_joueur,2,self.zoom_largeur,self.zoom_hauteur,(4,0)) self.monstres=[Slime([5,17],10,10,100,5,1,0,(0,0,100)),Fatti([8,25],10,10,100,5,1,1,(0,0,100)),Runner(self.lab.getMatrice_cases(),5,59,[3,48],10,10,100,5,1,2,(0,0,100)),Fatti([5,59],10,10,100,5,1,3,(0,0,100))] self.entitees=[self.joueur] elif niveau == 4: #niveau monstrueux sans labyrinthe pour apprendre à se battre self.CASES_X = 15 self.CASES_Y = 15 res = False self.salles=[Patern((3,0),3,15,self.LARGEUR_CASE,self.LARGEUR_MUR,[[0,13],[2,1]]),Patern((6,0),3,15,self.LARGEUR_CASE,self.LARGEUR_MUR,[[0,1],[2,13]]),Patern((9,0),3,15,self.LARGEUR_CASE,self.LARGEUR_MUR,[[0,13],[2,1]]),Patern((12,0),3,15,self.LARGEUR_CASE,self.LARGEUR_MUR,[[0,1]])] #variables correspondants a la largeur et la hauteur du zoom self.zoom_largeur=13 self.zoom_hauteur=13 self.force_joueur = 10 self.hp_joueur = 200 inventaire_joueur = Inventaire() pygame.init() #poids permettants de manipuler l'aléatoire self.poids=[6,2,1,2] #salle pour exp monstres self.salles.append(Patern((0,0),3,15,self.LARGEUR_CASE,self.LARGEUR_MUR,[[2,13]])) #génération du labyrinthe self.lab=Labyrinthe(self.CASES_X,self.CASES_Y,self.CASES_X-1,self.CASES_Y-1,self.LARGEUR_CASE,self.LARGEUR_MUR,self.poids,self.salles) self.lab.generation() self.lab.casser_X_murs(0.0) mat_lab=self.lab.getMatrice_cases() self.lab.matrice_cases=mat_lab if res : self.lab.resolution(self.CASES_X-1,self.CASES_Y-1,0,0,"Largeur") pygame.display.set_caption("test") self.screen = pygame.display.set_mode((FENETRE_X,FENETRE_Y),pygame.RESIZABLE) self.screen.fill((0,0,0)) #entitées self.joueur=Joueur(inventaire_joueur,self.hp_joueur,self.force_joueur,2,self.zoom_largeur,self.zoom_hauteur) self.monstres=[Slime([1,5],10,10,100,5,1,1,(0,0,100)),Slime([2,12],10,10,100,5,1,1,(0,0,100)),Slime([0,12],10,10,100,5,1,1,(0,0,100)),Slime([1,13],10,10,100,5,1,1,(0,0,100)),Slime([2,8],10,10,100,5,1,1,(0,0,100)),Slime([0,8],10,10,100,5,1,1,(0,0,100)),Slime([1,9],10,10,100,5,1,1,(0,0,100)),Slime([2,10],10,10,100,5,1,1,(0,0,100)),Slime([0,10],10,10,100,5,1,1,(0,0,100)),Slime([1,11],10,10,100,5,1,1,(0,0,100)),Slime([7,5],10,10,100,5,1,2,(0,0,100)),Slime([8,12],10,10,100,5,1,2,(0,0,100)),Slime([6,12],10,10,100,5,1,2,(0,0,100)),Slime([7,13],10,10,100,5,1,2,(0,0,100)),Slime([8,8],10,10,100,5,1,2,(0,0,100)),Slime([6,8],10,10,100,5,1,2,(0,0,100)),Slime([7,9],10,10,100,5,1,2,(0,0,100)),Slime([8,10],10,10,100,5,1,2,(0,0,100)),Slime([6,10],10,10,100,5,1,2,(0,0,100)),Slime([7,11],10,10,100,5,1,2,(0,0,100))] self.entitees=[self.joueur] for i in range(0,len(self.monstres)): self.entitees.append(self.monstres[i]) #objet qui traite les collisions self.collision=Collision() #événements self.evenements=[] #objet d'affichage self.affichage=Affichage(self.screen,self.mode_affichage,self.LARGEUR_CASE,self.LARGEUR_MUR) #texte de fin font = pygame.font.SysFont(None, 72) self.textWin = font.render("Vous avez gagné!! \(^o^)/", True, (128, 0, 0)) self.textLose = font.render("Vous avez perdu!! ;o;", True, (0, 128, 128)) self.position_screen=(0,0) def run(self): run=True self.redraw() #objet qui permet de gérer le temps en pygame clock = pygame.time.Clock() #nb de frames que le joueur doit attendre entre chaque action cooldown_joueur=3 compteur_j=0 #nb de frames que les monstres doivent attendre entre chaque action cooldown_monstres=20 compteur_m=0 while run: #on cadence à 60 frames/sec clock.tick(60) move_j = False move_m=False #si l'utilisateur décide de mettre fin au programme on sort de la boucle for event in pygame.event.get(): if event.type==pygame.QUIT: run=False if event.type == pygame.VIDEORESIZE: self.zoom_largeur = event.w//(self.LARGEUR_CASE + self.LARGEUR_MUR) self.zoom_hauteur = event.h//(self.LARGEUR_CASE + self.LARGEUR_MUR) self.redraw() #partie gérant le joueur if compteur_j==0: compteur_j=cooldown_joueur self.action_joueur() vue,position=self.actualiser_vue(self.joueur.getPosition(),self.joueur.largeur_vue,self.joueur.hauteur_vue) self.joueur.actualiser_vue(vue,position) self.joueur=self.actualiser_donnee(self.joueur) move_j=self.traitement_action(self.joueur) else: compteur_j-=1 #partie gérant les monstres if compteur_m==0: compteur_m=cooldown_monstres move_m=self.actions_entitees() else: compteur_m-=1 #si on détecte un mouvement on redessine l'écran #if move_j or move_m: self.redraw() self.traitement_evenements() if self.lab.as_gagner(self.joueur.getPosition()): self.ecran_fin_niveau(self.textWin) run=False if self.as_perdu(): self.ecran_fin_niveau(self.textLose) run=False pygame.display.update() def traitement_evenements(self): """ Fonction qui traite les événements """ events_tmps=[self.evenements[i] for i in range(0,len(self.evenements))] nbSup=0 for i in range(0,len(events_tmps)): #print (events_tmps) if events_tmps[i].execute(): self.evenements.pop(i-nbSup) nbSup+=1 def action_joueur(self): """ Fonction qui exécute la partie du code ou le jpueur demande à agir et qui renvoie rien """ #on récupère toutes les touches préssés sous forme de keys=pygame.key.get_pressed() if keys[pygame.K_UP]: self.joueur.va_vers_le_haut() elif keys[pygame.K_DOWN]: self.joueur.va_vers_le_bas() elif keys[pygame.K_RIGHT]: self.joueur.va_vers_la_droite() elif keys[pygame.K_LEFT]: self.joueur.va_vers_la_gauche() elif keys[pygame.K_SPACE]: self.joueur.attaque() def actions_entitees(self): """ Fonction qui exécute les actions des entitées renvoie un booléen indiquant si il y a besoin de redessiner l'écran """ redessiner=False agissants=self.getAgissants() self.actualiser_vues_agissants(agissants) for agissant in agissants: agissant=self.actualiser_donnee(agissant) agissant.prochaine_action() if redessiner: self.traitement_action(agissant) else: redessiner=self.traitement_action(agissant) #print(redessiner,type(entitee)) self.delete_entitees() return redessiner def getAgissants(self): """ Fonction qui renvoie un tableau contenant les agissants """ agissants=[] for entitee in self.entitees: if issubclass(type(entitee),Agissant): agissants.append(entitee) return agissants def delete_entitees(self): """ Fonction qui supprime les entitees mortes """ nbSupp=0 for i in range(0,len(self.entitees)): if issubclass(type(self.entitees[i-nbSupp]),Agissant): if self.entitees[i-nbSupp].pv<=0: self.entitees.pop(i-nbSupp) nbSupp+=1 elif issubclass(type(self.entitees[i-nbSupp]),Item): if self.entitees[i-nbSupp].position==None: self.entitees.pop(i-nbSupp) nbSupp+=1 def actualiser_vues_agissants(self,agissants): """ Fonction qui actualise la vue de touts les agissants (meutes inclues) Entrée: -les agissants """ for agissant in agissants: #l'id 0 indique que l'entitée n'appartient a aucune meute if not(issubclass(type(agissant),Monstre)) or agissant.id_meute==0: #on actualise la vue de l'entitée seule vue_entitee,position_vue=self.actualiser_vue(agissant.getPosition(),agissant.getLargeurVue(),agissant.getHauteurVue()) agissant.actualiser_vue(vue_entitee,position_vue) id_meutes=[0] meute=Meute(self.CASES_X,self.CASES_Y) for agissant in agissants: #on vérifie si on n'as pas déja executée la meute de l'entitée if issubclass(type(agissant),Monstre) and not(agissant.id_meute in id_meutes): id_meutes.append(agissant.id_meute) #on récupère les données de la vue de la meute vues,positions=self.recuperer_vues_meute(agissant.id_meute) #on crée la vue de la meute vue_meute=meute.actualisation_vues(vues,positions) #on actualise les vues des monstres de la meute for agissant_bis in agissants: if issubclass(type(agissant_bis),Monstre): if agissant_bis.id_meute==agissant.id_meute: agissant_bis.actualiser_vue(vue_meute,[0,0]) def recuperer_vues_meute(self,identifiant): """ Fonction qui doit renvoyer les vues nécessaires a une meute Entrées: -l'identifiant de la meute Sorties: -les vues des monstres -les positions des vues """ vues=[] positions=[] for entitee_bis in self.entitees: if issubclass(type(entitee_bis),Monstre): if entitee_bis.id_meute==identifiant: vue_entitee,position_vue=self.actualiser_vue(entitee_bis.getPosition(),entitee_bis.getLargeurVue(),entitee_bis.getHauteurVue()) vues.append(vue_entitee) positions.append(position_vue) return vues,positions def actualiser_vue(self,position,largeur_vue,hauteur_vue): """ Fonction qui construit la vue d'un agissant Entrée: -la position de la vue de l'agissant -la largeur de la vue de l'agissant -la hauteur de la vue de l'agissant Sortie: -la vue de l'agissant -la position de la vue de l'agissant """ vue_agissant,position_vue=self.lab.construire_vue(position,largeur_vue,hauteur_vue) return vue_agissant,position_vue def actualiser_donnee(self,agissant): """ Fonction qui actualise les données des agissant en fonction de leur type Entrée: un agissant Sortie: un agissant avec ces données actualisées """ if issubclass(type(agissant),Monstre): #on donne la position du joueur au monstre agissant.setPosition_joueur(self.joueur.getPosition()) elif type(agissant)==Joueur: self.action_joueur() return agissant def traitement_action(self,agissant): """ Fonction qui traite une action donnée d'un agissant et qui renvoie un booléen indiquant si l'action à été exécutée """ succes=False id_action,action=agissant.get_action() #print(type(agissant),id_action,action) if id_action==BOUGER: #print("veut bouger") direction_voulue=action if direction_voulue!=None: if issubclass(type(agissant),Joueur): passe,newcoord=self.lab.peut_passer(agissant.getPosition(),direction_voulue,agissant.inventaire) else: passe,newcoord=self.lab.peut_passer(agissant.getPosition(),direction_voulue) #print(passe) if passe: libre = self.collision.case_libre(agissant,newcoord,self.entitees) #print(libre) if libre: succes=True #print(succes) agissant.setPosition(newcoord) if agissant == self.joueur: nouveaux_evenements = self.collision.visite_case(newcoord,agissant,self.entitees) for evenement in nouveaux_evenements : self.evenements.append(evenement) elif id_action==ATTAQUER: self.affichage.ajout_animation(agissant.getPosition(),0,3,agissant.getRadius()*(self.LARGEUR_CASE+self.LARGEUR_MUR)) succes=self.collision.tentative_attaque(agissant,self.entitees) return succes def as_perdu(self): """ Fonction qui vérifie si le joueur as perdu(pv=0 ou soft lock) """ return (self.joueur.pv<=0) def ecran_fin_niveau(self,text): """ Fonction qui as pour but d'afficher l'écran de fin de niveau (stats etc) """ self.screen.fill((255,255,255)) self.screen.blit(text,(0,0)) def redraw(self): """ Fonction qui redessine l'entièreté de l'écran """ self.affichage.dessine_frame(self.joueur,self.lab,self.entitees,self.evenements)