def test_gameOver(self):
self.setUp()
# Call method with all stacks full
game_state = Dominion.gameover(self.supply)
# Test the game continues by returning false
self.assertEqual(game_state, False)
# Test that 3 empty stacks ends the game
self.supply["Estate"].clear()
self.supply["Duchy"].clear()
self.supply["Curse"].clear()
# Call the method with 3 empty stacks
game_state = Dominion.gameover(self.supply)
# Test that the game ends with 3 empty stacks
self.assertEqual(game_state, True)
# Clear out province cards
self.supply = testUtility.getDefaultSupply(self.supply,
self.player_names, self.nV,
self.nC)
self.supply["Province"].clear()
# Call method without province cards
game_state = Dominion.gameover(self.supply)
# Test that the game ends by returning true
self.assertEqual(game_state, True)
def test_gameover(self):
self.setUp()
# Remove all provinces
self.supply["Province"] = []
theGameIsOver = Dominion.gameover(self.supply)
self.assertEqual(theGameIsOver, True)
# Add the provinces back in.
self.supply["Province"] = [Dominion.Province()] * 3
theGameIsOver = Dominion.gameover(self.supply)
self.assertEqual(theGameIsOver, False)
# Remove two other cards. Should not cause the game to be over.
self.supply["Duchy"] = []
self.supply["Estate"] = []
theGameIsOver = Dominion.gameover(self.supply)
self.assertEqual(theGameIsOver, False)
# This is the third one to become empty, so it should end the game.
self.supply["Gold"] = []
theGameIsOver = Dominion.gameover(self.supply)
self.assertEqual(theGameIsOver, True)
# Fourth one to be removed. Game should still end.
self.supply["Silver"] = []
theGameIsOver = Dominion.gameover(self.supply)
self.assertEqual(theGameIsOver, True)
def playGame(supply_order, supply, players, trash):
turn = 0
while not Dominion.gameover(supply):
turn += 1
print("\r")
for value in supply_order:
print(value)
for stack in supply_order[value]:
if stack in supply:
print(stack, len(supply[stack]))
print("\r")
for player in players:
print(player.name, player.calcpoints())
print("\rStart of turn " + str(turn))
for player in players:
if not Dominion.gameover(supply):
print("\r")
player.turn(players, supply, trash)
#Final score
dcs = Dominion.cardsummaries(players)
vp = dcs.loc['VICTORY POINTS']
vpmax = vp.max()
winners = []
for i in vp.index:
if vp.loc[i] == vpmax:
winners.append(i)
if len(winners) > 1:
winstring = ' and '.join(winners) + ' win!'
else:
winstring = ' '.join([winners[0], 'wins!'])
print("\nGAME OVER!!!\n" + winstring + "\n")
print(dcs)
def playGame(supply, players, trash):
supply_order = {
0: ['Curse', 'Copper'],
2: ['Estate', 'Cellar', 'Chapel', 'Moat'],
3: ['Silver', 'Chancellor', 'Village', 'Woodcutter', 'Workshop'],
4: [
'Gardens', 'Bureaucrat', 'Feast', 'Militia', 'Moneylender',
'Remodel', 'Smithy', 'Spy', 'Thief', 'Throne Room'
],
5: [
'Duchy', 'Market', 'Council Room', 'Festival', 'Laboratory',
'Library', 'Mine', 'Witch'
],
6: ['Gold', 'Adventurer'],
8: ['Province']
}
turn = 0
while not Dominion.gameover(supply):
turn += 1
print("\r")
for value in supply_order:
print(value)
for stack in supply_order[value]:
if stack in supply:
print(stack, len(supply[stack]))
print("\r")
for player in players:
print(player.name, player.calcpoints())
print("\rStart of turn " + str(turn))
for player in players:
if not Dominion.gameover(supply):
print("\r")
player.turn(players, supply, trash)
def test_GameOver(self):
# init data
self.dataSetUp()
# test to make sure game is not over
self.assertEqual(False, Dominion.gameover(self.supply))
# remove all the provinces from the supply
del self.supply["Province"]
# test to make sure game is over
self.assertEqual(True, Dominion.gameover(self.supply))
# make a new supply
self.supply = testUtility.GetSupply(self.box, self.nV, self.nC, len(self.player_names), 5)
# test to make sure game is not over
self.assertEqual(False, Dominion.gameover(self.supply))
# remove 3 supply cards
removed = 0
for stack in self.supply:
if removed == 3:
break
if stack != 'Province':
self.supply[stack] = []
removed += 1
# test to make sure game is over
self.assertEqual(True, Dominion.gameover(self.supply))
def test_gameOver(self):
self.setUp()
#Test returns false right away
self.assertEqual(False, Dominion.gameover(self.supply))
self.supply["Province"] = []
#Remove Province card should end game
self.assertEqual(True, Dominion.gameover(self.supply))
#Add back in
self.supply["Province"] = [Dominion.Province()]
#force out to equal 2 should not end game
self.supply["Duchy"] = []
self.supply["Curse"] = []
self.assertEqual(False, Dominion.gameover(self.supply))
#force out to equal 3 should end game
self.supply["Silver"] = []
self.assertEqual(True, Dominion.gameover(self.supply))
def test_gameover(self):
#this function is to test that the game is over by meeting one of two conditions
#1. province in supply is empty
#2. two sets of the supply is empty
#initalize Supply
self.setUp()
# there are 3 players hence 12 cards
assert len(self.supply['Province']) == 12
assert len(self.supply['Estate']) == 12
assert len(self.supply['Duchy']) == 12
assert len(self.supply['Gold']) == 30
# make province equal to 0
'''
for i in range(12):
self.supply['Province'].pop()
assert len(self.supply['Province']) == 0
'''
for i in range(12):
self.supply['Estate'].pop()
for i in range(12):
self.supply['Duchy'].pop()
for i in range(30):
self.supply['Gold'].pop()
#call function
assert Dominion.gameover(self.supply)
#assert test
# assert flag == True
def test_gameover(self):
supply = testUtility.establishSupply(testUtility.getBoxes(1), 1, 1,
['Annie', 'Bob'])
# test case that end of function reached; returns False
self.assertFalse(Dominion.gameover(supply))
# test case to remove Province card, so first if branch returns True
supply["Province"].pop()
self.assertTrue(Dominion.gameover(supply))
# test case to force the out variable to increase above 3, which returns True
supply = testUtility.establishSupply(testUtility.getBoxes(1), 1, 1,
['Annie', 'Bob'])
for stack in supply:
supply[stack] = []
self.assertTrue(Dominion.gameover(supply))
def play_game(supply, supply_order, players, trash):
turn = 0
while not Dominion.gameover(supply):
turn += 1
print("\r")
for value in supply_order:
print(value)
for stack in supply_order[value]:
if stack in supply:
print(stack, len(supply[stack]))
print("\r")
for player in players:
print(player.name, player.calcpoints())
print("\rStart of turn " + str(turn))
for player in players:
if not Dominion.gameover(supply):
print("\r")
player.turn(players, supply, trash)
def PrintPlayers(players, supply, trash, turn):
print("\r")
for player in players:
print(player.name, player.calcpoints())
print("\rStart of turn " + str(turn))
for player in players:
if not Dominion.gameover(supply):
print("\r")
player.turn(players, supply, trash)
def test_gameover(self):
# set up data
self.set_up()
game_over = Dominion.gameover(self.supply)
self.assertEqual(False, game_over)
# set province cards to 0 sets gameover to true
self.supply["Province"] = [Dominion.Province()] * 0
game_over = Dominion.gameover(self.supply)
self.assertEqual(True, game_over)
# set three supply piles to empty sets gameover to true
self.supply = testUtility.getSupply(self.nV, self.nC,
self.player_names, self.box)
self.supply["Gold"] = [Dominion.Gold()] * 0
self.supply["Estate"] = [Dominion.Estate()] * 0
self.supply["Duchy"] = [Dominion.Duchy()] * 0
game_over = Dominion.gameover(self.supply)
self.assertEqual(True, game_over)
def PlayGame(supply, supply_order, players):
#initialize the trash
trash = []
turn = 0
#Play the game
while not Dominion.gameover(supply):
turn += 1
print("\r")
for value in supply_order:
print(value)
for stack in supply_order[value]:
if stack in supply:
print(stack, len(supply[stack]))
print("\r")
for player in players:
print(player.name, player.calcpoints())
print("\rStart of turn " + str(turn))
for player in players:
if not Dominion.gameover(supply):
print("\r")
player.turn(players, supply, trash)
def test_gameover(self):
supply = {}
supply['Province'] = [Dominion.Province()] * 10
supply['Market'] = [Dominion.Market()] * 10
supply['Gold'] = [Dominion.Gold()] * 10
supply['Festival'] = [Dominion.Festival()] * 10
# gameover should return false
self.assertFalse(Dominion.gameover(supply))
# gameover should return true
supply['Province'] = [Dominion.Province()] * 0
self.assertTrue(Dominion.gameover(supply))
# gameover should return false
supply['Province'] = [Dominion.Province()] * 1
supply['Market'] = [Dominion.Market()] * 0
supply['Gold'] = [Dominion.Gold()] * 0
self.assertFalse(Dominion.gameover(supply))
# gameover should return true
supply['Festival'] = [Dominion.Festival()] * 0
self.assertTrue(Dominion.gameover(supply))
def play(supply, supply_order, players, trash):
# Play the game
turn = 0
# Keep playing until someone wins
while not Dominion.gameover(supply):
turn += 1
print("\r")
# Print the supply
printSupply(supply_order, supply)
# Print current scores
for player in players:
print(player.name, player.calcpoints())
print("\rStart of turn " + str(turn))
# Go through each player's turn for this round while no one wins
for player in players:
if not Dominion.gameover(supply):
print("\r")
player.turn(players, supply, trash)
def playGame(supply, players):
#get the supply order
supply_order = _getSupplyOrder()
#initialize the trash
trash = []
#set the turn number
turn = 0
while not Dominion.gameover(supply):
turn += 1
print("\r")
for value in supply_order:
print(value)
for stack in supply_order[value]:
if stack in supply:
print(stack, len(supply[stack]))
print("\r")
for player in players:
print(player.name, player.calcpoints())
print("\rStart of turn " + str(turn))
for player in players:
if not Dominion.gameover(supply):
print("\r")
player.turn(players, supply, trash)
def test_gameOver(self):
#setup supply normal supply at the beginning of the game
self.setUp()
# check if the game is not over from the supply
isGameOver = Dominion.gameover(self.supply)
self.assertEqual(False, isGameOver)
#reduce the province cards to zero
self.supply["Province"] = []
isGameOver = Dominion.gameover(self.supply)
self.assertEqual(True, isGameOver)
# re setup supply
self.setUp()
# check if the game is not over from the supply
isGameOver = Dominion.gameover(self.supply)
self.assertEqual(False, isGameOver)
#remove the supply of throne room
self.supply["Throne Room"] = []
# game should not be over from removal of throne room
isGameOver = Dominion.gameover(self.supply)
self.assertEqual(False, isGameOver)
# remove the supply of throne room
self.supply["Festival"] = []
# game should not be over from removal of throne room and festival
isGameOver = Dominion.gameover(self.supply)
self.assertEqual(False, isGameOver)
# remove the supply of throne room
self.supply["Adventurer"] = []
# game should be over from removal of throne room, Adventurer and festival
isGameOver = Dominion.gameover(self.supply)
self.assertEqual(True, isGameOver)
#initialize the trash
trash = []
#Costruct the Player objects
players = []
for name in player_names:
if name[0] == "*":
players.append(Dominion.ComputerPlayer(name[1:]))
elif name[0] == "^":
players.append(Dominion.TablePlayer(name[1:]))
else:
players.append(Dominion.Player(name))
#Play the game
turn = 0
while not Dominion.gameover(supply):
turn += 1
print("\r")
for value in supply_order:
print(value)
for stack in supply_order[value]:
if stack in supply:
print(stack, len(supply[stack]))
print("\r")
for player in players:
print(player.name, player.calcpoints())
print("\rStart of turn " + str(turn))
for player in players:
if not Dominion.gameover(supply):
print("\r")
player.turn(players, supply, trash)
#initialize the trash
trash = []
#Costruct the Player objects
players = []
for name in player_names:
if name[0]=="*":
players.append(Dominion.ComputerPlayer(name[1:]))
elif name[0]=="^":
players.append(Dominion.TablePlayer(name[1:]))
else:
players.append(Dominion.Player(name))
#Play the game
turn = 0
while not Dominion.gameover(supply):
turn += 1
print("\r")
for value in supply_order:
print (value)
for stack in supply_order[value]:
if stack in supply:
print (stack, len(supply[stack]))
print("\r")
for player in players:
print (player.name,player.calcpoints())
print ("\rStart of turn " + str(turn))
for player in players:
if not Dominion.gameover(supply):
print("\r")
player.turn(players,supply,trash)
