def __init__(self):
self.plateau = Plateau()
self.plateau.placePion((4, 4), COULEURS[2])
self.plateau.placePion((4, 5), COULEURS[1])
self.plateau.placePion((5, 4), COULEURS[1])
self.plateau.placePion((5, 5), COULEURS[2])
self.__tour = 0
self.dictscore = {}
def initialiser(self):
"""
Cette méthode permet d'initialiser ou ré-initialiser la partie en créant les différants objets nécessaires.
Cette procédure n'est pas effectuer dans l'init car on peut lancer plusieurs partie dans un même game (recommancement...)
:return:
"""
self.plateau = Plateau(self) # le plateau est initialement vide
self.talon = Talon(self.pt_max) # le talon se remplit automatiquement
self.Joueurs = [] # liste des joueurs (objets hand) de la partie
self.thread.go()
with open("game_opening") as f: # Ascii art (voir self.fin_de_partie() pour les références)
game_opening = f.read()
print(game_opening)
self.thread.message_box("Choisissez le mode de jeu des participants (humain ou IA)")
for i in range(self.nb_joueur): # création des mains
# on récupère le mode de jeu de chaque joueur
#mode = input("Donnez le mode du joueur {0} (choisissez parmi {1}) ".format(i,self.modes_disponibles))
mode = self.thread.choix_mode(num = i)
while mode not in self.modes_disponibles :
print("---Saisie Incorrecte Veuillez Recommencer ---")
#mode = input("Donnez le mode du joueur {0} (choisissez parmi {1}) ".format(i,self.modes_disponibles))
mode = self.thread.choix_mode(num = i)
# Dans le cas ou self.scoring = True on demande le pseudo du joueur sinon
# on s'en tient à son mode de jeu
hand_name = None
if self.scoring and mode == "human" :
#hand_name = input("Donnez votre Pseudo")
hand_name = self.thread.choix_pseudo()
else:
hand_name = mode
couleur = self.couleurs_disponibles[i]
self.Joueurs.append(Hand(i, self, mode,hand_name,couleur=couleur))
print("\n")
# on remplit chaque main en tirant dans le talon
for joueur in self.Joueurs:
for i in range (self.nb_dominoparjoueur):
joueur.append(self.talon.tirer())
# on positionne le joueur ayant le plus grand domino en tête de la liste Joueurs
self.rang_premier_joueur = 0 # position dans la liste Joueurs du joueur ayant le plus fort domino au début du jeu
for i in range(len(self.Joueurs)):
if self.Joueurs[i].max_domino() > self.Joueurs[self.rang_premier_joueur].max_domino():
self.rang_premier_joueur = i
premier_joueur = self.Joueurs.pop(self.rang_premier_joueur)
self.Joueurs.insert(0,premier_joueur)
def main():
#création des objets
p = Partie()
pl = Plateau()
m = menu()
#définition du choix à 0
choix = 0
#Tant que le choix n'est pas de lancer une partie
while choix != 1:
m.affichage_main_menu() #On affiche le menu
choix = m.user_choix() #On demande à l'utilisateur son choix
if choix == 2: #Si son choix est de changer la taille
pl.dimenssion = m.taille() #On lui demande la taille qu'il veut
elif choix == 3: #Si son choix est de changer le nombre de joueurs
p.nbr_joueurs = m.nbr_joueur() #On lui demande le nombre de joueurs
elif choix == 4: #Si il veut connaitre les règles
webbrowser.open("http://www.ffothello.org/othello/regles-du-jeu/") #On le redirige vers la page officiel avec les règles
print("") #saut de ligne
#Une fois qu'il à lancer une partie on initialise la partie
p.tab = pl.initialisation(nbr_joueurs=p.nbr_joueurs)
#tant que la fin de partie n'est vérifié
while pl.test(p.tab) == 0:
p.joueurs() #On définie qui joue
if pl.joueur_eliminer(p.tour, p.nbr_joueurs) == 0 : #Si le joueur n'est pas éliminé
pl.affiche(p.tab, pl.dimenssion) #On affiche le plateau de jeu
print("C'est à", p.joueurs_du_tour[0], "de jouer !") #On affiche le nom du joueur qui doit jouer
a = p.coup() #On lui demande ou il veux jouer
if a[0] != "": #Si l'utilisateur rentre autre chose que entrer(qui sert a sauté le tour)
if p.validite_case(a, p.tab) == 0: #Si la case est vide
possibilite, valid_dir_lg, valid_dir_cl = p.validite_pos(a, p.tab) #On récupère les variables de la methode validite_pos
if possibilite >= 1: #Si on a au moins une possibilité de retourner un ou plusieurs pions
p.ajout_pion(a, p.tab) #On ajoute son pion
p.inversement(p.tab, a, valid_dir_lg, valid_dir_cl) #On retourne les pions encadrés
p.tour += 1 #On passe au tour suivant
else: #Sinon
print("Merci de choisir un emplacement correct") #On lui demande de choisir une position correcte
else: #Sinon
print("Cette emplacement est déjà pris !") #On lui dis que la case est deja occupé
else:
p.tour += 1 #Sinon on saute son tour
else: #Sinon on saute son tour
p.tour +=1
#Quand la partie prend fin on affiche le tableau final
pl.affiche(p.tab,pl.dimenssion)
def commandInterpreter(command, *args):
global plateau
if command is InputFileParser.PlateauConfigState.Commands.CREATE_PLATEAU:
plateau = Plateau(args[0]+1, args[1]+1)
elif command is InputFileParser.RoverInstructionsState.Commands.CREATE_ROVER:
rover_name = args[0]
rover_position = tuple(args[1:3])
rover_bearing = args[3]
rover_instructions = args[4]
rover = Rover(rover_name, plateau.getPosition(*rover_position), rover_bearing)
execute_rover_instructions(rover, rover_instructions)
print_rover_position(rover)
def test_placePion(self):
P = Plateau()
Move1 = P.placePion((5, 2), COULEURS[1])
Move2 = P.placePion((4, 4), COULEURS[2])
Move3 = P.placePion((4, 5), COULEURS[0])
Move4 = P.placePion((5, 4), COULEURS[2])
Move5 = P.placePion((8, 4), COULEURS[1])
Move6 = P.placePion((2, 2), COULEURS[0])
self.assertEqual(Move1, 'black')
self.assertEqual(Move2, 'white')
self.assertEqual(Move3, '')
self.assertEqual(Move4, 'white')
self.assertEqual(Move5, 'black')
self.assertEqual(Move6, '')
def commandInterpreter(command, *args):
global plateau
if command is InputFileParser.PlateauConfigState.Commands.CREATE_PLATEAU:
plateau = Plateau(args[0] + 1, args[1] + 1)
elif command is InputFileParser.RoverInstructionsState.Commands.CREATE_ROVER:
rover_name = args[0]
rover_position = tuple(args[1:3])
rover_bearing = args[3]
rover_instructions = args[4]
rover = Rover(rover_name, plateau.getPosition(*rover_position),
rover_bearing)
execute_rover_instructions(rover, rover_instructions)
print_rover_position(rover)
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,
plateau=p.Plateau(),
pioche=[Cartes.Carte() 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
self.listeJoueurs = [j.creerJoueur(i) for i in range(nbJoueurs)]
for joueur in self.listeJoueurs:
joueur.murs = self.plateau.listeMurs
def test_rempla(self):
R = Plateau()
R.placePion((2, 6), COULEURS[2])
R.placePion((2, 7), COULEURS[1])
R.placePion((3, 6), COULEURS[1])
R.placePion((3, 7), COULEURS[2])
self.assertIsNone(R.rempla((2, 6), (0, 1), 'black'))
def test_encadre2(self):
E = Plateau()
E.placePion((3, 5), COULEURS[1])
E.placePion((4, 5), COULEURS[2])
E.placePion((5, 5), COULEURS[2])
Encadre2 = E.encadre((5, 5), (-1, 0), 'white')
self.assertTrue(Encadre2)
def test_encadre(self):
E = Plateau()
E.placePion((4, 4), COULEURS[2])
E.placePion((4, 5), COULEURS[1])
E.placePion((5, 4), COULEURS[1])
E.placePion((5, 5), COULEURS[2])
Encadre1 = E.encadre((4, 4), (1, 0), 'black')
self.assertFalse(Encadre1)
def test_ouJouer(self):
J = Plateau()
J.placePion((4, 4), COULEURS[2])
J.placePion((4, 5), COULEURS[1])
J.placePion((5, 4), COULEURS[1])
J.placePion((5, 5), COULEURS[2])
Possib1 = J.ouJouer('black')
self.assertEqual(Possib1, [(5, 3), (6, 4), (3, 5), (4, 6)])
def __init__(self, parent):
self.parentWindow = parent
self.background = PhotoImage(file="../images/appli.gif")
self.game_over = PhotoImage(file="../images/gameOver.gif")
self.frame = Frame(self.parentWindow.window,
width=self.background.width(),
height=self.background.height())
parent.window.geometry("1104x640")
# creation du canvas qui contient les widjets
self.canvas = Canvas(self.frame,
width=self.background.width(),
height=self.background.height(),
background="white")
self.canvas.create_image(0, 0, image=self.background, anchor=NW)
self.time = datetime(2000, 1, 1, 0, 2, 0)
self.timeLeft = None
self.nbResults = 0
self.score = 0
self.scoreLabel = self.canvas.create_text(898,
555,
font=("Arial", 24, "bold"),
text="0")
self.myListBox = Listbox(parent.window,
bg="white",
width=15,
height=self.background.height())
self.myListBox.pack(side=RIGHT)
self.updateTimeLeft()
self.plateau = Plateau(self.parentWindow, self, self.canvas)
self.canvas.bind("<Button-1>",
lambda event, x=self.canvas: self.plateau.
click_canvas(event, x)) #self.plateau.click_triangle)
self.canvas.pack()
self.frame.pack(side=RIGHT)
def __init__(self):
""" Constructeur """
self.__nom = self.demanderNom()
self.__plateau = Plateau()
self.__flotte = [
Porte_avions(self.__plateau),
Croiseur(self.__plateau),
Contre_torpilleur(self.__plateau),
Sous_marin(self.__plateau),
Torpilleur(self.__plateau)
]
self.__vainceur = False
def create_plateau(plateau_input):
"""
Return a new Plateau, or a PlateauInputError if a problem was found with the input
:param plateau_input: String representing a new Plateau. Valid plateau_input will be two Integers separated by
a space
:return: Plateau if no errors were found with the input, otherwise a PlateauInputError
"""
raw_plateau = re.match('^(\d \d)$', plateau_input)
if raw_plateau:
coordinates = raw_plateau.group().split()
return Plateau(coordinates[0], coordinates[1])
else:
raise PlateauInputError
def main():
print("Enter the information of the ships and instructions")
plateuX, plateuY = input("Plateu: (X Y) ").split(" ")
howManyRovers = int(input("How many rovers do you want control? "))
plateau = Plateau(int(plateuX), int(plateuY))
for item in range(0, howManyRovers):
roverX, roverY, roverDirection = input("Landing: (X Y D)").split(" ")
instructions = input("Instructions: (LRM)")
rover = Rover("rover" + str(item + 1), int(roverX), int(roverY),
roverDirection, plateau)
executeRoverInstructions(rover, instructions)
class Main():
"""Classe Main
Lance le jeu.
"""
p = Plateau()
compteur = 0
action = [False, False]
while (p.finDeJeu is False):
p.afficherTabDeJeu()
p.tour(compteur, action)
compteur += 1
def test_estAdj(self):
A = Plateau()
A.placePion((4, 4), COULEURS[1])
Adjacent1 = A.estAdj((4, 5), 'black')
Adjacent2 = A.estAdj((4, 3), 'black')
Adjacent3 = A.estAdj((3, 4), 'black')
Adjacent4 = A.estAdj((5, 4), 'black')
self.assertTrue(Adjacent1)
self.assertTrue(Adjacent2)
self.assertTrue(Adjacent3)
self.assertTrue(Adjacent4)
class Main():
"""Classe Main
Lance le jeu.
"""
p = Plateau()
compteur = 0
while (p.finDeJeu is False):
p.afficherTabDeJeu()
if (compteur % 2 == 0):
p.tour(p.j1)
else:
p.tour(p.j2)
compteur += 1
class Main():
"""
Crée un plateau de jeu.
"""
p = Plateau()
p.init_matrice()
count = 0
while(p.finDeJeu == False):
p.initTabMurs()
p.affichejeu()
if(count % 2 == 0):
p.tour(p.j1)
else:
p.tour(p.j2)
count += 1
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat May 13 17:39:49 2017
@author: Corazza
"""
import Cases
import Cartes
import Murs
import Plateau
#Creation du plateau
plateau = Plateau.Plateau(16, 12)
platx = plateau.x - 1
platy = plateau.y - 1
#implementation des murs sur le plateau
mur = Murs.MurVertical((3, 2), (4, 2))
mur2 = Murs.MurHorizontal((7, 2), (7, 3))
listeMurs = [mur, mur2]
for murs in listeMurs:
plateau.ajouterMur(murs)
#implementation des cases sur 1/4 du plateau puis symetrie
tapis = Cases.Tapis((2, 1), 0, False)
tapis2 = Cases.Tapis((3, 1), 0, False)
tapis3 = Cases.Tapis((4, 1), 0, "Droite")
tapis4 = Cases.Tapis((5, 1), 0, False)
os.chdir(os.path.abspath(pathname))
os.chdir("ressources")
lvl = 2
fileName = "lvl" + str(lvl) + ".txt"
with open("lvl_actuel.txt", "w") as fill:
fill.write(str(lvl))
#0.2 creer lvl vide:
with open(fileName, "w") as fill:
fill.write("")
#0.3 initialisation lvl et affichage:
plateau = Plateau(pygame)
ninja1 = pygame.image.load("ninja1.png").convert_alpha()
ninja2 = pygame.image.load("ninja2.png").convert_alpha()
ninja3 = pygame.image.load("ninja3.png").convert_alpha()
ninja4 = pygame.image.load("ninja4.png").convert_alpha()
#1.1: taille de la map
(taillex, tailley) = (9, 3)
debutx = (plateau.nbCasesX - taillex) // 2
debuty = (plateau.nbCasesY - tailley) // 2
finx = debutx + taillex
finy = debuty + tailley
#1.2: nombres de caisses
dames.deplacer(i,j,nouv_i,nouv_j)
print("Temps ecoule : ",t2-t1)
print("L'ordinateur deplace la piece ",i,",",j," a la case ",nouv_i,",",nouv_j)
fichier = open("histo_partie.txt","a")
fichier.write(str(dames.get_historique())+"\n")
fichier.close()
if __name__=="__main__":
main()
## MODE IA VS IA
# def main():
"""Fonction principale du script"""
dames = Plateau()
print("IA VS IA")
while not(dames.get_finpartie()):
if len(dames.dict_mouvements())==0:
dames.set_finpartie(True)
print("Victoire des noirs !")
else:
i,j,nouv_i,nouv_j = dames.predire(1,3,"blanc")
dames.deplacer(i,j,nouv_i,nouv_j)
if len(dames.dict_mouvements())==0:
dames.set_finpartie(True)
print("Victoire des blancs !")
else:
i,j,nouv_i,nouv_j = dames.predire(1,-1,"noir")
def main():
"""Fonction principale du script"""
dames = Plateau()
print("Vous jouez les blancs")
while not(dames.get_finpartie()):
d = dames.dict_mouvements()
if len(d)==0:
dames.set_finpartie(True)
dames.afficher()
print("Victoire de l'ordinateur !")
else:
cond=False
while not(cond):
dames.afficher()
piece = input("Quelle piece voulez vous jouez ? Saisir i,j : ")
coord = input("Ou voulez vous la jouez ? Saisir i,j : ")
try:
i,j=int(piece[0]),int(piece[2])
nouv_i,nouv_j=int(coord[0]),int(coord[2])
if (i,j) not in d or (nouv_i,nouv_j) not in d[(i,j)]:
print("Deplacement impossible")
print("Liste des deplacements disponibles : ",d)
else:
dames.deplacer(i,j,nouv_i,nouv_j)
cond=True
except IndexError:
print("Erreur, coordonnees mal saisies")
except ValueError:
print("Erreur, coordonnees mal saisies")
if cond:
dames.afficher()
if len(dames.dict_mouvements())==0:
print("Vous avez gagne !")
dames.set_finpartie(True)
else:
print("L'ordinateur reflechit...")
t1 = time.time()
i,j,nouv_i,nouv_j = dames.predire(1,3,10,"noir")
t2 = time.time()
dames.deplacer(i,j,nouv_i,nouv_j)
print("Temps ecoule : ",t2-t1)
print("L'ordinateur deplace la piece ",i,",",j," a la case ",nouv_i,",",nouv_j)
fichier = open("histo_partie.txt","a")
fichier.write(str(dames.get_historique())+"\n")
fichier.close()
# -*- coding: utf-8 -*-
"""
Created on Tue May 9 13:01:20 2017
@author: Chojnacki
"""
import Cases
import Cartes
import Murs
import Plateau
plateau = Plateau.Plateau(10, 5)
engr = Cases.CaseEngrenage((3, 1), -1)
tapis2 = Cases.Tapis((3, 2), 0, False)
engr2 = Cases.CaseEngrenage((4, 3), -1)
arrivee = Cases.CaseArrivee((3, 3))
mur = Murs.MurVertical((0, 0), (1, 0))
#robot1_start = (5,2) # A ajouter dans le code
plateau.ajouterMur(mur)
for y in range(0, plateau.y, 1):
mur = Murs.MurVertical((-1, y), (0, y))
plateau.ajouterMur(mur)
mur = Murs.MurVertical((plateau.x - 1, y), (plateau.x, y))
plateau.ajouterMur(mur)
for x in range(0, plateau.x, 1):
mur = Murs.MurHorizontal((x, -1), (x, 0))
plateau.ajouterMur(mur)
mur = Murs.MurHorizontal((x, plateau.y - 1), (x, plateau.y))
# -*- coding: utf-8 -*-
"""
Created on Sun May 14 00:00:44 2017
@author: alex
"""
import Cases
import Cartes
import Murs
import Plateau
#Creation du plateau
plateau = Plateau.Plateau(8,6)
platx = plateau.x - 1
platy = plateau.y - 1
#implementation des murs sur le plateau
mur = Murs.MurVertical((3,2),(4,2))
mur2 = Murs.MurHorizontal((7,2),(7,3))
listeMurs= [mur,mur2]
for murs in listeMurs:
plateau.ajouterMur(murs)
#implementation des cases sur 1/4 du plateau puis symetrie
tapis = Cases.Tapis((2,1),0,False)
tapis2 = Cases.Tapis((3,1),0,False)
tapis3 = Cases.Tapis((4,1),0,"Droite")
def test_estvide(self):
V = Plateau()
V.placePion((5, 2), COULEURS[0])
V.placePion((4, 4), COULEURS[0])
V.placePion((4, 5), COULEURS[0])
V.placePion((5, 4), COULEURS[1])
V.placePion((8, 4), COULEURS[2])
V.placePion((2, 2), COULEURS[1])
Vide1 = V.estVide((5, 2))
Vide2 = V.estVide((4, 4))
Vide3 = V.estVide((4, 5))
Vide4 = V.estVide((5, 4))
Vide5 = V.estVide((2, 2))
Vide6 = V.estVide((8, 4))
self.assertTrue(Vide1)
self.assertTrue(Vide2)
self.assertTrue(Vide3)
self.assertFalse(Vide4)
self.assertFalse(Vide5)
self.assertFalse(Vide6)
def testNormalPlateau(self):
plateau = Plateau.Plateau(5, 3)
self.assertEqual(plateau.max_x, 5)
self.assertEqual(plateau.max_y, 3)
def testInvalidPosition(self):
plateau = Plateau.Plateau(5, 3)
self.assertFalse(plateau.is_valid_position(6, 1))
def testValidPositionEdgeCase(self):
plateau = Plateau.Plateau(5, 3)
self.assertTrue(plateau.is_valid_position(5, 3))
def testValidPosition(self):
plateau = Plateau.Plateau(5, 3)
self.assertTrue(plateau.is_valid_position(1, 1))