def lancejeu():
"""Routine de lancement du jeu"""
print('OTHELLO avec une IA')
#
#########joueur VS joueur #######################
jblanc = joueur.Joueur('Blanc', 'o')
jnoir = joueur.Joueur('Noir', 'x')
jeu = po.Othello(jblanc, jnoir)
# ####### joueur VS ia_faible #####################
# jblanc = joueur.Joueur('Blanc', 'o')
# ia_faib = iaf.IAFaible('iafaible','x')
# jeu = po.Othello(jblanc,ia_faib)
# ####### joueur VS ia_forte ######################
# jblanc = joueur.Joueur('Blanc', 'o')
# ia_fort = iaF.IAForte('iaforte','x')
# jeu = po.Othello(jblanc,ia_fort)
# ####### ia_faible VS ia_forte ###################
# ia_faib = iaf.IAFaible('iafaible','o')
# ia_fort = iaF.IAForte('iaforte','x')
# jeu = po.Othello(ia_faib,ia_fort)
# #################################################
#
jeu.info()
jeu.jeu()
def setUp(self):
"""
Creation de la méthode setUp permettant de générer un joueur fictif.
"""
self.tab = tableau.Tableau(5)
self.tab.creation_tableau()
self.j = joueur.Joueur("joueurNumero1", self.tab, 200)
self.j.score = 9000
self.nbr_bateaux = 3
self.bateau1 = bateau.Bateau("porte-avion", 4, "touché")
self.bateau1.coordonnees_bateau = [1, 1, "o"], [1, 2, "o"], [1, 3, "o"], [1, 4, "o"]
self.bateau2 = bateau.Bateau("torpilleur", 2, "actif")
self.bateau2.coordonnees_bateau = [4, 1, "o"], [4, 2, "o"]
self.bateau3 = bateau.Bateau("croiseur", 2, "actif")
self.bateau3.coordonnees_bateau = [5, 1, "o"], [5, 2, "o"]
self.bateau4 = bateau.Bateau("canonniere", 3, "actif")
self.bateau5 = bateau.Bateau("destroyer", 3, "actif")
self.j.porte_avion = self.bateau1
self.j.torpilleur = self.bateau2
self.j.croiseur = self.bateau3
self.j.canonniere = self.bateau4
self.j.destroyer = self.bateau5
def __init__(self,nb_joueur=5):
self.pile=pile.Pile()
self.nb_joueur=nb_joueur
self.joueurs=[]
self.paquet=paquet.Paquet()
self.classement=[]
if self.nb_joueur==2:
self.status=['Grand duc','Trou de chouette']
elif self.nb_joueur==3:
self.status=['Grand duc','Mi chouette','Trou de chouette']
elif self.nb_joueur==4:
self.status=['Grand duc','Duc','Chouette moisie','Trou de chouette']
elif self.nb_joueur==5:
self.status=['Grand duc','Duc','Mi chouette','Chouette moisie','Trou de chouette']
elif self.nb_joueur==6:
self.status=['Grand duc','Duc','Mi chouette','Mi chouette','Chouette moisie','Trou de chouette']
i=0
#Création des joueurs
while i < nb_joueur:
self.joueurs.append(joueur.Joueur(i,default_settings['Noms'][i]))
i+=1
#Melange et distribution en nb_joueurs tas
self.paquet.melanger()
mains = self.paquet.distribuer(nb_joueur)
#Attribution des mains
i=0
for m in mains:
self.joueurs[i].attributer_main(m)
i+=1
def __init__(self):
#nombre max de joueur et ennemie sur la map
self.nbrT = 4
#création d'une matrice de zéros qui représenteront le sol vide auquel on ajoutera des éléments
self.width = const.MAP_WIDTH
self.height = const.MAP_HEIGHT
self.plateau = np.zeros((self.width, self.height),dtype=int)
#matrice non affichée permettant d'avoir des boosts
self.plateau_boost = np.zeros((self.width, self.height),dtype=int)
#Créer le premier joueur
self.joueur_1 = joueur.Joueur('Joueur 1',1,1)
nbrJ = 1
nbrE = nbrT - nbrJ
#demander cb de joueur
self.create_map(3,1)
#self.create_map(3,n)
self.show()
#self.map = []
"""
def init_obj(__):
import map
reload(map)
__.map = map.Map(__, 50, 50, 800, filename=K.map)
import joueur
reload(joueur)
K.joueur = joueur.Joueur(vie_max=5)
def distribRole(self, joueur, role):
distrib = []
while (len(role) != 0 or len(joueur) != 0):
a = random.randrange(len(joueur))
b = random.randrange(len(role))
player = j.Joueur(joueur[a],role[b])
distrib.append(player)
joueur.remove(joueur[a])
role.remove(role[b])
return (distrib)
def test_getNom(self):
noms = ["toto", "azerty", "nom23"]
for nom in noms:
j = joueur.Joueur(nom)
nom_res = joueur.getNom(j)
self.assertEqual(
nom_res, nom, "Le nom du joueur " + str(j) + " devrait être " +
nom + " et getNom a retourné " + str(nom_res) +
"\nCela peut provenir de la fonction getNom ou de la fonction Joueur"
)
def creer_joueur(self):
""""fonction creant un nouveau joueur dans la base de donnée "scores" avec un score de départ de 0"""
dico_scores = self.get_dico_scores()
with open("scores", "wb") as fichier_crea:
new_entry = pickle.Pickler(fichier_crea)
dico_scores[self._nom_joueur] = joueur.Joueur(
self._nom_joueur) # ajout du joueur à la bibliothéque
new_entry.dump(dico_scores) # sauvegarde de l'objet
def test_changerJoueurCourant(self):
for noms in self.liste_noms:
liste_joueurs=listeJoueurs.ListeJoueurs(noms)
taille=len(noms)
for i in range(6):
jca=joueur.Joueur(noms[i%taille])
jc=listeJoueurs.getJoueurCourant(liste_joueurs)
self.assertEqual(joueur.getNom(jc),noms[i%taille],"Le joueur courant de la liste joueur créée à partir de "+str(noms)+" au bout de "+str(i)+
" tour(s) devrait être "+str(noms[i%taille])+" mais la fonction getJoueurCourant retourne "+str(joueur.getNom(jc))+
"\nCela peut provenir des fonctions ListeJoueurs, getJoueurCourant ou changerJoueurCourant")
listeJoueurs.changerJoueurCourant(liste_joueurs)
def test_getNbTresorsRestants(self):
j = joueur.Joueur("test")
for i in range(10):
res = joueur.getNbTresorsRestants(j)
self.assertEqual(
res, i,
"Le nombre de trésors du joueur " + str(j) + " devrait être " +
str(i) + " mais getNbTresors a retourné " + str(res) +
"\nCela peut provenir des fonctions getNbTresorsRestants, ajouterTresor ou Joueur"
)
joueur.ajouterTresor(j, i + 1)
def test_Joueur(self):
for noms in self.liste_noms:
liste_joueurs=listeJoueurs.ListeJoueurs(noms)
jo=joueur.Joueur(noms[0])
nbj=listeJoueurs.getNbJoueurs(liste_joueurs)
self.assertEqual(nbj,len(noms),"La liste de joueur crée à partir de "+str(noms)+" devrait contenir "+
str(len(noms))+" joueurs mais la fonction getNbJoueurs retourne "+str(nbj)+
"\nCela peut provenir des fonctions ListeJoueurs ou getNbJoueurs")
jc=listeJoueurs.getJoueurCourant(liste_joueurs)
self.assertEqual(joueur.getNom(jc),noms[0],"La liste de joueur crée à partir de "+str(noms)+" devrait avoir pour joueur courant "+
str(noms[0])+" mais la fonction getJoueurCourant retourne "+str(joueur.getNom(jc))+
"\nCela peut provenir des fonctions ListeJoueurs ou getJoueurCourant")
def test_ajouterTresor(self):
j = joueur.Joueur("test")
liste_tresors = [(2, 1), (6, 2), (4, 3), (6, 3), (2, 3), (14, 4)]
for tresor, nb_attendu in liste_tresors:
joueur.ajouterTresor(j, tresor)
res = joueur.getNbTresorsRestants(j)
self.assertEqual(
res, nb_attendu,
"Le nombre de trésors du joueur " + str(j) + " devrait être " +
str(nb_attendu) + " mais getNbTresors a retourné " + str(res) +
"\nCela peut provenir des fonctions getNbTresorsRestants, ajouterTresor ou Joueur"
)
def test_ajouterJoueur(self):
for noms in self.liste_noms:
liste_joueurs=listeJoueurs.ListeJoueurs([])
cpt=0
nbj=listeJoueurs.getNbJoueurs(liste_joueurs)
self.assertEqual(nbj,cpt,"La liste de joueur crée à partir de [] devrait contenir aucun joueur mais "+
"la fonction getNbJoueurs retourne "+str(nbj)+
"\nCela peut provenir des fonctions ListeJoueurs ou getNbJoueurs")
for nom in noms:
cpt+=1
listeJoueurs.ajouterJoueur(liste_joueurs,joueur.Joueur(nom))
nbj=listeJoueurs.getNbJoueurs(liste_joueurs)
self.assertEqual(nbj,cpt,"La liste de joueur devrait contenir "+str(cpt)+" joueur(s) mais "+
"la fonction getNbJoueurs retourne "+str(nbj)+
"\nCela peut provenir des fonctions ajouterJoueur ou getNbJoueurs")
def load(self, filename):
try:
with open(filename, 'rb') as fichier:
mon_depickler = pickle.Unpickler(fichier)
grille_recup = mon_depickler.load()
fichier.close()
except FileNotFoundError:
return False
except EOFError:
return False
else:
if not grille_recup:
return False
else:
for i in range(0, len(grille_recup)-1):
self.profils.append(joueur.Joueur(grille_recup[i][0], grille_recup[i][2]))
self.profils[-1]._setId(grille_recup[i][1])
self.profils[-1]._setCredits(grille_recup[i][3])
self.profils[-1]._setScorePoker(grille_recup[i][4])
self.currentProfil = grille_recup[-1]
def test_tresorTrouve(self):
j = joueur.Joueur("test")
liste_tresors = [2, 8, 4, 6, 10, 14]
for tresor in liste_tresors:
joueur.ajouterTresor(j, tresor)
for i in range(len(liste_tresors), 0, -1):
res = joueur.getNbTresorsRestants(j)
self.assertEqual(
res, i,
"Le nombre de trésors du joueur " + str(j) + " devrait être " +
str(i) + " mais getNbTresors a retourné " + str(res) +
"\nCela peut provenir des fonctions getNbTresorsRestants, tresorTrouve ou Joueur"
)
joueur.tresorTrouve(j)
res = joueur.getNbTresorsRestants(j)
self.assertEqual(
res, 0,
"Le nombre de trésors du joueur " + str(j) + " devrait être " +
str(0) + " mais getNbTresors a retourné " + str(res) +
"\nCela peut provenir des fonctions getNbTresorsRestants, tresorTrouve ou Joueur"
)
async def on_ready():
print('Logged in as')
print(bot.user.name)
print(bot.user.id)
print('------')
if len(bot.servers) > 1:
raise NotImplementedError('Juste un serveur à la fois')
for channel in bot.get_all_channels():
if channel.name == bot.channel_annonces:
bot.channel_annonces = channel
break
persos = {}
with open("init.csv", 'r') as file:
for line in file:
persos[line.split('\t')[0]] = line.split('\t')[1][:-1]
for user in bot.get_all_members():
if user.name in persos:
role_user = ''
for role in list(pl.Roles):
if role.value[0] == persos[user.name]:
role_user = role
if role_user == '':
raise ValueError('Rôle inconnu : {}'.format(persos[user.name]))
bot.groupe.ajouter_joueur(
pl.Joueur(nom=user.name,
discordID=user.id,
role=role_user,
etat=pl.Etat.vivant))
persos.pop(user.name, None)
if len(persos) != 0:
message = 'Nom de joueur inconnu :'
for key in persos:
message += ' {},'.format(persos[key])
message = message[:-1]
raise ValueError(message)
def test_prochainTresor(self):
j = joueur.Joueur("test")
liste_tresors = [2, 8, 4, 6, 10, 14]
for tresor in liste_tresors:
joueur.ajouterTresor(j, tresor)
for i in range(len(liste_tresors)):
j_copie = copy.deepcopy(j)
res = joueur.prochainTresor(j)
self.assertEqual(
res, liste_tresors[i], "Le prochain trésor du joueur " +
str(j_copie) + " devrait être " + str(liste_tresors[i]) +
" mais prochainTresor a retourné " + str(res) +
"\nCela peut provenir des fonctions prochainTresor, tresorTrouve ou Joueur"
)
joueur.tresorTrouve(j)
j_copie = copy.deepcopy(j)
res = joueur.prochainTresor(j)
self.assertEqual(
res, None, "Le joueur " + str(j_copie) +
" ne devrait pas avoir de trésor à trouver mais prochainTresor a retourné "
+ str(res) +
"\nCela peut provenir des fonctions prochainTresor, tresorTrouve ou Joueur"
)
def create_map(self,nbrJ:int):
#matrice remplie de mur
for i in range(self.width):
for j in range(self.height):
self.plateau[i,j] = const.MUR
#remplir de case et d'herbe dans la matrice
for i in range(1,self.width):
for j in range(1,self.height):
self.plateau[i,j] = random.randint(const.SOL, const.CASE)
self.plateau[2::2, ::2] = const.MUR
#joueur
if self.nbrJ == 2:
self.joueur_2 = joueur.Joueur('Joueur 2',self.width,self.height)
elif self.nbrJ == 3:
self.joueur_2 = joueur.Joueur('Joueur 2',self.width,1)
self.joueur_3 = joueur.Joueur('Joueur 3',self.width,self.height)
elif self.nbrJ == 4:
self.joueur_2 = joueur.Joueur('Joueur 2',self.width,1)
self.joueur_3 = joueur.Joueur('Joueur 3',1,self.height)
self.joueur_4 = joueur.Joueur('Joueur 4',self.width,self.height)
#casser les blocs a 1 pas de chaque joueur et ennemie
#remplacer CASE par SOL
#haut gauche
self.plateau[2,1] = const.SOL
self.plateau[1,2] = const.SOL
#haut droite
self.plateau[self.width-1,1] = const.SOL
self.plateau[self.width,2] = const.SOL
#bas gauche
self.plateau[1,self.height-1] = const.SOL
self.plateau[2,self.height] = const.SOL
#bas droite
self.plateau[self.width-1,self.height] = const.SOL
self.plateau[self.width,self.height-1] = const.SOL
import map
import dessin
import joueur
import ennemi
import math
import ia
#charge la map
map.theMap = map.map()
#charge les sprites
dessin.loadAllSprites()
#defini un joueur et ennemi
player = joueur.Joueur(2,2)
listEnnemis = []
for i in range(2):
for j in range(2):
listEnnemis.append( ennemi.Ennemi(4+i,4+j+2) )
#vitesse du déplacement
speed = 1/16
speedDiag = speed
#crée la fenetre
fenetre = pygame.display.set_mode( (dessin.SCR_WIDTH*64,dessin.SCR_HEIGHT*64) )
pygame.display.set_caption("Chaptal Quest XIII - reloaded")
clock = pygame.time.Clock()
def createProfil(self, Pseudo, MDP):
if not self.ProfilExist(Pseudo):
self.profils.append(joueur.Joueur(Pseudo, MDP))
self.save("profilsData.data")
return True
return False
def test_nom_joueur(self):
joueur_nom = joueur.Joueur("Player ONE", self.tab, 200)
self.assertEqual(joueur_nom.nom, "Player ONE")
"""Ce fichier contient le jeu du pendu.
Il s'appuie sur les fichiers :
- donnees.py
- fonctions.py"""
import joueur
import croupier
# Initialisation
croupier = croupier.Croupier() # Initialisation du pot
Thibaut = joueur.Joueur('Thibaut')
croupier.liste_joueur.append(Thibaut)
Negreanu = joueur.Joueur('Negreanu')
croupier.liste_joueur.append(Negreanu)
Helmut = joueur.Joueur('Helmut')
croupier.liste_joueur.append(Helmut)
croupier.nouvelle_donne()
