def build_deck(self, cards):
deck = Deck()
for card in cards:
if card is None:
card = Card()
deck.add_card(card)
return deck
def main():
# create window for uno
root = tk.Tk()
root.title("Uno++")
# build a list of players for the game
players = [
HumanPlayer("Ravi"),
HumanPlayer(generate_name()),
ComputerPlayer(generate_name())
]
# build a pickup pile
pickup_pile = Deck(build_deck(FULL_DECK))
pickup_pile.shuffle()
# deal players cards from the pickup pile
for player in players:
cards = pickup_pile.pick(7)
player.get_deck().add_cards(cards)
# create and play the game
game = UnoGame(pickup_pile, players)
app = UnoApp(root, game)
app.play()
# update window dimensions
root.update()
root.minsize(root.winfo_width(), root.winfo_height())
root.mainloop()
def main():
# create window for coders
root = tk.Tk()
root.title("Sleeping Coders")
# build a list of players for the game
players = [Player(generate_name()), Player(generate_name())]
# build a pickup pile
pickup_pile = Deck(build_deck(FULL_DECK))
for i in range(5):
pickup_pile.copy(pickup_pile)
pickup_pile.shuffle()
# deal players cards from the pickup pile
for player in players:
cards = pickup_pile.pick(5)
player.get_hand().add_cards(cards)
# build a list of sleeping coder cards
coders = CODERS[:]
# create and play the game
game = CodersGame(pickup_pile, coders, players)
app = CoderApp(root, game)
app.play()
# update window dimensions
root.update()
root.minsize(root.winfo_width(), root.winfo_height())
root.mainloop()
def __init__(self, deck, players):
"""
Construct a game of uno from a pickup pile and list of players.
Parameters:
deck (Deck): The pile of cards to pickup from.
players (list<Player>): The players in this game of uno.
"""
self.pickup_pile = deck
self.players = players
self._turns = TurnManager(players)
self.putdown_pile = Deck(self.pickup_pile.pick())
self.special_pile = Deck()
self._is_over = False
self.winner = None
def new_game(self):
"""Start a new game"""
# clone the old players
players = []
for player in self.game.players:
players.append(player.__class__(player.get_name()))
# generate a new deck
pickup_pile = Deck(build_deck(FULL_DECK))
pickup_pile.shuffle()
# make players pickup cards
for player in players:
cards = pickup_pile.pick(7)
player.get_deck().add_cards(cards)
self.game = UnoGame(pickup_pile, players)
self.render_decks()
self.update()
def __init__(self, deck, coders, players):
"""
Construct a game of Sleeping Coders from a pickup pile, a list of coder
cards and a list of players.
Parameters:
deck (Deck): The pile of cards to pickup from.
coders (List<Card>): The list of sleeping coder cards.
players (list<Player>): The players in this game.
"""
self._pickup_pile = deck
self._coders = coders
self.players = players
self._turns = TurnManager(players)
self.putdown_pile = Deck()
self._is_over = False
self.winner = None
self._action = None
def init():
anna = ComputerPlayer("Anna Truffet")
players = [
anna,
HumanPlayer("Henry O'Brien"),
ComputerPlayer("Josh Arnold")
]
deck = Deck(
[Card(1, "red"),
Card(2, "blue"),
Card(3, "red"),
Card(4, "green")])
game = UnoGame(deck, players)
return anna, players, deck, game
class UnoGame:
"""
A game of Uno++.
"""
def __init__(self, deck, players):
"""
Construct a game of uno from a pickup pile and list of players.
Parameters:
deck (Deck): The pile of cards to pickup from.
players (list<Player>): The players in this game of uno.
"""
self.pickup_pile = deck
self.players = players
self._turns = TurnManager(players)
self.putdown_pile = Deck(self.pickup_pile.pick())
self.special_pile = Deck()
self._is_over = False
self.winner = None
def next_player(self):
"""
Changes to the next player in the game and returns an instance of them.
Returns:
(Player): The next player in the game.
"""
return self._turns.next()
def current_player(self):
"""
(Player) Returns the player whose turn it is currently.
"""
return self._turns.current()
def skip(self):
"""Prevent the next player from taking their turn."""
self._turns.skip()
def reverse(self):
"""Transfer the turn back to the previous player and reverse the order."""
self._turns.reverse()
def get_turns(self):
"""(TurnManager) Returns the turn manager for this game."""
return self._turns
def is_over(self):
"""
(bool): True iff the game has been won. Assigns the winner variable.
"""
for player in self.players:
if player.has_won():
self.winner = player
self._is_over = True
return self._is_over
def select_card(self, player, card):
"""Perform actions for a player selecting a card
Parameters:
player (Player): The selecting player.
card (Card): The card to select.
"""
card.play(player, self)
if card.__class__ in SPECIAL_CARDS:
self.special_pile.add_card(card)
else:
self.putdown_pile.add_card(card)
def take_turn(self, player):
"""
Takes the turn of the given player by having them select a card.
Parameters:
player (Player): The player whose turn it is.
"""
card = player.pick_card(self.putdown_pile)
if card is None:
player.get_deck().add_cards(self.pickup_pile.pick())
return
if card.matches(self.putdown_pile.top()):
self.select_card(player, card)
def take_turns(self):
"""
Plays an entire round by taking the turn for each player in the game.
"""
for player in self.players:
self.take_turn(player)
if player.has_won():
return
class CodersGame:
"""
A game of Sleeping Coders.
"""
def __init__(self, deck, coders, players):
"""
Construct a game of Sleeping Coders from a pickup pile, a list of coder
cards and a list of players.
Parameters:
deck (Deck): The pile of cards to pickup from.
coders (List<Card>): The list of sleeping coder cards.
players (list<Player>): The players in this game.
"""
self._pickup_pile = deck
self._coders = coders
self.players = players
self._turns = TurnManager(players)
self.putdown_pile = Deck()
self._is_over = False
self.winner = None
self._action = None
def get_pickup_pile(self):
"""(Deck): Returns the pickup file of a game."""
return self._pickup_pile
def get_sleeping_coders(self):
"""(List[Card]): Returns the list of coders who are still asleep in the game."""
return self._coders
def get_sleeping_coder(self, slot):
"""(Card): Returns the sleeping coder card at the given slot.
Parameters:
slot (int): The slot within the sleeping coders collection to get.
"""
return self._coders[slot]
def set_sleeping_coder(self, slot, card):
"""Set the coder at the given slot in the sleeping coders collection
Parameters:
slot (int): The slot within the sleeping coders collection to set.
card (Card): The card to place in the given slot.
"""
self._coders[slot] = card
def pick_card(self, blocked_classes=()):
"""
Pick a the first card from the pickup pile that is not an instance of
any of the classes in the blocked_classes.
Parameters:
blocked_classes (tuple<Card>): The classes that the card cannot be
an instance of.
Returns:
(List[Card]): The card picked from the top of the pickup pile.
"""
while True:
picked_card = self._pickup_pile.pick()
if not any((isinstance(picked_card, card_class)
for card_class in blocked_classes)):
return picked_card
def next_player(self):
"""
Changes to the next player in the game and returns an instance of them.
Returns:
(Player): The next player in the game.
"""
return self._turns.next()
def current_player(self):
"""
(Player) Returns the player whose turn it is currently.
"""
return self._turns.current()
def skip(self):
"""Prevent the next player from taking their turn."""
self._turns.skip()
def reverse(self):
"""Transfer the turn back to the previous player and reverse the order."""
self._turns.reverse()
def get_turns(self):
"""(TurnManager) Returns the turn manager for this game."""
return self._turns
def is_over(self):
"""
(bool): True iff the game has been won. Assigns the winner variable.
"""
if self._pickup_pile.get_amount() == 0:
return True
for player in self.players:
if player.has_won():
self.winner = player
self._is_over = True
return self._is_over
def select_card(self, player, card):
"""Perform actions for a player selecting a card
Parameters:
player (Player): The selecting player.
card (Card): The card to select.
"""
card.play(player, self)
self.putdown_pile.add_card(card)
def get_action(self):
"""
Get the current action being performed.
"""
return self._action
def set_action(self, action):
"""
Set the current action being performed to action.
Possible Actions:
NO_ACTION: No action is being performed.
PICKUP_CODER: Tutor card played to pickup a coder.
STEAL_CODER: Keyboard Kidnapper played to steal another players coder.
SLEEP_CODER: All-nighter played to put another players coder to sleep.
Parameters:
action (str): The current action.
"""
self._action = action
def get_last_card(self):
"""
(Card): Get the last card that was played.
"""
return self.putdown_pile.top()
print('-' * 5)
print('card.matchs(spical_card)')
print(card.matches(special_card))
print('-' * 5)
blue_card = ReverseCard(0, "blue")
print('special_card.matches(blue_card)')
print(special_card.matches(blue_card))
print('-' * 5)
print('*' * 40)
# Deck
cards = [card, special_card, blue_card]
deck = Deck(cards)
print('deck.get_cards()')
print(deck.get_cards())
print('-' * 5)
print('deck.get_amount()')
print(deck.get_amount())
print('-' * 5)
print('deck.top()')
print(deck.top())
print('-' * 5)
new_card = SkipCard(0, "green")
deck.add_card(new_card)
from os import system
system('pause')
deck.add_cards([card, special_card, blue_card])
def test_deck():
# Setup
card = Card(12, "red")
special_card = Pickup2Card(0, "red")
blue_card = ReverseCard(0, "blue")
cards = [card, special_card, blue_card]
deck = Deck(cards)
# Testing
print("Get Cards:", deck.get_cards(
)) #== [Card(12, 'red'), Pickup2Card(0, 'red'), ReverseCard(0, 'blue')])
print("Amount:", deck.get_amount() == 3)
print("Top:", deck.top()) #ReverseCard(0, blue)
print()
new_card = SkipCard(0, "green")
deck.add_card(new_card)
deck.add_cards([card, special_card, blue_card])
print("new amount:", deck.get_amount() == 7)
print(
"New Deck:", deck.get_cards()
) # [Card(12, red), Pickup2Card(0, red), ReverseCard(0, blue), SkipCard(0, green), Card(12, red), Pickup2Card(0, red),ReverseCard(0, blue)])
print("Pick:", deck.pick()) # [ReverseCard(0, blue)]
print("Pick 2:",
deck.pick(amount=2)) # [Pickup2Card(0, red), Card(12, red)]
deck.shuffle()
print(
"New Deck", deck.get_cards()
) #[SkipCard(0, green), Card(12, red), Pickup2Card(0, red),ReverseCard(0, blue)]
from a2 import Card, Player, Pickup2Card, Pickup4Card, HumanPlayer, ComputerPlayer, Deck, ReverseCard, SkipCard
import a2_support
# Set Up Uno Game
anna = ComputerPlayer("Anna Truffet")
players = [anna, HumanPlayer("Henry O'Brien"), ComputerPlayer("Josh Arnold")]
deck = Deck(
[Card(1, "red"),
Card(2, "blue"),
Card(3, "red"),
Card(4, "green")])
game = a2_support.UnoGame(deck, players)
def test_reverse_card():
print("reverse", '*' * 10)
card = ReverseCard(0, "red")
print(game.current_player().get_name())
# 'Anna Truffet'
print(game.next_player().get_name())
# "Henry O'Brien"
print(game.next_player().get_name())
# 'Josh Arnold'
print(game.next_player().get_name())
# 'Anna Truffet'
print("Reverse", '-' * 10)
card.play(anna, game)
print(game.next_player().get_name())
# 'Josh Arnold'
from a2 import Pickup2Card, Card, ReverseCard, SkipCard, ComputerPlayer, HumanPlayer, Pickup4Card
from a2 import Deck
import a2_support
card = Card(42, "red")
special_card = Pickup2Card(0, "red")
blue_card = ReverseCard(0, "blue")
cards = [card, special_card, blue_card]
new_card = SkipCard(0, "green")
deck = Deck(cards)
anna = ComputerPlayer("Anna")
players = [anna, HumanPlayer("Henry"), ComputerPlayer("john")]
game = a2_support.UnoGame(deck, players)
for i in game.players:
print(i.get_name())
print(i.get_deck().get_cards())
special_card.play(anna, game)
for i in game.players:
print(i)
print(i.get_name())
print(i.get_deck().get_cards())
print(id(i.get_deck().get_cards()))
