def __init__(self, listeJoueurs, debug=False):
self._debug = debug
random.seed()
self._nombreJoueurs = len(listeJoueurs)
if self._debug:
self._numeroSequenceDes = 0
self._mappe = Mappe([
'foret', 'champ', 'colline', 'champ', 'colline', 'montagne',
'pre', 'foret', 'montagne', 'desert', 'foret', 'colline',
'pre', 'champ', 'montagne', 'pre', 'pre', 'foret', 'champ'
])
self._paquetCartes = Cartes(True)
else:
random.shuffle(listeJoueurs)
self._mappe = Mappe()
self._paquetCartes = Cartes()
self._joueurs = []
self._longueurCheminPlusLong = 1
self._joueurAyantCheminPlusLong = None
self._armeePlusPuissante = 0
self._joueurAyantArmeePlusPuissante = None
for i in range(self._nombreJoueurs):
self._joueurs.append(fabrique.creerJoueur(listeJoueurs[i], i))
def testDistribuerRessources1(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(12, Occupation.COLONIE, 1)
ressources = self.mappe._distribuerRessources(2)
self.assertEqual(ressources[(1, Ressource.BLE)], 1)
print "Test - Distribuer ressources 1"
def testVoleurs3(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._deplacerVoleurs(7)
t = self.mappe.obtenirTerritoireContenantVoleurs()
self.assertEqual(t.id(), 7)
print "Test - Voleurs 3"
def testDistribuerRessources2(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(24, Occupation.COLONIE, 1)
self.mappe._deplacerVoleurs(7)
ressources = self.mappe._distribuerRessources(3)
self.assertEqual(len(ressources), 0)
print "Test - Distribuer ressources 2"
def testVoleurs4(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._deplacerVoleurs(10)
self.assertRaisesRegexp(
RuntimeError,
'On ne peut pas déplacer les voleurs dans le territoire où ils se trouvent déjà',
self.mappe._deplacerVoleurs, 10)
print "Test - Voleurs 4"
def testDistribuerRessources1(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(12,Occupation.COLONIE,1)
ressources = self.mappe._distribuerRessources(2)
self.assertEqual(ressources[(1,Ressource.BLE)],1)
print "Test - Distribuer ressources 1"
def testVoleurs3(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._deplacerVoleurs(7)
t = self.mappe.obtenirTerritoireContenantVoleurs()
self.assertEqual(t.id(),7)
print "Test - Voleurs 3"
def testDistribuerRessources2(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(24,Occupation.COLONIE,1)
self.mappe._deplacerVoleurs(7)
ressources = self.mappe._distribuerRessources(3)
self.assertEqual(len(ressources),0)
print "Test - Distribuer ressources 2"
def __init__(self,listeJoueurs,debug=False):
self._debug = debug
random.seed()
self._nombreJoueurs = len(listeJoueurs)
if self._debug:
self._numeroSequenceDes = 0
self._mappe = Mappe(['foret','champ','colline','champ','colline','montagne','pre','foret','montagne','desert','foret','colline','pre','champ','montagne','pre','pre','foret','champ'])
self._paquetCartes = Cartes(True)
else:
random.shuffle(listeJoueurs)
self._mappe = Mappe()
self._paquetCartes = Cartes()
self._joueurs = []
self._longueurCheminPlusLong = 1
self._joueurAyantCheminPlusLong = None
self._armeePlusPuissante = 0
self._joueurAyantArmeePlusPuissante = None
for i in range(self._nombreJoueurs):
self._joueurs.append(fabrique.creerJoueur(listeJoueurs[i],i))
class Controleur(object):
def __init__(self,listeJoueurs,debug=False):
self._debug = debug
random.seed()
self._nombreJoueurs = len(listeJoueurs)
if self._debug:
self._numeroSequenceDes = 0
self._mappe = Mappe(['foret','champ','colline','champ','colline','montagne','pre','foret','montagne','desert','foret','colline','pre','champ','montagne','pre','pre','foret','champ'])
self._paquetCartes = Cartes(True)
else:
random.shuffle(listeJoueurs)
self._mappe = Mappe()
self._paquetCartes = Cartes()
self._joueurs = []
self._longueurCheminPlusLong = 1
self._joueurAyantCheminPlusLong = None
self._armeePlusPuissante = 0
self._joueurAyantArmeePlusPuissante = None
for i in range(self._nombreJoueurs):
self._joueurs.append(fabrique.creerJoueur(listeJoueurs[i],i))
def jouer(self):
# Premier tour: chaque joueur place une colonie et une route
for i in range(self._nombreJoueurs):
#print 'Premier tour,', self._joueurs[i].nom()
try:
(positionColonie, extremiteRoute) = self._joueurs[i].premierTour(self._mappe)
self._mappe._ajouterOccupationInitiale(positionColonie,Occupation.COLONIE,i)
self._joueurs[i].ajusterCapaciteEchange(self._mappe.obtenirIntersection(positionColonie))
self._mappe._ajouterRoute(positionColonie, extremiteRoute, i)
#print 'Occupation placée avec succès'
except RuntimeError as e:
print 'ERREUR:', e
# Deuxième tour: en ordre inverse, chaque joueur place une seconde colonie et une seconde route
for i in range(self._nombreJoueurs-1,-1,-1):
#print 'Deuxième tour,', self._joueurs[i].nom()
try:
(positionColonie, extremiteRoute) = self._joueurs[i].deuxiemeTour(self._mappe)
self._mappe._ajouterOccupationInitiale(positionColonie,Occupation.COLONIE,i)
self._joueurs[i].ajusterCapaciteEchange(self._mappe.obtenirIntersection(positionColonie))
self._mappe._ajouterRoute(positionColonie, extremiteRoute, i)
#print 'Occupation placée avec succès'
# Distribuer les ressources initiales
self._mappe._distribuerRessourcesInitiales(self._joueurs[i],positionColonie)
except RuntimeError as e:
print 'ERREUR:', e
#print 'État après le placement initial:'
#self._mappe.afficher()
#self._afficherEtatJoueurs()
# À partir de maintenant on commence les tours réguliers
joueurCourant = 0
numeroTour = 0
while not self._joueurGagnant() and numeroTour < 1000:
numeroTour += 1
valeur = self._lancerDes()
#print 'Tour', numeroTour
#print 'Valeur des dés',valeur
# Si la valeur des dés est 7, chaque joueur possédant plus de 7 cartes doit en discarter la
# moitié et le joueur courant doit déplacer les voleurs
if (valeur == 7):
for joueur in self._joueurs:
if joueur.nombreRessources() > 7:
#print joueur.nom(),"se fait voler"
quantiteVolee = joueur.nombreRessources() // 2
joueur.volerRessources(quantiteVolee)
if self._debug:
(positionVoleurs,joueurVole) = self._joueurs[joueurCourant].jouerVoleurs(self._mappe,self._infoJoueurs())
else:
(positionVoleurs,joueurVole) = self._joueurs[joueurCourant].jouerVoleurs(self._mappe,self._infoJoueurs())
if 1 <= positionVoleurs and positionVoleurs <= 19 and joueurVole in range(self._nombreJoueurs):
self._mappe._deplacerVoleurs(positionVoleurs)
#print self._joueurs[joueurCourant].nom(), 'vole', self._joueurs[joueurVole].nom()
ressourceVolee = self._joueurs[joueurVole].pigerRessourceAleatoirement()
if ressourceVolee == None:
print "ERREUR : Ce joueur ne possède aucune ressource"
else:
self._joueurs[joueurCourant].ajouterRessources(ressourceVolee,1)
# Sinon, chaque joueur reçoit les ressources auxquelles il a droit
else:
ressources = self._mappe._distribuerRessources(valeur)
for (j,r) in ressources:
self._joueurs[j].ajouterRessources(r,ressources[(j,r)])
# On rend jouables les cartes chevalier recues dans le tour précédent
self._joueurs[joueurCourant].activerChevaliers()
#print 'Etat des joueurs après distribution des ressources:'
for i in range(self._nombreJoueurs):
self._joueurs[i].afficher()
#print
#print self._joueurs[joueurCourant].nom(), '[', joueurCourant, '] joue'
# On exécute toutes les actions choisies par le joueur courant
nombreActions = 0
if self._debug:
action = self._joueurs[joueurCourant].choisirAction(self._mappe,self._infoJoueurs(),self._paquetCartes.vide(),self._numeroSequenceDes)
else:
action = self._joueurs[joueurCourant].choisirAction(self._mappe,self._infoJoueurs(),self._paquetCartes.vide())
while action != Action.TERMINER and nombreActions < 50:
self._executer(action,joueurCourant)
if self._debug:
action = self._joueurs[joueurCourant].choisirAction(self._mappe,self._infoJoueurs(),self._paquetCartes.vide(),self._numeroSequenceDes)
else:
action = self._joueurs[joueurCourant].choisirAction(self._mappe,self._infoJoueurs(),self._paquetCartes.vide())
nombreActions += 1
# On passe au joueur suivant
#print "État à la fin du tour"
#self._mappe.afficher()
#self._afficherEtatJoueurs()
joueurCourant = (joueurCourant+1) % self._nombreJoueurs
# Retourne une liste contenant un triplet (pv, car, ch) pour chaque joueur
# où pv = nombre de points de victoire (excluant les cartes de points de victoire cachées)
# car = nombre de cartes ressources que le joueur a en sa possession
# ch = nombre de cartes chevalier jouées
def _infoJoueurs(self):
infoJoueurs = []
for i in range(self._nombreJoueurs):
infoJoueurs.append((self._joueurs[i].nombrePointsVictoireVisibles(),
self._joueurs[i].nombreCartesRessources(),
self._joueurs[i].nombreChevaliers()))
return infoJoueurs
def _afficherEtatJoueurs(self):
for i in range(self._nombreJoueurs):
self._joueurs[i].afficher()
def _joueurGagnant(self):
for j in range(self._nombreJoueurs):
if self._joueurs[j].nombrePointsVictoire() >= 10:
#print self._joueurs[j].nom(),"a gagné la partie"
for k in range(self._nombreJoueurs):
self._joueurs[k].finDePartie(self._mappe,self._joueurs[j].id())
return True
return False
def _executer(self,(action,donnees),joueurCourant):
if action == Action.ACHETER_CARTE:
#print "ACHETER CARTE"
if (self._joueurs[joueurCourant].quantiteRessources(Ressource.LAINE) >= 1 and
self._joueurs[joueurCourant].quantiteRessources(Ressource.MINERAL) >= 1 and
self._joueurs[joueurCourant].quantiteRessources(Ressource.BLE) >= 1):
if self._paquetCartes.vide():
i=0
#print "ERREUR: Paquet de cartes vide"
else:
self._joueurs[joueurCourant].retirerRessources(Ressource.LAINE,1)
self._joueurs[joueurCourant].retirerRessources(Ressource.MINERAL,1)
self._joueurs[joueurCourant].retirerRessources(Ressource.BLE,1)
self._joueurs[joueurCourant].ajouterCarte(self._paquetCartes.pigerCarte())
else:
print "ERREUR: Pas assez de ressources pour acheter une carte"
elif action == Action.AJOUTER_COLONIE:
#print "AJOUTER COLONIE"
if (self._joueurs[joueurCourant].quantiteRessources(Ressource.BOIS) >= 1 and
self._joueurs[joueurCourant].quantiteRessources(Ressource.ARGILE) >= 1 and
self._joueurs[joueurCourant].quantiteRessources(Ressource.BLE) >= 1 and
self._joueurs[joueurCourant].quantiteRessources(Ressource.LAINE) >= 1):
try:
self._mappe._ajouterOccupation(donnees[0],Occupation.COLONIE,joueurCourant)
self._joueurs[joueurCourant].ajusterCapaciteEchange(self._mappe.obtenirIntersection(donnees[0]))
self._joueurs[joueurCourant].retirerRessources(Ressource.BOIS,1)
self._joueurs[joueurCourant].retirerRessources(Ressource.ARGILE,1)
self._joueurs[joueurCourant].retirerRessources(Ressource.BLE,1)
self._joueurs[joueurCourant].retirerRessources(Ressource.LAINE,1)
self._joueurs[joueurCourant].augmenterPointsVictoire(1)
except RuntimeError as e:
print 'ERREUR:',e
else:
print "ERREUR: Pas assez de ressources pour construire une colonie"
elif action == Action.AJOUTER_VILLE:
#print "AJOUTER VILLE"
if (self._joueurs[joueurCourant].quantiteRessources(Ressource.BLE) >= 2 and
self._joueurs[joueurCourant].quantiteRessources(Ressource.MINERAL) >= 3):
try:
self._mappe._ajouterOccupation(donnees[0],Occupation.VILLE,joueurCourant)
self._joueurs[joueurCourant].retirerRessources(Ressource.BLE,2)
self._joueurs[joueurCourant].retirerRessources(Ressource.MINERAL,3)
self._joueurs[joueurCourant].augmenterPointsVictoire(1)
except RuntimeError as e:
print 'ERREUR:',e
else:
print "ERREUR: Pas assez de ressources pour construire une ville"
elif action == Action.AJOUTER_ROUTE:
#print "AJOUTER ROUTE"
if (self._joueurs[joueurCourant].quantiteRessources(Ressource.BOIS) >= 1 and
self._joueurs[joueurCourant].quantiteRessources(Ressource.ARGILE) >= 1):
try:
self._mappe._ajouterRoute(donnees[0],donnees[1],joueurCourant)
self._joueurs[joueurCourant].retirerRessources(Ressource.BOIS,1)
self._joueurs[joueurCourant].retirerRessources(Ressource.ARGILE,1)
self._attribuerPointsRoutePlusLongue(joueurCourant)
except RuntimeError as e:
print 'ERREUR:',e
else:
print "ERREUR: Pas assez de ressources pour construire une route"
elif action == Action.JOUER_CARTE_CHEVALIER:
#print "JOUER CARTE CHEVALIER"
try:
self._joueurs[joueurCourant].jouerCarteChevalier()
self._attribuerPointsArmeePlusPuissante(joueurCourant)
self._mappe._deplacerVoleurs(donnees[0])
joueurVole = donnees[1]
if joueurVole in [v.obtenirOccupant() for v in self._mappe.obtenirTerritoire(donnees[0]).obtenirVoisins()]:
ressourceVolee = self._joueurs[joueurVole].pigerRessourceAleatoirement()
self._joueurs[joueurCourant].ajouterRessources(ressourceVolee,1)
except Exception as e:
print 'ERREUR:', e
elif action == Action.ECHANGER_RESSOURCES:
#print "ECHANGER"
self._echanger(joueurCourant,donnees[0],donnees[1],donnees[2])
else:
pass # Action invalide
def setUp(self):
self.mappe = Mappe()
class TestPrincipal(unittest.TestCase):
def setUp(self):
self.mappe = Mappe()
def tearDown(self):
pass
#self.mappe.afficher()
def testAjouterOccupationInitiale1(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.assertTrue(self.mappe.obtenirIntersection(23).occupe())
self.assertFalse(self.mappe.joueurPossedeRoute(23,24,1))
print "Test - Occupation initiale 1"
def testAjouterOccupationInitiale2(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterRoute(23,24,1)
self.assertTrue(self.mappe.obtenirIntersection(23).occupe())
self.assertTrue(self.mappe.joueurPossedeRoute(23,24,1))
print "Test - Occupation initiale 2"
def testAjouterOccupationInitiale3(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterRoute(23,24,1)
self.assertRaisesRegexp(RuntimeError,'Une intersection voisine est déjà occupée',self.mappe._ajouterOccupationInitiale,22,Occupation.COLONIE,2)
print "Test - Occupation initiale 3"
def testAjoutColonie(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.assertRaisesRegexp(RuntimeError,'Emplacement déjà occupé',self.mappe._ajouterOccupationInitiale,23,Occupation.COLONIE,1)
print "Test- Ajout colonie"
def testAjoutVille1(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterRoute(23,24,1)
self.mappe._ajouterRoute(14,24,1)
self.assertRaisesRegexp(RuntimeError,'On ne peut construire une ville que sur l\'emplacement d\'une colonie',self.mappe._ajouterOccupationInitiale,14,Occupation.VILLE,1)
print "Test - Ajout ville 1"
def testAjoutVille2(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.assertRaisesRegexp(RuntimeError,'On ne peut construire une ville sur un emplacement occupé par un autre joueur',self.mappe._ajouterOccupationInitiale,23,Occupation.VILLE,2)
print "Test - Ajout ville 2"
def testAjoutVille3(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterOccupationInitiale(23,Occupation.VILLE,1)
self.assertEqual(self.mappe.obtenirIntersection(23).afficherOccupation(),'V1')
print "Test - Ajout ville 3"
def testAjoutVille4(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterOccupationInitiale(23,Occupation.VILLE,1)
self.assertRaisesRegexp(RuntimeError,'Il y a déjà une ville à l\'emplacement spécifié',self.mappe._ajouterOccupationInitiale,23,Occupation.VILLE,2)
print "Test - Ajout ville 4"
def testAjoutRoute1(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterRoute(23,24,1)
self.mappe._ajouterRoute(25,24,1)
self.assertTrue(self.mappe.joueurPossedeRoute(24,25,1))
print "Test - Ajouter route 1"
def testAjoutRoute2(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterRoute(23,24,1)
self.assertRaisesRegexp(RuntimeError,'Le joueur 1 ne peut pas construire une route à cet endroit',self.mappe._ajouterRoute,18,19,1)
print "Test - Ajouter route 2"
def testAjoutRoute3(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterRoute(23,24,1)
self.assertRaisesRegexp(RuntimeError,'Le joueur 2 ne peut pas construire une route à cet endroit',self.mappe._ajouterRoute,24,25,2)
print "Test - Ajouter route 3"
def testPeutConstruireOccupation1(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterRoute(23,24,1)
self.assertRaisesRegexp(RuntimeError,'Une intersection voisine est déjà occupée',self.mappe._ajouterOccupation,24,Occupation.COLONIE,1)
print "Test - Peut contruire occupation 1"
def testPeutConstruireOccupation2(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterRoute(23,24,1)
self.assertRaisesRegexp(RuntimeError,'Une intersection voisine est déjà occupée',self.mappe._ajouterOccupation,25,Occupation.COLONIE,1)
print "Test - Peut contruire occupation 2"
def testPeutConstruireOccupation3(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterRoute(23,24,1)
self.assertRaisesRegexp(RuntimeError,'Une intersection voisine est déjà occupée',self.mappe._ajouterOccupation,25,Occupation.COLONIE,2)
print "Test - Peut contruire occupation 3"
def testPeutConstruireOccupation4(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterRoute(23,24,1)
self.mappe._ajouterRoute(24,25,1)
self.mappe._ajouterOccupation(25,Occupation.COLONIE,1)
self.assertTrue(self.mappe.obtenirIntersection(25).occupe())
print "Test - Peut construire occupation 4"
def testPeutConstruireOccupation5(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterOccupationInitiale(33,Occupation.COLONIE,1)
self.mappe._ajouterOccupationInitiale(35,Occupation.COLONIE,1)
self.assertRaisesRegexp(RuntimeError,'Une intersection voisine est déjà occupée',self.mappe._ajouterOccupation,34,Occupation.COLONIE,2)
print "Test - Peut construire occupation 5"
def testCheminPlusLong1(self):
self.mappe._ajouterOccupationInitiale(23,Occupation.COLONIE,1)
self.mappe._ajouterOccupationInitiale(12,Occupation.COLONIE,2)
self.mappe._ajouterOccupationInitiale(43,Occupation.COLONIE,2)
self.mappe._ajouterRoute(23,24,1)
self.mappe._ajouterRoute(24,25,1)
self.mappe._ajouterRoute(25,36,1)
self.mappe._ajouterRoute(36,37,1)
self.mappe._ajouterRoute(37,38,1)
self.mappe._ajouterRoute(38,27,1)
self.mappe._ajouterRoute(37,47,1)
self.mappe._ajouterRoute(26,27,1)
self.mappe._ajouterRoute(26,25,1)
self.mappe._ajouterRoute(16,26,1)
self.mappe._ajouterRoute(15,16,1)
self.mappe._ajouterRoute(43,44,2)
self.mappe._ajouterRoute(52,44,2)
self.mappe._ajouterRoute(12,13,2)
self.mappe._ajouterOccupation(38,Occupation.COLONIE,1)
self.mappe._ajouterOccupation(43,Occupation.VILLE,2)
self.assertEqual(self.mappe.cheminPlusLong(1), 9)
self.assertEqual(self.mappe.cheminPlusLong(2), 2)
print "Test - Chemin plus long 1"
def testCheminPlusLong2(self):
self.mappe._ajouterOccupationInitiale(12,Occupation.COLONIE,2)
self.mappe._ajouterOccupationInitiale(43,Occupation.COLONIE,2)
self.mappe._ajouterRoute(43,44,2)
self.mappe._ajouterRoute(52,44,2)
self.mappe._ajouterRoute(45,44,2)
self.mappe._ajouterRoute(45,46,2)
self.mappe._ajouterRoute(12,13,2)
self.assertEqual(self.mappe.cheminPlusLong(2), 3)
print "Test - Chemin plus long 2"
def testCheminPlusLong3(self):
self.mappe._ajouterOccupationInitiale(12,Occupation.COLONIE,2)
self.mappe._ajouterOccupationInitiale(43,Occupation.COLONIE,2)
self.mappe._ajouterRoute(43,44,2)
self.mappe._ajouterRoute(52,44,2)
self.mappe._ajouterRoute(45,44,2)
self.mappe._ajouterRoute(45,46,2)
self.mappe._ajouterRoute(12,13,2)
self.mappe._ajouterRoute(12,22,2)
self.mappe._ajouterRoute(21,22,2)
self.assertEqual(self.mappe.cheminPlusLong(2), 3)
print "Test - Chemin plus long 3"
def testCheminPlusLong4(self):
self.mappe._ajouterOccupationInitiale(12,Occupation.COLONIE,2)
self.mappe._ajouterOccupationInitiale(43,Occupation.COLONIE,2)
self.mappe._ajouterRoute(43,44,2)
self.mappe._ajouterRoute(52,44,2)
self.mappe._ajouterRoute(45,44,2)
self.mappe._ajouterRoute(45,46,2)
self.mappe._ajouterRoute(12,13,2)
self.mappe._ajouterRoute(12,22,2)
self.mappe._ajouterRoute(21,22,2)
self.mappe._ajouterRoute(5,13,2)
self.assertEqual(self.mappe.cheminPlusLong(2), 4)
print "Test - Chemin plus long 4"
def testVoleurs1(self):
t = self.mappe.obtenirTerritoireContenantVoleurs()
self.assertTrue(isinstance(t,Desert))
print "Test - Voleurs 1"
def testVoleurs3(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._deplacerVoleurs(7)
t = self.mappe.obtenirTerritoireContenantVoleurs()
self.assertEqual(t.id(),7)
print "Test - Voleurs 3"
def testVoleurs4(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._deplacerVoleurs(10)
self.assertRaisesRegexp(RuntimeError,'On ne peut pas déplacer les voleurs dans le territoire où ils se trouvent déjà',self.mappe._deplacerVoleurs,10)
print "Test - Voleurs 4"
def testVoleurs5(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._deplacerVoleurs(5)
self.mappe._deplacerVoleurs(18)
t = self.mappe.obtenirTerritoireContenantVoleurs()
self.assertEqual(t.id(),18)
print "Test - Voleurs 5"
#self.mappe.afficher()
def testDistribuerRessources1(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(12,Occupation.COLONIE,1)
ressources = self.mappe._distribuerRessources(2)
self.assertEqual(ressources[(1,Ressource.BLE)],1)
print "Test - Distribuer ressources 1"
def testDistribuerRessources2(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(24,Occupation.COLONIE,1)
self.mappe._deplacerVoleurs(7)
ressources = self.mappe._distribuerRessources(3)
self.assertEqual(len(ressources),0)
print "Test - Distribuer ressources 2"
def testDistribuerRessources3(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(24,Occupation.COLONIE,1)
self.mappe._ajouterOccupationInitiale(24,Occupation.VILLE,1)
ressources = self.mappe._distribuerRessources(3)
self.assertEqual(ressources[(1,Ressource.BOIS)],2)
print "Test - Distribuer ressources 3"
def testDistribuerRessources4(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(24,Occupation.COLONIE,1)
self.mappe._ajouterOccupationInitiale(24,Occupation.VILLE,1)
self.mappe._ajouterOccupationInitiale(16,Occupation.COLONIE,1)
ressources = self.mappe._distribuerRessources(3)
self.assertEqual(ressources[(1,Ressource.BOIS)],3)
print "Test - Distribuer ressources 4"
def testDistribuerRessources5(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(24,Occupation.COLONIE,1)
self.mappe._ajouterOccupationInitiale(24,Occupation.VILLE,1)
self.mappe._ajouterOccupationInitiale(16,Occupation.COLONIE,2)
ressources = self.mappe._distribuerRessources(3)
self.assertEqual(ressources[(1,Ressource.BOIS)],2)
self.assertEqual(ressources[(2,Ressource.BOIS)],1)
print "Test - Distribuer ressources 5"
def testDistribuerRessources6(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(19,Occupation.COLONIE,1)
self.mappe._ajouterOccupationInitiale(19,Occupation.VILLE,1)
self.mappe._ajouterOccupationInitiale(37,Occupation.COLONIE,2)
ressources = self.mappe._distribuerRessources(8)
self.assertEqual(ressources[(1,Ressource.BLE)],2)
self.assertEqual(ressources[(2,Ressource.LAINE)],1)
print "Test - Distribuer ressources 6"
def testDistribuerRessources7(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(19,Occupation.COLONIE,1)
self.mappe._ajouterOccupationInitiale(19,Occupation.VILLE,1)
self.mappe._ajouterOccupationInitiale(26,Occupation.COLONIE,1)
self.mappe._ajouterOccupationInitiale(37,Occupation.COLONIE,2)
ressources = self.mappe._distribuerRessources(8)
self.assertEqual(ressources[(1,Ressource.BLE)],2)
self.assertEqual(ressources[(1,Ressource.LAINE)],1)
self.assertEqual(ressources[(2,Ressource.LAINE)],1)
print "Test - Distribuer ressources 7"
def testVoleurs4(self):
typesTerritoires = ['champ','champ','champ','champ','foret','foret','foret','foret','pre','pre','pre','pre','montagne','montagne','montagne','colline','colline','colline','desert']
self.mappe = Mappe(typesTerritoires)
self.mappe._deplacerVoleurs(10)
self.assertRaisesRegexp(RuntimeError,'On ne peut pas déplacer les voleurs dans le territoire où ils se trouvent déjà',self.mappe._deplacerVoleurs,10)
print "Test - Voleurs 4"
class Controleur(object):
def __init__(self, listeJoueurs, debug=False):
self._debug = debug
random.seed()
self._nombreJoueurs = len(listeJoueurs)
if self._debug:
self._numeroSequenceDes = 0
self._mappe = Mappe([
'foret', 'champ', 'colline', 'champ', 'colline', 'montagne',
'pre', 'foret', 'montagne', 'desert', 'foret', 'colline',
'pre', 'champ', 'montagne', 'pre', 'pre', 'foret', 'champ'
])
self._paquetCartes = Cartes(True)
else:
random.shuffle(listeJoueurs)
self._mappe = Mappe()
self._paquetCartes = Cartes()
self._joueurs = []
self._longueurCheminPlusLong = 1
self._joueurAyantCheminPlusLong = None
self._armeePlusPuissante = 0
self._joueurAyantArmeePlusPuissante = None
for i in range(self._nombreJoueurs):
self._joueurs.append(fabrique.creerJoueur(listeJoueurs[i], i))
def jouer(self):
# Premier tour: chaque joueur place une colonie et une route
for i in range(self._nombreJoueurs):
#print 'Premier tour,', self._joueurs[i].nom()
try:
(positionColonie,
extremiteRoute) = self._joueurs[i].premierTour(self._mappe)
self._mappe._ajouterOccupationInitiale(positionColonie,
Occupation.COLONIE, i)
self._joueurs[i].ajusterCapaciteEchange(
self._mappe.obtenirIntersection(positionColonie))
self._mappe._ajouterRoute(positionColonie, extremiteRoute, i)
#print 'Occupation placée avec succès'
except RuntimeError as e:
print 'ERREUR:', e
# Deuxième tour: en ordre inverse, chaque joueur place une seconde colonie et une seconde route
for i in range(self._nombreJoueurs - 1, -1, -1):
#print 'Deuxième tour,', self._joueurs[i].nom()
try:
(positionColonie,
extremiteRoute) = self._joueurs[i].deuxiemeTour(self._mappe)
self._mappe._ajouterOccupationInitiale(positionColonie,
Occupation.COLONIE, i)
self._joueurs[i].ajusterCapaciteEchange(
self._mappe.obtenirIntersection(positionColonie))
self._mappe._ajouterRoute(positionColonie, extremiteRoute, i)
#print 'Occupation placée avec succès'
# Distribuer les ressources initiales
self._mappe._distribuerRessourcesInitiales(
self._joueurs[i], positionColonie)
except RuntimeError as e:
print 'ERREUR:', e
#print 'État après le placement initial:'
#self._mappe.afficher()
#self._afficherEtatJoueurs()
# À partir de maintenant on commence les tours réguliers
joueurCourant = 0
numeroTour = 0
while not self._joueurGagnant() and numeroTour < 1000:
numeroTour += 1
valeur = self._lancerDes()
#print 'Tour', numeroTour
#print 'Valeur des dés',valeur
# Si la valeur des dés est 7, chaque joueur possédant plus de 7 cartes doit en discarter la
# moitié et le joueur courant doit déplacer les voleurs
if (valeur == 7):
for joueur in self._joueurs:
if joueur.nombreRessources() > 7:
#print joueur.nom(),"se fait voler"
quantiteVolee = joueur.nombreRessources() // 2
joueur.volerRessources(quantiteVolee)
if self._debug:
(positionVoleurs,
joueurVole) = self._joueurs[joueurCourant].jouerVoleurs(
self._mappe, self._infoJoueurs())
else:
(positionVoleurs,
joueurVole) = self._joueurs[joueurCourant].jouerVoleurs(
self._mappe, self._infoJoueurs())
if 1 <= positionVoleurs and positionVoleurs <= 19 and joueurVole in range(
self._nombreJoueurs):
self._mappe._deplacerVoleurs(positionVoleurs)
#print self._joueurs[joueurCourant].nom(), 'vole', self._joueurs[joueurVole].nom()
ressourceVolee = self._joueurs[
joueurVole].pigerRessourceAleatoirement()
if ressourceVolee == None:
print "ERREUR : Ce joueur ne possède aucune ressource"
else:
self._joueurs[joueurCourant].ajouterRessources(
ressourceVolee, 1)
# Sinon, chaque joueur reçoit les ressources auxquelles il a droit
else:
ressources = self._mappe._distribuerRessources(valeur)
for (j, r) in ressources:
self._joueurs[j].ajouterRessources(r, ressources[(j, r)])
# On rend jouables les cartes chevalier recues dans le tour précédent
self._joueurs[joueurCourant].activerChevaliers()
#print 'Etat des joueurs après distribution des ressources:'
for i in range(self._nombreJoueurs):
self._joueurs[i].afficher()
#print
#print self._joueurs[joueurCourant].nom(), '[', joueurCourant, '] joue'
# On exécute toutes les actions choisies par le joueur courant
nombreActions = 0
if self._debug:
action = self._joueurs[joueurCourant].choisirAction(
self._mappe, self._infoJoueurs(),
self._paquetCartes.vide(), self._numeroSequenceDes)
else:
action = self._joueurs[joueurCourant].choisirAction(
self._mappe, self._infoJoueurs(),
self._paquetCartes.vide())
while action != Action.TERMINER and nombreActions < 50:
self._executer(action, joueurCourant)
if self._debug:
action = self._joueurs[joueurCourant].choisirAction(
self._mappe, self._infoJoueurs(),
self._paquetCartes.vide(), self._numeroSequenceDes)
else:
action = self._joueurs[joueurCourant].choisirAction(
self._mappe, self._infoJoueurs(),
self._paquetCartes.vide())
nombreActions += 1
# On passe au joueur suivant
#print "État à la fin du tour"
#self._mappe.afficher()
#self._afficherEtatJoueurs()
joueurCourant = (joueurCourant + 1) % self._nombreJoueurs
# Retourne une liste contenant un triplet (pv, car, ch) pour chaque joueur
# où pv = nombre de points de victoire (excluant les cartes de points de victoire cachées)
# car = nombre de cartes ressources que le joueur a en sa possession
# ch = nombre de cartes chevalier jouées
def _infoJoueurs(self):
infoJoueurs = []
for i in range(self._nombreJoueurs):
infoJoueurs.append(
(self._joueurs[i].nombrePointsVictoireVisibles(),
self._joueurs[i].nombreCartesRessources(),
self._joueurs[i].nombreChevaliers()))
return infoJoueurs
def _afficherEtatJoueurs(self):
for i in range(self._nombreJoueurs):
self._joueurs[i].afficher()
def _joueurGagnant(self):
for j in range(self._nombreJoueurs):
if self._joueurs[j].nombrePointsVictoire() >= 10:
#print self._joueurs[j].nom(),"a gagné la partie"
for k in range(self._nombreJoueurs):
self._joueurs[k].finDePartie(self._mappe,
self._joueurs[j].id())
return True
return False
def _executer(self, (action, donnees), joueurCourant):
if action == Action.ACHETER_CARTE:
#print "ACHETER CARTE"
if (self._joueurs[joueurCourant].quantiteRessources(
Ressource.LAINE) >= 1
and self._joueurs[joueurCourant].quantiteRessources(
Ressource.MINERAL) >= 1
and self._joueurs[joueurCourant].quantiteRessources(
Ressource.BLE) >= 1):
if self._paquetCartes.vide():
i = 0
#print "ERREUR: Paquet de cartes vide"
else:
self._joueurs[joueurCourant].retirerRessources(
Ressource.LAINE, 1)
self._joueurs[joueurCourant].retirerRessources(
Ressource.MINERAL, 1)
self._joueurs[joueurCourant].retirerRessources(
Ressource.BLE, 1)
self._joueurs[joueurCourant].ajouterCarte(
self._paquetCartes.pigerCarte())
else:
print "ERREUR: Pas assez de ressources pour acheter une carte"
elif action == Action.AJOUTER_COLONIE:
#print "AJOUTER COLONIE"
if (self._joueurs[joueurCourant].quantiteRessources(Ressource.BOIS)
>= 1 and self._joueurs[joueurCourant].quantiteRessources(
Ressource.ARGILE) >= 1
and self._joueurs[joueurCourant].quantiteRessources(
Ressource.BLE) >= 1
and self._joueurs[joueurCourant].quantiteRessources(
Ressource.LAINE) >= 1):
try:
self._mappe._ajouterOccupation(donnees[0],
Occupation.COLONIE,
joueurCourant)
self._joueurs[joueurCourant].ajusterCapaciteEchange(
self._mappe.obtenirIntersection(donnees[0]))
self._joueurs[joueurCourant].retirerRessources(
Ressource.BOIS, 1)
self._joueurs[joueurCourant].retirerRessources(
Ressource.ARGILE, 1)
self._joueurs[joueurCourant].retirerRessources(
Ressource.BLE, 1)
self._joueurs[joueurCourant].retirerRessources(
Ressource.LAINE, 1)
self._joueurs[joueurCourant].augmenterPointsVictoire(1)
except RuntimeError as e:
print 'ERREUR:', e
else:
print "ERREUR: Pas assez de ressources pour construire une colonie"
elif action == Action.AJOUTER_VILLE:
#print "AJOUTER VILLE"
if (self._joueurs[joueurCourant].quantiteRessources(Ressource.BLE)
>= 2 and self._joueurs[joueurCourant].quantiteRessources(
Ressource.MINERAL) >= 3):
try:
self._mappe._ajouterOccupation(donnees[0],
Occupation.VILLE,
joueurCourant)
self._joueurs[joueurCourant].retirerRessources(
Ressource.BLE, 2)
self._joueurs[joueurCourant].retirerRessources(
Ressource.MINERAL, 3)
self._joueurs[joueurCourant].augmenterPointsVictoire(1)
except RuntimeError as e:
print 'ERREUR:', e
else:
print "ERREUR: Pas assez de ressources pour construire une ville"
elif action == Action.AJOUTER_ROUTE:
#print "AJOUTER ROUTE"
if (self._joueurs[joueurCourant].quantiteRessources(Ressource.BOIS)
>= 1 and self._joueurs[joueurCourant].quantiteRessources(
Ressource.ARGILE) >= 1):
try:
self._mappe._ajouterRoute(donnees[0], donnees[1],
joueurCourant)
self._joueurs[joueurCourant].retirerRessources(
Ressource.BOIS, 1)
self._joueurs[joueurCourant].retirerRessources(
Ressource.ARGILE, 1)
self._attribuerPointsRoutePlusLongue(joueurCourant)
except RuntimeError as e:
print 'ERREUR:', e
else:
print "ERREUR: Pas assez de ressources pour construire une route"
elif action == Action.JOUER_CARTE_CHEVALIER:
#print "JOUER CARTE CHEVALIER"
try:
self._joueurs[joueurCourant].jouerCarteChevalier()
self._attribuerPointsArmeePlusPuissante(joueurCourant)
self._mappe._deplacerVoleurs(donnees[0])
joueurVole = donnees[1]
if joueurVole in [
v.obtenirOccupant()
for v in self._mappe.obtenirTerritoire(
donnees[0]).obtenirVoisins()
]:
ressourceVolee = self._joueurs[
joueurVole].pigerRessourceAleatoirement()
self._joueurs[joueurCourant].ajouterRessources(
ressourceVolee, 1)
except Exception as e:
print 'ERREUR:', e
elif action == Action.ECHANGER_RESSOURCES:
#print "ECHANGER"
self._echanger(joueurCourant, donnees[0], donnees[1], donnees[2])
else:
pass # Action invalide
def setUp(self):
self.mappe = Mappe()
class TestPrincipal(unittest.TestCase):
def setUp(self):
self.mappe = Mappe()
def tearDown(self):
pass
#self.mappe.afficher()
def testAjouterOccupationInitiale1(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.assertTrue(self.mappe.obtenirIntersection(23).occupe())
self.assertFalse(self.mappe.joueurPossedeRoute(23, 24, 1))
print "Test - Occupation initiale 1"
def testAjouterOccupationInitiale2(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterRoute(23, 24, 1)
self.assertTrue(self.mappe.obtenirIntersection(23).occupe())
self.assertTrue(self.mappe.joueurPossedeRoute(23, 24, 1))
print "Test - Occupation initiale 2"
def testAjouterOccupationInitiale3(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterRoute(23, 24, 1)
self.assertRaisesRegexp(
RuntimeError, 'Une intersection voisine est déjà occupée',
self.mappe._ajouterOccupationInitiale, 22, Occupation.COLONIE, 2)
print "Test - Occupation initiale 3"
def testAjoutColonie(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.assertRaisesRegexp(RuntimeError, 'Emplacement déjà occupé',
self.mappe._ajouterOccupationInitiale, 23,
Occupation.COLONIE, 1)
print "Test- Ajout colonie"
def testAjoutVille1(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterRoute(23, 24, 1)
self.mappe._ajouterRoute(14, 24, 1)
self.assertRaisesRegexp(
RuntimeError,
'On ne peut construire une ville que sur l\'emplacement d\'une colonie',
self.mappe._ajouterOccupationInitiale, 14, Occupation.VILLE, 1)
print "Test - Ajout ville 1"
def testAjoutVille2(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.assertRaisesRegexp(
RuntimeError,
'On ne peut construire une ville sur un emplacement occupé par un autre joueur',
self.mappe._ajouterOccupationInitiale, 23, Occupation.VILLE, 2)
print "Test - Ajout ville 2"
def testAjoutVille3(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterOccupationInitiale(23, Occupation.VILLE, 1)
self.assertEqual(
self.mappe.obtenirIntersection(23).afficherOccupation(), 'V1')
print "Test - Ajout ville 3"
def testAjoutVille4(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterOccupationInitiale(23, Occupation.VILLE, 1)
self.assertRaisesRegexp(
RuntimeError,
'Il y a déjà une ville à l\'emplacement spécifié',
self.mappe._ajouterOccupationInitiale, 23, Occupation.VILLE, 2)
print "Test - Ajout ville 4"
def testAjoutRoute1(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterRoute(23, 24, 1)
self.mappe._ajouterRoute(25, 24, 1)
self.assertTrue(self.mappe.joueurPossedeRoute(24, 25, 1))
print "Test - Ajouter route 1"
def testAjoutRoute2(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterRoute(23, 24, 1)
self.assertRaisesRegexp(
RuntimeError,
'Le joueur 1 ne peut pas construire une route à cet endroit',
self.mappe._ajouterRoute, 18, 19, 1)
print "Test - Ajouter route 2"
def testAjoutRoute3(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterRoute(23, 24, 1)
self.assertRaisesRegexp(
RuntimeError,
'Le joueur 2 ne peut pas construire une route à cet endroit',
self.mappe._ajouterRoute, 24, 25, 2)
print "Test - Ajouter route 3"
def testPeutConstruireOccupation1(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterRoute(23, 24, 1)
self.assertRaisesRegexp(
RuntimeError, 'Une intersection voisine est déjà occupée',
self.mappe._ajouterOccupation, 24, Occupation.COLONIE, 1)
print "Test - Peut contruire occupation 1"
def testPeutConstruireOccupation2(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterRoute(23, 24, 1)
self.assertRaisesRegexp(
RuntimeError, 'Une intersection voisine est déjà occupée',
self.mappe._ajouterOccupation, 25, Occupation.COLONIE, 1)
print "Test - Peut contruire occupation 2"
def testPeutConstruireOccupation3(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterRoute(23, 24, 1)
self.assertRaisesRegexp(
RuntimeError, 'Une intersection voisine est déjà occupée',
self.mappe._ajouterOccupation, 25, Occupation.COLONIE, 2)
print "Test - Peut contruire occupation 3"
def testPeutConstruireOccupation4(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterRoute(23, 24, 1)
self.mappe._ajouterRoute(24, 25, 1)
self.mappe._ajouterOccupation(25, Occupation.COLONIE, 1)
self.assertTrue(self.mappe.obtenirIntersection(25).occupe())
print "Test - Peut construire occupation 4"
def testPeutConstruireOccupation5(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterOccupationInitiale(33, Occupation.COLONIE, 1)
self.mappe._ajouterOccupationInitiale(35, Occupation.COLONIE, 1)
self.assertRaisesRegexp(
RuntimeError, 'Une intersection voisine est déjà occupée',
self.mappe._ajouterOccupation, 34, Occupation.COLONIE, 2)
print "Test - Peut construire occupation 5"
def testCheminPlusLong1(self):
self.mappe._ajouterOccupationInitiale(23, Occupation.COLONIE, 1)
self.mappe._ajouterOccupationInitiale(12, Occupation.COLONIE, 2)
self.mappe._ajouterOccupationInitiale(43, Occupation.COLONIE, 2)
self.mappe._ajouterRoute(23, 24, 1)
self.mappe._ajouterRoute(24, 25, 1)
self.mappe._ajouterRoute(25, 36, 1)
self.mappe._ajouterRoute(36, 37, 1)
self.mappe._ajouterRoute(37, 38, 1)
self.mappe._ajouterRoute(38, 27, 1)
self.mappe._ajouterRoute(37, 47, 1)
self.mappe._ajouterRoute(26, 27, 1)
self.mappe._ajouterRoute(26, 25, 1)
self.mappe._ajouterRoute(16, 26, 1)
self.mappe._ajouterRoute(15, 16, 1)
self.mappe._ajouterRoute(43, 44, 2)
self.mappe._ajouterRoute(52, 44, 2)
self.mappe._ajouterRoute(12, 13, 2)
self.mappe._ajouterOccupation(38, Occupation.COLONIE, 1)
self.mappe._ajouterOccupation(43, Occupation.VILLE, 2)
self.assertEqual(self.mappe.cheminPlusLong(1), 9)
self.assertEqual(self.mappe.cheminPlusLong(2), 2)
print "Test - Chemin plus long 1"
def testCheminPlusLong2(self):
self.mappe._ajouterOccupationInitiale(12, Occupation.COLONIE, 2)
self.mappe._ajouterOccupationInitiale(43, Occupation.COLONIE, 2)
self.mappe._ajouterRoute(43, 44, 2)
self.mappe._ajouterRoute(52, 44, 2)
self.mappe._ajouterRoute(45, 44, 2)
self.mappe._ajouterRoute(45, 46, 2)
self.mappe._ajouterRoute(12, 13, 2)
self.assertEqual(self.mappe.cheminPlusLong(2), 3)
print "Test - Chemin plus long 2"
def testCheminPlusLong3(self):
self.mappe._ajouterOccupationInitiale(12, Occupation.COLONIE, 2)
self.mappe._ajouterOccupationInitiale(43, Occupation.COLONIE, 2)
self.mappe._ajouterRoute(43, 44, 2)
self.mappe._ajouterRoute(52, 44, 2)
self.mappe._ajouterRoute(45, 44, 2)
self.mappe._ajouterRoute(45, 46, 2)
self.mappe._ajouterRoute(12, 13, 2)
self.mappe._ajouterRoute(12, 22, 2)
self.mappe._ajouterRoute(21, 22, 2)
self.assertEqual(self.mappe.cheminPlusLong(2), 3)
print "Test - Chemin plus long 3"
def testCheminPlusLong4(self):
self.mappe._ajouterOccupationInitiale(12, Occupation.COLONIE, 2)
self.mappe._ajouterOccupationInitiale(43, Occupation.COLONIE, 2)
self.mappe._ajouterRoute(43, 44, 2)
self.mappe._ajouterRoute(52, 44, 2)
self.mappe._ajouterRoute(45, 44, 2)
self.mappe._ajouterRoute(45, 46, 2)
self.mappe._ajouterRoute(12, 13, 2)
self.mappe._ajouterRoute(12, 22, 2)
self.mappe._ajouterRoute(21, 22, 2)
self.mappe._ajouterRoute(5, 13, 2)
self.assertEqual(self.mappe.cheminPlusLong(2), 4)
print "Test - Chemin plus long 4"
def testVoleurs1(self):
t = self.mappe.obtenirTerritoireContenantVoleurs()
self.assertTrue(isinstance(t, Desert))
print "Test - Voleurs 1"
def testVoleurs3(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._deplacerVoleurs(7)
t = self.mappe.obtenirTerritoireContenantVoleurs()
self.assertEqual(t.id(), 7)
print "Test - Voleurs 3"
def testVoleurs4(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._deplacerVoleurs(10)
self.assertRaisesRegexp(
RuntimeError,
'On ne peut pas déplacer les voleurs dans le territoire où ils se trouvent déjà',
self.mappe._deplacerVoleurs, 10)
print "Test - Voleurs 4"
def testVoleurs5(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._deplacerVoleurs(5)
self.mappe._deplacerVoleurs(18)
t = self.mappe.obtenirTerritoireContenantVoleurs()
self.assertEqual(t.id(), 18)
print "Test - Voleurs 5"
#self.mappe.afficher()
def testDistribuerRessources1(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(12, Occupation.COLONIE, 1)
ressources = self.mappe._distribuerRessources(2)
self.assertEqual(ressources[(1, Ressource.BLE)], 1)
print "Test - Distribuer ressources 1"
def testDistribuerRessources2(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(24, Occupation.COLONIE, 1)
self.mappe._deplacerVoleurs(7)
ressources = self.mappe._distribuerRessources(3)
self.assertEqual(len(ressources), 0)
print "Test - Distribuer ressources 2"
def testDistribuerRessources3(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(24, Occupation.COLONIE, 1)
self.mappe._ajouterOccupationInitiale(24, Occupation.VILLE, 1)
ressources = self.mappe._distribuerRessources(3)
self.assertEqual(ressources[(1, Ressource.BOIS)], 2)
print "Test - Distribuer ressources 3"
def testDistribuerRessources4(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(24, Occupation.COLONIE, 1)
self.mappe._ajouterOccupationInitiale(24, Occupation.VILLE, 1)
self.mappe._ajouterOccupationInitiale(16, Occupation.COLONIE, 1)
ressources = self.mappe._distribuerRessources(3)
self.assertEqual(ressources[(1, Ressource.BOIS)], 3)
print "Test - Distribuer ressources 4"
def testDistribuerRessources5(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(24, Occupation.COLONIE, 1)
self.mappe._ajouterOccupationInitiale(24, Occupation.VILLE, 1)
self.mappe._ajouterOccupationInitiale(16, Occupation.COLONIE, 2)
ressources = self.mappe._distribuerRessources(3)
self.assertEqual(ressources[(1, Ressource.BOIS)], 2)
self.assertEqual(ressources[(2, Ressource.BOIS)], 1)
print "Test - Distribuer ressources 5"
def testDistribuerRessources6(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(19, Occupation.COLONIE, 1)
self.mappe._ajouterOccupationInitiale(19, Occupation.VILLE, 1)
self.mappe._ajouterOccupationInitiale(37, Occupation.COLONIE, 2)
ressources = self.mappe._distribuerRessources(8)
self.assertEqual(ressources[(1, Ressource.BLE)], 2)
self.assertEqual(ressources[(2, Ressource.LAINE)], 1)
print "Test - Distribuer ressources 6"
def testDistribuerRessources7(self):
typesTerritoires = [
'champ', 'champ', 'champ', 'champ', 'foret', 'foret', 'foret',
'foret', 'pre', 'pre', 'pre', 'pre', 'montagne', 'montagne',
'montagne', 'colline', 'colline', 'colline', 'desert'
]
self.mappe = Mappe(typesTerritoires)
self.mappe._ajouterOccupationInitiale(19, Occupation.COLONIE, 1)
self.mappe._ajouterOccupationInitiale(19, Occupation.VILLE, 1)
self.mappe._ajouterOccupationInitiale(26, Occupation.COLONIE, 1)
self.mappe._ajouterOccupationInitiale(37, Occupation.COLONIE, 2)
ressources = self.mappe._distribuerRessources(8)
self.assertEqual(ressources[(1, Ressource.BLE)], 2)
self.assertEqual(ressources[(1, Ressource.LAINE)], 1)
self.assertEqual(ressources[(2, Ressource.LAINE)], 1)
print "Test - Distribuer ressources 7"
