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 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 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 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
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
[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.
