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)
