def testBuyingHutsChangesScore(self):
self.player.addResources([3, 3, 4, 3, 4, 5])
hut1 = SimpleHut(3, 3, 4)
hut2 = SimpleHut(3, 4, 5)
self.player.strategy.plannedCosts = {hut1 : [3,3,4],
hut2 : [3,4,5]}
self.assertEqual(0, self.player.score)
self.player.buyHuts([hut1, hut2])
self.assertEqual(22, self.player.score)
def testPlacePerson(self):
hut = SimpleHut(3, 3, 4)
self.assertFalse(hut.isOccupied())
self.assertEqual("", hut.isOccupiedBy())
hut.placePerson("r")
self.assertTrue(hut.isOccupied())
self.assertEqual("r", hut.isOccupiedBy())
def testPlacePerson(self):
hut = SimpleHut(3,3,4)
self.assertFalse(hut.isOccupied())
self.assertEqual("", hut.isOccupiedBy())
hut.placePerson("r")
self.assertTrue(hut.isOccupied())
self.assertEqual("r", hut.isOccupiedBy())
def testPlacePerson(self):
hut = SimpleHut(Resource.wood,Resource.wood,Resource.clay)
self.assertFalse(hut.isOccupied())
self.assertIsNone(hut.isOccupiedBy())
hut.placePerson(self.redPlayer)
self.assertTrue(hut.isOccupied())
self.assertEqual(self.redPlayer, hut.isOccupiedBy())
def testReapResources(self):
hutForRed = SimpleHut(3, 3, 4)
hutForBlue = SimpleHut(3, 4, 4)
self.board = Board(
[hutForRed, hutForBlue,
SimpleHut(3, 4, 5),
SimpleHut(4, 5, 6)])
self.board.placeOnHut(hutForRed, "r")
self.board.placeOnHut(hutForBlue, "b")
resources, huts = self.board.reapResources(self.redPlayer)
self.assertEqual([], resources)
self.assertEqual(1, len(huts))
self.assertEqual([hutForRed], huts)
resources, huts = self.board.reapResources(self.bluePlayer)
self.assertEqual([], resources)
self.assertEqual([hutForBlue], huts)
def testPlacingOfNoSimpleHutPersons(self):
self.board = Board([SimpleHut(3, 3, 4), SimpleHut(3, 3, 5), SimpleHut(3, 3, 6), SimpleHut(3, 4, 5)])
self.player.addResources([3, 3])
self.player.placePersons(self.board)
self.assertEqual(1, self.board.personCount("r"))
self.assertTrue(self.board.farmOccupied())
self.player.placePersons(self.board)
self.assertEqual(3, self.board.personCount("r"))
self.assertTrue(self.board.breedingHutOccupied())
self.player.placePersons(self.board)
self.assertEqual(4, self.board.personCount("r"))
self.assertTrue(self.board.toolSmithOccupied())
self.player.placePersons(self.board)
self.assertEqual(5, self.board.personCount("r"))
def testPlacingOrderWhenTwoHutsAffordable(self):
self.board = Board([SimpleHut(3, 3, 4), SimpleHut(3, 5, 6), SimpleHut(3, 3, 6), SimpleHut(3, 4, 5)])
self.player.addResources([3, 3, 4, 3, 4, 5])
self.player.placePersons(self.board)
self.assertEqual(1, self.board.personCount("r"))
self.assertTrue(self.board.farmOccupied())
self.player.placePersons(self.board)
self.assertEqual(3, self.board.personCount("r"))
self.assertTrue(self.board.breedingHutOccupied())
self.board.placeOnToolSmith("b")
self.player.placePersons(self.board)
self.assertEqual(4, self.board.personCount("r"))
self.assertEqual(1, self.board.personsOnHuts("r"))
self.player.placePersons(self.board)
self.assertEqual(5, self.board.personCount("r"))
self.assertEqual(2, self.board.personsOnHuts("r"))
def testIsFinished(self):
self.board = Board([
SimpleHut(3, 3, 4),
SimpleHut(3, 3, 4),
SimpleHut(3, 3, 4),
SimpleHut(3, 3, 4)
])
self.assertFalse(self.board.isFinished())
self.board = Board(
[SimpleHut(3, 3, 4),
SimpleHut(3, 3, 4),
SimpleHut(3, 3, 4)])
self.assertTrue(self.board.isFinished())
def testSimpleHutPayableWith2Jokers(self):
hut = SimpleHut(Resource.wood,Resource.stone,Resource.gold)
resources = [Resource.wood,Resource.joker,Resource.joker]
self.assertEqual([], hut.missing(resources))
self.assertEqual(14, hut.value(), "value should be 14")
hut = SimpleHut(Resource.wood,Resource.stone,Resource.gold)
resources = [Resource.joker,Resource.stone,Resource.joker]
self.assertEqual([], hut.missing(resources))
self.assertEqual(14, hut.value(), "value should be 14")
def testIsPayableBug(self):
self.player.addResources([3, 3, 3, 3, 3, 4, 4, 5, 6,])
firstHut = CountHut(4, 2)
self.player.strategy.adjustResources(firstHut, self.player.resources)
self.assertDictEqual({firstHut : [3,4,3,3]}, self.player.strategy.plannedCosts)
secondHut = CountHut(4, 3)
self.assertTrue(self.player.isPayable(secondHut))
self.player.strategy.adjustResources(secondHut, self.player.resources)
self.assertDictEqual({firstHut : [3,4,3,3], secondHut : [3,4,5,3]}, self.player.strategy.plannedCosts)
thirdHut = SimpleHut(5, 5, 6)
self.assertFalse(self.player.isPayable(thirdHut))
fourthHut = CountHut(5, 2)
self.assertFalse(self.player.isPayable(fourthHut))
def testHutNotPayable(self):
hut = SimpleHut(3, 3, 4)
resources = [3, 4, 4, 4]
self.assertEqual([3], hut.missing(resources))
def testHutNotPayable2(self):
hut = SimpleHut(3,3,4)
resources = [2,2,3,5,5]
self.assertEqual([3,4], hut.missing(resources))
def testPlacePersonTwice(self):
hut = SimpleHut(Resource.wood,Resource.wood,Resource.clay)
hut.placePerson(self.redPlayer)
from Board import PlacementError
with self.assertRaisesRegex(PlacementError, "hut is already occupied"):
hut.placePerson("g")
def testPlacePersonTwice(self):
hut = SimpleHut(3, 3, 4)
hut.placePerson("r")
from Board import PlacementError
with self.assertRaisesRegex(PlacementError, "hut is already occupied"):
hut.placePerson("g")
def testSimpleHutPayableWithoutJoker(self):
hut = SimpleHut(Resource.wood,Resource.wood,Resource.clay)
resources = [Resource.food,Resource.wood,Resource.wood,Resource.clay,Resource.joker]
self.assertEqual([], hut.missing(resources))
def testHutNotPayable2(self):
hut = SimpleHut(3, 3, 4)
resources = [2, 2, 3, 5, 5]
self.assertEqual([3, 4], hut.missing(resources))
def testSimpleHutNotPayable2(self):
hut = SimpleHut(Resource.wood,Resource.wood,Resource.clay)
resources = [Resource.food,Resource.food,Resource.wood,Resource.stone,Resource.stone]
self.assertEqual([Resource.wood,Resource.clay], hut.missing(resources))
def testHutPayable(self):
hut = SimpleHut(3, 3, 4)
resources = [3, 3, 3, 4, 4]
self.assertEqual([], hut.missing(resources))
self.assertEqual(10, hut.value(), "value should be 10")
def testSimpleHutPayable(self):
hut = SimpleHut(Resource.wood, Resource.wood,Resource.clay)
resources = [Resource.wood,Resource.wood,Resource.wood,Resource.clay,Resource.clay]
self.assertEqual([], hut.missing(resources))
self.assertEqual(10, hut.value(), "value should be 10")
def testHutNotPayable(self):
hut = SimpleHut(3,3,4)
resources = [3,4,4,4]
self.assertEqual([3], hut.missing(resources))
def testPlacePersonTwice(self):
hut = SimpleHut(3,3,4)
hut.placePerson("r")
from Board import PlacementError
with self.assertRaisesRegex(PlacementError, "hut is already occupied"):
hut.placePerson("g")
def _defaultHuts(self):
return [SimpleHut(3, 3, 4),
SimpleHut(3, 3, 5),
SimpleHut(3, 3, 6),
SimpleHut(3, 4, 5),
SimpleHut(3, 4, 4),
SimpleHut(3, 5, 5),
SimpleHut(3, 4, 6),
SimpleHut(3, 4, 6),
SimpleHut(3, 4, 5),
SimpleHut(3, 5, 6),
SimpleHut(3, 5, 6),
SimpleHut(4, 4, 5),
SimpleHut(4, 4, 6),
SimpleHut(4, 5, 5),
SimpleHut(4, 5, 6),
SimpleHut(4, 5, 6),
SimpleHut(5, 5, 6),
AnyHut(),
AnyHut(),
AnyHut(),
CountHut(4,1),
CountHut(4,2),
CountHut(4,3),
CountHut(4,4),
CountHut(5,1),
CountHut(5,2),
CountHut(5,3),
CountHut(5,4),
]
def testHutPayable(self):
hut = SimpleHut(3,3,4)
resources = [3,3,3,4,4]
self.assertEqual([], hut.missing(resources))
self.assertEqual(10, hut.value(), "value should be 10")
