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, 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 __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()
