game.py

import numbers
import numpy as np
from envido import Envido
from actions import game_actions, envido_actions, truco_actions, response_actions, playable_cards
from truco import Truco
from card_utils import encode_card_array, encode_envido, encode_truco
from card_game import CardGame
from dealer import Dealer

import logging


class TrucoGame:
    
    
    def __init__(self, players, goes_first=0):
        '''
        Initialize a Game of Truco.
        '''
        self.players = players
        self.dealer = Dealer()
        self.finished = False
        self.round = 0
        self.scoreboard = np.array([(p, 0) for p in players])
        self.first_move_by = self.players[goes_first] 
        self.second_move_by = self.players[1 - goes_first] 
        
        self.dealer.deal_cards_in_order(self.players)
        
        self.envido = Envido(self)
        self.truco = Truco(self)
        self.card_game = CardGame(self, self.first_move_by)

    def get_state(self, player):
        started =  1 if player == self.first_move_by else 0
        mano = 1 if player == self.get_mano() else 0
        game_config = np.array([started, mano], dtype=np.int8)
        
        score = []
        for p, s in self.scoreboard:
            p_id = 1 if player == p else 0
            turn = [p_id, s]
            score.append(np.array(turn, dtype = np.int8))
        
        score = np.vstack(score)
    
        # Order cards from highest to lowest rank to reduce potential card space
        ordered_cards = sorted(player.hand, key=lambda x: x.tier, reverse=True)
        
        player_cards = np.array(encode_card_array(ordered_cards), dtype=np.int8)
            
        state = {
            'game': game_config,
            'player_cards': player_cards,
            'score': score,
            'cards_played': self.card_game.get_state(player),
            'envido_state': self.envido.get_state(player),
            'truco_state': self.truco.get_state(player)
            
        }
            
        return state
    
    def get_score(self, player):
        if self.scoreboard[0][0] == player:
            return self.scoreboard[0][1]
        else:
            return self.scoreboard[1][1]
        
        return 0
    
    def get_winner(self):
        if self.finished:
            if self.scoreboard[0][1] >= self.scoreboard[1][1]:
                return self.scoreboard[0][0]
            else:
                return self.scoreboard[1][0]
            
        return None
        
    def get_legal_actions(self, player):
        if self.get_mano() != player:
            return []
        elif self.envido.is_active():
            return self.envido.get_legal_actions(player)  + ['fold']
        elif self.truco.is_active():
            return self.truco.get_legal_actions(player)  + ['fold']
        
        aggregate = ['fold']
        
        if self.round == 0 and not self.truco.is_started():
            aggregate.extend(self.envido.get_legal_actions(player))
    
        aggregate.extend(self.truco.get_legal_actions(player))
        
        return np.hstack((aggregate, self.card_game.get_legal_actions(player)))
            
    
    def get_cards_played(self):
        return self.card_game.cards_played

    def update_score(self, player, score):
        if player == self.scoreboard[0][0]:
            self.scoreboard[0][1] += score
        else:
            self.scoreboard[1][1] += score
        
    def get_opponent(self, player):
        if player == self.players[0]:
            return self.players[1]
        else:
            return self.players[0]
    
    def get_mano(self):
        if self.envido.envido_next is not None:
            return self.envido.envido_next
        elif self.truco.truco_next is not None:
            return self.truco.truco_next
        return self.card_game.card_next
        
    def finish_hand(self):
        self.finished = True
        logging.info("Hand finished.")
        logging.info(f"{self.scoreboard[0][0]} scored {self.scoreboard[0][1]}")
        logging.info(f"{self.scoreboard[1][0]} scored {self.scoreboard[1][1]}")
    
    def finish_round(self):
        self.round += 1
        
        first_played = self.card_game.cards_played[-2]
        second_played = self.card_game.cards_played[-1]
        comparison = first_played[1].tier - second_played[1].tier
        if comparison >= 0:
            self.card_game.switch_turn() # switch if second person wins round
            logging.debug(f"{second_played[0]} won the round playing {str(second_played[1])}. They will start the next one.")
        
        winner = self.card_game.get_winner()
        if winner is not None: 
            if self.truco.is_started():
                reward = self.truco.get_reward()
                self.update_score(winner, reward)
                logging.debug(f"{winner} was rewarded {reward} for winning truco.")
            else:
                self.update_score(winner, 1)
                logging.debug(f"{winner} was rewarded 1 for winning hand.")
            self.finish_hand()
        else:
            logging.debug("Round finished")
        
    def take_action(self, player, action):
        if self.get_mano() != player:
            logging.warning(f"{player}: Can't play out of turn.")
            return 
        
        action_played = game_actions[action] if isinstance(action, numbers.Number) else action
        
        if action_played in envido_actions:
            if self.round == 0:
                if not self.truco.is_started():
                    self.envido.take_action(player, action_played) 
                else:
                    logging.warn(f"{player}: Envido can only be played before Truco.")
            else:
                logging.warning(f"{player}: Envido can only be played in the first round")
        elif action_played in truco_actions:
            if not self.envido.is_active():
                self.truco.take_action(player, action_played)
            else:
                logging.warning(f"{player} can't call {action_played} unless envido has finished.")
        elif action_played in response_actions:
            if self.envido.is_active() and self.envido.is_valid_state(action_played):
                if self.envido.envido_next == player:
                    self.envido.take_terminal_action(player, action_played) 
                else:
                    logging.warning(f"{player} can't call {action_played} envido for others.")
            elif self.truco.is_active() and self.truco.is_valid_state(action_played):
                self.truco.take_terminal_action(player, action_played)
            else:
                logging.warning(f"{player} can't call {action_played} right now.")
        elif action_played in playable_cards:
            if not self.envido.is_active():
                if not self.truco.is_active():
                    self.card_game.take_action(player, action_played)
                else:
                    logging.warning(f"{player} can't play the card {action_played} before responding to truco.")
            else:
                logging.warning(f"{player} can't play the card {action_played} before responding to envido.")
        elif action_played == "fold":
            logging.info(f"{player} folded.")
            if self.envido.is_started():
                self.envido.fold(player)
                
            if self.truco.is_started():
                self.truco.fold(player)
            else:
                opponent = self.get_opponent(player)
                self.update_score(opponent, 1)
                logging.debug(f"{opponent} was rewarded 1 for winning hand.")
            self.finish_hand()