def __init__(self, player1, player2):
self._player1 = player1
self._player1.hand = []
self._player1.discard = []
self._player1.played = []
self._player2 = player2
self._player2.hand = []
self._player2.discard = []
self._player2.played = []
self._winner = None
deck = Deck()
deck.shuffle()
while not deck.is_empty():
player1.draw_card(deck)
player2.draw_card(deck)
def main(): #Function that brings all other functions together in one place
'''main function'''
RULES = '''
Basra Card Game:
This game belongs to a category of card games called “fishing cards games”.
Each player in turn matches a card from their hand with one (or more) of those
lying face-up on the table and then takes them.
If the card which the player played out does not match one of the existing cards,
it stays on the table.
To win, you have to collect more points.'''
print(RULES)
D = Deck()
p1_cards = [] # card in hands player1
p2_cards = [] #card in hands player2
t_cards = [] # card on the floor
p1_pile = [] # for player1
p2_pile = [] # for player2
basra_1 = []
basra_2 = []
p1_turn = (0,2,4,6)
p2_turn = (1,3,5,7)
game = True
game_quit = False
answer = input("Would you like to play? y/Y or n/N?")
while answer!='n':
print(" ---------Start The game--------")
D.shuffle()
while game == True: #replace by the correct condition
for rounds in range(6):
if rounds == 0:
distribute_cards(D,p1_cards,p2_cards,t_cards,True)
print('Dealing the cards, 4 cards for each player, 4 cards on the table')
print('Cards left: {}'.format(D.__len__()))
display_table(t_cards,p1_cards,p2_cards)
else:
distribute_cards(D,p1_cards,p2_cards,t_cards,False)
print('')
print('------Start new round-----')
print('Dealing the cards, 4 cards for each player')
print('Cards left: {}'.format(D.__len__()))
display_table(t_cards,p1_cards,p2_cards)
for turn in range(8):
while turn in p1_turn:
card_index = input("Player {:d} turn: -> ".format(1))
if card_index == 'q':
game = False
game_quit = True
break
try:
play(p1_cards[int(card_index)],p1_cards,p1_pile,basra_1,t_cards)
except:
print('Please enter a valid card index, 0 <= index <= {:d}'.format(len(p1_cards)-1))
else:
display_table(t_cards,p1_cards,p2_cards)
break
if game_quit == True:
break
while turn in p2_turn:
card_index = input("Player {:d} turn: -> ".format(2))
if card_index == 'q':
game = False
game_quit = True
break
try:
play(p2_cards[int(card_index)],p2_cards,p2_pile,basra_2,t_cards)
except:
print('Please enter a valid card index, 0 <= index <= {:d}'.format(len(p2_cards)-1))
else:
display_table(t_cards,p1_cards,p2_cards)
break
if game_quit == True:
break
turn = 0
if t_cards != []:
if game == True:
if turn in p1_turn:
p1_pile.append(t_cards)
else:
p2_pile.append(t_cards)
t_cards = []
display_table(t_cards,p1_cards,p2_cards)
if game == False:
break
if D.is_empty() == True:
display_table(t_cards,p1_cards,p2_cards)
score = compute_score(p1_pile,p2_pile,basra_1,basra_2)
print('player 1: {}'.format(score[0]))
print('player 2: {}'.format(score[1]))
print('')
if score[0] > score[1]:
print('Player 1 is the winner')
game = False
else:
print('Player 2 is the winner')
game = False
# useful strings to match tests (put them in a loop to reprompt on bad input)
# print('Please enter a valid card index, 0 <= index <= {:d}'.format(len(p1_cards)-1))
# card_index = input("Player {:d} turn: -> ".format(turn))
# remember to clear the data structures before the next game
# deck.reset()
# p1_cards.clear() # card in hands player1
# p2_cards.clear() #card in hands player2
# t_cards.clear() # card on the floor
# p1_pile.clear() # pile for player1
# p2_pile.clear() # pile for player2
# basra_1.clear() # basra for player1
# basra_2.clear() #basra for player2
if game_quit == True:
break
answer = input("Would you like to play? y/Y or n/N? ")
if answer.lower() == 'y':
D.reset()
p1_cards.clear() # card in hands player1
p2_cards.clear() #card in hands player2
t_cards.clear() # card on the floor
p1_pile.clear() # pile for player1
p2_pile.clear() # pile for player2
basra_1.clear() # basra for player1
basra_2.clear() #basra for player2
print('Thanks for playing. See you again soon.')
class Solitaire:
"""
Patience class representing a game of Golf Solitaire.
This game has 7 columns and 5 cards in each column,
but the methods should work with other valid values as well.
"""
columns = 7
cards_in_column = 5
def __init__(self):
"""
Constructor, do the setup here.
After setup with Solitaire.columns = 7, Solitaire.cards_in_column = 5
You should have:
self.tableau -> 7 columns of cards with 5 cards in each column
self.stock -> 16 cards
self.waste -> 1 card
"""
self.deck = Deck()
self.tableau = []
self.waste = []
self.stock = []
self.deck.shuffle_deck()
for col in range(Solitaire.columns):
column = []
# Deal cards to each column in range of given nr.
for cards in range(Solitaire.cards_in_column):
column.append(self.deck.deal_card())
self.tableau.append(column)
self.waste.append(self.deck.deal_card())
while not self.deck.is_empty():
self.stock.append(self.deck.deal_card())
def can_move(self, card) -> bool:
"""
Validate if a card from the tableau can be moved to the waste pile.
The card must be last in the column list and adjacent by rank
to the topmost card of the waste pile (last in waste list).
Example: 8 is adjacent to 7 and 9. Ace is only adjacent to 2.
King is only adjacent to Queen.
"""
if card.rank is not None:
for i in self.tableau:
if len(i) > 0:
if card == i[-1]:
return card.rank - 1 == self.waste[
-1].rank or card.rank + 1 == self.waste[-1].rank
return False
def move_card(self, col: int):
"""
Move a card from the tableau to the waste pile.
Does not validate the move.
:param col: index of column
"""
if len(self.tableau[col]) > 0:
card = self.tableau[col].pop()
self.waste.append(card)
def deal_from_stock(self):
"""
Deal last card from stock pile to the waste pile.
If the stock is empty, do nothing.
"""
if len(self.stock) > 0:
self.waste.append(self.stock.pop())
def has_won(self) -> bool:
"""Check for the winning position - no cards left in tableau."""
for i in self.tableau:
if len(i) != 0:
return False
return True
def last_cards(self):
"""Return list of last cards in the tableau."""
return [
self.tableau[i][-1] for i in range(len(self.tableau))
if len(self.tableau[i]) != 0
]
def has_lost(self) -> bool:
"""
Check for the losing position.
Losing position: no cards left in stock and no possible moves.
"""
return len(self.stock) == 0 and len(
[card for card in self.last_cards() if self.can_move(card)]) == 0
def print_game(self):
"""
Print the game.
Assumes:
Card(decorated=True) by default it is already set to True
self.tableau -> a list of lists (each list represents a column of cards)
self.stock -> a list of Card objects that are in the stock
self.waste_pile -> a list of Card objects that are in the waste pile
You may modify/write your own print_game.
"""
print(f" {' '.join(list('0123456'))}")
print('-' * 34)
print("\n".join([
(" ".join((map(str, x))))
for x in (zip_longest(*self.tableau, fillvalue=" "))
]))
print()
print(
f"Stock pile: {len(self.stock)} card{'s' if len(self.stock) != 1 else ''}"
)
print(f"Waste pile: {self.waste[-1] if self.waste else 'Empty'}")
@staticmethod
def rules():
"""Print the rules of the game."""
print("Rules".center(40, "-"))
print(
dedent("""
Objective: Move all the cards from each column to the waste pile.
A card can be moved from a column to the waste pile if the
rank of that card is one higher or lower than the topmost card
of the waste pile. Only the first card of each column can be moved.
You can deal cards from the stock to the waste pile.
The game is over if the stock is finished and
there are no more moves left.
The game is won once the tableau is empty.
Commands:
(0-6) - integer of the column, where the topmost card will be moved
(d) - deal a card from the stock
(r) - show rules
(q) - quit
"""))
def play(self):
"""
Play a game of Golf Solitaire.
Create the game loop here.
Use input() for player input.
Available commands are described in rules().
"""
allowed_moves = ["0", "1", "2", "3", "4", "5", "6"]
self.deck.shuffle_deck()
while True:
self.print_game()
if self.has_won():
print("You won.")
break
if self.has_lost():
print("You lost.")
break
command = input()
if command == "r":
self.rules()
continue
if command in allowed_moves:
cmd = int(command)
if cmd < Solitaire.columns:
if self.can_move(self.tableau[cmd][-1]) and len(
self.tableau[cmd]) != 0:
self.move_card(cmd)
continue
if command == "d":
self.deal_from_stock()
continue
if command == "q":
break
else:
print("Wrong input " + str(command))
continue
