TrucoV1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "statutory-crawford",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: rlcard in c:\\users\\bautista\\appdata\\local\\programs\\python\\python39\\lib\\site-packages (1.0.4)\n",
      "Requirement already satisfied: more_itertools in c:\\users\\bautista\\appdata\\local\\programs\\python\\python39\\lib\\site-packages (8.10.0)\n",
      "Requirement already satisfied: numpy>=1.16.3 in c:\\users\\bautista\\appdata\\local\\programs\\python\\python39\\lib\\site-packages (from rlcard) (1.20.1)\n",
      "Requirement already satisfied: termcolor in c:\\users\\bautista\\appdata\\local\\programs\\python\\python39\\lib\\site-packages (from rlcard) (1.1.0)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: You are using pip version 21.0.1; however, version 21.2.4 is available.\n",
      "You should consider upgrading via the 'c:\\users\\bautista\\appdata\\local\\programs\\python\\python39\\python.exe -m pip install --upgrade pip' command.\n"
     ]
    }
   ],
   "source": [
    "!pip install rlcard more_itertools "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "excellent-tribune",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\r\n",
    "random.seed(69)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bridal-freeze",
   "metadata": {},
   "outputs": [],
   "source": [
    "card_tiers = [\r\n",
    "        (['E1'], 13),\r\n",
    "        (['B1'], 12),\r\n",
    "        (['E7'], 11),\r\n",
    "        (['O7'], 10),\r\n",
    "        (['E3', 'B3', 'O3', 'C3'], 9),\r\n",
    "        (['E2', 'B2', 'O2', 'C2'], 8),\r\n",
    "        (['O1', 'C1'], 7),\r\n",
    "        (['E12', 'B12', 'O12', 'C12'], 6),\r\n",
    "        (['E11', 'B11', 'O11', 'C11'], 5),\r\n",
    "        (['E10', 'B10', 'O10', 'C10'], 4),\r\n",
    "        (['C7', 'B7'], 3),\r\n",
    "        (['E6', 'B6', 'O6', 'C6'], 2),\r\n",
    "        (['E5', 'B5', 'O5', 'C6'], 1),\r\n",
    "        (['E4', 'B4', 'O4', 'C4'], 0)\r\n",
    "    ]\r\n",
    "\r\n",
    "''' Game-related base classes\r\n",
    "'''\r\n",
    "class Card:\r\n",
    "    '''\r\n",
    "    Card stores the suit and rank of a single card\r\n",
    "    Note:\r\n",
    "        The suit variable in a standard card game should be one of [C, B, E, O] meaning [Copa, Basto, Espada, Oro]\r\n",
    "        Similarly the rank variable should be one of ['1', '2', '3', '4', '5', '6', '7', '10', '11', '12']\r\n",
    "    '''\r\n",
    "    suit = None\r\n",
    "    rank = None\r\n",
    "    valid_suit = ['C', 'B', 'E', 'O']\r\n",
    "    valid_rank = ['1', '2', '3', '4', '5', '6', '7', '10', '11', '12']\r\n",
    "    \r\n",
    "\r\n",
    "    def __init__(self, suit, rank):\r\n",
    "        ''' Initialize the suit and rank of a card\r\n",
    "        Args:\r\n",
    "            suit: string, suit of the card, should be one of valid_suit\r\n",
    "            rank: string, rank of the card, should be one of valid_rank\r\n",
    "        '''\r\n",
    "        self.suit = suit\r\n",
    "        self.rank = rank\r\n",
    "        for cards, tier in card_tiers:\r\n",
    "            if suit+rank in cards:\r\n",
    "                self.tier = tier\r\n",
    "                break\r\n",
    "        \r\n",
    "\r\n",
    "    def __eq__(self, other):\r\n",
    "        if isinstance(other, Card):\r\n",
    "            return self.rank == other.rank and self.suit == other.suit\r\n",
    "        else:\r\n",
    "            # don't attempt to compare against unrelated types\r\n",
    "            return NotImplemented\r\n",
    "\r\n",
    "    def __hash__(self):\r\n",
    "        suit_index = Card.valid_suit.index(self.suit)\r\n",
    "        rank_index = Card.valid_rank.index(self.rank)\r\n",
    "        return rank_index + 100 * suit_index\r\n",
    "\r\n",
    "    def __str__(self):\r\n",
    "        ''' Get string representation of a card.\r\n",
    "        Returns:\r\n",
    "            string: the combination of rank and suit of a card. Eg: AS, 5H, JD, 3C, ...\r\n",
    "        '''\r\n",
    "        return self.get_index()\r\n",
    "    \r\n",
    "    def compare_as_str(self, card_as_string):\r\n",
    "        return card_as_string == self.__str__()\r\n",
    "    \r\n",
    "    def get_index(self):\r\n",
    "        ''' Get index of a card.\r\n",
    "        Returns:\r\n",
    "            string: the combination of suit and rank of a card. Eg: 1S, 2H, AD, BJ, RJ...\r\n",
    "        '''\r\n",
    "        return self.suit+self.rank"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "integrated-investment",
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_truco_deck():\r\n",
    "    ''' Initialize a truco deck of 52 cards\r\n",
    "    Returns:\r\n",
    "        (list): A list of Card object\r\n",
    "    '''\r\n",
    "    suit_list = ['C', 'B', 'E', 'O']\r\n",
    "    rank_list = ['1', '2', '3', '4', '5', '6', '7', '10', '11', '12']\r\n",
    "    res = [Card(suit, rank) for suit in suit_list for rank in rank_list]\r\n",
    "    return res\r\n",
    "\r\n",
    "def shuffle_cards(cards, in_place=False):\r\n",
    "    import random\r\n",
    "    if in_place:\r\n",
    "        random.shuffle(cards)\r\n",
    "        return cards\r\n",
    "    else:\r\n",
    "        import copy \r\n",
    "        copied_cards = copy.deepcopy(cards)\r\n",
    "        random.shuffle(copied_cards)\r\n",
    "        return copied_cards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "employed-attachment",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Player:\r\n",
    "    \r\n",
    "    def __init__(self, player_id):\r\n",
    "        ''' Initilize a player.\r\n",
    "        Args:\r\n",
    "            player_id (int): The id of the player\r\n",
    "        '''\r\n",
    "        self.player_id = player_id\r\n",
    "        self.hand = []\r\n",
    "        \r\n",
    "    def __str__(self):\r\n",
    "        return f\"Player {self.player_id} | Cards: {[str(c) for c in self.hand]}\"\r\n",
    "    \r\n",
    "    def __eq__(self, other):\r\n",
    "        if isinstance(other, Player):\r\n",
    "            return self.get_id() == other.get_id()\r\n",
    "        return False\r\n",
    "\r\n",
    "    def get_id(self):\r\n",
    "        ''' Return the id of the player\r\n",
    "        '''\r\n",
    "\r\n",
    "        return self.player_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "dying-sculpture",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dealer:\r\n",
    "    \r\n",
    "    def __init__(self):\r\n",
    "        '''\r\n",
    "        Initialize a dealer.\r\n",
    "        '''\r\n",
    "        self.deck = init_truco_deck()\r\n",
    "        shuffle_cards(self.deck, True)\r\n",
    "        \r\n",
    "    def deal_cards_in_order(self, players, amount=3):\r\n",
    "        player_index = 0\r\n",
    "        for _ in range(amount * len(players)):\r\n",
    "            if player_index == len(players):\r\n",
    "                player_index = 0\r\n",
    "            players[player_index].hand.append(self.deck.pop())\r\n",
    "            player_index+=1\r\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "based-summer",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\r\n",
    "\r\n",
    "\r\n",
    "truco_actions = np.array([ \r\n",
    "    'truco', \r\n",
    "    're-truco', \r\n",
    "    'vale cuatro'\r\n",
    "])\r\n",
    "\r\n",
    "envido_actions = np.array([ \r\n",
    "    'envido',\r\n",
    "    'real envido',\r\n",
    "])\r\n",
    "\r\n",
    "response_actions = np.array([ \r\n",
    "    'quiero',\r\n",
    "    'no quiero',\r\n",
    "])\r\n",
    "\r\n",
    "other_actions = np.array([\r\n",
    "    'fold'\r\n",
    "])\r\n",
    "\r\n",
    "playable_actions = np.concatenate((truco_actions, envido_actions, response_actions, other_actions))\r\n",
    "\r\n",
    "\r\n",
    "playable_cards = np.array([str(c) for c in init_truco_deck()])\r\n",
    "\r\n",
    "game_actions = np.concatenate((playable_actions, playable_cards))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "liked-mills",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "cards1 = [Card('C', '7'), Card('O', '7'), Card('C', '10')] \r\n",
    "cards2 = [Card('B', '7'), Card('O', '7'), Card('C', '10')]\r\n",
    "cards3 = [Card('O', '7'), Card('C', '11'), Card('C', '10')]\r\n",
    "cards4 = [Card('B', '7'), Card('B', '5'), Card('C', '10')]\r\n",
    "cards5 = [Card('B', '7'), Card('O', '5'), Card('C', '3')] \r\n",
    "cards6 = [Card('C', '11'), Card('C','5'), Card('C', '1')] \r\n",
    "cards7 = [Card('C', '11'), Card('C','10'), Card('C', '1')] \r\n",
    "cards8 = [Card('C', '11'), Card('C','7'), Card('C', '1')] \r\n",
    "cards9 = [Card('C', '11'), Card('C','10'), Card('C', '12')] \r\n",
    "cards10 = [Card('B', '7'), Card('C','10'), Card('E', '12')] \r\n",
    "\r\n",
    "def test(cards, expected):\r\n",
    "    result = calculate_envido(cards)\r\n",
    "    if result == expected:\r\n",
    "        print(True)\r\n",
    "    else:\r\n",
    "        print(f\"expected {expected} but got {result}\")\r\n",
    "\r\n",
    "test(cards1, 27)\r\n",
    "test(cards2, 7)\r\n",
    "test(cards3, 20)\r\n",
    "test(cards4, 32)\r\n",
    "test(cards5, 7)\r\n",
    "test(cards6, 26)\r\n",
    "test(cards7, 21)\r\n",
    "test(cards8, 28)\r\n",
    "test(cards9, 20)\r\n",
    "test(cards10, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "suspected-carolina",
   "metadata": {},
   "outputs": [],
   "source": [
    "from more_itertools import locate\r\n",
    "import numbers\r\n",
    "\r\n",
    "envido_states = [\r\n",
    "    (['envido', 'quiero'], 2),\r\n",
    "    (['envido', 'no quiero'], 1),\r\n",
    "    (['envido','envido', 'quiero'], 4),\r\n",
    "    (['envido','envido', 'no quiero'], 2),\r\n",
    "   (['envido', 'real envido', 'quiero'], 5),\r\n",
    "    (['envido', 'real envido', 'no quiero'], 2),\r\n",
    "    (['real envido', 'quiero'], 3),\r\n",
    "    (['real envido', 'no quiero'], 1)\r\n",
    "]\r\n",
    "\r\n",
    "\r\n",
    "truco_states = [\r\n",
    "    (['truco', 'quiero'], 2),\r\n",
    "    (['truco', 'no quiero'], 1),\r\n",
    "   (['truco', 're-truco', 'quiero'], 3),\r\n",
    "   (['truco', 're-truco', 'no quiero'], 2),\r\n",
    "    (['truco', 're-truco', 'vale cuatro', 'quiero'], 4),\r\n",
    "    (['truco', 're-truco', 'vale cuatro', 'no quiero'], 3),\r\n",
    "    # double downs\r\n",
    "   (['truco', 'quiero','re-truco', 'quiero'], 3),\r\n",
    "    (['truco', 'quiero','re-truco', 'no quiero'], 2),\r\n",
    "    (['truco', 're-truco', 'quiero', 'vale cuatro', 'quiero'], 4),\r\n",
    "    (['truco', 're-truco', 'quiero', 'vale cuatro', 'no quiero'], 3),\r\n",
    "    (['truco', 'quiero', 're-truco', 'vale cuatro', 'quiero'], 4),\r\n",
    "    (['truco', 'quiero', 're-truco', 'vale cuatro', 'no quiero'], 3),\r\n",
    "]\r\n",
    "\r\n",
    "\r\n",
    "\r\n",
    "def is_valid_state(all_states, current_state, action):\r\n",
    "    raw_state = np.append([call for player, call in current_state], action)\r\n",
    "    \r\n",
    "    for state, score in all_states:\r\n",
    "        zipped = list(zip(state, raw_state))\r\n",
    "        if len(zipped) != len(raw_state):\r\n",
    "            continue\r\n",
    "        if np.all([True if a == b else False for a, b in zipped]):\r\n",
    "            return True\r\n",
    "    return False\r\n",
    "\r\n",
    "def is_wager_finished(current_state):\r\n",
    "    return len(current_state) > 0 and current_state[-1][1] == 'quiero' or current_state[-1][1] ==  'no quiero'\r\n",
    "\r\n",
    "def is_wager_started(current_state):\r\n",
    "    return len(current_state) > 0;\r\n",
    "\r\n",
    "def is_wager_active(current_state):\r\n",
    "    return is_wager_started(current_state) and not is_wager_finished(current_state)\r\n",
    "\r\n",
    "def get_wager_reward(all_states, current_state):\r\n",
    "    raw_state = [call for player, call in current_state]\r\n",
    "    for state, score in all_states:\r\n",
    "        if len(state) == len(raw_state) and np.all(state == raw_state):\r\n",
    "            return score\r\n",
    "    raise Exception(f\"Can't get wager reward. No wager matching {raw_state}\")\r\n",
    "    \r\n",
    "    \r\n",
    "def rank_to_envido_value(rank):\r\n",
    "    if rank in ['10', '11', '12']:\r\n",
    "        return 10;\r\n",
    "    else:\r\n",
    "        return int(rank)\r\n",
    "    \r\n",
    "def calculate_envido(cards):\r\n",
    "    groups = {}\r\n",
    "    \r\n",
    "    for card in cards:\r\n",
    "        value = rank_to_envido_value(card.rank)\r\n",
    "        if card.suit in groups:\r\n",
    "            groups[card.suit].append(value)\r\n",
    "        else:\r\n",
    "            groups[card.suit] = [value]\r\n",
    "    \r\n",
    "    score = 0\r\n",
    "    for key, values in groups.items():\r\n",
    "        if len(values) == 1:\r\n",
    "            score = max(score, values[0] if values[0] != 10 else 0)\r\n",
    "        elif len(values) == 2:\r\n",
    "            #list with no duplicates\r\n",
    "            new_values = list(dict.fromkeys(values))\r\n",
    "            # double face card\r\n",
    "            if len(new_values) < len(values):\r\n",
    "                score = max(score, sum(values))\r\n",
    "            elif 10 in new_values:\r\n",
    "                score = max(score, sum(new_values) + 10)\r\n",
    "            else:\r\n",
    "                score = max(score, sum(new_values) + 20)\r\n",
    "        else:\r\n",
    "            #list with no duplicates\r\n",
    "            new_values = list(dict.fromkeys(values))\r\n",
    "            if len(new_values) == 1:\r\n",
    "                score = max(score, 20)\r\n",
    "            elif len(new_values) == 2:\r\n",
    "                score = max(score, sum(new_values) + 10)\r\n",
    "            elif 10 in new_values:\r\n",
    "                score = max(score, sum(new_values) + 10)\r\n",
    "            else:\r\n",
    "                two_largest = np.argsort(new_values)\r\n",
    "                score = max(score, sum(two_largest[-2:]))\r\n",
    "                \r\n",
    "    return score\r\n",
    "            \r\n",
    "\r\n",
    "class TrucoHand:\r\n",
    "    \r\n",
    "    \r\n",
    "    def __init__(self, players, goes_first=0):\r\n",
    "        '''\r\n",
    "        Initialize a Hand of Truco.\r\n",
    "        '''\r\n",
    "        self.players = players\r\n",
    "        self.finished = False\r\n",
    "        self.round = 0\r\n",
    "        self.truco_next = None\r\n",
    "        self.envido_next = None\r\n",
    "        self.has_retruco = None\r\n",
    "        self.card_next = self.players[goes_first]\r\n",
    "        self.cards_played = []\r\n",
    "        self.truco_calls = []\r\n",
    "        self.envido_calls = []\r\n",
    "        self.scoreboard = np.array([(p, 0) for p in players])\r\n",
    "        self.first_move_by = self.players[goes_first] \r\n",
    "        self.second_move_by = self.players[1 - goes_first] \r\n",
    "        \r\n",
    "    def get_envido_winner(self):    \r\n",
    "        p1_cards = np.concatenate(([card for player, card in self.cards_played if player == self.first_move_by], self.first_move_by.hand))\r\n",
    "        p2_cards = np.concatenate(([card for player, card in self.cards_played if player == self.second_move_by], self.second_move_by.hand))\r\n",
    "        \r\n",
    "        p1_envido = calculate_envido(p1_cards)\r\n",
    "        p2_envido = calculate_envido(p2_cards)\r\n",
    "        \r\n",
    "        print(f\"{self.first_move_by} has an envido of {p1_envido}\")\r\n",
    "        print(f\"{self.second_move_by} has an envido of {p2_envido}\")\r\n",
    "        \r\n",
    "        return self.first_move_by if p1_envido >= p2_envido else self.second_move_by\r\n",
    "    \r\n",
    "    def get_card_winner(self):\r\n",
    "        p1_cards = [card for player, card in self.cards_played if player == self.first_move_by]\r\n",
    "        p2_cards = [card for player, card in self.cards_played if player == self.second_move_by]\r\n",
    "        \r\n",
    "        p1_wins=0\r\n",
    "        p2_wins=0\r\n",
    "        next_wins = False\r\n",
    "        for c1, c2 in zip(p1_cards, p2_cards):\r\n",
    "            comparison = c1.tier - c2.tier\r\n",
    "            if comparison > 0:\r\n",
    "                p1_wins += 1\r\n",
    "                if next_wins:\r\n",
    "                    break\r\n",
    "            elif comparison < 0:\r\n",
    "                p2_wins += 1\r\n",
    "                if next_wins:\r\n",
    "                    break\r\n",
    "            elif comparison == 0:\r\n",
    "                if p1_wins > p2_wins:\r\n",
    "                    p1_wins += 1\r\n",
    "                    break;\r\n",
    "                elif p2_wins > p1_wins:\r\n",
    "                    p2_wins += 1\r\n",
    "                    break;\r\n",
    "                else:\r\n",
    "                    next_wins = True\r\n",
    "                \r\n",
    "        if p1_wins < 2 and p2_wins < 2:\r\n",
    "            return None\r\n",
    "        \r\n",
    "        return self.first_move_by if p1_wins >= p2_wins or (p1_wins == 0 and p2_wins == 0 and next_wins) else self.second_move_by\r\n",
    "\r\n",
    "    def update_score(self, player, score):\r\n",
    "        if player == self.scoreboard[0][0]:\r\n",
    "            self.scoreboard[0][1] += score\r\n",
    "        else:\r\n",
    "            self.scoreboard[1][1] += score\r\n",
    "    \r\n",
    "    def get_envido_reward(self):\r\n",
    "        return get_wager_reward(envido_states, self.envido_calls)\r\n",
    "    \r\n",
    "    def get_truco_reward(self):\r\n",
    "        return get_wager_reward(truco_states, self.truco_calls)\r\n",
    "        \r\n",
    "    def is_truco_started(self):\r\n",
    "        return is_wager_started(self.truco_calls)\r\n",
    "\r\n",
    "    def is_truco_active(self):\r\n",
    "        return is_wager_active(self.truco_calls)\r\n",
    "\r\n",
    "    def is_envido_active(self):\r\n",
    "        return is_wager_active(self.envido_calls)\r\n",
    "\r\n",
    "\r\n",
    "    def is_valid_envido_state(self, action):\r\n",
    "        return is_valid_state(envido_states, self.envido_calls, action)\r\n",
    "\r\n",
    "    def is_valid_truco_state(self, action):\r\n",
    "        return is_valid_state(truco_states, self.truco_calls, action)\r\n",
    "    \r\n",
    "\r\n",
    "\r\n",
    "    def is_truco_finished(self):\r\n",
    "        return is_wager_finished(self.truco_calls)\r\n",
    "\r\n",
    "    def is_envido_finished(self):\r\n",
    "        return is_wager_finished(self.envido_calls)\r\n",
    "        \r\n",
    "    def get_opponent(self, player):\r\n",
    "        if player == self.players[0]:\r\n",
    "            return self.players[1]\r\n",
    "        else:\r\n",
    "            return self.players[0]\r\n",
    "        \r\n",
    "    def switch_card_turn(self):\r\n",
    "        self.card_next = self.get_opponent(self.card_next)\r\n",
    "    \r\n",
    "    def switch_envido_turn(self):\r\n",
    "        self.envido_next = self.get_opponent(self.envido_next)\r\n",
    "        \r\n",
    "    def switch_truco_turn(self):\r\n",
    "        self.truco_next = self.get_opponent(self.truco_next)\r\n",
    "        \r\n",
    "    def finish_hand(self):\r\n",
    "        self.finished = True\r\n",
    "        print(\"Hand finished.\")\r\n",
    "        print(f\"{self.scoreboard[0][0]} scored {self.scoreboard[0][1]}\")\r\n",
    "        print(f\"{self.scoreboard[1][0]} scored {self.scoreboard[1][1]}\")\r\n",
    "    \r\n",
    "    def finish_round(self):\r\n",
    "        self.round += 1\r\n",
    "        \r\n",
    "        first_played = self.cards_played[-2]\r\n",
    "        second_played = self.cards_played[-1]\r\n",
    "        comparison = first_played[1].tier - second_played[1].tier\r\n",
    "        if comparison >= 0:\r\n",
    "            self.switch_card_turn() # switch if second person wins round\r\n",
    "            print(f\"{self.card_next} won the round. They will start the next.\")\r\n",
    "            \r\n",
    "        print(\"Round finished\")\r\n",
    "        \r\n",
    "        winner = self.get_card_winner()\r\n",
    "        if winner is not None: \r\n",
    "            if self.is_truco_started():\r\n",
    "                reward = self.get_truco_reward()\r\n",
    "                self.update_score(winner, reward)\r\n",
    "                print(f\"{winner} was rewarded {reward} for winning truco.\")\r\n",
    "            else:\r\n",
    "                self.update_score(winner, 1)\r\n",
    "                print(f\"{winner} was rewarded 1 for winning hand.\")\r\n",
    "            self.finish_hand()\r\n",
    "        \r\n",
    "    def take_action(self, action):\r\n",
    "        player = self.card_next\r\n",
    "        if self.envido_next is not None:\r\n",
    "            player = self.envido_next\r\n",
    "        elif self.truco_next is not None:\r\n",
    "            player = self.truco_next\r\n",
    "            \r\n",
    "        action_played = game_actions[action] if isinstance(action, numbers.Number) else action\r\n",
    "        \r\n",
    "        if action_played in envido_actions:\r\n",
    "            if self.round == 0:\r\n",
    "                if not self.is_truco_active():\r\n",
    "                    if len(self.envido_calls) == 0:\r\n",
    "                        self.envido_calls.append((player, action_played))\r\n",
    "                        print(f\"{player} called {action_played}.\")\r\n",
    "                        self.envido_next = self.get_opponent(player)\r\n",
    "                    elif self.envido_calls[-1][0] != player and self.is_valid_envido_state(action_played):\r\n",
    "                        self.envido_calls.append((player, action_played))\r\n",
    "                        print(f\"{player} called {action_played}\")\r\n",
    "                        self.switch_envido_turn()\r\n",
    "                    else:\r\n",
    "                        print(f\"{player} can't call {action_played}.\")\r\n",
    "                else:\r\n",
    "                    print(f\"{player}: Envido can only be played before Truco.\")\r\n",
    "            else:\r\n",
    "                print(f\"{player}: Envido can only be played in the first round\")\r\n",
    "        elif action_played in truco_actions:\r\n",
    "            if not self.is_envido_active():\r\n",
    "                if not self.is_truco_started() and action_played == \"truco\":\r\n",
    "                    self.truco_calls.append((player,action_played))\r\n",
    "                    print(f\"{player} called {action_played}\")\r\n",
    "                    self.truco_next = self.get_opponent(player)\r\n",
    "                elif self.is_truco_started() and self.is_valid_truco_state(action_played):\r\n",
    "                    if self.is_truco_active() and self.truco_next == player:\r\n",
    "                        self.truco_calls.append((player, action_played))\r\n",
    "                        print(f\"{player} called {action_played}\")\r\n",
    "                        self.truco_next = self.get_opponent(player)\r\n",
    "                    elif self.has_retruco == player:\r\n",
    "                        self.truco_calls.append((player, action_played))\r\n",
    "                        print(f\"{player} called {action_played}\")\r\n",
    "                        self.truco_next = self.get_opponent(player)\r\n",
    "                        self.has_retruco = self.truco_next \r\n",
    "                    else:\r\n",
    "                        print(f\"{player} can't call {action_played}.\")\r\n",
    "                else:\r\n",
    "                    print(f\"{player} can't call {action_played}.\")\r\n",
    "            else:\r\n",
    "                print(f\"{player} can't call {action_played} unless envido has finished.\")\r\n",
    "        elif action_played in response_actions:\r\n",
    "            if self.is_envido_active() and self.is_valid_envido_state(action_played):\r\n",
    "                self.envido_calls.append((player, action_played))\r\n",
    "                print(f\"{player} called {action_played} envido\")\r\n",
    "                if action_played == \"no quiero\":\r\n",
    "                    opponent = self.get_opponent(player)\r\n",
    "                    reward = self.get_envido_reward()\r\n",
    "                    self.update_score(opponent, reward)\r\n",
    "                    print(f\"{opponent} was rewarded {reward} for winning envido.\")\r\n",
    "                else:\r\n",
    "                    winner = self.get_envido_winner()\r\n",
    "                    reward = self.get_envido_reward()\r\n",
    "                    self.update_score(winner, reward)\r\n",
    "                    print(f\"{winner} was rewarded {reward} for winning envido.\")\r\n",
    "                # de-activate envido    \r\n",
    "                self.envido_next = None\r\n",
    "            elif self.is_truco_active() and self.is_valid_truco_state(action_played):\r\n",
    "                self.truco_calls.append((player, action_played))\r\n",
    "                print(f\"{player} called {action_played} truco\")\r\n",
    "                if action_played == \"no quiero\":\r\n",
    "                    opponent = self.get_opponent(player)\r\n",
    "                    reward = self.get_truco_reward()\r\n",
    "                    self.update_score(opponent, reward)\r\n",
    "                    print(f\"{opponent} was rewarded {reward} for winning truco.\")\r\n",
    "                    self.finish_hand()\r\n",
    "                else:\r\n",
    "                    #No response needed\r\n",
    "                    self.has_retruco = player\r\n",
    "                    self.truco_next = None\r\n",
    "            else:\r\n",
    "                print(f\"{player} can't call {action_played} right now.\")\r\n",
    "        elif action_played in playable_cards:\r\n",
    "            if not self.is_envido_active():\r\n",
    "                if not self.is_truco_active():\r\n",
    "                    card_played_indexes = list(locate(player.hand, lambda c: c.compare_as_str(action_played)))\r\n",
    "                    if len(card_played_indexes) == 1:\r\n",
    "                        card_played = player.hand.pop(card_played_indexes[0])\r\n",
    "                        self.cards_played.append((player, card_played))\r\n",
    "                        print(f\"{player} played {card_played}\")\r\n",
    "                        if len(self.cards_played) % 2 == 0:\r\n",
    "                            self.finish_round()\r\n",
    "                        else:\r\n",
    "                            self.switch_card_turn()\r\n",
    "                    elif len(card_played_indexes) > 1:\r\n",
    "                        print(f\"{player}: card_played_indexes should never be > 1. Current value: {card_played_indexes}\")\r\n",
    "                    else:\r\n",
    "                        print(f\"{player} can't play the card {action_played}. They don't have it.\")\r\n",
    "                else:\r\n",
    "                    print(f\"{player} can't play the card {action_played} before responding to truco.\")\r\n",
    "            else:\r\n",
    "                print(f\"{player} can't play the card {action_played} before responding to envido.\")\r\n",
    "        elif action_played == \"fold\":\r\n",
    "            print(f\"{player} folded.\")\r\n",
    "            if self.is_envido_active():\r\n",
    "                self.envido_calls.append((player, 'no quiero'))\r\n",
    "                print(f\"{player} forfeited envido\")\r\n",
    "                opponent = self.get_opponent(player)\r\n",
    "                reward = self.get_envido_reward()\r\n",
    "                self.update_score(opponent, reward)\r\n",
    "                print(f\"{opponent} was rewarded {reward} for winning envido.\")\r\n",
    "            if self.is_truco_started():\r\n",
    "                if self.is_truco_active():\r\n",
    "                    self.truco_calls.append((player, 'no quiero'))\r\n",
    "                print(f\"{player} forfeited truco\")\r\n",
    "                opponent = self.get_opponent(player)\r\n",
    "                reward = self.get_truco_reward()\r\n",
    "                self.update_score(opponent, reward)\r\n",
    "                print(f\"{opponent} was rewarded {reward} for winning truco.\")\r\n",
    "            else:\r\n",
    "                opponent = self.get_opponent(player)\r\n",
    "                self.update_score(opponent, 1)\r\n",
    "                print(f\"{opponent} was rewarded 1 for winning hand.\")\r\n",
    "            self.finish_hand()\r\n",
    "            \r\n",
    "        \r\n",
    "            \r\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 430,
   "id": "arranged-reduction",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_players = 2\n",
    "\n",
    "players = [Player(id) for id in range(num_players)]\n",
    "\n",
    "dealer = Dealer()\n",
    "dealer.deal_cards_in_order(players)\n",
    "\n",
    "hand = TrucoHand(players)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 431,
   "id": "massive-respondent",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 0 | Cards: ['B4', 'O7', 'C10']\n",
      "Player 1 | Cards: ['E6', 'O6', 'C6']\n"
     ]
    }
   ],
   "source": [
    "for p in players:\n",
    "    print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 432,
   "id": "bridal-diversity",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 0 | Cards: ['B4', 'O7', 'C10'] called truco\n"
     ]
    }
   ],
   "source": [
    "hand.take_action('truco')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 437,
   "id": "brave-freight",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 0 | Cards: ['B4', 'C10'] called quiero truco\n"
     ]
    }
   ],
   "source": [
    "hand.take_action('quiero')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "subjective-section",
   "metadata": {},
   "outputs": [],
   "source": [
    "hand.take_action('envido')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "danish-vault",
   "metadata": {},
   "outputs": [],
   "source": [
    "hand.take_action('real envido')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "caroline-straight",
   "metadata": {},
   "outputs": [],
   "source": [
    "hand.take_action('no quiero')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 436,
   "id": "surrounded-climate",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 1 | Cards: ['E6', 'O6', 'C6'] called re-truco\n"
     ]
    }
   ],
   "source": [
    "hand.take_action('re-truco')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 435,
   "id": "outside-rouge",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 0 | Cards: ['B4', 'C10'] played O7\n"
     ]
    }
   ],
   "source": [
    "hand.take_action('O7')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 438,
   "id": "dominican-vietnamese",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 1 | Cards: ['O6', 'C6'] played E6\n",
      "Player 0 | Cards: ['B4', 'C10'] won the round. They will start the next.\n",
      "Round finished\n"
     ]
    }
   ],
   "source": [
    "hand.take_action('E6')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 439,
   "id": "northern-russia",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 0 | Cards: ['B4'] played C10\n"
     ]
    }
   ],
   "source": [
    "hand.take_action('C10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 440,
   "id": "polish-great",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 1 | Cards: ['O6'] played C6\n",
      "Player 0 | Cards: ['B4'] won the round. They will start the next.\n",
      "Round finished\n",
      "Player 0 | Cards: ['B4'] was rewarded 3 for winning truco.\n",
      "Hand finished.\n",
      "Player 0 | Cards: ['B4'] scored 3\n",
      "Player 1 | Cards: ['O6'] scored 0\n"
     ]
    }
   ],
   "source": [
    "hand.take_action('C6')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "protective-traffic",
   "metadata": {},
   "outputs": [],
   "source": [
    "hand.take_action('O1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "advised-privacy",
   "metadata": {},
   "outputs": [],
   "source": [
    "hand.take_action('B11')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "stuffed-leone",
   "metadata": {},
   "outputs": [],
   "source": [
    "hand.take_action('fold')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "drawn-times",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "4ec81e3063e9841f4fd33b228f9b15acb3165ee35d4a5a8c1e63f7b8fb05311e"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}