def __init__(self): j1Name = raw_input("Nickname of player 1 : ") self.j1 = Joueur(str(j1Name), "o") j2Name = raw_input("Nickname of player 2 : ") self.j2 = Joueur(str(j2Name), "x") self.j1.changeMyTurn() self.plateau = Plateau()
def test_rover_position_greater_than_plateau_should_raise_exception(self): rover = Rover(coord=(4, 0, 'E')) plateau = Plateau(upper_right=(3, 3), rovers=[rover]) self.assertRaises(ValueError, plateau.rover_explore) rover = Rover(coord=(3, -1, 'E')) plateau = Plateau(upper_right=(3, 3), rovers=[rover]) self.assertRaises(ValueError, plateau.rover_explore)
def test_ramasser_graines(self): """ Vérifie que la méthode ramasser_graines renvoie bien le bon nombre de graines. """ p1 = Plateau() i = 5 n = p1.ramasser_graines(i) self.assertEqual(p1[i], 0) self.assertEqual(n, 4) # chaque case doit avoir 3 graines
def test_plateau_rover_explore_should_print_expected_output(self): plateau = Plateau(upper_right=(3, 3), rovers=[self.rover1, self.rover2]) capturedOutput = io.StringIO() sys.stdout = capturedOutput plateau.rover_explore() sys.stdout = sys.__stdout__ output = capturedOutput.getvalue() self.assertEqual(output, self.expected_output)
def test_copie(self): """ Vérifie que la copie du plateau est bien un nouvel objet Plateau identique. """ p1 = Plateau() p2 = p1.copie() self.assertIsInstance(p2, Plateau) self.assertIsNot(p2, p1) self.assertEqual(p2, p1)
def set_plateau(self, x, y): """ Setting plateau dimensions. :param x: (int) x dimension on plateau grid. :param y: (int) y dimension on plateau grid :return: plateau object """ if self.plateau is None: self.plateau = Plateau(x_max=x, y_max=y) else: raise PlateauException("Plateau already defined")
def __init__(self): """ Méthode spéciale initialisant une nouvelle partie du jeu Tic-Tac-Toe. """ self.plateau = Plateau() # Le plateau du jeu contenant les 9 cases. self.joueurs = [] # La liste des deux joueurs (initialement une liste vide). # Au début du jeu, il faut ajouter les deux joueurs à cette liste. self.joueur_courant = None # Le joueur courant (initialisé à une valeur nulle: None) # Pendant le jeu et à chaque tour d'un joueur, # il faut affecter à cet attribut ce joueur courant. self.nb_parties_nulles = 0 # Le nombre de parties nulles (aucun joueur n'a gagné).
def __init__(self, demo: bool = True): self.pioche = [] self.demo = demo for i in range(1, 15): self.pioche.append("E") for i in range(1, 9): self.pioche.append("A") for i in range(1, 8): self.pioche.append("I") for i in range(1, 6): self.pioche.append("N") self.pioche.append("O") self.pioche.append("R") self.pioche.append("S") self.pioche.append("T") self.pioche.append("U") for i in range(1, 5): self.pioche.append("L") for i in range(1, 3): self.pioche.append("D") self.pioche.append("M") for i in range(1, 2): self.pioche.append("G") self.pioche.append("B") self.pioche.append("C") self.pioche.append("P") self.pioche.append("F") self.pioche.append("H") self.pioche.append("V") for i in range(1, 2): self.pioche.append("J") self.pioche.append("Q") self.pioche.append("K") self.pioche.append("W") self.pioche.append("X") self.pioche.append("Y") self.pioche.append("Z") self.plateau = Plateau() self.joueur = Joueur() if demo: random.Random(7).shuffle(self.pioche) for i in range(0, 7): self.joueur.ajouterLettre(self.pioche[0]) del self.pioche[0] else: random.shuffle(self.pioche) for i in range(1, 8): rand = random.randint(0, len(self.pioche)) self.joueur.ajouterLettre(self.pioche[rand]) del self.pioche[rand]
def test_if_rover_was_correctly_moved_east(Rover, Plateau): plat = Plateau(5, 5) rover = Rover(3, 3, 'E', plat) rover.change_position('M') assert rover.position_x == 4 rover.change_position('M') assert rover.position_x == 5
def test_if_rover_was_correctly_moved_south(Rover, Plateau): plat = Plateau(5, 5) rover = Rover(1, 3, 'S', plat) rover.change_position('M') assert rover.position_y == 2 rover.change_position('M') assert rover.position_y == 1
def test_if_face_was_correctly_changed_to_left(Rover, Plateau): plat = Plateau(5, 5) rover = Rover(1, 2, 'N', plat) rover.change_position('L') assert rover.face_direction == 'W' rover.change_position('L') assert rover.face_direction == 'S'
def test_choisir_case(self): j = JoueurMachineMaxGraines(1) p = Plateau() for i in range(12): p[i] = i case = j.choisir_case(p) self.assertEqual(case, 5 + 6 * j.cote)
def test_if_rover_was_correctly_moved_north(Rover, Plateau): plat = Plateau(5, 5) rover = Rover(1, 2, 'N', plat) rover.change_position('M') assert rover.position_y == 3 rover.change_position('M') assert rover.position_y == 4
def create(self, plateauSize, roverPosition, roverDirection): # Cria o plateau e o rover, e retorna o rover criado plateau = Plateau(plateauSize[0], plateauSize[1]) rover = Rover(roverPosition[0], roverPosition[1], roverDirection, plateau) return rover
def __init__(self, listeDeJoueur): self.plateau = Plateau() self.listDeJoueur = listeDeJoueur for i in range(len(self.listDeJoueur)): if self.listDeJoueur[i].getPieces() == None or len( self.listDeJoueur[i].getPieces()) == 0: self.listDeJoueur[i].setPieces( FactoryPiece.createAllPiece(self.listDeJoueur[i].couleur)) self.joueursEnVie = [] for p in self.listDeJoueur: self.joueursEnVie.append(p) self.joueurEnCours = None self.pieceEnCours = None self.runGame = True self.nbSurrender = 0 self.classement = []
def testPeutComparerFalse(self): p = Plateau(9) p.tapis[0][0] = Carte(0, 'X') p.tapis[1][0] = Carte(2, 'B') p.tapis[2][0] = Carte(3, 'C') p.tapis[4][0] = Carte(4, 'D') p.tapis[5][0] = Carte(5, 'E') p.tapis[6][0] = Carte(6, 'F') b = Borne(0, p) #Vérification peutComparer dans un cas Faux p.tapis[0][0] = Carte(0, 'X') b = Borne(0, p) self.assertEqual(b.peutComparer(), False)
class PlateauTestCase(unittest.TestCase): def setUp(self): rover1 = Rover(3, 4, CompassPoint.W) rover2 = Rover(2, 2, CompassPoint.N) self.plateau = Plateau(5, 5, [rover1, rover2]) def test_validPositionInside(self): self.assertTrue(self.plateau.isCoordinateAvailable(4, 4)) def test_invalidPositions(self): self.assertFalse(self.plateau.isCoordinateAvailable(6, 4)) self.assertFalse(self.plateau.isCoordinateAvailable(4, 6)) self.assertFalse(self.plateau.isCoordinateAvailable(-4, 4)) self.assertFalse(self.plateau.isCoordinateAvailable(4, -4)) def test_roverCollide(self): self.assertFalse(self.plateau.isCoordinateAvailable(3, 4))
def test_stoped_rover_with_correct_data_sample_two(Rover, Plateau): plat = Plateau(10, 12) rover = Rover(3, 3, 'E', plat) assert rover.position_x == 3 assert rover.position_y == 3 assert rover.face_direction == 'E' assert plat.max_x == 10 assert plat.max_y == 12
def test_stoped_rover_with_correct_data_sample_one(Rover, Plateau): plat = Plateau(5, 5) rover = Rover(1, 2, 'N', plat) assert rover.position_x == 1 assert rover.position_y == 2 assert rover.face_direction == 'N' assert plat.max_x == 5 assert plat.max_y == 5
def __init__(self): self.p = Plateau.Plateau((600, 400), 'resources/img', 200, 42, np.array([[300, 250, 0]])) self.f = PinholeFrame.PinholeFrame( id_=1, parameters='resources/parameters_webcam_victor.txt') self.d = Detector.Detector() self.Rref, self.Tref = None, None self.initialized = False
def test_init(self): """ Vérifie que la création du plateau est correcte. """ p1 = Plateau() # création d'instances de la classe plateau self.assertIsInstance(p1, Plateau) for i in range(12): self.assertEqual(p1[i], 4)
def test_choisir_case(self): cote = 1 j = JoueurMachineRandom(cote) p = Plateau() i = 2 + j.cote * 6 p[i] = 0 n = j.choisir_case(p) self.assertNotEqual(n, i) self.assertIn(n, range(6 * j.cote, 6 + 6 * j.cote))
def testPeutComparerTrue(self): p = Plateau(9) p.tapis[0][0] = Carte(1, 'A') p.tapis[1][0] = Carte(2, 'B') p.tapis[2][0] = Carte(3, 'C') p.tapis[4][0] = Carte(4, 'D') p.tapis[5][0] = Carte(5, 'E') p.tapis[6][0] = Carte(6, 'F') b = Borne(0, p) #Vérification peutComparer dans un cas Vrai self.assertEqual(b.peutComparer(), True)
def main(): plateau = Plateau(5, 5) rover = Rover(1, 2, "N", plateau) rover.run("LMLMLMLMM") print(rover.position) rover = Rover(3, 3, "E", plateau) rover.run("MMRMMRMRRM") print(rover.position)
def lancer_jeu(self, longueur=3, largeur=3): self.plateau = Plateau(longueur, largeur) self.afficher_jeu = AfficherJeu(self.plateau, self.gerer_click) self.afficher_jeu.actualiser_affichage() self.afficher_jeu.changer_title( "A {} de jouer !".format(self.joueur_en_cours.nom), self.joueur_en_cours.couleur) self.afficher_jeu.mainloop( ) #lance le jeu ! Ne s'arrete pas tant que le jeu n'est pas fini self.afficher_jeu.quit()
def test_if_rover_was_correctly_moved_over_boundary(Rover, Plateau): plat = Plateau(5, 5) rover = Rover(1, 2, 'N', plat) rover.change_position('M') assert rover.position_y == 3 rover.change_position('M') assert rover.position_y == 4 rover.change_position('M') rover.change_position('M') rover.change_position('M') assert rover.position_y == 5 assert rover.position_x == 1
def testComparerCondition2(self): #Cas dans lequel les deux groupes sont de force identique => on prnd en compte le total de points p = Plateau(9) p.tapis[0][0] = Carte(1, 'A') p.tapis[1][0] = Carte(2, 'A') p.tapis[2][0] = Carte(3, 'A') p.tapis[4][0] = Carte(4, 'B') p.tapis[5][0] = Carte(5, 'B') p.tapis[6][0] = Carte(6, 'B') b = Borne(0, p) b.g1.calculForce() b.g2.calculForce() b.comparer() self.assertEqual(p.tapis[3][0], 'J2')
def testComparerCondition1(self): p = Plateau(9) p.tapis[0][0] = Carte(1, 'A') p.tapis[1][0] = Carte(2, 'A') p.tapis[2][0] = Carte(3, 'A') p.tapis[4][0] = Carte(4, 'D') p.tapis[5][0] = Carte(5, 'E') p.tapis[6][0] = Carte(6, 'F') b = Borne(0, p) b.g1.calculForce() b.g2.calculForce() b.comparer() #Cas dans lequel J1 gagne, son groupe étant de force 5 contre g2 de force 2 self.assertEqual(p.tapis[3][0], 'J1')
def transform(self, data): x, y = self.__get_plateau_x_y(data) plato = Plateau(x, y) new_data = self.__transform_data(data) rovers_output = '' for i in range(0, len(new_data), 2): data_splited = new_data[i].split(' ') position_x, position_y = data_splited[0], data_splited[1] face_direction = data_splited[2] new_rover = Rover(position_x, position_y, face_direction, plato) output = self.__move_rover(new_rover, new_data[i + 1]) rovers_output += output return rovers_output
def testInit(self): p = Plateau(9) p.tapis[0][0] = Carte(1, 'A') p.tapis[1][0] = Carte(2, 'B') p.tapis[2][0] = Carte(3, 'C') p.tapis[4][0] = Carte(4, 'D') p.tapis[5][0] = Carte(5, 'E') p.tapis[6][0] = Carte(6, 'F') b = Borne(0, p) self.assertEqual( str(b.g1), str(GroupeCartes(Carte(1, 'A'), Carte(2, 'B'), Carte(3, 'C')))) self.assertEqual( str(b.g2), str(GroupeCartes(Carte(4, 'D'), Carte(5, 'E'), Carte(6, 'F')))) self.assertEqual(b.g1.carteCourante, 2) self.assertEqual(b.g2.carteCourante, 4)
def test(self) : # Tester les fonctions des autres classes taillePlateau = 8 nbBateaux = 3 plateauNao = Plateau(taillePlateau) #plateauNao.afficherPlateau() bateau1 = Bateau(3) bateau2 = Bateau(3) plateauNao.ajouterBateau(bateau1) plateauNao.ajouterBateau(bateau2) pos = Position(4,1) pos2 = Position(3,3) plateauNao.poserBateauVerticalement(bateau1, pos) bateau1.affichage() print() plateauNao.poserBateauHorizontalement(bateau2, pos2) bateau2.affichage() print() plateauNao.afficherPlateau()
return 2 else : if plateauAdverse.getNbPortionsBateaux() == 0: return 1 else: return 0 taillePlateau = 8 nbBateaux = 3 coupsNao = [] plateauNao = Plateau(taillePlateau) plateauAdv = PlateauAdversaire(taillePlateau, 12) #plateauNao.afficherPlateau() bateau1 = Bateau(3) bateau2 = Bateau(3) plateauNao.ajouterBateau(bateau1) plateauNao.ajouterBateau(bateau2) pos = Position(4,1) pos2 = Position(3,3) plateauNao.poserBateauVerticalement(bateau1, pos) bateau1.affichage() print() plateauNao.poserBateauHorizontalement(bateau2, pos2)