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_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 __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_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_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_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):
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_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 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 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_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 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 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 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 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 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 __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_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 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)
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 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 __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 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 main():
print("---WELCOME TO ROVER SIMULATOR---")
rover = Rover()
plateau = Plateau()
rover.setRoverName()
plateau.setPlateauSize()
rover.setCoordinatesAndOrientation()
rover.setInstruction()
plateau.setRoverCoordinates(rover.x, rover.y)
rover.setPlateauCoordinates(plateau.px, plateau.py)
print(
f"{rover.name} is starting at x: {rover.x},y: {rover.y}, orientation: {rover.orientation}"
)
rover.moveRover()
print(
f"{rover.name} has arrived at x: {rover.x},y: {rover.y}, orientation: {rover.orientation}"
)