def get_supply(box, num_players, nC, nV): """ :param box: dictionary containing starting lists of action cards :param num_players: number of players :param nC: starting number of curse cards :param nV: starting number of each victory card :return: dictionary of 10 randomly selected action cards and a prescribed amount of coin, victory, and curse cards (according to this function) """ boxlist = [k for k in box] random.shuffle(boxlist) random10 = boxlist[:10] supply = defaultdict(list, [(k, box[k]) for k in random10]) # The supply always has these cards supply["Copper"] = [Dominion.Copper()] * (60 - num_players * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC return supply
def test_draw(self): self.player = Dominion.Player("Annie") # Clear the hand and deck completely self.player.hand = [] self.player.deck = [] # The draw condition should work on 1 card self.player.deck.append(Dominion.Estate()) self.player.draw() # Our deck should now be empty, and our hand should have one card. self.assertEqual(len(self.player.deck), 0) self.assertEqual(len(self.player.hand), 1) # Drawing from an empty deck will cause the deck to be replaced with the discard pile. self.player.draw() # We didn't have a discard pile, so the deck should still be empty. self.assertEqual(len(self.player.deck), 0) self.player.discard.append(Dominion.Cellar()) self.player.draw() # Now the deck and discard should have zero cards, but the hand should have 2 cards self.assertEqual(len(self.player.deck), 0) self.assertEqual(len(self.player.hand), 2) self.assertEqual(len(self.player.discard), 0)
def initSupply(box, player_names): nC, nV = getCursesAndVictories(player_names) #Pick 10 cards from box to be in the supply. boxlist = [k for k in box] random.shuffle(boxlist) random10 = boxlist[:10] supply = defaultdict(list, [(k, box[k]) for k in random10]) #The supply always has these cards supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC 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'] } return supply, supply_order
def setUp(self): # Get player names # player_names = ["Annie","*Ben","*Carla"] self.player_names = testUtility.GetPlayers() # number of curses and victory cards if len(self.player_names) > 2: self.nV = 12 else: self.nV = 8 self.nC = -10 + 10 * len(self.player_names) # Refactored Get boxs self.box = testUtility.GetBoxes(self.nV) # refactored supplu order self.supply_order = testUtility.SupplyOrder() # Pick 10 cards from box to be in the supply. self.supply = defaultdict(list) # The supply always has these cards self.supply["Copper"] = [Dominion.Copper()] self.supply["Silver"] = [Dominion.Silver()] self.supply["Gold"] = [Dominion.Gold()] self.supply["Estate"] = [Dominion.Estate()] self.supply["Duchy"] = [Dominion.Duchy()] self.supply["Province"] = [Dominion.Province()] self.supply["Curse"] = [Dominion.Curse()] # initialize the trash self.trash = [] self.player = Dominion.Player('Annie')
def SetSupply(supply): supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC
def addDefaultSupplyCards(supply, nV, nC, player_names): supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC
def updateSupplyWithoutTreasure(supply, player_names, nV, nC): supply["Copper"] = [] supply["Silver"] = [] supply["Gold"] = [] supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC
def generateSupplies(nV, nC, supply, player_names): supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC return supply
def add_required_supplies(supply, nV, nC, player_names): # The supply always has these cards supply["Copper"]=[Dominion.Copper()]*(60-len(player_names)*7) supply["Silver"]=[Dominion.Silver()]*40 supply["Gold"]=[Dominion.Gold()]*30 supply["Estate"]=[Dominion.Estate()]*nV supply["Duchy"]=[Dominion.Duchy()]*nV supply["Province"]=[Dominion.Province()]*nV supply["Curse"]=[Dominion.Curse()]*nC
def SupplyBaseStart(supply, player_names, nV, nC): supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC return supply
def supplyCards(nC, nV, player_names, supply): #The supply always has these cards supply["Copper"]=[Dominion.Copper()]*(60-len(player_names)*7) supply["Silver"]=[Dominion.Silver()]*40 supply["Gold"]=[Dominion.Gold()]*30 supply["Estate"]=[Dominion.Estate()]*nV supply["Duchy"]=[Dominion.Duchy()]*nV supply["Province"]=[Dominion.Province()]*nV supply["Curse"]=[Dominion.Curse()]*nC
def test_action_balance(self): player = Dominion.Player('Annie') # base deck has nothing to balance, expect 0 self.assertEqual(0, player.action_balance()) # add one action card to change the balance variable, which will change return value to non-zero player.deck = [Dominion.Copper()] * 7 + [Dominion.Estate() ] * 3 + [Dominion.Thief()] * 1 self.assertIsNot(0, player.action_balance())
def addStandardCards(supply, numPlayers, nC, nV): supply["Copper"] = [Dominion.Copper()] * (60 - numPlayers * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC return supply
def GetStandardSupply(supply, player_names, nV, nC): #The supply always has these cards supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC return supply
def test_calcpoints(self): player = Dominion.Player('Tony') self.assertEqual(10, len(player.stack())) # asserts the player has 3 points self.assertEqual(3, player.calcpoints()) #adds an Estate victory card to deck and asserts player has 4 points player.deck = player.deck + [Dominion.Estate()] self.assertEqual(4, player.calcpoints())
def GetSupply(box, random10, player_names, nV, nC): supply = defaultdict(list, [(k, box[k]) for k in random10]) # The supply always has these cards supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC return supply
def update_supply(supply, num_victory, num_curses, num_players): """ Sets the supply of some of the items Modifies the given supply dict Nothing returned """ supply["Copper"] = [Dominion.Copper()] * (60 - num_players * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * num_victory supply["Duchy"] = [Dominion.Duchy()] * num_victory supply["Province"] = [Dominion.Province()] * num_victory supply["Curse"] = [Dominion.Curse()] * num_curses
def get_supply(box, player_names, nV, nC): boxlist = [k for k in box] random.shuffle(boxlist) random10 = boxlist[:10] supply = defaultdict(list, [(k, box[k]) for k in random10]) supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC return supply
def getSupply(nV, nC, player_names, box): # Pick 10 cards from box to be in the supply. boxlist = [k for k in box] random.shuffle(boxlist) random10 = boxlist[:10] supply = defaultdict(list, [(k, box[k]) for k in random10]) # The supply always has these cards supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC
def test_draw(self): player = Dominion.Player('Annie') self.assertEqual(5, len(player.deck)) # starting deck size self.assertEqual(5, len(player.hand)) # starting hand size # test case for draw() method; increase hand and decrease deck player.draw() self.assertEqual(4, len(player.deck)) # deck size decreases 1 self.assertEqual(6, len(player.hand)) # hand size increases 1 # test case if deck is length 0, will replenish it with discard pile player.discard = [Dominion.Copper()] * 7 + [Dominion.Estate()] * 3 player.deck = [] player.draw() self.assertEqual(9, len(player.deck))
def init_supply(box, nV, nC, num_players): boxlist = [k for k in box] random.shuffle(boxlist) random10 = boxlist[:10] supply = defaultdict(list, [(k, box[k]) for k in random10]) #The supply always has these cards supply["Copper"] = [Dominion.Copper()] * (60 - num_players * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC return supply
def getSupply(box, player_names): boxlist = [k for k in box] random.shuffle(boxlist) random10 = boxlist[:10] supply = defaultdict(list, [(k, box[k]) for k in random10]) #determine the victory and curse cards based on the number of players nV = _getVictoryNum(player_names) nC = _getCurseNum(player_names) #add the treasure, victory and curse cards, the supply always has these cards supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC return supply
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 create_supply(player_count): box = create_box(player_count) #Pick 10 cards from box to be in the supply. boxlist = [k for k in box] random.shuffle(boxlist) random10 = boxlist[:10] supply = defaultdict(list,[(k,box[k]) for k in random10]) #The supply always has these cards supply["Copper"]=[Dominion.Copper()]*(60-player_count*7) supply["Silver"]=[Dominion.Silver()]*40 supply["Gold"]=[Dominion.Gold()]*30 supply["Estate"]=[Dominion.Estate()]*number_of_victory_cards(player_count) supply["Duchy"]=[Dominion.Duchy()]*number_of_victory_cards(player_count) supply["Province"]=[Dominion.Province()]*number_of_victory_cards(player_count) supply["Curse"]=[Dominion.Curse()]*number_of_curse_cards(player_count) return supply
def setUp(self): self.player_names = testUtility.GetPlayers() # number of curses and victory cards if len(self.player_names) > 2: self.nV = 12 else: self.nV = 8 self.nC = -10 + 10 * len(self.player_names) # Refactored Get boxs self.box = testUtility.GetBoxes(self.nV) # refactored supplu order self.supply_order = testUtility.SupplyOrder() # Pick 10 cards from box to be in the supply. self.boxlist = [k for k in self.box] random.shuffle(self.boxlist) self.random10 = self.boxlist[:10] self.supply = defaultdict(list, [(k, self.box[k]) for k in self.random10]) # The supply always has these cards self.supply["Copper"] = [Dominion.Copper() ] * (60 - len(self.player_names) * 7) self.supply["Silver"] = [Dominion.Silver()] * 40 self.supply["Gold"] = [Dominion.Gold()] * 30 self.supply["Estate"] = [Dominion.Estate()] * self.nV self.supply["Duchy"] = [Dominion.Duchy()] * self.nV self.supply["Province"] = [Dominion.Province()] * self.nV self.supply["Curse"] = [Dominion.Curse()] * self.nC # initialize the trash self.trash = [] self.name = "Blueberry" self.actions = 3 self.coins = 10 self.player = Dominion.Player('Annie') self.player2 = Dominion.Player('Carla')
def getSupply(box, player_names, nV, nC): """ Returns a randomized supply for the current game. Takes in arguments the current box object, supply order, and the number of Victory Cards and Curses in play. """ #Pick 10 cards from box to be in the supply. boxlist = [k for k in box] random.shuffle(boxlist) random10 = boxlist[:10] supply = defaultdict(list, [(k, box[k]) for k in random10]) #The supply always has these cards supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC return supply
def test_calcpoints(self): self.player = Dominion.Player("Annie") # Clear the hand and deck completely self.player.hand = [] self.player.deck = [] self.assertEqual(self.player.calcpoints(), 0) # Estates are worth one point self.player.hand.append(Dominion.Estate()) self.assertEqual(self.player.calcpoints(), 1) # Gardens count as a multiplier of points, but they are not relevant until you have at least 10 victory cards self.player.hand.append(Dominion.Gardens()) self.assertEqual(self.player.calcpoints(), 1) # Add more gardens, to get to the boundary of 10 victory cards n = 0 while n < 8: self.player.hand.append(Dominion.Gardens()) n += 1 # 1 point for the victory point + 1 point for (number of cards / 10) * 9 gardens = 10 self.assertEqual(self.player.calcpoints(), 10)
], 6: ['Gold', 'Adventurer'], 8: ['Province'] } #Pick 10 cards from box to be in the supply. boxlist = [k for k in box] random.shuffle(boxlist) random10 = boxlist[:10] supply = defaultdict(list, [(k, box[k]) for k in random10]) #The supply always has these cards supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC #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:
# Get player names player_names = ["Isaac", "*Ben"] numPlayers = len(player_names) # number of curses and victory cards nV = testUtility.getNumVC(numPlayers) nC = testUtility.getNumCurses(numPlayers) # Define box box = testUtility.getBox(nV) supply_order = testUtility.getSupplyOrder() # Pick 10 cards from box to be in the supply. supply = testUtility.makeSupply(box, numPlayers, nV, nC) supply["Province"] = [Dominion.Estate()] * nV # initialize the trash trash = [] # Construct the Player objects players = testUtility.makePlayers(player_names) # Play the game testUtility.play(supply, supply_order, players, trash) # Final score testUtility.endGame(players)
import random import testUtility from collections import defaultdict #Get player names player_names = ["*Annie", "*Ben", "*Carla"] #number of curses and victory cards nV, nC = testUtility.victoryCurses(player_names) #define boxes box = testUtility.getBoxes(nV) ################################################################################## TEST INDICATOR #introducing a duplicate for testing box["Village"] = [Dominion.Estate()] * 10 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']