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