def demandeTir():
header()
print Partie.get_JoueurActif().get_NomJoueur()+" >> TIR : "
X = int(raw_input("X: "))
Y = int(raw_input("Y: "))
PosTir = Position(X,Y)
Resultat(PosTir,Partie.get_nextJoueur().get_Grille())
raw_input("Joueur suivant")
def afficherGagnant():
header()
print "===================================\n"
print "== FIN DE PARTIE ==\n"
print "===================================\n"
print "+GAGNANT: "+Partie.get_nextJoueur().get_NomJoueur()+"\n\n"
print "-Dommage "+Partie.get_JoueurActif().get_NomJoueur()+", vous avez perdu !\n\n"
print "===> Merci d'avoir joué ! ;)\n"
raw_input("'Entrée' pour quitter.")
def reset(self):
filename = FileChooser().get_filename()
questions = Reader(filename).get_questions()
if questions is None:
return False
self.partie = Partie(questions)
# reset game
self.partie.reset()
self.plateau.reset()
self.sound_manager.reset()
self.sound_manager.play_generic()
return True
def generer(self):
"""
Permet de generer la partie avec les paramètres choisi par le joueur
Paramètres
----------
Return
------
"""
nb_moy = self.ui.nb_IA_moyenne_choisi()
nb_fac = self.ui.nb_IA_facile_choisi()
nb_hn = self.ui.nb_Hn_choisi()
print(nb_hn,nb_fac,nb_moy)
self.partie = Partie(nb_fac,nb_moy,nb_hn,self)
self.carte=self.partie.carte
self.ui.lcdNumber_Metal.display(self.partie.L_joueur[0].metal_tot)
self.ui.lcdNumber_Energie.display(self.partie.L_joueur[0].energie_tot)
self.__xmax = Constante.xmax
self.__ymax = Constante.ymax
self.Epp = Constante.Ep_app
self.H=Constante.H_Z_Constructible
self.L=Constante.L_Z_Constructible
self.x_inf_b = (self.__xmax - self.L )//2 +1
self.x_sup_b= (self.__xmax + self.L )//2 -1
self.y_inf_b = (self.__ymax - self.H )//2 +1
self.y_sup_b = (self.__ymax + self.H)//2 -1
self.x_inf = (self.__xmax )//2 -1
self.x_sup = (self.__xmax)//2 +2
self.y_inf = (self.__ymax)//2 - 1
self.y_sup = (self.__ymax)//2 +2
def __init__(self):
super().__init__()
# Configuration de l'interface utilisateur.
self.ui = Ui_Minima_Accueil()
self.ui.setupUi(self)
self.ui.Bouton_Generer.clicked.connect(self.generer)
self.ui.Bouton_Findetour.clicked.connect(self.un_Tour)
self.partie = Partie(1, 1)
self.ui.lcdNumber_Metal.display(self.partie.L_joueur[0].metal_tot)
self.ui.lcdNumber_Energie.display(self.partie.L_joueur[0].energie_tot)
def IA_coup(self, plateau):
situation = plateau2mini(plateau, self)
situationConnue = situation in self.situationsConnues
loiProba = [] if not situationConnue else self.situationsConnues[situation]
pourcentageVictoires = 0
coupsConnusPre = len(loiProba)
if self.apprentissageVolee:
debut = time.time()
nbParties = 0
from Partie import Partie
while time.time() - debut < 3: #3 secondes
partie = Partie(self.situationsConnues, situation)
partie.interaction()
nbParties += 1
nbGagnants = 0 if situation not in self.situationsConnues else len(self.situationsConnues[situation])
pourcentageVictoires = 100 * (nbGagnants - coupsConnusPre) / nbParties
loiProba = [] if situation not in self.situationsConnues or len(self.situationsConnues[situation]) < 30 else self.situationsConnues[situation]
if self.apprentissageVolee:
coup = coupPlusFrequent(self.situationsConnues[situation])
self.coups[situation] = coup
return coup, pourcentageVictoires
for i in range(1, 5+1):
if i not in loiProba and not self.pieces[i-1].arrive():
loiProba.append(i)
coup = choice(loiProba)
self.coups[situation] = coup
return coup, pourcentageVictoires
def demandeNoms():
header()
NomJoueur = raw_input("Joueur 1>> Votre nom: ")
Partie.get_joueur1().set_NomJoueur(NomJoueur)
NomJoueur = raw_input("Joueur 2>> Votre nom: ")
Partie.get_joueur2().set_NomJoueur(NomJoueur)
print "Joueur 1 : "+Partie.get_joueur1().get_NomJoueur()
print "Joueur 2 : "+Partie.get_joueur2().get_NomJoueur()
def testSave(self):
"""
Test vérifiant que, sur une partie avec 3 joueurs humains qui vient juste
d'être initialisée :
*Que le nom de la sauvegarde (appelée blob.txt ici) est bien correct.
*Que la sauvegarde possède le bon nombre de lignes (34 ici).
*Que la dernière ligne de la sauvegarde est correcte.
"""
Game = Partie(0,3)
Carte = Game.carte
Save = sl.Save("blob",Carte)
self.assertEqual(Save.Nme,"blob.txt")
with open(Save.Nme, 'r') as f:
List_Save = [line.strip() for line in f]
self.assertEqual(len(List_Save),56)
self.assertEqual(List_Save[-1],"Fin sauvegarde")
def testInit_Hn(self):
"""
Test vérifiant :
*Que tous les joueurs humains ont bien été crées. (3, d'après
le paramètre d'entrée de Game)
*Que le premier joueur humain est bien un défenseur, avec le bon
nombre de métal et d'énergie initial.
*Que l'objet Game est bien une instance de la classe Partie.
"""
Game = Partie(0,3)
self.assertEqual(Game.nb_hn,0)
self.assertEqual(len(Game.L_joueur),3)
self.assertEqual(Game.L_joueur[0]._role,'DH')
self.assertEqual(Game.L_joueur[0].metal_tot,Constante.metal_tot)
self.assertEqual(Game.L_joueur[0].energie_tot, Constante.energie_tot)
self.assertIsInstance(Game,Partie)
async def back(ctx):
stop = await phaseTestsMsg(ctx)
if stop: return
if ctx.author not in partiesParJoueur:
await ctx.send(
"Vous ne pouvez pas utiliser cette commande sans être dans une partie !"
)
return
partie = partiesParJoueur[ctx.author]
infosPartie = parties[partie]
if len(minisParPartie[partie]) < 2:
await ctx.send(
"Vous ne pouvez pas utiliser cette commande au début de la partie !"
)
return
miniPrec = minisParPartie[partie][
-2] #on récupère la mini de la situation précédente
#on fait une nouvelle partie qui part de là
nouvPartie = Partie(situationsConnues, miniPrec, True, False, False,
False, True)
#on met à jour les enregistrements qu'il faut
for joueur in infosPartie["joueurs"]:
partiesParJoueur[joueur] = nouvPartie
joueurEnCours = infosPartie["joueurs"][partie.idJoueur]
parties[nouvPartie] = infosPartie.copy()
del parties[partie]
minisParPartie[nouvPartie] = minisParPartie[partie][:-1]
del minisParPartie[partie]
#on demande au joueur en cours de rejouer
await affichePlateau(ctx, nouvPartie)
await ctx.send("À votre tour joueur {} {}".format(
nouvPartie.idJoueur + 1, joueur.mention))
def placerBateaux(i=0):
# i = BateauCourant
while (Partie.get_JoueurActif().get_Bateaux().get_NombreBateauxNonPlaces() > 0):
header()
print "===> Placer vos bateaux <====\n"
print Partie.get_JoueurActif().get_NomJoueur()+" >> "+str(Partie.get_JoueurActif().get_Bateaux().get_NombreBateauxNonPlaces())+ " bateaux à placer."
print "Bateau selectionné: \nTaille:"+str(Partie.get_JoueurActif().get_Bateaux().get_Bateau(i).get_taille())+"\n"
print("Entrez une coordonnee: ")
X = int(raw_input("X: "))
Y = int(raw_input("Y: "))
LastPos=Position(X,Y,Partie.get_JoueurActif().get_Bateaux().get_Bateau(i))
try:
Partie.get_JoueurActif().get_Grille().marquerPosition(LastPos)
k=1
while(k < Partie.get_JoueurActif().get_Bateaux().get_Bateau(i).get_taille()):
header()
print "===> Placer vos bateaux <====\n"
print Partie.get_JoueurActif().get_NomJoueur()+" >> "+str(Partie.get_JoueurActif().get_Bateaux().get_NombreBateauxNonPlaces())+ " bateaux à placer."
print "Bateau selectionné: \nTaille:"+str(Partie.get_JoueurActif().get_Bateaux().get_Bateau(i).get_taille())+"\n"
print("Entrez une coordonnee: ")
X = int(raw_input("X: "))
Y = int(raw_input("Y: "))
pos=Position(X,Y,Partie.get_JoueurActif().get_Bateaux().get_Bateau(i))
if (pos.est_AdjacenteY(LastPos) or pos.est_AdjacenteX(LastPos)):
try:
Partie.get_JoueurActif().get_Grille().marquerPosition(pos)
k = k+1
LastPos = pos
except:
raw_input("Case occuppée et/ou hors grille !")
else:
raw_input("Mauvaise case, non adjacente.")
# k == taille(Bateau)
Partie.get_JoueurActif().get_Bateaux().get_Bateau(i).set_estPlace()
i=i+1
raw_input("Bateau place, Bateau suivant")
except:
raw_input("Case occuppée et/ou hors grille !")
placerBateaux(i)
print "== FIN DE PARTIE ==\n"
print "===================================\n"
print "+GAGNANT: "+Partie.get_nextJoueur().get_NomJoueur()+"\n\n"
print "-Dommage "+Partie.get_JoueurActif().get_NomJoueur()+", vous avez perdu !\n\n"
print "===> Merci d'avoir joué ! ;)\n"
raw_input("'Entrée' pour quitter.")
try:
Partie = Partie()
print "Création d'une partie à 2 joueurs"
except:
print "Erreur lors de la création de la partie !"
demandeNoms()
# Joueur 1 Actif : Placement des bateaux
placerBateaux()
raw_input("Joueur suivant")
Partie.joueurSuivant()
# Joueur 2 Actif : Placement des bateaux
placerBateaux()
raw_input("Joueur suivant")
Partie.joueurSuivant()
# Tous les bateaux sont placés !
# Tirs
# TO BE CONTINUED
while (not(Partie.get_JoueurActif().a_perdu())):
demandeTir()
Partie.joueurSuivant()
afficherGagnant()
L_Ht = TrPC.placement_pos(0,TrPC.Epp + 1,(y -TrPC.H )//2,(y + TrPC.H )//2,' ')
self.assertEqual(len(L_Ht),(TrPC.Epp+1)*TrPC.H)
L_Bas = TrPC.placement_pos(x-1-TrPC.Epp, x,(y - TrPC.H)//2,(y + TrPC.H )//2,' ')
self.assertEqual(len(L_Bas),(TrPC.Epp+1)*TrPC.H)
L_Gche = TrPC.placement_pos((x - TrPC.L)//2 , (x + TrPC.L )//2,0, TrPC.Epp+1,' ')
self.assertEqual(len(L_Gche),(TrPC.Epp+1)*TrPC.L)
L_Dte = TrPC.placement_pos((x - TrPC.L )//2,(x + TrPC.L )//2,y -1- TrPC.Epp, y,' ')
self.assertEqual(len(L_Dte),(TrPC.Epp+1)*TrPC.L)
L_pos = L_Ht + L_Bas + L_Gche + L_Dte
for k in range(3):
TrPC.production_unite_attaque_IA_0(1)
self.assertIn(GamePC.L_joueur[1]._liste_unite[-1].coords,L_pos)
self.assertEqual(TrPC.unite_disp_par_tour,1)
if __name__ == "__main__":
Game = Partie(0,3)
GamePC = Partie(2,)
Carte = Game.carte
Tr_jeu_0_Hn = Carte.TrHn
Tr_jeu_0_IA = Carte.TrIA
Tr_jeu_0_IAA = GamePC.carte.TrIA
unittest.main()
def generer(self):
# self.partie = Partie(self.ui.Nb_IA_Choisi(),self.ui.Nb_Humain_Choisi())
self.partie = Partie(1, 1)
self.ui.conteneur.update()
print('generer')
async def demarrage(ctx, here="non", moutons=""):
global partieEnCours
stop = await phaseTestsMsg(ctx)
if stop: return
here = str(here).lower()
moutons = True if moutons else False #True aussi si ce champ est un str non vide
user = ctx.author
if here.startswith("-") and estAdmin(
ctx.author
): #pour lancer une partie de tournoi dont les joueurs sont pré-enregistrés
idPartieAnticipee = here.replace(" ", "")
if idPartieAnticipee in partiesTournoi and partiesTournoi[
idPartieAnticipee]["gagnant"] is None:
partie = Partie(situationsConnues, MINI_DEPART, True, False,
False, False, True)
joueurs = partiesTournoi[idPartieAnticipee]["joueurs"]
#on initialise la partie comme une partie "normale"
parties[partie] = {
"joueurs": joueurs,
"dansSalon": ctx.channel,
"moutons": moutons
}
partiesParJoueur[joueurs[0]] = partie
partiesParJoueur[joueurs[1]] = partie
#on enregistre dans partiesTournoi l'instance de la partie pour identifier que c'est une partie de tournoi
partiesTournoi[partie] = idPartieAnticipee
await ctx.send("La partie {} VS {} va commencer !".format(
joueurs[0].mention, joueurs[1].mention))
await affichePlateau(ctx, partie)
await ctx.send(
"À votre tour, joueur 1 {}. Vous jouez les pions jaunes/horizontaux"
.format(joueurs[0].mention))
minisParPartie[partie] = [MINI_DEPART]
return
else:
return
if user not in partiesParJoueur: #le joueur lance une nouvelle partie
await ctx.send("Démarrage d'une nouvelle partie...")
IA1 = "ia1" in here
IA2 = not IA1 and "ia2" in here #on empêche les parties IA vs IA
partieEnCours = Partie(situationsConnues, MINI_DEPART, True, True,
IA1, IA2, True)
if IA1:
joueurs = [1]
elif IA2:
joueurs = [2]
else:
joueurs = []
parties[partieEnCours] = {
"joueurs": joueurs,
"dansSalon": ctx.channel if "here" in here else False,
"moutons": moutons
}
await ctx.send(
"En attente de joueurs...\nPour se déclarer joueur, il faut écrire **{pf}moi**. Le joueur 1 doit se déclarer en premier, puis le joueur 2."
.format(pf=prefixeBot))
else: #le joueur est déjà dans une partie
await ctx.send(
"Vous participez déjà à une partie, vous ne pouvez pas participer à plusieurs parties en même temps."
)
await ctx.send(
"Vous pouvez déclarer forfait dans votre partie en cours si vous le souhaitez avec la commande {pf}forfait"
.format(pf=prefixeBot))
return
class Main:
def __init__(self):
#questions = QuestionPack4().questions
pygame.init()
self.plateau = Plateau(1280, 700, "./images")
self.partie = None
self.sound_manager = SoundManager("./audio")
# Call public -> P
# Call friend -> J
# 50/50 -> L
# Reset -> R
# Next question -> N
# A B C D -> SELECT RESPONSE
# ENTER -> Show result
# ESCAPE -> Quit game
#
def reset(self):
filename = FileChooser().get_filename()
questions = Reader(filename).get_questions()
if questions is None:
return False
self.partie = Partie(questions)
# reset game
self.partie.reset()
self.plateau.reset()
self.sound_manager.reset()
self.sound_manager.play_generic()
return True
def start_game(self):
question = self.partie.get_current_question()
index = self.partie.current_question_index
self.sound_manager.start_party_jingle()
self.plateau.fill_question_area(question)
self.sound_manager.play_ongoing_question(index)
def select_response(self, letter):
question = self.partie.get_current_question()
index = self.partie.current_question_index
self.partie.select_response(letter)
self.plateau.select_answer(question, letter)
self.sound_manager.play_last_word(index)
def show_response(self):
question = self.partie.get_current_question()
index = self.partie.current_question_index
good = self.partie.response_is_good()
if good:
self.sound_manager.play_good_response(index)
winned_price = self.partie.gains[index]
self.plateau.good_response(question, winned_price,
self.partie.letter_selected)
else:
self.sound_manager.play_wrong_answer()
self.plateau.wrong_response(question, question.good_letter)
def run(self):
self.reset()
self.running = True
while self.running:
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
print("key")
print(event.key)
if event.key == pygame.K_q:
print("press A")
# answer a
self.select_response("A")
elif event.key == pygame.K_b:
print("press B")
# answer b
self.select_response("B")
elif event.key == pygame.K_c:
print("press C")
# answer c
self.select_response("C")
elif event.key == pygame.K_d:
print("press D")
# answer d
self.select_response("D")
elif event.key == pygame.K_p:
print("press P")
# public vote
# DISABLED
elif event.key == pygame.K_j:
print("press J")
# call friend
if self.partie.call_friend_available > 0:
self.partie.call_friend_available = self.partie.call_friend_available - 1
index = self.partie.current_question_index
self.sound_manager.play_call_friend(index)
if self.partie.call_friend_available == 0:
self.plateau.update_call_friend(False)
elif event.key == pygame.K_l:
print("press L")
# 50/50
if self.partie.fiftyfifty_available > 0:
self.partie.fiftyfifty_available = self.partie.fiftyfifty_available - 1
index = self.partie.current_question_index
question = self.partie.get_current_question()
choices = ["A", "B", "C", "D"]
choices.remove(question.good_letter)
first_answer_removed = choices[randint(
0,
len(choices) - 1)]
choices.remove(first_answer_removed)
second_answer_removed = choices[randint(
0,
len(choices) - 1)]
self.sound_manager.play_fifty_fifty()
self.plateau.hide_answers(
[first_answer_removed, second_answer_removed])
if self.partie.fiftyfifty_available == 0:
self.plateau.update_fifty_fifty(False)
elif event.key == pygame.K_r:
print("press R")
if self.reset():
pass
else:
self.running = False
pygame.quit()
return
elif event.key == pygame.K_s:
print("press S")
# start game
self.start_game()
elif event.key == pygame.K_n:
print("press N")
# next question
question = self.partie.next_question()
index = self.partie.current_question_index
self.plateau.fill_question_area(question)
self.sound_manager.play_ongoing_question(index)
elif event.key == pygame.K_RETURN:
print("press ENTER")
# enter show response
self.show_response()
elif event.key == pygame.K_ESCAPE:
print("press ESCAPE")
self.running = False
pygame.quit()
return
nb_joueurs = input(
"Choix non valide. Veuillez-entrer le nombre de joueurs avec lequel vous voulez jouer.\n"
)
nb_joueurs = int(nb_joueurs)
## Code utile si jamais on veut jouer contre l'IA en cours de construction ##
# if nb_joueurs == 2:
# choix_IA = input("Souhaitez vous jouer contre une intelligence artificielle ? \n"
# "1. Oui \n"
# "2. Non\n"
# "Votre choix : ")
#
# while choix_IA not in ['1', '2']:
# nb_joueurs = input("Choix non valide. Veuillez-entrer une réponse correcte : \n")
#
# choix_IA = int(choix_IA)
#
# if choix_IA == 1: # Jeu contre une IA
# partie_IA = PartieIA.nouvelle_partie_IA(nb_joueurs)
# partie_IA.jouerIA()
# else: # Jeu à 2 sans IA
# partie = Partie.nouvelle_partie(nb_joueurs)
# partie.jouer()
#else: # Jeu à 4
partie = Partie.nouvelle_partie(nb_joueurs)
partie.jouer()
input('Appuyer sur ENTER pour quitter.')
[910, 550], [850, 550], [790, 550], [730, 550], [670, 550], [610, 550],
[550, 550], [490, 550], [430, 550], [370, 550], [310, 550], [250, 550],
[190, 550], [130, 550], [130, 410], [190, 410], [250, 410], [310, 410],
[370, 410], [430, 410], [490, 410], [550, 410], [610, 410], [770, 410]],
os.path.join("ressources", "img", "carte1.png")) ##Carte Niveau 1
carte2 = Carte([[285, 30], [285, 150], [515, 150], [515, 360], [675, 360],
[675, 185], [920, 185], [920, 540], [630, 540], [630, 605],
[380, 605], [380, 375], [220, 375], [220, 480], [70, 480]],
[[219, 153], [282, 211], [437, 92], [578, 213], [459, 349],
[596, 427], [738, 238], [829, 122], [859, 328], [980, 478],
[861, 484], [683, 482], [689, 601], [504, 671], [436, 552],
[317, 561], [298, 432], [334, 312], [161, 372], [220, 541]],
os.path.join("ressources", "img",
"carte2.png")) ##Carte Niveau 2
carte = carte1
partie = Partie(carte, affichage)
enseignantutils = EnseignantUtils()
#Musique
pygame.mixer.music.load(os.path.join("ressources", "audio", "musique.wav"))
pygame.mixer.music.play(-1, 0.0)
pygame.mixer.music.set_volume(0.6)
musique = True
execution = True
def ecoute_evenements(evenements, musique, carte):
"""Fonction qui traite les évenements et retourne si l'utilisateur veut quitter.
