class Golf_relaxed: def __init__(self): self.deck = Deck() self.deckA = pygame.sprite.LayeredDirty() self.deckB = pygame.sprite.LayeredDirty() self.col1 = pygame.sprite.LayeredDirty() self.col2 = pygame.sprite.LayeredDirty() self.col3 = pygame.sprite.LayeredDirty() self.col4 = pygame.sprite.LayeredDirty() self.col5 = pygame.sprite.LayeredDirty() self.col6 = pygame.sprite.LayeredDirty() self.col7 = pygame.sprite.LayeredDirty() self.set_up_game() def set_up_game(self): for i in range(0,17): self.deckA.add(self.deck.get()) for i in range(0,5): self.col1.add(self.deck.get()) self.col2.add(self.deck.get()) self.col3.add(self.deck.get()) self.col4.add(self.deck.get()) self.col5.add(self.deck.get()) self.col6.add(self.deck.get()) self.col7.add(self.deck.get()) self.deckB.add(self.deck.get())
def __init__(self, noOfColors): self.piles = [] self.timesDistributed = 0 self.stacks = [] if noOfColors == 1: deck = Deck.generateDeck(deckType='double-one-color') elif noOfColors == 2: deck = Deck.generateDeck(deckType='double-two-color') elif noOfColors == 4: deck = Deck.generateDeck(deckType='double') elif noOfColors == -1: for i in range(10): cardStack = CardStack() self.stacks.append(cardStack) return else: print(str(noOfColors) + 'is not a valid color') for i in range(5): self.piles.append(deck[-10:]) del deck[-10:] for i in range(10): cardStack = CardStack() if i < 4: cardStack.faceDownCards = deck[-6:] del deck[-6:] else: cardStack.faceDownCards = deck[-5:] del deck[-5:] cardStack.flipCard() self.stacks.append(cardStack)
def test_draw_tiles_7(self): # moving where a player that does not have the dragon tile makes a move # and it causes an elimination of the player that has the dragon tile # 3 players active -> 1 player died # player 1 owns dragon and gets killed by player 2 and return 1 tile # return dragon to deck server = Server.reset_get_instance() board = Board() deck = Deck() tile_1 = init_tile_1() tile_3 = init_tile_3() tile_4 = init_tile_4() tile_5 = init_tile_5() tile_6 = init_tile_6() tile_7 = init_tile_7() player_1 = SPlayer(1, True, (1, 1, 5)) player_2 = SPlayer(2, True, (2, 2, 7)) player_3 = SPlayer(3, True, (4, 4, 6)) board.matrix_player[1][1][5] = player_1 board.matrix_player[2][2][7] = player_2 board.matrix_player[4][4][6] = player_3 board.place_tile(tile_3, Tile_location((1, 1))) board.place_tile(tile_5, Tile_location((2, 2))) board.place_tile(tile_6, Tile_location((4, 4))) active_players = [player_2, player_3, player_1] players_last_out = [] player_1.add_hand(tile_7) player_2.hand.num_tiles = 2 player_2.add_hand(tile_4) player_3.hand.num_tiles = 3 server.dragon_owner = player_1 deck.own_dragon = False self.assertEqual(server.dragon_owner, player_1) self.assertFalse(deck.has_dragon()) self.assertEqual(player_1.hand.get_num(), 1) self.assertEqual(player_2.hand.get_num(), 3) self.assertEqual(player_3.hand.get_num(), 3) d, sa, so, b, res = server.play_a_turn(deck, copy(active_players), copy(players_last_out), board, tile_4) # player 2 moves and kills player 1 # player 1 returns 1 tile, player 2 draws that tile and has 3 # dragon back to deck self.assertEqual(sa, [player_3, player_2]) self.assertEqual(b.get_splayer_by_loc(Player_location((1, 1, 2))), None) self.assertEqual(server.dragon_owner, None) self.assertTrue(deck.has_dragon()) self.assertFalse(player_1.is_alive()) self.assertEqual(player_2.hand.get_num(), 3) self.assertEqual(player_3.hand.get_num(), 3)
def __init__(self): name1 = input("p1 name ") name2 = input("p2 name ") self.deck = Deck() self.p1 = Player(name1) self.p2 = Player(name2)
def __init__(self, playerCount, parent): self.deck = Deck() self.parent = parent self.roundStep = ATACK_ROUND self.playerCount = playerCount self.players = [] for i in range(playerCount): plr = Player(i, []) plr.FillHand(self.deck) self.players.append(plr) self.trump = self.deck.GetCard() self.trump: Card self.deck.PutBottom(self.trump) self.atackList = [] self.defendList = [] self.attackerIndex = 0 self.winner = None self.show_splitter = False self.turnDownButton = False self.takeAllButton = False self.nextPlayerButton = False self.botTurn = False
def test_bot_when_not_legal_play(self): # 2 players active -> 2 players active, not over # making a move where the tile is not placed in its original Location (i.e., it is rotated) # need to check location matches and splayers_active in correct order server = Server.reset_get_instance() board = Board() server.board = board deck = Deck() tile_1 = init_tile_1() tile_3 = init_tile_3() tile_4 = init_tile_4() tile_5 = init_tile_5() player_1 = SPlayer("red", True, (1, 1, 2)) player_2 = SPlayer(2, True, (6, 6, 0)) player_4 = SPlayer(4, False, (4, 5, 2)) active_players = [player_1, player_2] server.splayers_active = copy(active_players) players_last_out = [player_4] board.place_tile(tile_5, Tile_location((1, 1))) tile_4.set_rotation(1) # check deck number player_1.hand.num_tiles = 0 player_1.add_hand(tile_3) player_2.hand.num_tiles = 3 deck.add_tile(tile_1) self.assertEqual(player_1.player, None) d, sa, so, b, res = server.play_a_turn(deck, copy(active_players), copy(players_last_out), board, tile_4) self.assertEqual(player_1.player.name, "bot_red")
def test_draw_tiles_3(self): # moving where the player that has the dragon tile makes # a move that causes an elimination (of another player) # the eliminated player has 1 tile, another player gets the dragon server = Server.reset_get_instance() deck = Deck() board = Board() tile_1 = init_tile_1() tile_3 = init_tile_3() tile_4 = init_tile_4() tile_5 = init_tile_5() tile_6 = init_tile_6() tile_7 = init_tile_7() player_1 = SPlayer(1, True, (1, 1, 2)) player_2 = SPlayer(2, True, (1, 3, 6)) player_3 = SPlayer(3, True, (5, 5, 6)) board.matrix_player[1][1][2] = player_1 board.matrix_player[1][3][6] = player_2 board.matrix_player[5][5][6] = player_3 player_4 = SPlayer(4, False, (2, 5, 2)) active_players = [player_2, player_1, player_3] players_last_out = [player_4] board.place_tile(tile_5, Tile_location((1, 1))) board.place_tile(tile_4, Tile_location((1, 3))) board.place_tile(tile_6, Tile_location((5, 5))) player_1.add_hand(tile_7) player_2.add_hand(tile_3) player_3.hand.num_tiles = 1 server.dragon_owner = player_2 deck.own_dragon = False self.assertEqual(server.dragon_owner, player_2) self.assertFalse(deck.has_dragon()) self.assertEqual(player_1.hand.get_num(), 1) self.assertEqual(player_2.hand.get_num(), 1) self.assertEqual(player_3.hand.get_num(), 1) d, sa, so, b, res = server.play_a_turn(deck, copy(active_players), copy(players_last_out), board, tile_3) # player 1 killed, returning 1 tile to deck # player 2 draws 1 tile, returns dragon # player 3 gets dragon self.assertEqual(d.get_num(), 0) self.assertEqual(sa, [player_3, player_2]) self.assertTrue(player_1 in so) self.assertFalse(player_2 in so) self.assertFalse(player_3 in so) self.assertFalse(res) self.assertEqual(server.dragon_owner, player_3) self.assertFalse(deck.has_dragon()) self.assertFalse(player_1.is_alive()) self.assertEqual(player_2.hand.get_num(), 1) self.assertEqual(player_3.hand.get_num(), 1)
def test_05_shuffle(self): d1 = Deck() d2 = Deck() d1.shuffle() self.assertFalse(same_cards(d1,d2), "deck wasn't shuffled") d1.sort() self.assertTrue(same_cards(d1,d2), "deck wasn't sorted")
def test_hit(self): deck = Deck() player = Player() sizeBefore = len(player.hand()) player.hit(deck.draw()) self.assertEqual(len(player.hand()), sizeBefore + 1)
def __init__(self, numPlayers, maxSimulationDepth): self._players = [] self._currentPlayerIndex = 0 self._deck = Deck() self._cardDrawManager = CardDrawManager(self) print "===========" self._deck.printCards() for playerIndex in range(numPlayers): player = Player(self, playerIndex) self._players.append(player) for drawIndex in range(InitialDrawCount): self._cardDrawManager.handleDrawFor(player) for player in self._players: print player print "=============" self._progress = {} for suit in SUITS: self._progress[suit] = 0 self._hintTokens = InitialHintTokens self._deathTokens = InitialDeathTokens self._maxSimulationDepth = maxSimulationDepth
def test_get_random_card(self): test_deck = Deck() # Go through all possible cards in the deck for i in range(0, 52): test_deck.get_random_card() # Verify that the set of used_cards is equal to 52, thus every card is unique self.assertEqual(len(set(test_deck.used_cards)), 52)
def setUp(self): self._deck = Deck.Deck() self._player1 = Deck.Player("Jack") self._player2 = Deck.Player("John") self._board = Deck.Player("Board") self._deck.reset_deck() print "SetUp. Deck has", self._deck._cards
class Game(): def __init__(self, amountOfPlayers, amountOfDecks): self.players = Players(amountOfPlayers) self.deck=Deck(amount=amountOfDecks) self.playedDeck=Deck() self.activePlayer=self.players.GetCurrentValue() #Clears the CL. def ClearScreen(self): os.system("cls") #Sets up the starting conditions of the game. (7 cards for each player and 1 played card) def SetStartConditions(self): for i in range(7): while(not self.players.Empty()): self.players.GetCurrentValue().DrawCard(self.deck.DrawCard()) self.players.Next() self.players.Reset() self.playedDeck.AddExistingNode(self.deck.DrawCard()) #TODO Prints the basic ui. def PrintBase(self): #Change the type, not the string... lastCard="Change me" print("Last played card: " + lastCard.ToString()) print("Active player: "+self.activePlayer.name) print("Your hand: ") self.activePlayer.hand.PrintHand() #TODO Defines player actions. def PlayerAction(self): x= input("enter to continue") self.ClearScreen() #TODO Switches the active player to the next player in the list. def SwitchTurn(self): self.players.Next() #If what? if(): self.players.Reset() self.activePlayer=self.players.GetCurrentValue() input("switch to player {}. Press enter to continue".format(self.activePlayer.name)) #TODO Basic gameloop. def GameLoop(self): while(True): self.PrintBase() self.PlayerAction() self.SwitchTurn() #TODO Game "Run" function. def Run(self): self.RandomizePlayerOrder() self.SetStartConditions() self.GameLoop() #TODO Randomize the player order. def RandomizePlayerOrder(self): pass
def __init__(self, game_file, players=None): self.board = GameBoard.GameBoard(game_file) self.playerList = [] self.chance = Deck.Deck("Chance.txt") self.community = Deck.Deck("Community_Chest.txt") if players: for player in range(players): self.__add_players(player)
def __init__(self): self.board = [] #cards on the board(hand) self.on = True self.deck = Deck() #the deck self.deck.shuffle() for i in range(0, 4): self.board.append(self.deck.draw()) self.beginDisplay() self.redisplay()
def reset(self): self.hand = Deck.Deck() self.won_goals = Deck.Deck() self.is_ready = False # This is the players vote regarding starting the game or not self.last_toggled_ready = 0 self.is_spectating = True self.reset_at_turns_end()
def __init__(self, cut_index=0, num_players=1): self.deck = Deck() self.deck.shuffle() self.deck.cut(cut_index) self.players = [ Hand(self.deck.draw(), self.deck.draw()) for i in range(num_players) ] self.dealer = Dealer(self.deck.draw(), self.deck.draw())
def test_hand_value(self): test_deck = Deck() # Test to non face cards test_player_hand = [(2, 3), (3, 4)] self.assertEqual(test_deck.hand_value(test_player_hand), 9) # Test face card and Ace test_player_hand = [(0, 0), (0, 12)] self.assertEqual(test_deck.hand_value(test_player_hand), (11, 21))
def make_decks(self): #make a shuffled weapons deck self.weapon_deck = Deck(WEAPON) #make players deck, shuffle self.player_deck = Deck(PLAYER) #make rooms deck, shuffle self.room_deck = Deck(ROOM)
class Dealer: def __init__(self): self.deck = Deck(False) def shuffleDeck(self): self.deck = Deck(False) self.deck.shuffle() self.deck.shuffle() self.deck.shuffle() self.deck.shuffle()
def __init__(self): card1 = randint(0, 12) card2 = randint(0, 12) self.deck = Deck() value1 = self.deck.get_card_value(card1) value2 = self.deck.get_card_value(card2) self.total = value1 + value2 self.game_done = False self.busted = False self.has_ace = False
def __init__(self): if self.__server == None: self.board = Board() self.deck = Deck() self.splayers_active = [] self.splayers_out = [] self.dragon_owner = None Server.__server = self else: raise Exception("This class is a singleton! use get_instance() for access")
def setup_game(self): self.player_one = Player(player_deck=Deck.PlayerDeck(), player_name="Player one") self.player_two = Player(player_deck=Deck.PlayerDeck(), player_name="Player two") self.player_one.get_hand() self.player_two.get_hand() self.card_deck = Deck.GameDeck() self.explorer_deck = Deck.ExplorerDeck() self.cards_on_the_table = [] for i in range(5): self.cards_on_the_table.append(self.card_deck.draw())
def __init__(self, hand_size=0, hand_count=0, max_hand_size=0, ace_rank=None, discard_type=None, sort=None): """Initializes the game object""" self._init_hand_size = 0 self._hand_count = 0 self._max_hand_size = 52 self._acerank = Rank.ACELOW self._discard_type = Visibility.INVISIBLE self._hands = [] self._deck = [] self._empty_hands = 0 self._active = None self._sort = Sort.SUITTHENRANKD self._log_file = Error.log_error("Game initalized", "Game.__init__") """Instantiating properties""" if hand_size != 0 and type(hand_size) == int: self._init_hand_size = hand_size if hand_count != 0 and type(hand_count) == int: self._hand_count = hand_count if max_hand_size != 0 and type(max_hand_size) == int: self._max_hand_size = max_hand_size if ace_rank != None and type(ace_rank) == Rank: self._acerank = ace_rank if discard_type != None and type(discard_type) == Visibility: self._discard_type = discard_type if sort != None and type(sort) == Sort: self._sort = sort """Building the deck""" deck = Deck(ace_rank=self.ace_rank) self._deck = deck deck.shuffle() temp_hands = {} """Dealing the hands""" if self._hand_count != 0 and self._hands == []: for i in range(self.hand_count): hand = Hand(visibility=self.discard_type, sort=self.sort_method) for j in range(self.init_hand_size): card = deck.deal() hand.add_card(card) name = "hands%s" % i score = 0 temp_hands[name] = [hand, score] self._hands = temp_hands tk.Frame.__init__(self, parent) label = tk.Label(self, text="Hello, world") label.pack() label.bind("<1>", self.quit)
def test_draw_tiles_1(self): # moving where one player has the dragon tile before # and no one gets any new tiles server = Server.reset_get_instance() deck = Deck() board = Board() tile_1 = init_tile_1() tile_3 = init_tile_3() tile_4 = init_tile_4() tile_5 = init_tile_5() tile_6 = init_tile_6() tile_7 = init_tile_7() player_1 = SPlayer(1, True, (1, 0, 2)) player_2 = SPlayer(2, True, (6, 6, 0)) player_4 = SPlayer(4, True, (2, 5, 2)) player_1.add_hand(tile_3) player_2.add_hand(tile_1) player_4.add_hand(tile_4) active_players = [player_1, player_2, player_4] players_last_out = [] server.dragon_owner = player_1 deck.own_dragon = False self.assertEqual(server.dragon_owner, player_1) self.assertFalse(deck.has_dragon()) self.assertEqual(player_1.hand.get_num(), 1) self.assertEqual(player_2.hand.get_num(), 1) self.assertEqual(player_4.hand.get_num(), 1) d, sa, so, b, res = server.play_a_turn(deck, copy(active_players), copy(players_last_out), board, tile_3) self.assertEqual(d.get_num(), 0) self.assertEqual(d.tiles, []) self.assertEqual(sa, [player_2, player_4, player_1]) self.assertEqual(so, players_last_out) self.assertEqual(player_1.get_location().into_tuple(), (1, 1, 2)) self.assertEqual(b.num_tiles, 1) self.assertEqual(b.get_tile_by_loc(Tile_location((1, 1))), tile_3) self.assertEqual(b.get_splayer_by_loc(Player_location((1, 1, 2))), player_1) self.assertFalse(res) self.assertEqual(server.dragon_owner, player_1) self.assertFalse(deck.has_dragon()) self.assertEqual(player_1.hand.get_num(), 0) self.assertEqual(player_2.hand.get_num(), 1) self.assertEqual(player_4.hand.get_num(), 1)
def test_equal(self): deck1 = Deck() deck2 = Deck() tile_1 = init_tile_1() tile_2 = init_tile_2() deck1.add_tile(tile_1) deck1.add_tile(tile_2) deck2.add_tile(tile_2) self.assertFalse(deck1 == deck2) deck2.add_tile(tile_1) self.assertTrue(deck1 == deck2)
def startGame(): gameboard = GameManager.Gameboard() #set up decks Deck.newDeck(gameboard) print("Setting up player...") gameboard.playerSetUp() print("Setting up opponent...") gameboard.oppSetUp() if gameboard.turn == 'p': gameboard.playerDrawCard() elif gameboard.turn == 'o': gameboard.oppDrawCard() return gameLoop(gameboard)
def __init__(self, game_engine): self._game_engine = game_engine # decks self._dog = Deck() self._last_trick = None self._current_trick = Deck() self._deck = self.init_deck() # players self._taker = game_engine.players[0] self._dealer = game_engine.players[0] self._last_trick_leader = game_engine.players[0]
class Game: def __init__(self): name1 = input("P1 name:") name2 = input("P2 name:") self.deck = Deck() self.p1 = Player(name1) self.p2 = Player(name2) def wins(self, winner): w = "{} 赢得了这一局".format(winner) print(w) def draw(self, p1n, p1c, p2n, p2c): d = "{} drew {} {} drew {}".format(p1n, p1c, p2n, p2c) print(d) def play_game(self): cards = self.deck.cards print("开始游戏!") while len(cards) >= 2: m = "q: 退出。 任一" + "键进行游戏:" response = input(m) if response == "q": break p1n = self.p1.name p2n = self.p2.name p1c = self.deck.rm_card() print("{} card: {}".format(p1n, p1c)) p2c = self.deck.rm_card() print("{} card: {}".format(p2n, p2c)) if p1c > p2c: self.p1.wins += 1 self.wins(self.p1.name) else: self.p2.wins += 1 self.wins(self.p2.name) win = self.winner(self.p1, self.p2) print("Game is over,{} Wins!".format(win)) def winner(self, p1, p2): if p1.wins > p2.wins: return p1.name if p1.wins < p2.wins: return p2.name return "All have no"
def newRound(self): self.deck = Deck.Deck() self.activePlayers = list(self.players) for player in self.activePlayers: player.hand = Deck.Hand(self.deck) player.active = True player.playerBet = 0 self.pot = 0 self.activeBet = 0 self.phase = 0 self.community = [] self.roundOver = False Prediction.predictRound(self) Display.displayGameState(self)
def test_shuffle(): newdeck = Deck() beforeshuffle = [] for card in newdeck: beforeshuffle.append(card) newdeck.shuffle() sameplace = 0 index = 0 for card in newdeck: if card.card_value == beforeshuffle[index].card_value: sameplace += 1 index += 1 assert sameplace < newdeck.size/3
def test_function_count_three(self): deck = Deck() deck.build() deck.deal() deck.deal() deck.deal() self.assertEqual(deck.count, 49, "Count not initializing to 51.")
def threaded_client(conn, p, gameId): global idCount conn.send(str.encode(str(p))) reply = "" while True: try: data = conn.recv(4096).decode() if gameId in games: game = games[gameId] if not data: break else: if data == "reset": game.resetWent() elif data == "False": game.not_redraw() elif data == "draw": deck2 = Deck() deck2.Shuffle() game.reset_game(deck2) elif data == "score": game.update_score() elif data == "first": game.update_curr_player(p) elif data[0:4] == "flip": game.flip_card(data, p) elif data == "finished": game.game_is_finished() elif data[0:16] == "next_play_player": game.update_next_play_player(data) elif data != 'get': game.play(data, p) conn.sendall(pickle.dumps(game)) else: break except: break print("Lost connection") try: del games[gameId] print("Closing Game", gameId) except: pass idCount -= 1 conn.close()
def test_start_round(self): test_dealer = Dealer() test_player = Player() test_deck = Deck() for i in range(0, 2): test_player.hand.append(test_deck.get_random_card()) test_dealer.hand.append(test_deck.get_random_card()) self.assertEqual(len(test_player.hand), 2) self.assertEqual(len(test_dealer.hand), 2) for x in range(0, 2): self.assertEqual(type(test_player.hand[x]), tuple) self.assertEqual(type(test_dealer.hand[x]), tuple)
def __init__(self): self.isPlaying = True self.boardRows = 4 self.boardCols = 10 #Stokkur leiksins self.deck = Deck(52) self.deck.shuffleCards() #2D array of cards in the board, initialized as None self.board = self.initBoard() self.dealToBoard() #Cards in the heap self.heap = [self.deck.cards.pop()] #Breyta sem heldur utan um stig self.score = 0 #Breyta sem byrjar ad taka tima self.start_time = time.time() #Lokatimi leiks self.finaltime = 0.0 #Breyta sem heldur utanum 'moves' self.moves = 0
def __init__(self): self.board = [] #cards on the board(hand) self.on = True self.deck = Deck() #the deck self.deck.shuffle() for i in range(0,4): self.board.append(self.deck.draw()) self.beginDisplay() self.redisplay()
def deck_entropy(deck_1, deck_2 = Deck.construct_standard_deck()): total=0 for i, card in enumerate(deck_1): diff = 0 for j, compare in enumerate(deck_2): if(card==compare): diff == i-j if(diff<0): diff*=(-1) total+=diff return total
def __init__(self): self.deck = Deck() self.deckA = pygame.sprite.LayeredDirty() self.deckB = pygame.sprite.LayeredDirty() self.col1 = pygame.sprite.LayeredDirty() self.col2 = pygame.sprite.LayeredDirty() self.col3 = pygame.sprite.LayeredDirty() self.col4 = pygame.sprite.LayeredDirty() self.col5 = pygame.sprite.LayeredDirty() self.col6 = pygame.sprite.LayeredDirty() self.col7 = pygame.sprite.LayeredDirty() self.set_up_game()
def main(): size = int(sys.argv[1]) me = Deck(range(1,size+1)) print("initial state:") me.debugprint() for i in range(15): me.shuffle() print("---") print(" below is the", i,"th iteration:") me.debugprint()
def dealSomeHands(): # Generate the initial deck and shuffle it. d = Deck() d.shuffle() # Find out from the user how many hands to generate. while True: # Run this while loop until we get a legal (positive # integer) answer from the user. nStr = input("How many hands should I deal? ") if not nStr.isdigit(): print (" Positive number required. Try again!") else: n = int( nStr ); break # Generate n hands. for i in range( n ): # If there are not enough cards left in the deck # to deal a hand, generate and shuffle a new deck. if ( len(d) < 5 ): print("\nDealing a new deck.") d = Deck() d.shuffle() # Generate a new hand, print it, and evaluate it. h = Hand(d) print("\n\tHand drawn (", i + 1, "): ", sep="") print(h) print( "\t -", h.evaluateHand())
def start(): new_deck1 = copy.deepcopy(Deck.deck()) new_dealer1 = 0 new_hand1 = 0 ace_dealer1 = 0 ace_hand1 = 0 print() card_d = int(input("What card should the dealer start with? ")) print() card_d = new_deck1[card_d-1] print(card_d[0]) new_dealer1 += card_d[1] if card_d[1] == 11: ace_dealer1 += 1 print() cards_h = input("What cards should the player start with? ").split(" ") card_h = [] for card in cards_h: card_h.append(int(card)) print() card_h0 = new_deck1[card_h[0]-1] card_h1 = new_deck1[card_h[1]-1] new_deck1.remove(card_d) new_deck1.remove(card_h0) new_deck1.remove(card_h1) new_hand1 += card_h0[1] new_hand1 += card_h1[1] if card_h0[1] == 11: ace_hand1 += 1 if card_h1[1] == 11: ace_hand1 += 1 print(card_h0[0]) print(card_h1[0]) print() print("The dealer has", new_dealer1) print("You have", new_hand1) print() return new_deck1, new_dealer1, new_hand1, ace_dealer1, ace_hand1
def __init__(self, playerName): ''' Initializes the game by - shuffling the deck - initializing a player1 (with given playerName) and dealer object (both are Player objects) ''' self.gamedeck = Deck() self.gamedeck.reset() self.gamedeck.shuffle() self.playerName = playerName self.user = Player(self.playerName) self.dealer = Player("Dealer")
def deal(): ''' resets game, deals 4 cards face down, flips 3 to begin (1 dealer, 2 player) ''' global dealer_hand_display global player_hand_display global dealer_hand global player_hand global global_deck # resets global variables and shuffles deck, creating new game dealer_hand = [] player_hand = [] global_deck = Deck() global_deck.shuffle() current_bet.config(state=NORMAL) for i in range(2): dealer_hand.append(global_deck.nextcard()) player_hand.append(global_deck.nextcard()) for i in range(2,6): dealer_hand_display[i].display('blank') player_hand_display[i].display('blank') player_hand_display[0].display('front', player_hand[0].ID) player_hand_display[1].display('front', player_hand[1].ID) dealer_hand_display[0].display('back') dealer_hand_display[1].display('front', dealer_hand[1].ID) # extra credit, checks for "Blackjack" if (check_blackjack(dealer_hand)) or (check_blackjack(player_hand)): dealer_hand_display[0].display('front', dealer_hand[0].ID) if (check_blackjack(dealer_hand)): win_process('dealer') elif (check_blackjack(player_hand)): win_process('player')
def test_06_hands(self): d = Deck() h = d.deal(5) self.assertEqual(5, len(h), "hand doesn't have 5 cards") self.assertEqual(47, len(d), "hand wasn't removed from deck") d.restore(h) self.assertEqual(52, len(d), "had wasn't put back in deck") d.sort() self.assertTrue(same_cards(d, Deck()), "restored deck incomplete")
def deal(): """Generates a new round. Deals a hand to the dealer and player. Checks if either hand is a BlackJack""" global outcome, in_play, dealer, player, deck, score, total_games if total_games != 0: outcome = "" if in_play: outcome = "Player dealed again, lost a point. " score -= 1 in_play = False dealer = Hand() player = Hand() deck = Deck() deck.shuffle() dealer.add_card(deck.deal_card()) dealer.add_card(deck.deal_card()) player.add_card(deck.deal_card()) player.add_card(deck.deal_card()) in_play = True outcome += "New Game! Hit or Stand?" if in_play and player.get_value() == 21: stand() if in_play and dealer.get_value() == 21: stand()
def test_deck(self): a = Card(ONE, RED, FILLED, STAR) b = Card(TWO, RED, FILLED, STAR) c = Card(THREE, RED, FILLED, STAR) d = Card(THREE, RED, FILLED, CIRCLE) e = Card(THREE, RED, FILLED, SQUARE) self.assertEqual(Deck.numberOfSets([a, b, c, d, e]), 2) self.assertTrue(Deck.hasSet([a, b, c, d, e])) badSet = {Card(number=3, colour=5, filling=8, shape=11), Card(number=2, colour=6, filling=7, shape=12), Card(number=2, colour=6, filling=9, shape=11)} self.assertFalse(Deck.hasSet(badSet)) self.assertEqual(Deck.similarities(*list(badSet)), 0) self.assertTrue( Deck.hasSet({Card(number=3, colour=5, filling=8, shape=11), Card(number=2, colour=6, filling=7, shape=12), Card(number=2, colour=6, filling=9, shape=11)} | {a})) deck = Deck() threeCards = deck.drawGuarantee() self.assertTrue(Deck.hasSet(threeCards)) self.assertRaises( ValueError, lambda x: deck.drawGuarantee(numberofcards=x), 0)
def __init__(self): #spots are the 14 possible spots where you can play a minion self.spots = ([],[]) for i in range (0,7): self.spots[0].append(Spot((200*i+70,390))) self.spots[1].append(Spot((200*i+70,190))) #Hands are each player's hands self.hands = (Hand(),Hand()) #Creates two dummy decks, which will be filled in later self.Deck1 = Deck("Player1", "Warlock") self.Deck2 = Deck("Player2", "Druid") #Effects begins null, and will hold all of the effects self.effects = [] #Initializes the Players with their own decks and placement order self.player1 = Player(self.hands[0], self.Deck1, self.spots[0], 0, 0) self.player2 = Player(self.hands[1], self.Deck2, self.spots[1], 1, 1) #Set each player as each others enemy self.player1.setEnemies(self.player2) #Set the current player self.currentPlayer = self.player2
def __init__(self, parent): """ Buttons and card labels initialized. """ Frame.__init__(self, parent) self.configure(background = 'white') self._cards = Deck(BlackjackCard) self._cards.shuffle() self.pack() CardLabel.load_images() self._dc1 = CardLabel(self) self._dc1.grid(row = 0, column = 0) self._dc2 = CardLabel(self) self._dc2.grid(row = 0, column = 1) self._dc3 = CardLabel(self) self._dc3.grid(row = 0, column = 2) self._dc4 = CardLabel(self) self._dc4.grid(row = 0, column = 3) self._dc5 = CardLabel(self) self._dc5.grid(row = 0, column = 4) self._dc6 = CardLabel(self) self._dc6.grid(row = 0, column = 5) self._pc1 = CardLabel(self) self._pc1.grid(row = 1, column = 0) self._pc2 = CardLabel(self) self._pc2.grid(row = 1, column = 1) self._pc3 = CardLabel(self) self._pc3.grid(row = 1, column = 2) self._pc4 = CardLabel(self) self._pc4.grid(row = 1, column = 3) self._pc5 = CardLabel(self) self._pc5.grid(row = 1, column = 4) self._pc6 = CardLabel(self) self._pc6.grid(row = 1, column = 5) self._deal = Button(self, text = 'Deal', command = self.dealcb) self._deal.grid(row = 2, column = 0, padx = 10, pady = 10) self._hit = Button(self, text = 'Hit', command = self.hitcb) self._hit.grid(row = 2, column = 2, padx = 10, pady = 10) self._stand = Button(self, text = 'Stand', command = self.standcb) self._stand.grid(row = 2, column = 4, padx = 10, pady = 10) self.dealcb()
def setUp(self): self.testCard1a = Card('H',10, 0, 0, None) self.testCard1b = Card('H',10, 0, 0, None) self.testCard2a = Card('S',5, 0, 0, None) self.testCard2b = Card('S',5, 0, 0, None) self.testCard3 = Card('T',3, 0, 0, None) self.initialDeck = Deck(52) self.sortedDeck = Deck(52) self.sortedDeck.cards.sort() self.shuffledDeck = Deck(52) self.shuffledDeck.shuffleCards() self.game1 = TriPeaks() self.game2 = TriPeaks() self.deckCard = self.game1.deck.cards[-1] self.heapCard = self.game1.heap[-1] self.legalCard = Card('H', (self.heapCard.value)%13+1, 3,3,None) self.illegalCard = Card('H', (self.heapCard.value)%13+5, 0,0,None)
def test_deal(): newdeck = Deck() newdeck.shuffle() first_player = [] second_player = [] third_player = [] card_per_hand = 7 for card in range(card_per_hand): first_player.append(newdeck.deal()) second_player.append(newdeck.deal()) third_player.append(newdeck.deal()) assert len(first_player) == 7 assert len(second_player) == 7 assert len(third_player) == 7
def __init__(self, comp_players): self.comp_players = comp_players #Create a list of Hand objects, one for each player self.hands = [] print "Computer Players: ", self.comp_players #Build and shuffle the deck self.poker_deck = Deck() self.poker_deck.shuffle() #Add the player's Hand to self.hands self.hands.append(Hand(self.poker_deck.dealHand())) #Add one Hand to self.hands for each computer player for i in range(comp_players): self.hands.append(Hand(self.poker_deck.dealHand()))
def newGame(self, difficulty): self.deck = Deck() # stokkurinn self.pyramid = self.buildPyr() # hluti af stokknum verður pýramíddi self.drawDeck = deque() # fyrri stokkurinn af spilum self.activeDeck = deque() # seinni stokkurinn af spilum self.discardPile = deque() # spilin sem að hafa verið tekin út for i in range(0, len(self.deck.cards)): self.drawDeck.append(self.deck.draw()) self.score = 0 self.difficulty = difficulty # því hærri tala því auðveldari er leikurinn self.initPyramid = copy.deepcopy(self.pyramid) # state savefyrir restart same game for i in range(len(self.pyramid)): self.initPyramid.append(self.pyramid[i]) self.initDrawDeck = copy.deepcopy(self.drawDeck) # state savefyrir restart same game for i in range(len(self.drawDeck)): self.initDrawDeck.append(self.drawDeck[i]) self.initDifficulty = self.difficulty self.tempPyramid = copy.deepcopy(self.pyramid) self.tempDrawDeck = deque() self.tempDiscardpile = deque() self.tempScore = 0 self.startTime = time.ctime()
def __init__(self, host, port, capacity): self.players = [] self.host = host self.port = port self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.bind((self.host, self.port)) self.socket.listen(20) self.capacity = capacity self.recvStrList = '' self.allIn = False self.isReady = [False for i in range(self.capacity)] self.heroSelected = [False for i in range(50)] self.choosedHero = [False for i in range(10)] self.deck = Deck() self.nowRoundPlayer = "1" self.trickStack = ["" for i in range(10)] self.trickPointer = 0 self.trickList = [] self.havePeople = True self.playerNum = 0 self.inStringList = [] self.data = '' self.con = threading.Condition()
class MainWindow(QMainWindow): AUTOSAVE_INTERVAL = 10000 AUTOSAVE_PATH = './resource/AutoSave.sav' CONFIG_PATH = './resource/config.ini' def __init__(self, parent=None): super(MainWindow, self).__init__(parent) self.createUI() self.nameAreaMapping = { 'hand': self.handArea, 'hero': self.heroArea, 'engaged': self.engagedArea, 'staging': self.stagingArea, 'location': self.locationDeck, 'quest': self.questDeck, 'encounter': self.encounterDeck, 'encounterDP': self.encounterDiscardPile, 'prepare': self.prepareDeck, 'removed': self.removedPile, 'playerDP': self.playerDiscardPile, } self.deckManipulatorList = [] # for bookkeeping existing DeckManipulator instances self.scenarioId = 0 self.playerDeckId = 0 self.isFirstPlayer = True # might change in MultiplayerMainWindow self.playerCount = 1 # might change in MultiplayerMainWindow if self.__class__.__name__ == 'MainWindow': # not true in MultiplayerMainWindow if self.checkIfprogramCrashed(): self.loadGame(MainWindow.AUTOSAVE_PATH) else: self.startNewGame() # auto save just work in Solo game self.prevState = self.getState() def autoSave(): state = self.getState() if state != self.prevState: jsonState = self.dumpState(state) with open(MainWindow.AUTOSAVE_PATH, 'w') as f: f.write(jsonState) self.prevState = state timer = QTimer(self) timer.timeout.connect(autoSave) timer.start(MainWindow.AUTOSAVE_INTERVAL) def addDeckManipulator(self, widget): self.deckManipulatorList.append(widget) def cleanupDeckManipulators(self): for widget in self.deckManipulatorList: try: widget.close() except RuntimeError: pass self.deckManipulatorList = [] def cleanup(self): self.victorySpinBox.setValue(0) self.cleanupDeckManipulators() for area in (self.engagedArea, self.heroArea, self.handArea, self.stagingArea, self.locationDeck, self.questDeck, self.encounterDeck, self.encounterDiscardPile, self.prepareDeck, self.removedPile, self.playerDeck, self.playerDiscardPile): area.setList([]) while True: # remove Card from scene until none left for card in area.scene.items(): if isinstance(card, Card): area.scene.removeItem(card) del card break else: break area.update() self.journeyLogger.clearLog() def startNewGame(self): self.cleanup() setupDialog = SetupDialog(self) setupDialog.exec_() self.scenarioId = setupDialog.selectedScenarioId() self.playerDeckId = setupDialog.selectedDeckId() self.setup() self.prisonAct.setEnabled(self.scenarioId == 2) # is it Escape From Dol Guldur? def restartGame(self): self.cleanup() self.setup() self.prisonAct.setEnabled(self.scenarioId == 2) # is it Escape From Dol Guldur? def startNewGameAction(self): self.startNewGame() def restartGameAction(self): self.restartGame() def saveGame(self): state = self.getState() state['version'] = VERSION jsonState = self.dumpState(state) filePath = QFileDialog.getSaveFileName(self, QCoreApplication.translate('MainWindow', 'Save game'), 'LotRLCG.sav', QCoreApplication.translate('MainWindow', 'Game Save (*.sav)')) if filePath: if not saveFile(filePath, jsonState): QMessageBox.critical(self, QCoreApplication.translate('MainWindow', "Can't save game"), QCoreApplication.translate('MainWindow', 'Failed to write file!')) def loadGame(self, filePath=''): if not filePath: filePath = QFileDialog.getOpenFileName(self, QCoreApplication.translate('MainWindow', 'Load game'), '.', QCoreApplication.translate('MainWindow', 'Game Save (*.sav)')) if filePath: file = QFile(filePath) if file.open(QIODevice.ReadOnly | QIODevice.Text): jsonState = str(file.readAll()) try: state = json.loads(jsonState, encoding='ascii') except ValueError: QMessageBox.critical(self, QCoreApplication.translate('MainWindow', "Can't load game"), QCoreApplication.translate('MainWindow', 'Game save corrupted!')) return self.victorySpinBox.setValue(state['victory']) self.threatDial.setValue(state['threat']) for (name, area) in self.nameAreaMapping.items(): area.setState(state[name]) file.close() else: QMessageBox.critical(self, QCoreApplication.translate('MainWindow', "Can't load game"), QCoreApplication.translate('MainWindow', 'Failed to open file!')) def dumpState(self, dictObject): return json.dumps(dictObject, separators=(',', ':'), encoding='ascii') def getState(self): state = {} state['victory'] = self.victorySpinBox.value() state['threat'] = self.threatDial.value for (name, area) in self.nameAreaMapping.items(): state[name] = area.getState() return state def setup(self): self.setupPlayerCards() self.promptMulligan() def setupPlayerCards(self): heroList = [] playerList = [] for (set_, id) in playerDecksInfo[self.playerDeckId]['deck']: if isHeroCard(set_, id): heroList.append((set_, id)) else: playerList.append((set_, id)) random.shuffle(playerList) # start creating Card instances for (set_, id) in heroList: self.heroArea.addCard(Card(cardsInfo[set_][id], revealed=True)) for (set_, id) in playerList: self.playerDeck.addCard(Card(cardsInfo[set_][id])) for i in range(6): if self.playerDeck.getList(): card = self.playerDeck.draw() if not card.revealed(): card.flip() self.handArea.addCard(card) threatValue = 0 for card in self.heroArea.getList(): threatValue += card.info.get('cost', 0) self.threatDial.setValue(threatValue) def promptMulligan(self): mulliganDialog = _MulliganDialog(self) mulliganDialog.show() def takeMulligan(self): for i in range(6): card = self.handArea.draw() card.flip() self.playerDeck.addCard(card) self.playerDeck.shuffle() for i in range(6): card = self.playerDeck.draw() card.flip() self.handArea.addCard(card) self.mulliganDecisionIsMade() def giveUpMulligan(self): self.mulliganDecisionIsMade() def mulliganDecisionIsMade(self): self.setupEncounterCards() self.logInitialState() def setupEncounterCards(self): assert(self.isFirstPlayer) scenarioId = self.scenarioId heroList = [] # additional cards that First Player gains control, according to quest card's instructions questList = [] encounterList = [] stagingList = [] prepareList = [] for encounterName in scenariosInfo[scenarioId]['encounters']: for set_ in SETS: for (id, card) in enumerate(cardsInfo[set_]): if card['icon'] == encounterName and card['type'] != 'quest': for i in range(card['quantity']): encounterList.append((set_, id)) random.shuffle(encounterList) s = '' if scenarioId <= 2: s = 'core' elif scenarioId <= 8: s = 'mirkwood' elif scenarioId == 9: s = 'osgiliath' elif scenarioId <= 12: s = 'khazaddum' else: s = 'dwarrowdelf' # EXPANSION if scenarioId == 0: # Passage Through Mirkwood questList = [(s, 119), (s, 120), (s, 121 + random.choice((0, 1)))] stagingList = [(s, 96), (s, 99)] for card in stagingList: encounterList.remove(card) random.shuffle(encounterList) elif scenarioId == 1: # Journey Along the Anduin questList = [(s, 126), (s, 127), (s, 128)] hillTroll = (s, 82) for i in range(self.playerCount): stagingList.append(encounterList.pop(-1)) # draw one card from encounter deck to staging area. 1 card per player. hillTrollAppeared = False for card in stagingList: if card == hillTroll: hillTrollAppeared = True if not hillTrollAppeared: stagingList.append(hillTroll) encounterList.remove(hillTroll) random.shuffle(encounterList) elif scenarioId == 2: # Escape From Dol Guldur questList = [(s, 123), (s, 124), (s, 125)] prepareList = [(s, 102)] # Nazgul of Dol Guldur encounterList.remove((s, 102)) stagingList = [(s, 108), (s, 109), (s, 110)] # Gandalf's Map, Dungeon Torch, Shadow Key for card in stagingList: encounterList.remove(card) elif scenarioId == 3: # The Hunt for Gollum questList = [(s, 11), (s, 12), (s, 13)] if self.playerCount == 1: stagingList.append(encounterList.pop(-1)) # 1 card per player elif scenarioId == 4: # Conflict at the Carrock questList = [(s, 35), (s, 36)] stagingList = [(s, 43)] # The Carrock encounterList.remove((s, 43)) prepareList = [(s, 38), (s, 39), (s, 40), (s, 41)] # 4 Trolls for card in prepareList: encounterList.remove(card) sacked = (s, 48) while encounterList.count(sacked) > self.playerCount: # 1 Sacked! per player encounterList.remove(sacked) random.shuffle(encounterList) elif scenarioId == 5: # A Journey to Rhosgobel questList = [(s, 60), (s, 61), (s, 62)] heroList.append((s, 64)) # Wilyador, damage tokens will be placed after Card instance created # TODO: this is for first player encounterList.remove((s, 64)) stagingList = [(s, 65)] # Rhosgobel encounterList.remove((s, 65)) elif scenarioId == 6: # The Hills of Emyn Muil questList = [(s, 82)] stagingList = [(s, 83), (s, 84)] # Amon Hen, Amon Lhaw for card in stagingList: encounterList.remove(card) elif scenarioId == 7: # The Dead Marshes questList = [(s, 105), (s, 106)] stagingList = [(s, 107)] # Gollum encounterList.remove((s, 107)) if self.playerCount == 1: stagingList.append(encounterList.pop(-1)) # 1 card per player elif scenarioId == 8: # Return to Mirkwood questList = [(s, 126), (s, 127), (s, 128), (s, 129)] gollum = (s, 130) encounterList.remove(gollum) if self.playerCount == 1: heroList.append(gollum) stagingList.append(encounterList.pop(-1)) # 1 card per player else: stagingList.append(gollum) elif scenarioId == 9: # The Massing at Osgiliath questList = [(s, 16), (s, 17), (s, 18), (s, 19)] scouts = ((s, 2), (s, 3), (s, 4)) # 3 Scouts per player for scout in scouts: for i in range(min(4, self.playerCount)): stagingList.append(scout) for card in stagingList: encounterList.remove(card) random.shuffle(encounterList) prepareList = [(s, 1)] # The Witch-king encounterList.remove((s, 1)) elif scenarioId == 10: # Into the Pit questList = [(s, 64), (s, 65), (s, 66)] stagingList = [(s, 16)] # East-gate, put it to staging area and draw to location deck later encounterList.remove((s, 16)) heroList.append((s, 41)) # Cave Torch, for first player # TODO: this is for first player encounterList.remove((s, 41)) prepareList = [(s, 17), (s, 18)] # First Hall, Bridge of Khazad-dum for card in prepareList: encounterList.remove(card) elif scenarioId == 11: # The Seventh Level questList = [(s, 67), (s, 68)] heroList.append((s, 24)) # Book of Mazarbul, for first player encounterList.remove((s, 24)) elif scenarioId == 12: # Flight from Moria questList = [(s, i) for i in range(70, 77)] random.shuffle(questList) questList.insert(0, (s, 69)) stagingList = [(s, 25)] # The Nameless Fear encounterList.remove((s, 25)) foe = (s, 28) # A Foe Beyond while encounterList.count(foe) > self.playerCount: # 1 "A Foe Beyond" per player encounterList.remove(foe) random.shuffle(encounterList) if self.playerCount == 1: stagingList.append(encounterList.pop(-1)) # 1 card per player elif scenarioId == 13: # The Redhorn Gate questList = [(s, 11), (s, 12), (s, 13)] stagingList = [(s, 15)] # Caradhras encounterList.remove((s, 15)) prepareList = [(s, 22), (s, 22), (s, 22), (s, 22), (s, 22)] # 5 Snowstorms for card in prepareList: encounterList.remove(card) heroList.append((s, 14)) # Arwen Undomiel, for first player # TODO: this is for first player encounterList.remove((s, 14)) if self.playerCount == 1: stagingList.append(encounterList.pop(-1)) # 1 card per player elif scenarioId == 14: # Road to Rivendell questList = [(s, 38), (s, 39), (s, 40)] heroList.append((s, 41)) # Arwen Undomiel, for first player # TODO: this is for first player encounterList.remove((s, 41)) if self.playerCount == 1: stagingList.append(encounterList.pop(-1)) # 1 card per player elif scenarioId == 15: # The Watcher in the Water questList = [(s, 63), (s, 64)] prepareList = [(s, 72), (s, 65)] # The Watcher, Doors of Durin for card in prepareList: encounterList.remove(card) stagingList.append(encounterList.pop(-1)) # reveal 1 card elif scenarioId == 16: # The Long Dark questList = [(s, 86), (s, 87)] heroList.append(('khazaddum', 41)) # Cave Torch, for first player # TODO: this is for first player encounterList.remove(('khazaddum', 41)) # EXPANSION prepareList.reverse() # start creating Card instances for (set_, id) in heroList: self.heroArea.addCard(Card(cardsInfo[set_][id], revealed=True)) for (set_, id) in reversed(questList): self.questDeck.addCard(Card(cardsInfo[set_][id], revealed=True)) for (set_, id) in encounterList: self.encounterDeck.addCard(Card(cardsInfo[set_][id])) for (set_, id) in stagingList: self.stagingArea.addCard(Card(cardsInfo[set_][id], revealed=True)) for (set_, id) in prepareList: self.prepareDeck.addCard(Card(cardsInfo[set_][id], revealed=True)) # post processing title = QCoreApplication.translate('MainWindow', 'Manually Setup Required') if scenarioId == 2: # Escape From Dol Guldur QMessageBox.information(self, title, QCoreApplication.translate('MainWindow', 'Objective cards are Guarded!')) elif scenarioId in (3, 7, 12, 13, 14): # The Hunt for Gollum, The Dead Marshes, Flight from Moria, The Redhorn Gate, Road to Rivendell if self.playerCount > 1: QMessageBox.information(self, title, QCoreApplication.translate('MainWindow', 'Reveal 1 card per player!')) elif scenarioId == 5: # A Journey to Rhosgobel for i in range(2): # attach 2 damage token to Wilyador self.heroArea.getList()[-1].attach(Token('damage')) elif scenarioId == 8: # Return to Mirkwood if self.playerCount > 1: QMessageBox.information(self, title, QString('%1<br>%2').arg(QCoreApplication.translate('MainWindow', 'Choose a player to guard %1,').arg('<b>"Gollum"</b>')).arg(QCoreApplication.translate('MainWindow', 'then reveal 1 card per player.'))) elif scenarioId == 10: # Into the Pit self.locationDeck.addCard(self.stagingArea.draw()) # make East-gate as active location QMessageBox.information(self, title, QString('%1<br>%2').arg(QCoreApplication.translate('MainWindow', 'Attach %1 to a hero,').arg('<b>"Cave Torch"</b>')).arg(QCoreApplication.translate('MainWindow', 'then reveal 1 card per player.'))) elif scenarioId == 11: # The Seventh Level QMessageBox.information(self, title, QString('%1<br>%2').arg(QCoreApplication.translate('MainWindow', 'Attach %1 to a hero,').arg('<b>"Book of Mazarbul"</b>')).arg(QCoreApplication.translate('MainWindow', 'then reveal 1 card per player.'))) elif scenarioId == 15: # The Watcher in the Water card = self.stagingArea.getList()[0] if ('strength' not in card.info) or (card.info['strength'] < self.playerCount * 2): QMessageBox.information(self, title, QCoreApplication.translate('MainWindow', 'Reveal cards until total threat >= %1.').arg(self.playerCount * 2)) elif scenarioId == 16: # The Long Dark QMessageBox.information(self, title, QString('%1<br>%2').arg(QCoreApplication.translate('MainWindow', 'Attach %1 to a hero,').arg('<b>"Cave Torch"</b>')).arg(QCoreApplication.translate('MainWindow', "then follow Quest card's setup instruction."))) # EXPANSION def logInitialState(self): heroes = [repr(card) for card in self.heroArea.getList()] heroesString = '' pronoun = 'their' if len(heroes) == 1: heroesString = heroes[0] pronoun = 'his/her' elif len(heroes) == 2: heroesString = '{0} and {1}'.format(heroes[0], heroes[1]) elif len(heroes) >= 3: heroesString = '{0} and {1}'.format(', '.join(heroes[:-1]), heroes[-1]) self.log('<h3>{0} started {1} journey on <b>[{2}]</b>...</h3><br>'.format(heroesString, pronoun, scenariosInfo[self.scenarioId]['name'])) self.logCurrentState() if self.questDeck.getList(): self.log('Questing {0}'.format(repr(self.questDeck.getList()[-1]))) def logCurrentState(self): self.threatDial.appendLog() hand = [repr(card) for card in self.handArea.getList()] self.log('Hand: {0}'.format(', '.join(hand))) staging = [repr(card) for card in self.stagingArea.getList()] self.log('Staging: {0}<br>'.format(', '.join(staging))) def setLargeImage(self, card): if card.info['type'] != 'quest': if self.largeImageLabel.currentCard == (card, card.revealed()): return if card.info['type'] == 'quest': ratio = float(CARD_WIDTH) / CARD_HEIGHT transform = QTransform.fromScale(ratio, ratio) transform = transform.rotate(90) pixmap = card.pixmap().transformed(transform, Qt.SmoothTransformation) else: pixmap = card.currentImage() self.largeImageLabel.setPixmap(pixmap) self.largeImageLabel.currentCard = (card, card.revealed()) def proceedResourcePhase(self): for card in self.heroArea.getList(): if card.info['type'] == 'hero' and card.revealed(): card.attach(Token('resource')) tokenCount = card.getState().get('R', 0) self.log('{0}->{1}({2})'.format('resource', repr(card), tokenCount)) card = self.playerDeck.draw() if card: if not card.revealed(): card.flip() self.handArea.addCard(card) self.log('Draw {0}'.format(repr(card))) def proceedRefreshPhase(self): for card in self.heroArea.getList(): card.ready() for child in card.attachedItems.equipments: child.ready() self.heroArea.update() self.heroArea.update() # don't ask me why... self.log('All card readied') self.threatDial.increaseValue() self.threatDial.appendLog() # TODO: pass first player token in multiplayer game def proceedDealShadows(self): enemies = filter(lambda card: 'cost' in card.info, list(self.engagedArea.getList())) enemies.sort(reverse=True, key=lambda card: card.info['cost']) # sort from highest to lowest engagement cost for enemy in enemies: card = self.encounterDeck.draw() if card: enemy.attach(card) shadow = repr(card) if card.revealed() else '[???]' self.log('Deal shadow {0} to {1}'.format(shadow, enemy)) def writeSettings(self): settings = QSettings(MainWindow.CONFIG_PATH, QSettings.IniFormat) settings.beginGroup('Localization') settings.setValue('Interface', self.locale) settings.endGroup() settingMapping = { 'MainWindow': self, 'JourneyLogger': self.journeyLogger, 'ScoringDialog': self.scoringDialog, 'PhaseTips': self.phaseTips, } settings.beginGroup('Geometry') for (name, widget) in settingMapping.items(): settings.beginGroup(name) if name == 'MainWindow': settings.setValue('maximized', widget.isMaximized()) settings.setValue('size', widget.size()) settings.setValue('pos', widget.pos()) settings.endGroup() settings.endGroup() settings.beginGroup('ProgramState') settings.setValue('crashed', False) # if program ended up normally, this flag is set to False settings.endGroup() def readSettings(self): settings = QSettings(MainWindow.CONFIG_PATH, QSettings.IniFormat) settings.beginGroup('Geometry') settings.beginGroup('MainWindow') maximized = settings.value('maximized', True).toBool() if maximized: self.showMaximized() else: self.resize(settings.value('size', QSize(1024, 728)).toSize()) self.move(settings.value('pos', QPoint(0, 0)).toPoint()) settings.endGroup() settingMapping = { 'JourneyLogger': self.journeyLogger, 'PhaseTips': self.phaseTips, } for (name, widget) in settingMapping.items(): settings.beginGroup(name) widget.resize(settings.value('size', QSize(500, 300)).toSize()) pos = settings.value('pos').toPoint() if pos != QPoint(): widget.move(pos) settings.endGroup() settings.beginGroup('ScoringDialog') self.scoringDialog.resize(settings.value('size', QSize(300, 300)).toSize()) pos = settings.value('pos').toPoint() if pos != QPoint(): self.scoringDialog.move(pos) settings.endGroup() settings.endGroup() # Geometry def checkIfprogramCrashed(self): '''did program crash on last time running?''' settings = QSettings(MainWindow.CONFIG_PATH, QSettings.IniFormat) settings.beginGroup('ProgramState') crashed = settings.value('crashed', False).toBool() settings.setValue('crashed', True) # set it to True to detect next crash settings.endGroup() return crashed def log(self, message): '''method for logging what happened. Will be rebinded to JourneyLogger in createUI()''' pass def createUI(self): self.newGameAct = QAction(QCoreApplication.translate('MainWindow', '&New Journey...'), self) self.newGameAct.triggered.connect(self.startNewGameAction) self.newGameAct.setShortcut(QKeySequence.New) self.restartGameAct = QAction(QCoreApplication.translate('MainWindow', '&Restart Journey'), self) self.restartGameAct.triggered.connect(self.restartGameAction) self.restartGameAct.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_R)) self.saveGameAct = QAction(QCoreApplication.translate('MainWindow', '&Save Game'), self) self.saveGameAct.triggered.connect(self.saveGame) self.saveGameAct.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_S)) self.loadGameAct = QAction(QCoreApplication.translate('MainWindow', '&Load Game'), self) self.loadGameAct.triggered.connect(self.loadGame) self.loadGameAct.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_L)) quitAct = QAction(QCoreApplication.translate('MainWindow', '&Quit'), self) quitAct.triggered.connect(self.close) quitAct.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_Q)) gameMenu = self.menuBar().addMenu(QCoreApplication.translate('MainWindow', '&Game')) gameMenu.addAction(self.newGameAct) gameMenu.addAction(self.restartGameAct) gameMenu.addSeparator() gameMenu.addAction(self.saveGameAct) gameMenu.addAction(self.loadGameAct) gameMenu.addSeparator() gameMenu.addAction(quitAct) self.journeyLogger = JourneyLogger(self) self.log = self.journeyLogger.append # this 'log' function will be called by those who wants to write journey log self.journeyLoggerAct = QAction(QCoreApplication.translate('MainWindow', '&Journey Logger'), self) self.journeyLoggerAct.triggered.connect(lambda: self.journeyLogger.show()) self.journeyLoggerAct.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_J)) self.journeyLoggerAct.setIcon(QIcon(':/images/tokens/progress.png')) self.phaseTips = _PhaseTips(self) phaseTipsAct = QAction(QCoreApplication.translate('MainWindow', '&Phase Tips'), self) phaseTipsAct.triggered.connect(lambda: self.phaseTips.show()) phaseTipsAct.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_P)) def prisonRandomHero(): hero = random.choice(self.heroArea.getList()) self.log('{0} is prisoned!'.format(hero)) hero.flip() hero.attach(Token('damage')) self.prisonAct = QAction(QCoreApplication.translate('MainWindow', 'Prison a random Hero'), self) self.prisonAct.triggered.connect(prisonRandomHero) self.prisonAct.setToolTip(QCoreApplication.translate('MainWindow', 'For "Escape From Dol Guldur" scenario')) self.scoringDialog = _ScoringDialog(self) self.scoringAct = QAction(QCoreApplication.translate('MainWindow', 'Scoring...'), self) self.scoringAct.triggered.connect(lambda: self.scoringDialog.show()) utilityMenu = self.menuBar().addMenu(QCoreApplication.translate('MainWindow', '&Utility')) utilityMenu.addAction(self.journeyLoggerAct) utilityMenu.addAction(phaseTipsAct) utilityMenu.addSeparator() utilityMenu.addAction(self.prisonAct) utilityMenu.addAction(self.scoringAct) self.about = _About(self) aboutAct = QAction(QCoreApplication.translate('MainWindow', '&About'), self) aboutAct.triggered.connect(lambda: self.about.show()) helpMenu = self.menuBar().addMenu(QCoreApplication.translate('MainWindow', '?')) def currentLocaleSetting(): settings = QSettings(MainWindow.CONFIG_PATH, QSettings.IniFormat) settings.beginGroup('Localization') locale = str(settings.value('Interface', 'None').toString()) settings.endGroup() return locale def detectUsableLocalization(): locale = QLocale().system().name() for qmFilePath in glob.glob('./resource/translations/*.qm'): qmFilePath = qmFilePath.replace('\\', '/') qm = qmFilePath[qmFilePath.rindex('/') + 1 : -3] qm = qm.replace('qt_', '') if locale == qm: return locale return 'en_US' self.locale = currentLocaleSetting() if self.locale == 'None': # first start up self.locale = detectUsableLocalization() def changeLocale(locale): def changeLocale_(): self.locale = locale QMessageBox.information(self, QCoreApplication.translate('MainWindow', 'Setting Changed'), QCoreApplication.translate('MainWindow', 'Restart program to apply change.')) return changeLocale_ languages = collections.OrderedDict() languages[QCoreApplication.translate('MainWindow', 'English')] = 'en_US' languages[QCoreApplication.translate('MainWindow', 'Traditional Chinese')] = 'zh_TW' languages[QCoreApplication.translate('MainWindow', 'Simplified Chinese')] = 'zh_CN' interfaceLanguageMenu = helpMenu.addMenu(QCoreApplication.translate('MainWindow', 'Interface Langauge')) languageGroup = QActionGroup(self) for (language, locale) in languages.items(): changeLanguageAct = QAction(language, self, checkable=True) changeLanguageAct.triggered.connect(changeLocale(locale)) languageGroup.addAction(changeLanguageAct) interfaceLanguageMenu.addAction(changeLanguageAct) if locale == self.locale: changeLanguageAct.setChecked(True) helpMenu.addAction(aboutAct) self.largeImageLabel = QLabel() self.largeImageLabel.setFixedSize(CARD_WIDTH, CARD_HEIGHT) self.largeImageLabel.setPixmap(QPixmap(':/images/player_card_back.jpg')) self.largeImageLabel.currentCard = None self.threatDial = ThreatDial() self.threatDial.setFixedWidth(CARD_WIDTH) resourcePhaseButton = QPushButton(QCoreApplication.translate('MainWindow', 'Resource Phase')) resourcePhaseButton.clicked.connect(self.proceedResourcePhase) resourcePhaseButton.setToolTip(QString('%1<br>%2').arg(QCoreApplication.translate('MainWindow', 'Add 1 resource to each hero and draw 1 card.')).arg(QCoreApplication.translate('MainWindow', 'Special card-effects are not concerned.'))) resourcePhaseButton.setFocusPolicy(Qt.NoFocus) dealShadowsButton = QPushButton(QCoreApplication.translate('MainWindow', 'Deal Shadows')) dealShadowsButton.clicked.connect(self.proceedDealShadows) dealShadowsButton.setToolTip(QString('%1<br>%2').arg(QCoreApplication.translate('MainWindow', 'Deal 1 shadow card to each engaged enemy.')).arg(QCoreApplication.translate('MainWindow', 'Special card-effects are not concerned.'))) dealShadowsButton.setFocusPolicy(Qt.NoFocus) refreshPhaseButton = QPushButton(QCoreApplication.translate('MainWindow', 'Refresh Phase')) refreshPhaseButton.clicked.connect(self.proceedRefreshPhase) refreshPhaseButton.setToolTip(QString('%1<br>%2').arg(QCoreApplication.translate('MainWindow', 'Ready all cards and raise 1 threat.')).arg(QCoreApplication.translate('MainWindow', 'Special card-effects are not concerned.'))) refreshPhaseButton.setFocusPolicy(Qt.NoFocus) self.victorySpinBox = QSpinBox() self.victorySpinBox.valueChanged.connect(lambda: self.log('<font color="#3f48cc">Victory Points: {0}</font>'.format(self.victorySpinBox.value()))) victoryLabel = QLabel(QCoreApplication.translate('MainWindow', '&Victory:')) victoryLabel.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred) victoryLabel.setBuddy(self.victorySpinBox) self.engagedArea = Area('Engaged Area') self.heroArea = Area('Hero Area') self.handArea = Area('Hand Area') self.stagingArea = Area('Staging Area', orientation=Qt.Vertical) self.locationDeck = Deck('Active Location', QCoreApplication.translate('MainWindow', 'Active<br>Location', 'Deck')) self.questDeck = Deck('Quest Deck', QCoreApplication.translate('MainWindow', 'Quest<br>Deck', 'Deck')) self.encounterDeck = Deck('Encounter Deck', QCoreApplication.translate('MainWindow', 'Encounter<br>Deck', 'Deck')) self.encounterDiscardPile = Deck('Encounter Discard Pile', QCoreApplication.translate('MainWindow', 'Encounter<br>Discard<br>Pile', 'Deck')) self.tokenBank = TokenBank() self.prepareDeck = Deck('Prepare Deck', QCoreApplication.translate('MainWindow', 'Prepare<br>Deck', 'Deck'), Qt.Horizontal) self.removedPile = Deck('Removed From Play', QCoreApplication.translate('MainWindow', 'Removed<br>From<br>Play', 'Deck'), Qt.Horizontal) self.playerDeck = Deck('Player Deck', QCoreApplication.translate('MainWindow', 'Player<br>Deck', 'Deck')) self.playerDiscardPile = Deck('Player Discard Pile', QCoreApplication.translate('MainWindow', 'Player<br>Discard<br>Pile', 'Deck')) self.engagedArea.setBackgroundBrush(QBrush(Qt.darkRed)) self.heroArea.setBackgroundBrush(QBrush(Qt.darkBlue)) self.handArea.setBackgroundBrush(QBrush(Qt.darkCyan)) self.stagingArea.setBackgroundBrush(QBrush(Qt.black)) self.locationDeck.setBackgroundBrush(QBrush(Qt.darkGreen)) self.questDeck.setBackgroundBrush(QBrush(Qt.darkGreen)) self.encounterDeck.setBackgroundBrush(QBrush(Qt.gray)) self.encounterDiscardPile.setBackgroundBrush(QBrush(Qt.darkGray)) self.prepareDeck.setBackgroundBrush(QBrush(Qt.gray)) self.removedPile.setBackgroundBrush(QBrush(Qt.black)) self.playerDeck.setBackgroundBrush(QBrush(Qt.yellow)) self.playerDiscardPile.setBackgroundBrush(QBrush(Qt.darkYellow)) leftLayout = QVBoxLayout() leftLayout.addWidget(self.largeImageLabel) leftLayout.addStretch(1) leftLayout.addWidget(self.threatDial) littleLayout = QGridLayout() littleLayout.addWidget(resourcePhaseButton, 0, 0, 1, 2) littleLayout.addWidget(dealShadowsButton, 0, 2, 1, 2) littleLayout.addWidget(refreshPhaseButton, 0, 4, 1, 2) littleLayout.addWidget(victoryLabel, 0, 6, 1, 1) littleLayout.addWidget(self.victorySpinBox, 0, 7, 1, 1) leftLayout.addLayout(littleLayout) midLayout = QVBoxLayout() midLayout.addWidget(self.engagedArea) midLayout.addWidget(self.heroArea) midLayout.addWidget(self.handArea) rightLayout = QGridLayout() rightLayout.addWidget(self.locationDeck, 0, 0, 1, 1) rightLayout.addWidget(self.questDeck, 0, 1, 1, 1) rightLayout.addWidget(self.encounterDeck, 1, 0, 1, 1) rightLayout.addWidget(self.encounterDiscardPile, 1, 1, 1, 1) rightLayout.addWidget(self.prepareDeck, 2, 0, 1, 1) rightLayout.addWidget(self.removedPile, 2, 1, 1, 1) rightLayout.addWidget(self.tokenBank, 3, 0, 1, 2) rightLayout.addWidget(self.playerDeck, 4, 0, 1, 1) rightLayout.addWidget(self.playerDiscardPile, 4, 1, 1, 1) layout = QHBoxLayout() layout.addLayout(leftLayout) layout.addLayout(midLayout) layout.addWidget(self.stagingArea) layout.addLayout(rightLayout) centralWidget = QWidget() centralWidget.setLayout(layout) self.setCentralWidget(centralWidget) self.setWindowTitle(QCoreApplication.translate('MainWindow', 'The Lord of the Rings: The Card Game')) self.setWindowIcon(QIcon(':/images/icons/LotRLCG.ico')) self.showMaximized() # will trigger resizeEvent() self.readSettings() def resizeEvent(self, event): if hasattr(self, 'locationDeck'): # if self.createUI() is called for deck in (self.locationDeck, self.questDeck, self.encounterDeck, self.encounterDiscardPile, self.playerDeck, self.playerDiscardPile): ratio = float(deck.height()) / CARD_HEIGHT deck.setFixedWidth((CARD_WIDTH + PADDING * 2) * ratio) for deck in (self.prepareDeck, self.removedPile): deck.setFixedSize(self.locationDeck.width(), self.locationDeck.height() * 2 / 5) self.stagingArea.setMinimumWidth(self.locationDeck.width()) self.stagingArea.setMaximumWidth(self.locationDeck.width() * 1.1) self.engagedArea.setMinimumHeight(self.height() / 3) self.heroArea.setMinimumHeight(self.height() / 3) self.handArea.setMinimumHeight(self.height() / 4) width = self.stagingArea.width() * 2 self.engagedArea.setMinimumWidth(width) self.heroArea.setMinimumWidth(width) self.handArea.setMinimumWidth(width) QApplication.processEvents() # force immediate update def closeEvent(self, event): self.writeSettings() event.accept()
def create_widgets(self): deck = Deck() deck.shuffle() topframe = PanedWindow(self,orient=VERTICAL) topframe.pack(fill=BOTH,anchor=CENTER,expand=True) topframe.grid(row=0,column=0,sticky="news") #topframe.columnconfigure(0, weight=1) #topframe.columnconfigure(0, weight=1) frame4 = PanedWindow(topframe) topcardframe = Frame(topframe) bottomcardframe = Frame(topframe) self.frame5container = Canvas(bottomcardframe,scrollregion=(0,0,1500,0)) frame5 = Frame(self.frame5container) frame5.pack(fill=BOTH,expand=TRUE,padx=10) xscoller= Scrollbar(bottomcardframe,orient=HORIZONTAL,command=self.frame5container.xview) xscoller.pack(side=BOTTOM,fill=X,padx=10) self.frame5container.create_window((0,0), window=frame5, anchor=NW) self.frame5container.pack(fill=BOTH,expand=TRUE) self.frame5container.configure(xscrollcommand=xscoller.set) self.frame5container.create_oval(0,0,400,300,fill='red') frame2container = Canvas(topcardframe,scrollregion=(0,0,1500,0)) frame2 = Frame(frame2container) frame2.pack(fill=BOTH,expand=TRUE) xscollertop= Scrollbar(topcardframe,orient=HORIZONTAL,command=frame2container.xview) xscollertop.pack(side=BOTTOM,fill=X,padx=10) frame2container.create_window((0,0), window=frame2, anchor=NW) frame2container.pack(side=TOP,fill=X,padx=10) frame2container.configure(xscrollcommand=xscollertop.set) topframe.add(topcardframe,stretch="always") topframe.add(frame4,stretch="always") topframe.add(bottomcardframe,stretch="always") playerorderFrame = PanedWindow(frame4,orient=VERTICAL) playerRankFrame = PanedWindow(frame4,orient=VERTICAL) middleFrame = PanedWindow(frame4) self.porderlv = Listbox(playerorderFrame,selectmode=NONE,height=8,width=20) self.pranklv = Listbox(playerRankFrame,selectmode=NONE,height=8,width=22) playerorderFrame.add(Label(playerorderFrame,text="플레이어 순서")) playerRankFrame.add(Label(playerRankFrame,text="플레이어 현재 랭킹")) playerorderFrame.add(self.porderlv) playerRankFrame.add(self.pranklv) frame4.add(playerorderFrame,stretch="always") frame4.add(middleFrame,stretch="always") frame4.add(playerRankFrame,stretch="always") self.__preparingFrame = Frame(frame2) #self.__preparingFrame.pack(fill=X,expand=TRUE) self.__preparingFrame.pack(fill=X,expand=TRUE) self.__preparingFrame.grid(row=0,column=0,stick="news") Label(self.__preparingFrame,text="모든 플레이어들의 패에서 중복 숫자를 가진 카드들이 없을때 까지 기다리는중...").grid(row=0,column=0,columnspan=3) #self.__preparingFrame.pack() playerControllView = PanedWindow(middleFrame,orient=VERTICAL) playerControllView.add(Button(middleFrame,text="턴넘기기 ",command=self.changeText),stretch="always") playerControllView.add(Button(middleFrame,text="선택한 카드 버리기 ",command=self.popCards),stretch="always") playerControllView.add(Button(middleFrame,text="패 섞기 ",command=self.shuffleCurrentHand),stretch="always") playerControllView.add(Button(middleFrame,text="패 정렬",command=self.sortCurrentHand),stretch="always") middleFrame.add(playerControllView,stretch="always") for i in range(len(self.__players)): self.porderlv.insert(self.porderlv.size(),self.__playerNames[i]) self.__players[self.__playerNames[i]].getCardFrame(parent=frame5,mgcls=self ,rootCanvas=self.frame5container) self.__players[self.__playerNames[i]].getPublicCardFrame(parent=frame2,mgcls=self,rootCanvas=frame2container) self.refreshDisplayedCardFrame() self.refreshPlayerRank() #topframe.pack(fill=BOTH,expand=TRUE) self.frame5container.configure(scrollregion = self.frame5container.bbox("all")) frame2container.configure(scrollregion = frame2container.bbox("all")) self.doThread(self.frame5container,frame2container)
class TriPeaks(object): #Smidur def __init__(self): self.isPlaying = True self.boardRows = 4 self.boardCols = 10 #Stokkur leiksins self.deck = Deck(52) self.deck.shuffleCards() #2D array of cards in the board, initialized as None self.board = self.initBoard() self.dealToBoard() #Cards in the heap self.heap = [self.deck.cards.pop()] #Breyta sem heldur utan um stig self.score = 0 #Breyta sem byrjar ad taka tima self.start_time = time.time() #Lokatimi leiks self.finaltime = 0.0 #Breyta sem heldur utanum 'moves' self.moves = 0 def initBoard(self): board = [] for i in range(self.boardRows): board.append([None for _ in range(self.boardCols)]) return board # Pre: self.deck contains a deck of cards # Post: 28 cards from the deck have been dealt to the board # Run: TriPeaks.dealToBoard() def dealToBoard(self): ''' Deals cards from the deck to the board ''' # board is a 4x10 list with None values in gaps # Row 0: for col in range(0,self.boardCols-1,3): self.board[0][col] = self.deck.cards.pop() self.board[0][col].col = col self.board[0][col].row = 0 # Row 1: for col in range(self.boardCols-1): if (col%3 != 2): # TODO: haegt ad gera i einni linu? self.board[1][col] = self.deck.cards.pop() self.board[1][col].col = col self.board[1][col].row = 1 # Row 2: for col in range(self.boardCols-1): self.board[2][col] = self.deck.cards.pop() self.board[2][col].col = col self.board[2][col].row = 2 # Row 3: for col in range(self.boardCols): self.board[3][col] = self.deck.cards.pop() self.board[3][col].col = col self.board[3][col].row = 3 # Post: returns how many cards are left in the deck # Run: TriPeaks.deckSize() def deckSize(self): return len(self.deck.cards) # Pre: row and col are integers # Post: returns true if the card at self.board[row][col] is movable # Run: TriPeaks.isMovable(row,col) def isMovable(self, row, col): ''' Checks if a card in the board is movable ''' if self.board[row][col] is None: return False if (row == self.boardRows-1): return True return (self.board[row+1][col] is None and self.board[row+1][col+1] is None) # Pre: card is a Card object # Post: returns True if card has a value one higher or lower than the # top card on the heap # Run: TriPeaks.isLegal(card) def isLegal(self, card): ''' Checks if a card move is legal ''' if card is None: return False return abs(self.heap[-1].value - card.value)%11 == 1 # Pre: row and col are integers # Post: card no. col in row no. row has been printed to the console # Run: TriPeaks.printCard(row, col) def printCard(self, row, col): if (self.board[row][col] is None): print ' ', elif (not self.isMovable(row,col)): print ' # ', else: print '%-3s' % (self.board[row][col]), # Post: the board has been printed to the console # Run: TriPeaks.printBoard() def printBoard(self): ''' Prints the board to the console ''' print "---------------------------------------" print "Cards in board: \n" for row in range(self.boardRows): print ' '*(3-row), for col in range(self.boardCols): self.printCard(row, col) print ' ' print '\nCard in heap: ', self.heap[-1] print '' print 'Cards left in deck:', self.deckSize() print 'Score: ', self.score print 'Moves: ', self.moves self.elapsedTime() print 'Time:', int(self.finaltime), 'seconds' # Pre: # Post: userInput contains the string input from the user # Run: TriPeaks.getUserInput() def getUserInput(self): ''' Handles user inputs ''' user = '' while (len(user) < 1): user = raw_input("\nWhat is your move? ").split() return user # Pre: cardString is a string # Post: removes card from board and returns it # Run: TriPeaks.getBoardCard(cardString) def getBoardCard(self, cardString): ''' Finds the card cardString in the board and moves to the heap ''' for i,row in enumerate(self.board): for j,c in enumerate(row): if (c is not None and c.toString() == cardString): if (self.isLegal(self.board[i][j]) and self.isMovable(i,j)): self.board[i][j] = None self.addScore(150) self.heap.append(c) return c else: print "\nThis move is not legal, try again!" # Pre: card is a Card object # Post: removes card from board to the heap and returns it # Run: TriPeaks.moveToHeap(card) def moveToHeap(self, card): ''' Moves the card to the heap ''' if (card is not None): if (self.isLegal(card) and self.isMovable(card.row,card.col)): self.board[card.row][card.col] = None self.addScore(150) self.moves += 1 self.heap.append(card) return card else: print "\nThis move is not legal, try again!" return # Pre: self.deck contains at least one Card object, self.heap is a # list of Card objects # Post: the next card in the deck is moved on top of the heap # Run: TriPeaks.toHeap() def toHeap(self): ''' Moves the next card from the deck to the heap ''' if len(self.deck.cards) > 0: self.heap.append(self.deck.cards.pop()) # Pre: self.deck contains at least one Card object # Post: the next card in the deck has been removed and is returned # Run: TriPeaks.drawCard() def drawCard(self): ''' Draws a card from the deck ''' self.deck.pop() # Pre: self.score is an integer # Post: self.score has been increased by points # Run: self.addScore(points) def addScore(self, points): ''' Increases the game score by points ''' self.score += points # Pre: self.start_time is a time object # Post: returns the time elapsed since self.start_time # Run: TriPeaks.elapsedTime def elapsedTime(self): ''' Measures the time elapsed since the game started ''' if self.isPlaying: self.finaltime = time.time() - self.start_time # Post: returns true if the game is won, false otherwise # Run: TriPeaks.hasWon() def hasWon(self): ''' Checks if the game is won ''' for r,row in enumerate(self.board): if any(c is not None for c in self.board[r]): return False self.isPlaying = False return True # Post: returns true if there are no more moves possible, false otherwise # Run: TriPeaks.hasLost() def hasLost(self): ''' Checks if the game is lost ''' if not len(self.deck.cards) == 0: return False for r,row in enumerate(self.board): for c,card in enumerate(row): if (self.isLegal(card) and self.isMovable(r,c)): return False self.isPlaying = False return True # Skrifar highscore i csv skra svo haegt se ad geyma highscore def highscoreTable(self): ''' Writes a highscore to a csv file ''' scores = [] newhighscore = False with open("highscores.csv") as f: data = csv.reader(f, delimiter = ',') for row in data: players = [] checker = 0 for col in row: checker += 1 try: players.append(int(col)) if checker == 2 and self.score > int(col): newhighscore = True except: players.append(col) scores.append(players) if newhighscore and self.hasWon(): print '' name = raw_input("You are one of the top 5 Tri Peaks players! Enter your name: ") with open("highscores.csv", "w") as csvfile: a = csv.writer(csvfile, delimiter = ',') scores.append([name, self.score, self.finaltime, self.moves]) scores.sort(key=lambda x: x[1]) scores.reverse() a.writerows(scores[0:5]) print '' print "Name\t", "\tPoints", "\tTime", "\tMoves" print "---------------------------------------" for row in scores[0:5]: playername = row[0] print playername[0:6], '\t', '\t', row[1], '\t', math.ceil(float(row[2])), '\t', row[3] print '' # Responds to the user input def gameAction(self, userInput): ''' Responds to the user input ''' if userInput[0] == "draw": self.toHeap() self.addScore(100) self.moves += 1 elif userInput[0] == "move": '''Moves userInput[1] to heap if legal''' if len(userInput) == 1: card = self.getBoardCard(raw_input("What card do you want to move? ")) else: card = self.getBoardCard(userInput[1]) self.moves += 1 elif userInput[0] == "move" and not self.isLegal(userInput[1]): print "This move is not legal." elif userInput[0] == "help": self.showRules() elif userInput[0] == "top5": self.highscoreTable() elif userInput[0] == "quit": self.quitGame() else: print "\nUnknown command, remember to write 'help' to view known inputs" print "and the rules of the game.\n" # Writes out in the end of game if you have won or lost def gameSettlement(self): ''' Writes out message to the user after the game ''' if self.hasWon(): self.elapsedTime() self.addScore(self.deckSize()*150) print '' print "You won, congratulations! You are a Tri Peaks master" print "Your time was", self.finaltime, "seconds" print "and you got", self.score, "points in", self.moves, "moves." self.highscoreTable() elif self.hasLost(): print "You lost. Practice makes perfect." # Post: the game rules have been printed to the terminal # Run: TriPeaks.showRules() def showRules(self): ''' Prints the game rules to the terminal''' print """ --------------------------------------------------------------------------- ' TRI-PEAKS RULES: ' ' ---------------- ' ' The object of Tri-Peaks is to transfer all the cards from the board ' ' to the heap. ' ' ' ' You can move a card from the board that has a value one lower or ' ' higher than the top card on the heap if it is not covered by ' ' another card. ' ' ' ' If you run out of moves you can move a card from the deck to the ' ' heap and try again to move a card from the board. ' ' ' ' How to play: ' ' Write "draw" to draw a card from the deck ' ' Write "move H7" to move H7 from board to heap ' ' Write "help" to view this message ' ' Write "top5" to view the highscore table ' ' Write "quit" to quit the game ' ' ' --------------------------------------------------------------------------- """ # Post: runs the game logic # Run: TriPeaks.playGame() def playGame(self): ''' Plays the game ''' self.printBoard() while ((not self.hasWon() and not self.hasLost()) and self.isPlaying): self.gameAction(self.getUserInput()) self.printBoard() def quitGame(self): ''' Quits current game ''' self.isPlaying = False
def main(): '''Main program for the blackjack game''' #Creates the GUI and the deck object setupGUI() deck = Deck() #List of the card objects listUser = [] listDealer = [] #List the the card values userTotal = [] dealerTotal = [] counter = 0 pt = win.getMouse() while not quitt.clicked(pt): if start.clicked(pt): #Shuffles the deck deck.shuffle() #Gets the users first 2 cards and draws them to the window uCard1 = deck.dealCard() uCard1.draw(win,userCard1.getAnchor()) uCard2 = deck.dealCard() uCard2.draw(win,userCard2.getAnchor()) #Adds the 2 cards to the users list of cards listUser.append(uCard1) listUser.append(uCard2) #Gets the dealers 2 cards and draws one of them to the window dCard1 = deck.dealCard() dCard2 = deck.dealCard() dCard2.draw(win,dealerCard2.getAnchor()) #Adds the 2 cards to the dealers list of cards listDealer.append(dCard1) listDealer.append(dCard2) #Gets the values of the users cards and appends them to the list num = addTotal(uCard1) userTotal.append(num) num = addTotal(uCard2) userTotal.append(num) message.setText("Press Hit Me or Stand") start.deactivate() stand.activate() hitMe.activate() #Checks the users total to see if they have 21 userTotal = winLose(userTotal) if hitMe.clicked(pt): #Deals a card to the user and adds it to the list listUser.append(deck.dealCard()) #Draws the new card to the window x = userCard2.getAnchor().getX() y = userCard2.getAnchor().getY() listUser[counter+2].draw(win,Point(x+20*(counter+1),y)) #Adds the value of the card to the list and checks to see if the #user has got 21 or over 21 num = addTotal(listUser[counter+2]) userTotal.append(num) userTotal = winLose(userTotal) counter = counter + 1 if stand.clicked(pt): stand.deactivate() hitMe.deactivate() playAgain.activate() #Reveals the dealers cards dCard2.undraw() dCard1.draw(win,dealerCard1.getAnchor()) dCard2.draw(win,dealerCard2.getAnchor()) #Gets the value of the dealers cards and adds them to the list num2 = addTotal(dCard1) dealerTotal.append(num2) num2 = addTotal(dCard2) dealerTotal.append(num2) #Calls the dealerAI dealerAI(listDealer,dealerTotal,userTotal,deck) if playAgain.clicked(pt): #Undraws all the cards for card in listUser: card.undraw() for card in listDealer: card.undraw() #Empties the lists listUser = [] listDealer = [] userTotal = [] dealerTotal = [] counter = 0 #Creates a new deck deck = Deck() playAgain.deactivate() start.activate() message.setText("Press Start to start the game") pt = win.getMouse() win.close()
def createUI(self): self.newGameAct = QAction(QCoreApplication.translate('MainWindow', '&New Journey...'), self) self.newGameAct.triggered.connect(self.startNewGameAction) self.newGameAct.setShortcut(QKeySequence.New) self.restartGameAct = QAction(QCoreApplication.translate('MainWindow', '&Restart Journey'), self) self.restartGameAct.triggered.connect(self.restartGameAction) self.restartGameAct.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_R)) self.saveGameAct = QAction(QCoreApplication.translate('MainWindow', '&Save Game'), self) self.saveGameAct.triggered.connect(self.saveGame) self.saveGameAct.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_S)) self.loadGameAct = QAction(QCoreApplication.translate('MainWindow', '&Load Game'), self) self.loadGameAct.triggered.connect(self.loadGame) self.loadGameAct.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_L)) quitAct = QAction(QCoreApplication.translate('MainWindow', '&Quit'), self) quitAct.triggered.connect(self.close) quitAct.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_Q)) gameMenu = self.menuBar().addMenu(QCoreApplication.translate('MainWindow', '&Game')) gameMenu.addAction(self.newGameAct) gameMenu.addAction(self.restartGameAct) gameMenu.addSeparator() gameMenu.addAction(self.saveGameAct) gameMenu.addAction(self.loadGameAct) gameMenu.addSeparator() gameMenu.addAction(quitAct) self.journeyLogger = JourneyLogger(self) self.log = self.journeyLogger.append # this 'log' function will be called by those who wants to write journey log self.journeyLoggerAct = QAction(QCoreApplication.translate('MainWindow', '&Journey Logger'), self) self.journeyLoggerAct.triggered.connect(lambda: self.journeyLogger.show()) self.journeyLoggerAct.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_J)) self.journeyLoggerAct.setIcon(QIcon(':/images/tokens/progress.png')) self.phaseTips = _PhaseTips(self) phaseTipsAct = QAction(QCoreApplication.translate('MainWindow', '&Phase Tips'), self) phaseTipsAct.triggered.connect(lambda: self.phaseTips.show()) phaseTipsAct.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_P)) def prisonRandomHero(): hero = random.choice(self.heroArea.getList()) self.log('{0} is prisoned!'.format(hero)) hero.flip() hero.attach(Token('damage')) self.prisonAct = QAction(QCoreApplication.translate('MainWindow', 'Prison a random Hero'), self) self.prisonAct.triggered.connect(prisonRandomHero) self.prisonAct.setToolTip(QCoreApplication.translate('MainWindow', 'For "Escape From Dol Guldur" scenario')) self.scoringDialog = _ScoringDialog(self) self.scoringAct = QAction(QCoreApplication.translate('MainWindow', 'Scoring...'), self) self.scoringAct.triggered.connect(lambda: self.scoringDialog.show()) utilityMenu = self.menuBar().addMenu(QCoreApplication.translate('MainWindow', '&Utility')) utilityMenu.addAction(self.journeyLoggerAct) utilityMenu.addAction(phaseTipsAct) utilityMenu.addSeparator() utilityMenu.addAction(self.prisonAct) utilityMenu.addAction(self.scoringAct) self.about = _About(self) aboutAct = QAction(QCoreApplication.translate('MainWindow', '&About'), self) aboutAct.triggered.connect(lambda: self.about.show()) helpMenu = self.menuBar().addMenu(QCoreApplication.translate('MainWindow', '?')) def currentLocaleSetting(): settings = QSettings(MainWindow.CONFIG_PATH, QSettings.IniFormat) settings.beginGroup('Localization') locale = str(settings.value('Interface', 'None').toString()) settings.endGroup() return locale def detectUsableLocalization(): locale = QLocale().system().name() for qmFilePath in glob.glob('./resource/translations/*.qm'): qmFilePath = qmFilePath.replace('\\', '/') qm = qmFilePath[qmFilePath.rindex('/') + 1 : -3] qm = qm.replace('qt_', '') if locale == qm: return locale return 'en_US' self.locale = currentLocaleSetting() if self.locale == 'None': # first start up self.locale = detectUsableLocalization() def changeLocale(locale): def changeLocale_(): self.locale = locale QMessageBox.information(self, QCoreApplication.translate('MainWindow', 'Setting Changed'), QCoreApplication.translate('MainWindow', 'Restart program to apply change.')) return changeLocale_ languages = collections.OrderedDict() languages[QCoreApplication.translate('MainWindow', 'English')] = 'en_US' languages[QCoreApplication.translate('MainWindow', 'Traditional Chinese')] = 'zh_TW' languages[QCoreApplication.translate('MainWindow', 'Simplified Chinese')] = 'zh_CN' interfaceLanguageMenu = helpMenu.addMenu(QCoreApplication.translate('MainWindow', 'Interface Langauge')) languageGroup = QActionGroup(self) for (language, locale) in languages.items(): changeLanguageAct = QAction(language, self, checkable=True) changeLanguageAct.triggered.connect(changeLocale(locale)) languageGroup.addAction(changeLanguageAct) interfaceLanguageMenu.addAction(changeLanguageAct) if locale == self.locale: changeLanguageAct.setChecked(True) helpMenu.addAction(aboutAct) self.largeImageLabel = QLabel() self.largeImageLabel.setFixedSize(CARD_WIDTH, CARD_HEIGHT) self.largeImageLabel.setPixmap(QPixmap(':/images/player_card_back.jpg')) self.largeImageLabel.currentCard = None self.threatDial = ThreatDial() self.threatDial.setFixedWidth(CARD_WIDTH) resourcePhaseButton = QPushButton(QCoreApplication.translate('MainWindow', 'Resource Phase')) resourcePhaseButton.clicked.connect(self.proceedResourcePhase) resourcePhaseButton.setToolTip(QString('%1<br>%2').arg(QCoreApplication.translate('MainWindow', 'Add 1 resource to each hero and draw 1 card.')).arg(QCoreApplication.translate('MainWindow', 'Special card-effects are not concerned.'))) resourcePhaseButton.setFocusPolicy(Qt.NoFocus) dealShadowsButton = QPushButton(QCoreApplication.translate('MainWindow', 'Deal Shadows')) dealShadowsButton.clicked.connect(self.proceedDealShadows) dealShadowsButton.setToolTip(QString('%1<br>%2').arg(QCoreApplication.translate('MainWindow', 'Deal 1 shadow card to each engaged enemy.')).arg(QCoreApplication.translate('MainWindow', 'Special card-effects are not concerned.'))) dealShadowsButton.setFocusPolicy(Qt.NoFocus) refreshPhaseButton = QPushButton(QCoreApplication.translate('MainWindow', 'Refresh Phase')) refreshPhaseButton.clicked.connect(self.proceedRefreshPhase) refreshPhaseButton.setToolTip(QString('%1<br>%2').arg(QCoreApplication.translate('MainWindow', 'Ready all cards and raise 1 threat.')).arg(QCoreApplication.translate('MainWindow', 'Special card-effects are not concerned.'))) refreshPhaseButton.setFocusPolicy(Qt.NoFocus) self.victorySpinBox = QSpinBox() self.victorySpinBox.valueChanged.connect(lambda: self.log('<font color="#3f48cc">Victory Points: {0}</font>'.format(self.victorySpinBox.value()))) victoryLabel = QLabel(QCoreApplication.translate('MainWindow', '&Victory:')) victoryLabel.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred) victoryLabel.setBuddy(self.victorySpinBox) self.engagedArea = Area('Engaged Area') self.heroArea = Area('Hero Area') self.handArea = Area('Hand Area') self.stagingArea = Area('Staging Area', orientation=Qt.Vertical) self.locationDeck = Deck('Active Location', QCoreApplication.translate('MainWindow', 'Active<br>Location', 'Deck')) self.questDeck = Deck('Quest Deck', QCoreApplication.translate('MainWindow', 'Quest<br>Deck', 'Deck')) self.encounterDeck = Deck('Encounter Deck', QCoreApplication.translate('MainWindow', 'Encounter<br>Deck', 'Deck')) self.encounterDiscardPile = Deck('Encounter Discard Pile', QCoreApplication.translate('MainWindow', 'Encounter<br>Discard<br>Pile', 'Deck')) self.tokenBank = TokenBank() self.prepareDeck = Deck('Prepare Deck', QCoreApplication.translate('MainWindow', 'Prepare<br>Deck', 'Deck'), Qt.Horizontal) self.removedPile = Deck('Removed From Play', QCoreApplication.translate('MainWindow', 'Removed<br>From<br>Play', 'Deck'), Qt.Horizontal) self.playerDeck = Deck('Player Deck', QCoreApplication.translate('MainWindow', 'Player<br>Deck', 'Deck')) self.playerDiscardPile = Deck('Player Discard Pile', QCoreApplication.translate('MainWindow', 'Player<br>Discard<br>Pile', 'Deck')) self.engagedArea.setBackgroundBrush(QBrush(Qt.darkRed)) self.heroArea.setBackgroundBrush(QBrush(Qt.darkBlue)) self.handArea.setBackgroundBrush(QBrush(Qt.darkCyan)) self.stagingArea.setBackgroundBrush(QBrush(Qt.black)) self.locationDeck.setBackgroundBrush(QBrush(Qt.darkGreen)) self.questDeck.setBackgroundBrush(QBrush(Qt.darkGreen)) self.encounterDeck.setBackgroundBrush(QBrush(Qt.gray)) self.encounterDiscardPile.setBackgroundBrush(QBrush(Qt.darkGray)) self.prepareDeck.setBackgroundBrush(QBrush(Qt.gray)) self.removedPile.setBackgroundBrush(QBrush(Qt.black)) self.playerDeck.setBackgroundBrush(QBrush(Qt.yellow)) self.playerDiscardPile.setBackgroundBrush(QBrush(Qt.darkYellow)) leftLayout = QVBoxLayout() leftLayout.addWidget(self.largeImageLabel) leftLayout.addStretch(1) leftLayout.addWidget(self.threatDial) littleLayout = QGridLayout() littleLayout.addWidget(resourcePhaseButton, 0, 0, 1, 2) littleLayout.addWidget(dealShadowsButton, 0, 2, 1, 2) littleLayout.addWidget(refreshPhaseButton, 0, 4, 1, 2) littleLayout.addWidget(victoryLabel, 0, 6, 1, 1) littleLayout.addWidget(self.victorySpinBox, 0, 7, 1, 1) leftLayout.addLayout(littleLayout) midLayout = QVBoxLayout() midLayout.addWidget(self.engagedArea) midLayout.addWidget(self.heroArea) midLayout.addWidget(self.handArea) rightLayout = QGridLayout() rightLayout.addWidget(self.locationDeck, 0, 0, 1, 1) rightLayout.addWidget(self.questDeck, 0, 1, 1, 1) rightLayout.addWidget(self.encounterDeck, 1, 0, 1, 1) rightLayout.addWidget(self.encounterDiscardPile, 1, 1, 1, 1) rightLayout.addWidget(self.prepareDeck, 2, 0, 1, 1) rightLayout.addWidget(self.removedPile, 2, 1, 1, 1) rightLayout.addWidget(self.tokenBank, 3, 0, 1, 2) rightLayout.addWidget(self.playerDeck, 4, 0, 1, 1) rightLayout.addWidget(self.playerDiscardPile, 4, 1, 1, 1) layout = QHBoxLayout() layout.addLayout(leftLayout) layout.addLayout(midLayout) layout.addWidget(self.stagingArea) layout.addLayout(rightLayout) centralWidget = QWidget() centralWidget.setLayout(layout) self.setCentralWidget(centralWidget) self.setWindowTitle(QCoreApplication.translate('MainWindow', 'The Lord of the Rings: The Card Game')) self.setWindowIcon(QIcon(':/images/icons/LotRLCG.ico')) self.showMaximized() # will trigger resizeEvent() self.readSettings()
def test_empty(): with pytest.raises(Exception): newdeck = Deck() for numcards in len(xrange(53)): newdeck.deal()