def __init__(self, J1, J2, t_jeux, main1, main2):
self.J1 = Joueur(J1, t_jeux, main1)
self.J2 = Joueur(J2, t_jeux,
main2) # valeur par défaut qui sera modifiée
self.jeuCartes = JeuCartes(
t_jeux) # valeur par défaut qui sera modifiée
def test():
jeuxCarte = JeuCartes(52)
print(jeuxCarte.getTailleJeu())
main = jeuxCarte.creerJeu()
a = jeuxCarte.distribuerJeu(2, jeuxCarte.getTailleJeu())
d = jeuxCarte.distribuerJeu(2, jeuxCarte.getTailleJeu())
jeuxCarte.melanger()
j1 = Joueur("Rob", jeuxCarte.getTailleJeu(), a)
j2 = Joueur("Pablo", jeuxCarte.getTailleJeu(), a)
b = Bataille(j1, j2, jeuxCarte.getTailleJeu(), a, d)
print(b.jouer())
def jouer(self, nbTours):
# Distribution de 26 cartes à 2 joueurs
distribution_2j_26c = self.jeu.distribuerJeu(2, 26)
# Creer 2 joueurs
joueur1 = Joueur('Joueur1', 26)
listeCartes1 = distribution_2j_26c[0]
joueur1.setMain(listeCartes1)
joueur2 = Joueur('Joueur2', 26)
listeCartes2 = distribution_2j_26c[1]
joueur2.setMain(listeCartes2)
# Debut du jeu
print('Debut: ', joueur1.getNbCartes(), joueur2.getNbCartes())
# Jouer nbTours tours
for i in range(nbTours):
carte_joueur1 = joueur1.jouerCarte()
carte_joueur2 = joueur2.jouerCarte()
print('La carte du jouer', joueur1.getNom(), 'est:',
carte_joueur1.getNom(), 'de', carte_joueur1.getCouleur())
print('La carte du jouer', joueur2.getNom(), 'est:',
carte_joueur2.getNom(), 'de', carte_joueur2.getCouleur())
# Si la carte de joueur 1 est plus fort que celle de joueur 2
# Joueur 1 recupere sa carte ainsi que la carte de joueur 2
if carte_joueur1.estSuperieureA(carte_joueur2):
print('Le joueur', joueur1.getNom(), 'a gagne ce tour')
joueur1.insererMain([carte_joueur1, carte_joueur2])
# Si la carte de joueur 1 est moins fort que celle de joueur 2
# Joueur 2 recupere sa carte ainsi que la carte de joueur 1
elif carte_joueur1.estInferieureA(carte_joueur2):
print('Le joueur', joueur2.getNom(), 'a gagne ce tour')
joueur2.insererMain([carte_joueur1, carte_joueur2])
# Si l'egalite des cartes de deux joueurs
# Chacun recupere sa carte
elif carte_joueur1.egalite(carte_joueur2):
print('Egalite!')
joueur1.insererMain([carte_joueur1])
joueur2.insererMain([carte_joueur2])
print('Nombre de carte en sortie du dernier coup:')
print('NbCarte de', joueur1.getNom(), joueur1.getNbCartes())
print('NbCarte de', joueur2.getNom(), joueur2.getNbCartes())
# Fin du jeu si l'un des joueurs n'a plus de carte
if joueur1.getNbCartes() == 0 or joueur2.getNbCartes() == 0:
print('Fin du jeu !')
break
def __init__(self):
"""Constructeur de la classe Plateau
Un plateau possède :
- un nombre de ligne,
- un nombre de colonnes,
- deux joueurs.
"""
self.ligne = 19
self.colonne = 17
self.j1 = Joueur('A', self.ligne-1, 1, 8)
self.j2 = Joueur('B', 0, self.ligne-2, 8)
self.initTabDeJeu()
def __init__(self, master=None):
"""
Constructeur de l'application
Initialise tous les éléments visuels, sonores et touches
@param master: Fenetre mère tkinter
"""
self.canvas = None
self.main_frame = None
self.hp_canvas = None
self.frameHeros = None
self.rows = None
self.ennemies = None
self.vague = 1
super().__init__(master)
self.master = master
self.pack(fill="both")
self.score = Score()
self.create_HPBAR()
self.create_MAIN()
self.hero = Joueur(ask_name())
self.drawJoueur()
self.init_game(fullreset=True)
self.pause()
self.init_sound()
self.init_touch_binding()
def __init__(self,
plateau=p.Plateau(),
pioche=[None for i in range(9)],
nbJoueurs=1):
"""
Initialise le jeu.
1 - Recupère le plateau de jeu
2 - Recupère les cartes de la pioche
3 - Cree les joueurs avec la methode definie dans Joueur.py
4 - Verifie que toutes les variables sont bien instanciees
Paramètres
----------
plateau: le plateau de jeu pour la partie
pioche: une liste de cartes
"""
self.plateau = plateau
self.pioche = pioche
self.step = 0
self.__finSequence = False
self.__hasPicked = False #est-ce que l'humain a pioché correctement?
# nbJoueurs = int(input("Nombre de joueurs?"))
self.nbJoueurs = nbJoueurs
try:
self.listeJoueurs = [
j.Joueur(self.plateau.listeEtatsDepart[i])
for i in range(nbJoueurs)
]
except IndexError:
print('les positions de départ ne sont pas définies')
for joueur in self.listeJoueurs:
joueur.murs = self.plateau.listeMurs
def __init__(self, personages, nbJoueurs, socket):
#self.user = ""
self.chat = ""
self.nbJoueurs = nbJoueurs
self.players = [
Joueur("no one", personages) for i in xrange(0, nbJoueurs)
]
self.perso = ""
self.root = Tk()
self.personages = personages
self.cptJoueurs = 0
self.socket = socket
self.root.title("Loup Garou")
s = Label(text="Bienvenue", font=(('Times'), 20))
s.grid(row=2, column=0)
N = Label(
text="Nouvelle partie de Loup Garou\n \nVeuillez entrer votre nom")
N.grid(row=3, column=0)
self.e = Entry(self.root)
self.e.focus_set()
self.e.grid(row=4, column=0)
play = Button(text="Play", width=50, command=self.Play)
play.grid(row=6, column=0)
self.root.mainloop()
def __init__(self):
"""
Attributs de la classe Plateau :
- nombre de colonnes
- nombre de lignes
- Joueur 1
- Joueur 2
"""
self.ligne = 19
self.colonne = 17
self.j1 = Joueur('A', 8, 1)
self.j2 = Joueur('B', 8, 17)
# Ajout de la liste pour obtenir un tableau à 2 dimensions.
for i in range(self.ligne):
self.tab.append([])
"""
Remplissage du tableau :
5 : zone d'arrivée pour le joueur B
7 : zone d'arrivée pour le joueur A
0 : cellule vide (pour les déplacements du joueur)
m : cellule pour la pose des murs
PS : schéma à l'appui pour plus de details.
"""
if (i == 0):
for c in range(self.colonne):
self.tab[i].append(5)
elif (i == self.ligne - 1):
for c in range(self.colonne):
self.tab[i].append(7)
elif (i % 2 == 0):
for c in range(self.colonne):
self.tab[i].append('m')
else:
for c in range(self.colonne):
if (c % 2 == 0):
self.tab[i].append(0)
else:
self.tab[i].append('m')
# Ajout des joueurs au centre de chaque extrémité du plateau.
self.tab[self.j1.y][self.j1.x] = self.j1.letter
self.tab[self.j2.y][self.j2.x] = self.j2.letter
def main():
#Placement des bateaux (la fonction creerBateau est appelee a l interieur de entrerBateau avec les informations entrees par l utilisateur)
print("Joueur 1")
b11 = entrerBateau(1)
b12 = entrerBateau(2)
b13 = entrerBateau(3)
b14 = entrerBateau(3)
b15 = entrerBateau(4)
print("Joueur 2")
b21 = entrerBateau(1)
b22 = entrerBateau(2)
b23 = entrerBateau(3)
b24 = entrerBateau(3)
b25 = entrerBateau(4)
#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)
#Boucle de jeu
while (j1.nbBateauxRestants() != 0) and (j2.nbBateauxRestants() != 0):
print("Joueur" + str(tour + 1) + " " + " choisit une position de tir")
x = input("Coordonnee x : ")
y = input("Coordonnee y : ")
if tour == 1:
tir = Tir(x, y, j1)
else:
tir = Tir(x, y, j2)
print(tir.resultatTir())
# Dans resultatTir on appelle les fonctions verifierEnVue, etatPosition et nbBateauxRestants
if tour == 1:
tour += 1
else:
tour -= 1
if (j1.nbBateauxRestants == 0):
print("Joueur 2 a gagne")
else:
print("Joueur 1 a gagne")
def create_players(self):
"""This method create the players instances"""
count = 0
for i in range(4):
if self._active_players[i] == 'Active':
count += 1
self.players[count] = Joueur(count, False, self._colors[i + 1],
self._ui)
elif self._active_players[i] == 'CPU':
count += 1
self.players[count] = Joueur(count, True, self._colors[i + 1],
self._ui,
self._ui.get_difficulty(count))
for i in self.players:
print("Giocatore {}: id={} Color={} AI={} Difficulty={}".format(
i, self.players[i]._id, self.players[i]._color,
self.players[i].isAI, self.players[i].difficulty))
return count
def testsTir():
b1 = Bateau(1, "verticale", 2, 12)
b2 = Bateau(1, "verticale", 3, 12)
b3 = Bateau(1, "verticale", 4, 12)
b4 = Bateau(1, "verticale", 5, 12)
b5 = Bateau(1, "verticale", 6, 12)
joueur1 = Joueur([b1, b2, b3, b4, b5])
tir = Tir(1, 18, joueur1)
assert ((tir.resultatTir() == "coulé") or (tir.resultatTir() == "touche")
or (tir.resultatTir() == "en vue")
or (tir.resultatTir() == "à l'eau")), "erreur_resultatTir"
assert (tir.resultatTir() == "en vue") and (tir.verifierEnVue()
== True), "erreur_resultatTir"
assert (Tir(-2, 3, joueur1) == "erreur"), "erreur_resultatTir"
assert (Tir(5, 21, joueur1) == "erreur"), "erreur_resultatTir"
def creerplanetes(self, joueurs):
bordure = 10
for i in range(100):
x = random.randrange(self.largeur - (2 * bordure)) + bordure
y = random.randrange(self.hauteur - (2 * bordure)) + bordure
self.planetes.append(Planete(x, y))
np = len(joueurs)
planes = []
while np:
p = random.choice(self.planetes)
if p not in planes:
planes.append(p)
self.planetes.remove(p)
np -= 1
couleurs = [
"red", "blue", "lightgreen", "yellow", "lightblue", "pink", "gold",
"purple"
]
for i in joueurs:
self.joueurs[i] = Joueur(self, i, planes.pop(0), couleurs.pop(0))
def __init__(self):
self.screen = pygame.display.set_mode((WindowW, WindowH))
self.clock = pygame.time.Clock()
self.running = True
self.state = 'start'
self.caseW = MazeW//COLONNES
self.caseH = MazeH//LIGNES
self.joueur = Joueur(self, JOUEUR_START_POS)
self.case_vides = [] # 0
self.murs = [] # 5
self.bouffes = [] # 1
self.Gbouffes = [] # 8
self.porte = [] # P
self.f_nope = [] # N
self.all = [] # Toutes les cases
self.fantomes = []
self.f_pos = []
#self.make_fantomes()
self.load()
def testJoueur():
#Instancier un joueur
j1 = Joueur()
B1 = Bateau(0, 0, 0, 4)
B2 = Bateau(0, 0, 0, 4)
if (not (testCreation(j1))):
print("TEST creation FAIL")
return False
if (not (testAjoutBateau(j1, B1))):
print("TEST testAjoutBateau FAIL")
return False
if (testAjoutBateau(j1, B2)):
print("TEST testAjoutBateau déjà occupé FAIL")
return False
if (not (testSeFaitTirerEstTouche(j1, 0, 0))):
print("TEST testSeFaiTirerEstTouche FAIL")
return False
if (not (testSeFaitTirerEnVue(j1, 0, 10))):
print("TEST testSeFaitTirerEnVue FAIL")
return False
if (not (testSeFaitTirerAleau(j1, 20, 20))):
print("TEST testSeFaitTirerAleau FAIL")
return False
if (not (testViser(j1))):
print("TEST testViser FAIL")
return False
#On coule B1
j1.seFaitTirer(0, 0)
j1.seFaitTirer(0, 1)
j1.seFaitTirer(0, 2)
j1.seFaitTirer(0, 3)
j1.seFaitTirer(0, 4)
if (not (testAperdu(j1))):
print("TEST testAperdu FAIL")
return False
return True
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)
import threading
import sys
import random as rd
#initialisation de la partie
nb_joueurs = int(sys.argv[1])
personages = ["Loup garou", "Villageois"]
players = []
#On a ttribue le bon nombre de loups garous (et autres personages)
for i in xrange(0, nb_joueurs):
perso = "Villageois"
if (i < int(nb_joueurs / 2)):
perso = personages[0]
players.append(Joueur("no one", perso))
#on melange aleatoirement les joueurs
rd.shuffle(players)
cptJoueurs = 0
threads = []
#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)
global nomMort
print "En attente de connexion"
connexion_avec_client, infos_connexion = connexion_principale.accept(
)
print("Nouveau Joueur connecté !")
nom, prenom = tuple(
connexion_avec_client.recv(1000).decode('utf8').split(','))
for j in joueurs:
j.soc.send(
str("Nouveau joueur connecté : " + nom + " " +
prenom).encode('utf8'))
print("info connexion : " + str(infos_connexion))
connexion_avec_client.send(
str("Bienvenue au quiz " + prenom).encode('utf8'))
p = joueur.Joueur(nom, prenom, infos_connexion[0],
infos_connexion[1], connexion_avec_client, 0,
'waiting')
print(p)
joueurs.append(p)
if len(joueurs) >= 2:
for x in joueurs:
x.soc.send(
"Envoyez 'start' pour lancer le jeu ...".encode(
"utf8"))
elif len(joueurs) == 1:
p.soc.send(
"Veuillez patienter que au moins 2 joueurs se connectent... "
.encode("utf8"))
sockets.append(connexion_avec_client)
#to exit the server safly
default="0")
options, args = parser.parse_args(sys.argv)
if __name__ == '__main__':
read_opt()
# Création d'une nouvelle partie
game = PyGo(options.size)
# Création des joueurs
p1 = None
p2 = None
# Joueur noir
if options.player1 == "" or options.player1 == "player1":
p1 = Joueur(0, game)
else:
filename = options.player1
filename = filename[:-3]
exec("from " + filename + " import " + filename)
exec("p1 = " + filename + "(0, game)")
# Joueur blanc
if options.player2 == "" or options.player2 == "player2":
p2 = Joueur(1, game, score=options.komi)
else:
filename = options.player2
filename = filename[:-3]
exec("from " + filename + " import " + filename)
exec("p2 = " + filename + "(1, game, score = options.komi)")
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 est_finit(self):
for domino in
def gagnant(self):
if self.est_finit():
if self.joueur_1 == self.perdant:
return self.joueur_2
else:
return self.joueur_1
if __name__ == "__main__":
d1 = Domino(3,2)
d2 = Domino(2,3)
d3 = Domino(6,2)
d4 = Domino(4,3)
joueur1 = Joueur("Toto")
joueur2 = Joueur("Titi")
joueur1.ajoute_a_la_main(d1)
joueur2.ajoute_a_la_main(d2)
joueur1.ajoute_a_la_main(d3)
joueur2.ajoute_a_la_main(d4)
jeu = JeuDeDomino(joueur1, joueur2)
jeu.affiche()
jeu.ajoute_en_queue(d1, joueur1)
jeu.affiche()
jeu.ajoute_en_tete(d2, joueur2)
jeu.affiche()
jeu.jouer(d3, joueur1)
jeu.affiche()
jeu.jouer(d4, joueur2)
print("Est-fini ?", jeu.est_finit())
# 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 :
def __init__(self):
self.joueur1 = Joueur("Toto")
self.joueur2 = Joueur("Titi")
self.jeuDeCarte = PaquetCartes()
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")
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)
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: "))
while (y1 < 0 or y1 > 20):
y1 = int(input("Entrez un y de depart: "))
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: "))
while (y1 < 0 or y1 > 20):
y1 = int(input("Entrez un y de depart: "))
while (x2 < 0 or x2 > 20):
x2 = int(input("Entrez un x de fin: "))
while (y2 < 0 or y2 > 20):
y2 = int(input("Entrez un y de fin: "))
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 = joueurs[courant].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
