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