def __repr__(self):
# type: () -> str
"""
:return: A concise string representation of the state in one line
"""
rep = "The game is in phase: {}\n".format(self.__phase)
rep += "Player 1's points: {}, pending: {}\n".format(self.__p1_points, self.__p1_pending_points)
rep += "Player 2's points: {}, pending: {}\n".format(self.__p2_points, self.__p2_pending_points)
rep += "The trump suit is: {}\n".format(self.get_trump_suit())
rep += "Player 1's hand:"
for card in self.__deck.get_player_hand(1):
rank, suit = util.get_card_name(card)
rep += " {}{}".format(rank, suit)
rep += "\n"
rep += "Player 2's hand:"
for card in self.__deck.get_player_hand(2):
rank, suit = util.get_card_name(card)
rep += " {}{}".format(rank, suit)
rep += "\n"
rep += "There are {} cards in the stock\n".format(self.__deck.get_stock_size())
trick = self.__deck.get_trick()
if trick[0] is not None:
rep += "Player 1 has played card: {} of {}\n".format(util.get_rank(trick[0]), util.get_suit(trick[0]))
if trick[1] is not None:
rep += "Player 2 has played card: {} of {}\n".format(util.get_rank(trick[1]), util.get_suit(trick[1]))
return rep
def play(
player1,
player2,
state, # type: State
max_time=5000, # type: int
verbose=True # type: bool
):
"""
Play a game between two given players, from the given starting state.
"""
pr('player1: {}'.format(player1), verbose)
pr('player2: {}'.format(player2), verbose)
# The game loop
while not state.finished():
player = player1 if state.whose_turn() == 1 else player2
move = get_move(state, player, max_time, verbose)
check(move, player) # check for common mistakes TODO
if move[0] is None:
pr(
'* Player {} performs a trump jack exchange'.format(
state.whose_turn()), verbose)
else:
pr(
'* Player {} plays: {}{}'.format(state.whose_turn(),
util.get_rank(move[0]),
util.get_suit(move[0])),
verbose)
if move[1] is not None:
pr(
'* Player {} melds a marriage between {}{} and {}{}'.
format(state.whose_turn(), util.get_rank(move[0]),
util.get_suit(move[0]), util.get_rank(move[1]),
util.get_suit(move[1])), verbose)
state = state.next(move)
pr(state, verbose)
if not state.revoked() is None:
pr(
'! Player {} revoked (made illegal move), game finished.'.
format(state.revoked()), verbose)
if state.finished():
pr(
'Game finished. Player {} has won, receiving {} points.'.format(
state.winner()[0],
state.winner()[1]), verbose)
else:
pr('Maximum turns exceed. No winner.', verbose)
return state.winner() if state.finished() else None
def general_information(kb, state, index): # Loads fuzzy symbols, gives them fuzzy values and adds them to fuzzy knowledge base
RV = FuzzySymbol("rv", set_fuzzyRankValue(state, util.get_rank(index))) # rank value
TV = FuzzySymbol("tv", 0.01 if state.get_trump_suit() == util.get_suit(index) else 1.00) # trump value
SV = FuzzySymbol("sv", set_fuzzySuitValue(state, util.get_suit(index))) # suit value
kb.add_clause(RV)
kb.add_clause(TV)
kb.add_clause(SV)
def play(
player1, # type: Bot
player2, # type: Bot
state, # type: State
max_time=5000, # type: int
verbose=True, # type: bool
fast=False # type: bool
):
"""
Play a game between two given players, from the given starting state.
"""
pr('player1: {}'.format(player1), verbose)
pr('player2: {}'.format(player2), verbose)
# The game loop
while not state.finished():
player = player1 if state.whose_turn() == 1 else player2
# We introduce a state signature which essentially obscures the deck's perfect knowledge from the player
given_state = state.clone(signature=state.whose_turn()) if state.get_phase() == 1 else state.clone()
move = player.get_move(given_state) if fast else get_move(given_state, player, max_time, verbose)
if is_valid(move, player): # check for common mistakes
if move[0] is None:
pr('* Player {} performs a trump jack exchange'.format(state.whose_turn()), verbose)
else:
pr('* Player {} plays: {}{}'.format(state.whose_turn(), util.get_rank(move[0]), util.get_suit(move[0])), verbose)
if move[1] is not None:
pr('* Player {} melds a marriage between {}{} and {}{}'.format(state.whose_turn(), util.get_rank(move[0]), util.get_suit(move[0]), util.get_rank(move[1]), util.get_suit(move[1])), verbose)
state = state.next(move)
pr(state, verbose)
if not state.revoked() is None:
pr('! Player {} revoked (made illegal move), game finished.'.format(state.revoked()), verbose)
else:
state.set_to_revoked()
pr('Game finished. Player {} has won, receiving {} points.'.format(state.winner()[0], state.winner()[1]), verbose)
return state.winner()
def get_hand_value(self, state):
total_points = 0
for card in state.hand():
rank = util.get_rank(card)
if rank == 'J':
total_points += 2
elif rank == 'Q':
total_points += 3
elif rank == 'K':
total_points += 4
elif rank == '10':
total_points += 10
else:
total_points += 11
print(f"Total hand value = {total_points}")
return total_points
def heuristic_2a(self, player: int, depth: int,
curr_state: State) -> float:
MAX_POSSIBLE_POTENTIAL_POINTS = 11
potential_points = 0
played_card = curr_state.get_opponents_played_card()
if played_card is not None:
played_card = util.get_rank(played_card)
if played_card == 'J':
potential_points -= 2
elif played_card == 'Q':
potential_points -= 3
elif played_card == 'K':
potential_points -= 4
elif played_card == '10':
potential_points -= 10
elif played_card == 'A':
potential_points -= 11
return potential_points / MAX_POSSIBLE_POTENTIAL_POINTS
