def vopt(hands, trick, depth):
if depth == 0:
return utility(hands, trick)
score = 0
turn = (players.index(trick.play_order[-1]) + 1) % len(players)
# first we calculate the score if possible
if not trick.left_to_play: # all players have played
if game_state.are_partners(player.name, trick.winning_player().name):
score = 1
else:
score = -1
turn = players.index(trick.winning_player())
if not players[turn].cards: # game complete
return score
trick = Trick(players, game_state.trump)
depth = depth - 1
# QUESTION: Does get_legal_cards also consider trump suite? How does human_player consider trump?
cards = util.get_legal_cards(hands[players[turn].name], trick.suit_led)
plays = []
# next we attempt to play cards
if not cards: # this branch cannot be satisified, prune it
return 0
for card in set(cards):
trick.play_card(players[turn], card)
hands[players[turn].name].remove(card)
plays.append(score + vopt(hands, trick, depth))
hands[players[turn].name].append(card)
trick.revert_play(players[turn], card)
# finally we return the highest score
if game_state.are_partners(player.name, players[turn].name): # max
return max(plays)
else: # min
return min(plays)
def vopt(pred, trick, depth):
if depth == 0:
return utility(pred, trick)
score = 0
turn = (players.index(trick.play_order[-1]) + 1) % whist.NUM_PLAYERS
# first we calculate the score if possible
if not trick.left_to_play: # all players have played
if game_state.are_partners(self.name, trick.winning_player().name):
score = 1
else:
score = -1
turn = players.index(trick.winning_player())
if not players[turn].cards: # game complete
return score
trick = Trick(players, game_state.trump)
depth = depth - 1
cards = util.get_legal_cards(pred.predict(players[turn]), trick.suit_led)
cards = cards if len(cards) < self.breadth else random.sample(cards, self.breadth)
plays = []
# next we attempt to play cards
if not cards: # this branch cannot be satisified, prune it
return 0
for card in cards:
trick.play_card(players[turn], card)
pred.try_play(players[turn], card)
plays.append(score + vopt(pred, trick, depth))
pred.revert_play(players[turn], card)
trick.revert_play(players[turn], card)
# finally we return the highest score
if game_state.are_partners(self.name, players[turn].name): # max
return max(plays)
else: # min
return min(plays)
def end(self):
self.logger.info("Game ended! Determining winner...")
players = self.players
players.remove(self.declarer)
defenders_points = 0
for player in players:
defenders_points += player.result()
declarer_points = self.declarer.result()
# For now: adding points of "Skat" to Declarer
skat = Trick()
skat.add_card(self.deck.draw())
skat.add_card(self.deck.draw())
skat_points = skat.value()
declarer_points += skat_points
self.logger.info("Defenders: " + str(defenders_points) +
", Declarer: " + str(declarer_points))
if declarer_points >= 61:
self.logger.info("Declarer " + str(self.declarer) + " won with " +
str(declarer_points) + " points.")
else:
self.logger.info("Defenders " + str(players[0]) + " and " +
str(players[1]) + " won with " +
str(defenders_points) + " points.")
def get_trick(self, starting_player, spades_broken): """"Play a trick by getting a card from each player in order.""" current_trick = Trick() for i in range(4): player_id = (starting_player + i) % 4 card_played = self.players[player_id].play_card(current_trick.make_copy(player_id), self.get_valid_cards(player_id, current_trick, spades_broken)) assert self.verify_card_validity(card_played, player_id, current_trick, spades_broken) current_trick.add_card(card_played, player_id) self.hands[player_id].remove(card_played) return current_trick
def __init__(self, chat):
self.chat = chat
self.last_card = None
self.last_trick_winner = None
self.tricks_played = 0
self.declarer = None
self.current_trick = Trick()
self.deck = Deck()
self.logger = logging.getLogger(__name__)
def all_relevant_snapshots(self) -> \
Tuple[List[List[Player]], List[Trick], List[Card]]:
"""
Get all relevant data from DataGame: snapshots from all tricks, for the
positions of both winners.
:return: tuple of 3 elements:
1. list of all sets-of-hands during game, one set-of-hands for every trick
2. list of all open cards in specific trick, one set-of-cards for every trick
3. list of all real cards the player should act, one for every trick
all above are *concatenation* of results of both winners. For example,
cards_list = [cards_list_winner_1] + [cards_list_winner_2]
"""
winners_indices = [w.value - 1 for w in self.winner]
# List of hands and trick for every winner
hands_list_1: List[List[Player]] = []
curr_hands = deepcopy(self.players)
for trick_idx in range(len(self.tricks)):
hands_list_1.append(deepcopy(curr_hands))
for player_idx, player in enumerate(curr_hands):
curr_hands[player_idx].hand.play_card(
self.tricks[trick_idx].trick[player])
hands_list_2 = deepcopy(hands_list_1)
trick_list_1: List[Trick] = []
trick_list_2: List[Trick] = []
trick_list = [trick_list_1, trick_list_2]
chosen_cards_list_1: List[Card] = []
chosen_cards_list_2: List[Card] = []
chosen_cards_list = [chosen_cards_list_1, chosen_cards_list_2]
for winner_idx, winner_list in enumerate([hands_list_1, hands_list_2]):
for trick_idx, hands in enumerate(winner_list):
curr_player = self.position_to_player(
self.tricks[trick_idx].first_position)
curr_trick = Trick({})
while curr_player.position != POSITIONS[
winners_indices[winner_idx]]:
winner_list[trick_idx][PLAYERS_DICT[
curr_player.position.name]].play_card(
self.tricks[trick_idx].trick[curr_player])
curr_trick.add_card(
curr_player, self.tricks[trick_idx].trick[curr_player])
curr_player = self.players[PLAYERS_DICT[PLAYERS_CYCLE[
curr_player.position].name]]
trick_list[winner_idx].append(curr_trick)
chosen_cards_list[winner_idx].append(
self.tricks[trick_idx].trick[curr_player])
return hands_list_1 + hands_list_2, trick_list_1 + trick_list_2, \
chosen_cards_list_1 + chosen_cards_list_2
def play_round(self, player_list, teams, victory_score):
# A trick count is initalized to zero
trick_count = 0
spades = {"is_broken": False}
player_list = player_list
while trick_count < 13:
trick_count += 1
trick = Trick()
find_high_card = self.find_high_card
# Lead player leads off trick
# reorder players so that lead player has index of 0
index_of_lead = player_list.index(self.current_lead)
lead_order = player_list[index_of_lead:]
lead_order.extend(player_list[:index_of_lead])
# Players play cards in turn
# When all players have played a card
# The winning card is determined
for player in lead_order:
find_high_card = find_high_card(player.play_turn(
trick, spades))
sleep(1.0)
print()
# The winning player takes the trick
print(
f"The winner of that round is {find_high_card.owner.fullname} with a winning card of {find_high_card}"
)
find_high_card.owner.tricks.append(trick)
# The winning player is set as the lead player
self.current_lead = find_high_card.owner
# The scores are updated
self.update_scores(player_list, teams)
# The scores are checked to see if a team has won
# The round is reset
self.reset_play()
def create_game(agent,
other_agent,
games_counter,
verbose_mode,
from_db=False,
cards_in_hand=13):
""" Returns Game object, either new random game or a game initialized from game DB"""
if from_db:
pass
# todo(maryna): create single game from db. pay attention to players
# initialization + the iterator.
trick_counter = [
0,
0,
] # [Team 0, Team 1]
previous_tricks = []
game = Game(agent,
other_agent,
games_counter,
trick_counter,
verbose_mode,
previous_tricks,
Trick({}),
cards_in_hand=cards_in_hand)
return game
def __init__(self, players=None):
self.game_over = False
cards = Deck()
divided_cards = cards.split_equally(4)
if players is None:
players = [DumbAI(hand=Hand(cards_list=hand), name='Player %s' % index) for index, hand in enumerate(divided_cards)]
if all(player.hand is None for player in players):
for idx, player in enumerate(players):
player.hand = divided_cards[idx]
self.players = players
for player in self.players:
player.create_players([p.name for p in self.players])
print(*['%s - %s' % (player.name, player.hand) for player in self.players], sep='\n')
self.present_trick = Trick(len(self.get_player_still_game()))
def play_card(self, card):
"""
Plays a card and triggers its effects.
Should be called only from Player.play.
Card is added to current trick.
"""
self.last_card = card
self.current_trick.add_card(card)
self.logger.info("Player " + str(card.owner) + " is playing card " +
repr(card))
if len(self.current_trick.cards) == 3:
self.tricks_played += 1
# Determine trick winner
winnercard = self.current_trick.winner(self.trump)
# Add trick to trick winner
winnercard.owner.won_tricks.append(self.current_trick)
# Set last trick winner of game
self.last_trick_winner = winnercard.owner
self.logger.info("Player " + str(winnercard.owner) +
" won the trick " + str(self.current_trick.cards))
# Start a new trick
self.current_trick = Trick()
self.last_card = None
# Trick winner starts new trick
self.current_player = self.last_trick_winner
if self.tricks_played == 10:
self.end()
else:
self.turn()
def profile(userid):
user = User(userid)
con = lite.connect('bucketlist.db')
con.text_factory = str
cursor = con.execute('SELECT * FROM trickslist WHERE trick_type = "flip"')
result = cursor.fetchall()
flip_tricks = list()
for item in result:
trick = Trick(item[0], item[1], item[2], item[3])
flip_tricks.append(trick)
cursor = con.execute('SELECT * FROM trickslist WHERE trick_type = "grind"')
result = cursor.fetchall()
grind_tricks = list()
for item in result:
trick = Trick(item[0], item[1], item[2], item[3])
grind_tricks.append(trick)
cursor = con.execute('SELECT * FROM trickslist WHERE trick_type = "grab"')
result = cursor.fetchall()
grab_tricks = list()
for item in result:
trick = Trick(item[0], item[1], item[2], item[3])
grab_tricks.append(trick)
return render_template("profile.html", user=user, flip_tricks=flip_tricks, grind_tricks=grind_tricks, grab_tricks=grab_tricks)
def snapshot(self, trick_idx: int, position: PositionEnum) -> \
Tuple[List[Player], Trick, Card]:
"""
Image of one moment in game, in trick_idx trick, when player should play
:param trick_idx: first trick is 0
:param position: the player to commit its turn now
:return: current hands situation (ordered list of players), trick on
desk and the chosen card (by player in given position).
"""
if trick_idx >= len(self.tricks):
raise IndexError(f"trick_idx argument has to be smaller then "
f"{len(self.tricks)}")
# Load initial hands situation
curr_hands = deepcopy(self.players)
# Remove cards from all last tricks from hands
for i in range(trick_idx):
for j, p in enumerate(curr_hands):
curr_hands[j].hand.play_card(self.tricks[i].trick[p])
# Remove cards of current trick from hands of all players which play
# before given player. In addition, store these cards
curr_pos = self.tricks[trick_idx].first_position
curr_player = self.position_to_player(curr_pos)
curr_trick = Trick({})
while curr_player.position != position:
curr_hands[PLAYERS_DICT[curr_player.position.name]].play_card(
self.tricks[trick_idx].trick[curr_player])
curr_trick.add_card(curr_player,
self.tricks[trick_idx].trick[curr_player])
curr_player = self.players[PLAYERS_DICT[PLAYERS_CYCLE[
curr_player.position].name]]
chosen_card = self.tricks[trick_idx].trick[curr_player]
return curr_hands, curr_trick, chosen_card
def run(self, dis):
next_trick_time = 3
while not self.should_exit:
try:
if CommandHelper.run("killall htop") == 0 or CommandHelper.run("killall top") == 0:
Term.print_all("You tough that this will be as easy as this?\n")
sa.WaveObject.from_wave_file("data/goose.wav").play()
next_trick_time -= 1
if next_trick_time <= 0:
trick = Trick.get_random_trick(not dis)
next_trick_time = trick.delay
trick.run()
if trick.is_reversible:
self.tricks.append(trick)
time.sleep(1)
except KeyboardInterrupt:
...
def apply_action(self, card: Card, is_real_game: bool = False) -> Trick:
"""
:param card: Action to apply on current state
:param is_real_game: indicator to differentiate a state used in simulation of a game
by the object Game, from a state used within tree search.
:returns Trick: Trick status after applying card.
"""
assert (len(self.trick) < len(self.players_pos))
assert card not in self.already_played
prev_num_cards = len(self.curr_player.hand.cards)
self.curr_player.play_card(card)
curr_num_cards = len(self.curr_player.hand.cards)
assert prev_num_cards != curr_num_cards
self.trick.add_card(self.curr_player, card)
self.already_played.add(card)
assert self.already_played.isdisjoint(self.curr_player.hand.cards)
curr_trick = self.trick
if len(self.trick) == len(
self.players_pos): # last card played - open new trick
if is_real_game:
self.prev_tricks.append(copy(self.trick))
winner_position = self.trick.get_winner()
self.curr_player = self.players_pos[winner_position]
i = 0 if self.teams[0].has_player(self.curr_player) else 1
self.score[self.teams[i]] += 1
self.trick = Trick({})
else:
assert self.curr_player in self.players_pos.values()
assert self.curr_player in self.players
# print(f"Mapping of position->next player: {repr(self.players_pos)}")
self.curr_player = self.players_pos[PLAYERS_CYCLE[
self.curr_player.position]]
assert self.curr_player in self.players_pos.values()
assert self.curr_player in self.players
return curr_trick
def main():
pygame.init()
pygame.font.init()
name_font = pygame.font.SysFont('arial', 20)
message_font = pygame.font.SysFont('arial', 16)
clock = pygame.time.Clock()
screen_size = (900, 600) # place_holder for board size
diagram_width = 600
message_screen_height = 150
game_display = pygame.display.set_mode((screen_size[0] + diagram_width, screen_size[1] + message_screen_height))
game_display.fill((205, 205, 255), pygame.Rect(0, 0, screen_size[0], screen_size[1]))
game_display.fill((255, 255, 255), pygame.Rect(screen_size[0] + 2, 0, diagram_width, screen_size[1]))
game_display.fill((255, 255, 255), pygame.Rect(0, screen_size[1] + 2, screen_size[0] + diagram_width, message_screen_height))
pygame.display.update()
#while not game_over:
pygame.time.wait(1000)
#initialize randomized cards and trump
if fixed_hands:
trump = 'Diamonds'
else:
trump = SUITS[random.randint(0, 3)]
print(str(trump) + ' is trump')
ord_cards = []
cards = []
for suit in SUITS:
for face in FACES:
rank = NORMAL_POINTS[face] if suit != trump else TRUMP_POINTS[face]
ord_cards.append((suit, face, rank))
if fixed_hands:
#SUITS = ['Hearts', 'Spades', 'Diamonds', 'Clubs']
#FACES = ['ace', 'king', 'queen', 'jack', 'ten', 'nine', 'eight', 'seven']
fixed_cards = {}
# the hands are fixed, because we know the order of ord_cards, from the order of SUITS and FACES, we can use this to pick cards
# for the hands, first number determines suit, second number determines rank
#fixed_cards['South'] = [ord_cards[8 + 7], ord_cards[0 + 4], ord_cards[16 + 4], ord_cards[0 + 1], ord_cards[0 + 6], ord_cards[16 + 5], ord_cards[16 + 6], ord_cards[16 + 3]]
#fixed_cards['West'] = [ord_cards[8 + 3], ord_cards[8 + 0], ord_cards[24 + 0], ord_cards[24 + 2], ord_cards[24 + 5], ord_cards[16 + 1], ord_cards[0 + 7], ord_cards[0 + 5]]
#fixed_cards['North'] = [ord_cards[8 + 5], ord_cards[8 + 2], ord_cards[8 + 6], ord_cards[24 + 1], ord_cards[24 + 7], ord_cards[16 + 0], ord_cards[16 + 2], ord_cards[0 + 2]]
#fixed_cards['East'] = [ord_cards[8 + 4], ord_cards[8 + 1], ord_cards[0 + 3], ord_cards[24 + 4], ord_cards[24 + 6], ord_cards[24 + 3], ord_cards[16 + 7], ord_cards[0 + 0]]
fixed_cards['South'] = [ord_cards[0 + 1], ord_cards[0 + 2], ord_cards[0 + 3], ord_cards[0 + 7],
ord_cards[16 + 0], ord_cards[16 + 4], ord_cards[16 + 5], ord_cards[16 + 6]]
fixed_cards['West'] = [ord_cards[0 + 0], ord_cards[0 + 5], ord_cards[0 + 6], ord_cards[0 + 4],
ord_cards[16 + 3], ord_cards[16 + 1], ord_cards[16 + 2], ord_cards[16 + 7]]
fixed_cards['North'] = [ord_cards[8 + 7], ord_cards[8 + 4], ord_cards[8 + 2], ord_cards[8 + 1],
ord_cards[24 + 6], ord_cards[24 + 5], ord_cards[24 + 7], ord_cards[24 + 0]]
fixed_cards['East'] = [ord_cards[8 + 3], ord_cards[8 + 0], ord_cards[24 + 1], ord_cards[24 + 2],
ord_cards[8 + 6], ord_cards[8 + 5], ord_cards[24 + 3], ord_cards[24 + 4]]
cards = list(ord_cards)
random.shuffle(cards)
# print(cards)
# initialize players
assert NUM_PLAYERS == 4
player_1 = Player(Team('South', 'North', '1'), 0, 'South', cards)
player_2 = Player(Team('East', 'West', '2'), 1, 'West', cards)
player_3 = Player(Team('South', 'North', '1'), 2, 'North', cards)
player_4 = Player(Team('East', 'West', '2'), 3, 'East', cards)
players = [player_1, player_2, player_3, player_4]
common_knowledge = [('GAME_RULE_TRUMP', trump, True)]
idx = 0
idx2 = CLOSED_CARDS
#assert CLOSED_CARDS == OPEN_CARDS
for player in players: # Card division between players
if not fixed_hands:
player.closed_cards = cards[idx:idx2]
idx = idx2
idx2 += OPEN_CARDS
player.open_cards = cards[idx:idx2]
idx = idx2
idx2 += CLOSED_CARDS
else:
idx = 0
idx2 = CLOSED_CARDS
player.closed_cards = fixed_cards[player.name][idx:idx2]
idx = idx2
idx2 += OPEN_CARDS
player.open_cards = fixed_cards[player.name][idx:idx2]
player.own_cards = list(player.closed_cards + player.open_cards)
for open_card in player.open_cards: # Add open cards to common knowledge
common_knowledge.append((player.name, open_card, False))
print(str(player.name) + ' has ' + str(player.closed_cards) + ' and ' + str(player.open_cards))
#print(str(player.name) + ' has ' + str(len(player.closed_cards)) + ' closed cards and ' + str(len(player.open_cards)) + ' open cards')
for player in players: # Knowledge init
player.knowledge.extend(common_knowledge)
for closed_card in player.closed_cards:
player.knowledge.append((player.name, closed_card, False))
player.create_possibles()
if debug:
print(player.name + " knows (initial) " + str(player.knowledge))
score = {'1' : 0, '2' : 0}
# First rounds HE RE THE GAME BEGINS!!!!!!!!!!!!!!!!!!
game_pause = True
for game_round in range(NUM_ROUNDS):
game_display.fill((255, 255, 255), pygame.Rect(screen_size[0] + 2, 0, diagram_width, screen_size[1]))
model_title = 'Current card knowledge of players:'
model_title_display = name_font.render(model_title, 1, (0, 0, 0))
game_display.blit(model_title_display, (screen_size[0] + 10, 10))
dropdown_width = 140
dropdown = pygame.Rect(screen_size[0] + 10, 35, dropdown_width, 20)
pygame.draw.rect(game_display, (0, 0, 0), dropdown, 1)
dropdown_display = message_font.render('choose a card', 1, (0, 0, 0))
game_display.blit(dropdown_display, ((dropdown.left + 5), dropdown.top))
for player in players: # Each following player picks card to play and plays
pygame.draw.line(game_display, (0, 0, 0), (screen_size[0], screen_size[1]),
(screen_size[0] + diagram_width, screen_size[1]), 2)
pygame.display.update()
message_counter = 0
turn = True
menu_open = False
select_available = False
while turn:
if player == players[0] and game_round == 0:
run_one_frame = True
else:
run_one_frame = False
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
game_pause = not game_pause
print('PAUSED ' + str(game_pause))
if event.key == pygame.K_RIGHT:
run_one_frame = True
x, y = pygame.mouse.get_pos()
#print(x, y)
m_pressed = pygame.mouse.get_pressed()
x_hover_dropdown = dropdown.left < x < dropdown.left + dropdown.width
y_hover_dropdown = dropdown.top < y < dropdown.top + dropdown.height
if x_hover_dropdown and y_hover_dropdown and m_pressed[0]:
for i in range(1, len(ord_cards) + 1):
dropdown_opt = pygame.Rect(screen_size[0] + 10, 35 + 20*i, dropdown_width, 20)
pygame.draw.rect(game_display, (255, 255, 255), dropdown_opt, 0)
pygame.draw.rect(game_display, (0, 0, 0), dropdown_opt, 1)
card = ord_cards[i - 1]
card_display = message_font.render(card[1] + ' of ' + card[0], 1, (0, 0, 0))
game_display.blit(card_display, ((dropdown_opt.left + 5), dropdown_opt.top))
pygame.display.update()
menu_open = True
if menu_open and not m_pressed[0]:
select_available = True
if select_available and m_pressed[0]:
if x_hover_dropdown and dropdown.top + dropdown.height < y < dropdown.top + dropdown.height*(len(ord_cards) + 1):
game_display.fill((255, 255, 255), pygame.Rect(screen_size[0] + dropdown_width + 10, 55, diagram_width,
screen_size[1] - 55))
i = int((y - 35) / 20 - 1)
card = ord_cards[i]
picked_card = message_font.render('card is: ' + card[1] + ' of ' + card[0], 1, (0, 0, 0))
game_display.blit(picked_card, (screen_size[0] + 200, 60))
draw_model(game_display, players, message_font, card, screen_size[0], 55, diagram_width, screen_size[1] - 55)
#else:
# game_display.fill((255, 255, 255), pygame.Rect(screen_size[0] + 2, 55, diagram_width, screen_size[1] + message_screen_height - 55))
# pygame.draw.line(game_display, (0, 0, 0), (screen_size[0], screen_size[1]), (screen_size[0] + diagram_width, screen_size[1]), 2)
pygame.display.update()
select_available = False
if not game_pause or run_one_frame:
if player == players[0]:
game_display.fill((205, 205, 255), pygame.Rect(0, 0, screen_size[0], screen_size[1]))
for i in range(len(PLAYERS)):
name_display = name_font.render(PLAYERS[i], 1, (0, 0, 0))
game_display.blit(name_display, name_pos(PLAYERS[i], 8, screen_size))
trump_display = name_font.render(str(trump) + ' is trump', 1, (0, 0, 0))
open_close_info = 'Game with ' + str(OPEN_CARDS) + ' open cards and ' + str(
CLOSED_CARDS) + ' closed cards.'
open_close_display = message_font.render(open_close_info, 1, (0, 0, 0))
continue_info1 = 'Press right arrow to continue'
continue_info2 = 'Press space bar to skip to end and close'
continue_display1 = message_font.render(continue_info1, 1, (0, 0, 0))
continue_display2 = message_font.render(continue_info2, 1, (0, 0, 0))
score_update1 = 'South and North: ' + str(score['1'])
score_update2 = 'East and West: ' + str(score['2'])
score_update_display1 = message_font.render(score_update1, 1, (0, 0, 0))
score_update_display2 = message_font.render(score_update2, 1, (0, 0, 0))
game_display.blit(score_update_display1, (20, screen_size[1] - 50))
game_display.blit(score_update_display2, (20, screen_size[1] - 35))
game_display.blit(trump_display, (10, 10))
game_display.blit(open_close_display, (10, 35))
game_display.blit(continue_display1, (600, 10))
game_display.blit(continue_display2, (600, 25))
else:
clear_hands(game_display, (205, 205, 255), len(player.closed_cards)+len(player.open_cards), screen_size)
game_display.fill((255, 255, 255), pygame.Rect(screen_size[0] + 2, 55, diagram_width, screen_size[1] - 55))
for pla in players:
for i in range(len(pla.closed_cards)): # Draw hands closed cards
card = pla.closed_cards[i]
if pla == player:
file_name = IMAGE_DICT[card[1]] + IMAGE_DICT[card[0]] + '.gif'
else:
file_name = 'b.gif'
image, im_rect = load_image(file_name)
game_display.blit(image, calc_offset(pla.name, len(pla.closed_cards)+len(pla.open_cards), screen_size, i))
for i in range(len(pla.open_cards)):
card = pla.open_cards[i]
if pla == player:
file_name = IMAGE_DICT[card[1]] + IMAGE_DICT[card[0]] + '.gif'
else:
file_name = IMAGE_DICT[card[1]] + IMAGE_DICT[card[0]] + '.gif'
image, im_rect = load_image(file_name)
game_display.blit(image, calc_offset(pla.name, len(pla.closed_cards)+len(pla.open_cards), screen_size, i+len(pla.closed_cards)))
pygame.display.update()
if game_pause:
if fast:
pygame.time.delay(100)
else:
pygame.time.delay(1500)
clear_hands(game_display, (205, 205, 255), len(player.closed_cards) + len(player.open_cards),
screen_size)
if player == players[0]:
print('\nnew round') # First player plays a card here
card, thoughts = players[0].play_card(trump)
trick = Trick(trump, players[0], card)
else:
card, thoughts = player.play_card(trump, trick)
trick.add_card(player, card)
#
game_display.fill((255, 255, 255), pygame.Rect(0, screen_size[1] + 2, screen_size[0] + diagram_width, message_screen_height))
for i in range(len(thoughts)):
message = message_font.render(thoughts[i], 1, (0, 0, 0))
game_display.blit(message, (10, screen_size[1] + 10 + (message_counter * 20)))
message_counter += 1
# Draw trick
card = trick.cards[-1]
file_name = IMAGE_DICT[card[1]] + IMAGE_DICT[card[0]] + '.gif'
image, im_rect = load_image(file_name)
game_display.blit(image, (screen_size[0]/2 + CENTER_POS[player.name][0], screen_size[1]/2 + CENTER_POS[player.name][1]))
public_ann_played_card = 'public announcement: ' + player.name + ' plays ' + trick.cards[-1][1] + ' of ' + trick.cards[-1][0]
played_card_display = message_font.render(public_ann_played_card, 1, (0, 0, 0))
game_display.blit(played_card_display, (10, screen_size[1] + 10 + (message_counter * 20)))
message_counter += 1
pa_updated = False
for pla in players:
for i in range(len(pla.closed_cards)): # Draw hands closed cards
card = pla.closed_cards[i]
if pla == player:
file_name = IMAGE_DICT[card[1]] + IMAGE_DICT[card[0]] + '.gif'
else:
file_name = 'b.gif'
image, im_rect = load_image(file_name)
game_display.blit(image, calc_offset(pla.name, len(pla.closed_cards)+len(pla.open_cards), screen_size, i))
for i in range(len(pla.open_cards)):
card = pla.open_cards[i]
if pla == player:
file_name = IMAGE_DICT[card[1]] + IMAGE_DICT[card[0]] + '.gif'
else:
file_name = IMAGE_DICT[card[1]] + IMAGE_DICT[card[0]] + '.gif'
image, im_rect = load_image(file_name)
game_display.blit(image, calc_offset(pla.name, len(pla.closed_cards)+len(pla.open_cards), screen_size, i+len(pla.closed_cards)))
pygame.display.update()
try: # Knowledge update for all players
pla.knowledge.remove((trick.players[-1].name, trick.cards[-1], False))
except ValueError:
pass
pla.knowledge.append((trick.players[-1].name, trick.cards[-1], True))
notices = pla.update_possibles(trick)
if not pa_updated:
for i in range(len(notices)):
message = message_font.render(notices[i], 1, (0, 0, 0))
game_display.blit(message, (10, screen_size[1] + 10 + (message_counter * 20)))
message_counter += 1
pa_updated = True
if debug:
print(pla.name + ' Knows (update): ' + str(pla.knowledge))
if game_pause:
if fast:
pygame.time.delay(100)
else:
pygame.time.delay(1500)
if player.turn == 3:
trick.check_bonus()
if game_round == (NUM_ROUNDS - 1):
score[trick.winner.team.nr] += int(trick.score + 10) # Final round is worth 10 points
end = trick.winner.name + ' wins the final trick with highest card ' + str(
trick.high_card) + ', trick score ' + str(int(trick.score + 10))
print(end)
end_display = message_font.render(end, 1, (0, 0, 0))
game_display.blit(end_display, (10, screen_size[1] + message_screen_height - 25))
else:
score[trick.winner.team.nr] += int(trick.score) # Score is added to winning team
end = trick.winner.name + ' wins the trick with highest card ' + str(
trick.high_card) + ', trick score ' + str(int(trick.score))
print(end)
end_display = message_font.render(end, 1, (0, 0, 0))
game_display.blit(end_display, (10, screen_size[1] + message_screen_height - 25))
pygame.display.update()
if not game_pause or run_one_frame:
turn = False
players = players[trick.winner.turn:] + players[:trick.winner.turn] # Winning player is new starter
for i in range(NUM_PLAYERS):
players[i].turn = i
print(score)
pit = False
total = score['1']+score['2']
if score['1'] == 0:
score['2'] = total + 100
print('team 2: PIT!')
pit = True
elif score['2'] == 0:
score['1'] = total + 100
print('team 1: PIT!')
pit = True
if score['1'] <= (total/2) and not pit:
print('team 1: NAT!')
score['1'] = 0
score['2'] = total
print(score)
game_display.fill((205, 205, 255), pygame.Rect(20, screen_size[1] - 50, 150, 30))
pygame.display.update()
score_update1 = 'South and North: ' + str(score['1'])
score_update2 = 'East and West: ' + str(score['2'])
score_update_display1 = message_font.render(score_update1, 1, (0, 0, 0))
score_update_display2 = message_font.render(score_update2, 1, (0, 0, 0))
game_display.blit(score_update_display1, (20, screen_size[1] - 50))
game_display.blit(score_update_display2, (20, screen_size[1] - 35))
pygame.display.update()
pygame.time.delay(2500)
cred = credentials.Certificate('key.json')
firebase_admin.initialize_app(
cred,
{'databaseURL': 'https://project-5641153190345267944.firebaseio.com/'})
root = db.reference()
# Add a new user under /users.
tricktionary = []
tricknames = []
id = 0
for i in range(5):
tricks = root.child('tricks').child(str(i)).child('subs').get()
for trick in tricks:
if True: #trick['type'] == 'Multiples':
t = Trick(id, i, trick['name'],
types.index(str(trick['type']).lower()))
prereqs = []
for prereq in trick['prerequisites']:
if prereq['name'] != 'None':
prereqs.append(prereq['name'])
t.prereqs = prereqs
id += 1
tricktionary.append(t)
tricknames.append(t.name)
print(t.name)
nodes = []
links = []
for trick in tricktionary:
nodes.append({'group': trick.type, 'name': trick.name})
class GameManager():
players = None
lead_player = None
present_trick = None
game_over = None
wish_for_power = None
def __init__(self, players=None):
self.game_over = False
cards = Deck()
divided_cards = cards.split_equally(4)
if players is None:
players = [DumbAI(hand=Hand(cards_list=hand), name='Player %s' % index) for index, hand in enumerate(divided_cards)]
if all(player.hand is None for player in players):
for idx, player in enumerate(players):
player.hand = divided_cards[idx]
self.players = players
for player in self.players:
player.create_players([p.name for p in self.players])
print(*['%s - %s' % (player.name, player.hand) for player in self.players], sep='\n')
self.present_trick = Trick(len(self.get_player_still_game()))
def check_if_game_finished(self):
number_still_in = sum([1 if not x.is_out() else 0 for x in self.players])
if number_still_in <= 1:
self.game_over = False
else:
self.game_over = True
def is_game_over(self):
if self.game_over:
return True
# CHECK if both people from same team are out
self.game_over = sum([1 if not x.is_out() else 0 for x in self.players]) <= 1
return self.game_over
def run_game(self):
# Until 3 players are out
# Game
self.exchange_cards()
for player in self.players:
if Mahjong() in player.hand.cards:
self.lead_player = player
break
#TODO How to decide lead player
else:
self.lead_player = self.players[0]
while not self.is_game_over():
print('',
'### new trick with players %s' %
(', '.join(['%s (%spts)' % (player.name, player.points) for player in self.get_player_still_game()])),
'### leading player is %s' % self.lead_player,
'### trick - %s' % self.present_trick,
'',
sep='\n')
# Take action from the lead player
self.get_player_action(self.lead_player)
# Check if game is over
if self.is_game_over():
continue
self.check_for_bomb()
# Initialize the rolling cycle of player
player_iterator = self.next_active_player()
if self.lead_player.is_out():
self.lead_player = next(player_iterator)
continue
active_player = next(player_iterator)
# Until somebody wins the hand
while not self.present_trick.is_over() and not self.is_game_over():
player_action = self.get_player_action(active_player)
if not player_action.has_passed():
# Check if game is over
if self.is_game_over():
break
self.check_for_bomb()
if self.lead_player.is_out():
self.lead_player = next(player_iterator)
self.check_for_bomb()
active_player = next(player_iterator)
self.end_of_trick()
def publish_action_to_players(self, action, starting=False):
for player in self.players:
player.publish_action(action, starting)
def end_of_trick(self):
last_play = self.present_trick.get_last_play()
trick_owner = self.present_trick.get_last_player()
if Dragon() in last_play.combination.cards:
trick_owner_name = trick_owner.get_player_to_pass_dragon_to()
print('Trick is given to %s' % trick_owner_name)
else:
trick_owner_name = trick_owner.name
# notify all players
for player in self.players:
player.end_of_trick(trick_owner_name=trick_owner_name, trick=self.present_trick)
self.present_trick.reset()
# Returns a cyclic iterators on players still n starting after the start player
def next_active_player(self):
# should always be 4
cycle = itertools.cycle(self.players)
player = next(cycle)
while player != self.lead_player:
player = next(cycle)
while True:
player = next(cycle)
if not player.is_out():
yield player
def get_player_action(self, player=None, bomb=False):
if player is None:
player = self.lead_player
# Check for any bomb here
if bomb:
player_action = player.bomb(self.present_trick)
# Do not update anything for bomb
if player_action is None:
return
else:
player_action = player.play(self.present_trick, self.wish_for_power)
print(player_action)
# Ensure action is valid
try:
self.assert_valid_action(player, player_action)
if player_action.wish is not None:
self.wish_for_power = player_action.wish
# TODO - TEMP
if player.is_out():
print('=====> %s is out' % player)
self.present_trick.update(action=player_action, out=player.is_out())
self.publish_action_to_players(action=player_action,
starting=self.present_trick.is_first_run())
if not player_action.has_passed():
self.lead_player = player
if Dog() in player_action.combination.cards:
self.lead_player = self.get_player(player.get_partner().name)
self.end_of_trick()
return player_action
except Exception as e:
print('AI Error - %s' % e)
# If not valid, publish an error message to the player
player.misplay(player_action, self.present_trick)
raise ValueError(e)
# FOR THE MOMENT ONLY check for bomb in the order
def check_for_bomb(self):
for player in self.get_player_still_game():
# Assuming that people would not terminate on a Bomb
self.get_player_action(player, bomb=True)
def assert_valid_action(self, player, action):
if self.present_trick.is_first_run() and action.has_passed() and not player.is_out():
raise GameManagerException('Cannot pass on an empty trick')
if self.present_trick is not None and not action.has_passed():
# Make sure action is valid
action.assert_valid()
last_play = self.present_trick.get_last_play()
if last_play:
if last_play.combination >= action.combination:
raise GameManagerException('Combination should be greater than last played')
if self.wish_for_power is not None:
if self.wish_for_power in [card.power for card in action.combination.cards]:
self.wish_for_power = None
# TODO assert for combination not possible
elif self.wish_for_power in [card.power for card in player.hand.cards]:
raise GameManagerException('Wish should be fulfilled')
def get_player_still_game(self):
return [player for player in self.players if not player.is_out()]
def exchange_cards(self):
# Get all cards
exchanged_cards = {}
for player in self.players:
exchanged_cards[player.name] = player.give_cards()
print('%s gives %s' % (player.name, exchanged_cards[player.name]))
for from_player, gifts in exchanged_cards.items():
for player_to_give, card in gifts.items():
self.get_player(player_to_give).received_card(from_player, card)
def get_player(self, player_name):
for player in self.players:
if player.name == player_name:
return player
class Game(object):
""" This class represents a game of UNO """
current_player = None
current_trick = None
trump = None
started = False
starter = None
highest_bid = 0
highest_bidder = None
reizen_done = False
weitersagen = False
reizen_sagenoderhoeren = 0
sager = None
hoerer = None
out = None
#owner = ADMIN_LIST
#open = OPEN_LOBBY
def __init__(self, chat):
self.chat = chat
self.last_card = None
self.last_trick_winner = None
self.tricks_played = 0
self.declarer = None
self.current_trick = Trick()
self.deck = Deck()
self.logger = logging.getLogger(__name__)
@property
def players(self):
"""Returns a list of all players in this game"""
players = list()
if not self.current_player:
return players
current_player = self.current_player
itplayer = current_player.next
players.append(current_player)
while itplayer and itplayer is not current_player:
players.append(itplayer)
itplayer = itplayer.next
return players
def start(self):
if len(self.players) < 3:
self.logger.info("Can't start, not enough players.")
else:
self.started = True
self.deck._fill_classic_()
self.logger.info("Game started.")
self.sagen_oder_hoeren = 0
self.sager = self.current_player.next
self.hoerer = self.current_player
self.logger.info("Geben: " + str(self.current_player.prev) +
" Hören: " + str(self.current_player) +
" Sagen: " + str(self.current_player.next))
#self.
def turn(self):
"""Marks the turn as over and change the current player"""
self.logger.debug("Next Player")
self.current_player = self.current_player.next
def play_card(self, card):
"""
Plays a card and triggers its effects.
Should be called only from Player.play.
Card is added to current trick.
"""
self.last_card = card
self.current_trick.add_card(card)
self.logger.info("Player " + str(card.owner) + " is playing card " +
repr(card))
if len(self.current_trick.cards) == 3:
self.tricks_played += 1
# Determine trick winner
winnercard = self.current_trick.winner(self.trump)
# Add trick to trick winner
winnercard.owner.won_tricks.append(self.current_trick)
# Set last trick winner of game
self.last_trick_winner = winnercard.owner
self.logger.info("Player " + str(winnercard.owner) +
" won the trick " + str(self.current_trick.cards))
# Start a new trick
self.current_trick = Trick()
self.last_card = None
# Trick winner starts new trick
self.current_player = self.last_trick_winner
if self.tricks_played == 10:
self.end()
else:
self.turn()
def end(self):
self.logger.info("Game ended! Determining winner...")
players = self.players
players.remove(self.declarer)
defenders_points = 0
for player in players:
defenders_points += player.result()
declarer_points = self.declarer.result()
# For now: adding points of "Skat" to Declarer
skat = Trick()
skat.add_card(self.deck.draw())
skat.add_card(self.deck.draw())
skat_points = skat.value()
declarer_points += skat_points
self.logger.info("Defenders: " + str(defenders_points) +
", Declarer: " + str(declarer_points))
if declarer_points >= 61:
self.logger.info("Declarer " + str(self.declarer) + " won with " +
str(declarer_points) + " points.")
else:
self.logger.info("Defenders " + str(players[0]) + " and " +
str(players[1]) + " won with " +
str(defenders_points) + " points.")
def set_new_trick(self):
"""Resets trick"""
self.active_trick = Trick()
def __init__(self, mobyPath, **kwargs):
Trick.__init__(self, **kwargs)
with open(str(mobyPath)) as f:
self.container = OrderedDict([(wordList[0], set(wordList[1:])) for wordList in [line.strip().split(',') for line in f]])
