BriscolAI.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/IGieckI/BriscolAI/blob/main/BriscolAI.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "zT1ofZKnU84E"
      },
      "outputs": [],
      "source": [
        "from enum import Enum\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "In08FhowRBdU",
        "outputId": "df8a6a27-3646-495b-a063-1fd030b952d0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.15.0\n",
            "Num GPUs Available:  0\n"
          ]
        }
      ],
      "source": [
        "# Cell not related to the project itself, but to check the GPU availability\n",
        "import tensorflow as tf\n",
        "import os\n",
        "print(tf.__version__)\n",
        "print(\"Num GPUs Available: \", len(tf.config.list_physical_devices('GPU')))\n",
        "os.environ['CUDA_VISIBLE_DEVICES'] = '0'\n",
        "# An AI model trained with reinforcement learning to play with Cactus 🥱\n",
        "# Look at the future reward management in the training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "uHxMGD3qfN4z"
      },
      "outputs": [],
      "source": [
        "class Card:\n",
        "    \"\"\"\n",
        "        Game card class\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, rank: int, seed: int):\n",
        "        self.rank = int(rank)\n",
        "        self.seed = int(seed)\n",
        "\n",
        "    def __str__(self):\n",
        "        return f\"{self.get_rank()} of {self.get_seed()}\"\n",
        "\n",
        "    def __hash__(self):\n",
        "        return self.seed * 10 + self.rank\n",
        "\n",
        "    def get_value(self) -> int:\n",
        "        \"\"\"\n",
        "        Get the point value of the card based on its rank\n",
        "        \"\"\"\n",
        "        point_values = {\n",
        "            0: 11,\n",
        "            1: 0,\n",
        "            2: 10,\n",
        "            3: 0,\n",
        "            4: 0,\n",
        "            5: 0,\n",
        "            6: 0,\n",
        "            7: 2,\n",
        "            8: 3,\n",
        "            9: 4,\n",
        "        }\n",
        "        return point_values.get(self.rank)\n",
        "\n",
        "    def get_value_from_hash(hash) -> int:\n",
        "        \"\"\"\n",
        "        Get the point value of the card based on its rank from hash\n",
        "        \"\"\"\n",
        "        point_values = {\n",
        "            0: 11,\n",
        "            1: 0,\n",
        "            2: 10,\n",
        "            3: 0,\n",
        "            4: 0,\n",
        "            5: 0,\n",
        "            6: 0,\n",
        "            7: 2,\n",
        "            8: 3,\n",
        "            9: 4,\n",
        "        }\n",
        "\n",
        "        return point_values[hash%10]\n",
        "\n",
        "    def get_rank(self) -> str:\n",
        "        \"\"\"\n",
        "        Get the rank of the card as string\n",
        "        \"\"\"\n",
        "        ranks = {\n",
        "            0: \"Ace\",\n",
        "            1: \"Two\",\n",
        "            2: \"Three\",\n",
        "            3: \"Four\",\n",
        "            4: \"Five\",\n",
        "            5: \"Six\",\n",
        "            6: \"Seven\",\n",
        "            7: \"Knave\",\n",
        "            8: \"Knight\",\n",
        "            9: \"King\"\n",
        "        }\n",
        "\n",
        "        return ranks.get(self.rank)\n",
        "\n",
        "    def get_seed(self) -> str:\n",
        "        \"\"\"\n",
        "        Get the seed of the card as string\n",
        "        \"\"\"\n",
        "        seeds = {\n",
        "            0: \"Cups\",\n",
        "            1: \"Denari\",\n",
        "            2: \"Swords\",\n",
        "            3: \"Sticks\"\n",
        "        }\n",
        "\n",
        "        return seeds.get(self.seed)\n",
        "\n",
        "    def compare_cards(self, other_card: 'Card') -> 'Card':\n",
        "        \"\"\"\n",
        "        Compare two cards to determine the winner ONLY based on their ranks NOT the seed\n",
        "\n",
        "        Args:\n",
        "            other_card : Card, The other card to compare\n",
        "\n",
        "        Returns:\n",
        "            Card: The winner card\n",
        "        \"\"\"\n",
        "        if self.get_point_value() > other_card.get_point_value():\n",
        "            return self\n",
        "        else:\n",
        "            return other_card\n",
        "\n",
        "class CardState(Enum):\n",
        "    NOT_IN_GAME_YET = 0\n",
        "    BRISCOLA = 1\n",
        "    IN_P1_HAND = 2\n",
        "    IN_P2_HAND = 3\n",
        "    PLAYED = 4\n",
        "    PLAYED_IN_PREVIOUS_TURNS = 5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "bajJlzu3d083"
      },
      "outputs": [],
      "source": [
        "class Agent():\n",
        "    \"\"\"\n",
        "        BriscolAI default Agent\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, gamma: float, memory_limit: int = 1000):\n",
        "        # Define hyper-parameters\n",
        "        self.gamma = gamma\n",
        "\n",
        "        def create_model():\n",
        "            model = keras.Sequential(\n",
        "                [\n",
        "                    layers.Input(shape=(40, 40)),\n",
        "                    layers.Flatten(),\n",
        "                    layers.Dense(32, activation='relu'),\n",
        "                    layers.Dense(32, activation='relu'),\n",
        "                    layers.Dense(32, activation='relu'),\n",
        "                    layers.Dense(32, activation='relu'),\n",
        "                    layers.Dense(units=3, activation='softmax')\n",
        "                ]\n",
        "            )\n",
        "\n",
        "            # !!! TRY ALSO MSE LOSS !!!\n",
        "            model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
        "\n",
        "            return model\n",
        "\n",
        "        # Create the action and target network\n",
        "        self.action_model = create_model()\n",
        "\n",
        "        self.target_model = create_model()\n",
        "        self.target_model.set_weights(self.action_model.get_weights())\n",
        "\n",
        "        # Create the state\n",
        "        self.previous_state = None\n",
        "        self.state = None\n",
        "\n",
        "        # Create the memory of states\n",
        "        self.memory = np.array([])\n",
        "        self.memory_limit = memory_limit\n",
        "\n",
        "    def set_state(self, state: np.ndarray):\n",
        "        \"\"\"\n",
        "            Set the new state and automatically the previous state\n",
        "        \"\"\"\n",
        "        self.previous_state = self.state\n",
        "        if self.state is None:\n",
        "            self.previous_state = state\n",
        "\n",
        "        self.state = state\n",
        "\n",
        "    def get_state(self) -> np.ndarray:\n",
        "        return np.copy(self.state)\n",
        "\n",
        "    def get_previous_state(self) -> np.ndarray:\n",
        "        return self.previous_state\n",
        "\n",
        "    def get_action(self) -> int:\n",
        "        return np.argmax(self.action_model.predict(self.state.reshape(-1, 40, 40), verbose=0)[0])\n",
        "\n",
        "    def save_in_memory(self, game_id: int, player: int, state: np.ndarray, action: int, reward: int, new_state: np.ndarray, done: bool):\n",
        "        if len(self.memory) >= self.memory_limit:\n",
        "            self.memory = self.memory[int(self.memory_limit / 2):]\n",
        "\n",
        "        self.memory = np.append(self.memory, {\n",
        "            \"game_id\": game_id,\n",
        "            \"player\": player,\n",
        "            \"current_state\": state,\n",
        "            \"action\":action,\n",
        "            \"reward\":reward,\n",
        "            \"next_state\":new_state,\n",
        "            \"done\" :done\n",
        "        })\n",
        "\n",
        "    def train(self, batch_size: int = 30):\n",
        "        # Choose a batch of random samples for training\n",
        "        random_indices = np.random.choice(len(self.memory), size=batch_size, replace=False)\n",
        "        batch_sample = self.memory[random_indices]\n",
        "        self.memory = np.delete(self.memory, random_indices)\n",
        "\n",
        "        q_target_values = []\n",
        "\n",
        "        # Train the network over the batch\n",
        "        for i, experience in enumerate(batch_sample):\n",
        "            q_target_value = self.target_model.predict(experience[\"current_state\"].reshape(1, 40, 40), verbose=0)\n",
        "            q_action_value = self.action_model.predict(experience[\"current_state\"].reshape(1, 40, 40), verbose=0)\n",
        "            print(\">>>>>>>>>>>>>>>>>>>>>>>>>>\")\n",
        "            print(q_target_value)\n",
        "            print(\"--------------------------\")\n",
        "            print(q_action_value)\n",
        "            print(\"<<<<<<<<<<<<<<<<<<<<<<<<<<\")\n",
        "\n",
        "            q_target_values.append(q_target_value)\n",
        "\n",
        "            if not experience[\"done\"]:\n",
        "                target_value = experience[\"reward\"] + self.gamma * np.amax(q_target_value)\n",
        "            else:\n",
        "                target_value = experience[\"reward\"]\n",
        "            print(q_action_value)\n",
        "            q_action_value[experience[\"action\"]] = target_value\n",
        "\n",
        "        self.action_model.train_on_batch(batch_sample[\"current_state\"], q_action_values)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "yrOWLoQGs0bD"
      },
      "outputs": [],
      "source": [
        "class Briscola():\n",
        "    def __init__(self):\n",
        "        self.reset()\n",
        "\n",
        "    def __str__(self):\n",
        "        out = f'''Cards in the deck: {len(self.deck) + 1} \\nBriscola: {self.briscola_card} \\nPlayed Card: {self.played_card}\\n\\n'''\n",
        "\n",
        "        out += 'Your hand:\\n'\n",
        "        for x, i in enumerate(self.p2_hand):\n",
        "            out += f'{x}) {i}\\n'\n",
        "\n",
        "        return out\n",
        "\n",
        "    def get_P1_state(self) -> np.ndarray:\n",
        "        p1_state = np.copy(self.state)\n",
        "        p1_state[p1_state == CardState.IN_P2_HAND.value] = CardState.NOT_IN_GAME_YET.value\n",
        "        return p1_state\n",
        "\n",
        "    def get_P2_state(self) -> np.ndarray:\n",
        "        p2_state = np.copy(self.state)\n",
        "        p2_state[p2_state == CardState.IN_P1_HAND.value] = CardState.NOT_IN_GAME_YET.value\n",
        "        return p2_state\n",
        "\n",
        "    def print_state(state):\n",
        "        # Utility function to save a state as scv\n",
        "        df = pd.DataFrame(state)\n",
        "        df.to_csv('data.csv', index=False)\n",
        "\n",
        "    def draw_card(self) -> Card:\n",
        "        \"\"\"\n",
        "        Each player draw from the deck taking out cards from the deck list\n",
        "        \"\"\"\n",
        "        if len(self.deck) == 0:\n",
        "            self.briscola_drawn = True\n",
        "            return self.briscola_card\n",
        "\n",
        "        if len(self.deck) == 0:\n",
        "            return []\n",
        "\n",
        "        return self.deck.pop(0)\n",
        "\n",
        "    def create_deck(self) -> list[Card]:\n",
        "        \"\"\"\n",
        "        Create a new deck with cards in random position\n",
        "        \"\"\"\n",
        "        deck = [Card(rank, seed) for rank in np.arange(0,10) for seed in np.arange(0,4)]\n",
        "        np.random.shuffle(deck)\n",
        "\n",
        "        return deck\n",
        "\n",
        "    def fight(self, first_card: Card, second_card: Card):\n",
        "        \"\"\"\n",
        "        Tells who win between the two cards\n",
        "\n",
        "        Args:\n",
        "            first_card : Card, first card played\n",
        "            second_card : Card, second card played\n",
        "\n",
        "        Returns:\n",
        "            Card : The winner Card\n",
        "        \"\"\"\n",
        "\n",
        "        if first_card.seed == second_card.seed:\n",
        "            return first_card.compare_cards(second_card)\n",
        "\n",
        "        if first_card.seed == self.briscola_card.seed:\n",
        "            return first_card\n",
        "\n",
        "        if second_card.seed == self.briscola_card.seed:\n",
        "            return second_card\n",
        "\n",
        "        return first_card\n",
        "\n",
        "    def fight_hash(self, first_card_hash: int, second_card_hash: int):\n",
        "        \"\"\"\n",
        "        Tells who win between the two cards\n",
        "\n",
        "        Args:\n",
        "            first_card_hash : First card played's hash\n",
        "            second_card_hash : Second card played's hash\n",
        "\n",
        "        Returns:\n",
        "            Card : The winner Card's hash\n",
        "        \"\"\"\n",
        "\n",
        "        if first_card_hash//10 == second_card_hash//10:\n",
        "            power = {\n",
        "                0: 9, # Ace\n",
        "                1: 0, # Two\n",
        "                2: 8, # Three\n",
        "                3: 1, # Four\n",
        "                4: 2, # Five\n",
        "                5: 3, # Six\n",
        "                6: 4, # Seven\n",
        "                7: 5, # Knave\n",
        "                8: 6, # Knight\n",
        "                9: 7  # King\n",
        "            }\n",
        "            return power[first_card_hash%10] > power[second_card_hash%10]\n",
        "\n",
        "        if first_card_hash//10 == self.briscola_card.seed:\n",
        "            return first_card_hash\n",
        "\n",
        "        if second_card_hash//10 == self.briscola_card.seed:\n",
        "            return second_card_hash\n",
        "\n",
        "        return first_card_hash\n",
        "\n",
        "    def reset(self, ai_turn: bool = None):\n",
        "        \"\"\"Reset the current environement\"\"\"\n",
        "\n",
        "        # Create a deck and give cards to each player\n",
        "        self.deck = self.create_deck()\n",
        "\n",
        "        self.p1_hand = []\n",
        "        self.p2_hand = []\n",
        "\n",
        "        self.p1_hand.append(self.draw_card())\n",
        "        self.p1_hand.append(self.draw_card())\n",
        "        self.p1_hand.append(self.draw_card())\n",
        "\n",
        "        self.p2_hand.append(self.draw_card())\n",
        "        self.p2_hand.append(self.draw_card())\n",
        "        self.p2_hand.append(self.draw_card())\n",
        "\n",
        "        # Choose the briscola of the game and set a variable to check if the briscola (last card of the game) was drawn\n",
        "        self.briscola_card = self.draw_card()\n",
        "        self.briscola_drawn = False\n",
        "\n",
        "        # Initialize the scores\n",
        "        self.p1_score, self.p2_score = 0, 0\n",
        "\n",
        "        # Choose who start\n",
        "        self.turn = np.random.randint(0, 1) if ai_turn is None else int(ai_turn)\n",
        "        self.turn_number = 0\n",
        "\n",
        "        # Create the state to be given to the network\n",
        "        self.state = np.full((40,40), CardState.NOT_IN_GAME_YET.value)\n",
        "        self.state[hash(self.briscola_card), :] = CardState.BRISCOLA.value\n",
        "\n",
        "        for x in self.p1_hand:\n",
        "            self.state[hash(x), 0] = CardState.IN_P1_HAND.value\n",
        "        for x in self.p2_hand:\n",
        "            self.state[hash(x), 0] = CardState.IN_P2_HAND.value\n",
        "\n",
        "        # Last turn played card (if there is a card on the field, helping variable to save complexity later)\n",
        "        self.played_card = None\n",
        "        self.episode_ended = False\n",
        "\n",
        "        return\n",
        "\n",
        "    def step(self, action: int):\n",
        "        \"\"\"Apply action and return new time_step.\"\"\"\n",
        "\n",
        "        # Determine if the player choose a card number he don't have in the hand\n",
        "        if action < 0 or (self.turn == 0 and action >= len(self.p1_hand)) or (self.turn == 1 and action >= len(self.p2_hand)):\n",
        "            return self.state, -10000, False\n",
        "\n",
        "        # Each turn at the beginning is a copy of the previous turn\n",
        "        if self.turn_number > 0:\n",
        "            self.state[:, self.turn_number] = self.state[:, self.turn_number - 1]\n",
        "\n",
        "        chosen_card = self.p1_hand[action] if self.turn == 0 else self.p2_hand[action]\n",
        "\n",
        "        # Setup reward variable with model training purpose only, will be 0 if currently playing the first card on the table\n",
        "        reward = 0\n",
        "\n",
        "        # Id of the winner\n",
        "        winner = (self.turn + 1) % 2\n",
        "\n",
        "        # Determine if the turn player played the first card or is a reply to a played card\n",
        "        if self.turn_number % 2 == 0:\n",
        "            # Update the previous turn PLAYED cards into PLAYED_IN_PREVIOUS_TURNS cards\n",
        "            self.state[self.state[:, self.turn_number] == CardState.PLAYED.value, self.turn_number] = CardState.PLAYED_IN_PREVIOUS_TURNS.value\n",
        "            self.played_card = chosen_card\n",
        "        else:\n",
        "            # Determine the winner and assign round_points\n",
        "            winner = self.turn if self.fight_hash(hash(self.played_card), hash(chosen_card)) == hash(chosen_card) else (self.turn + 1) % 2\n",
        "            reward = Card.get_value_from_hash(hash(chosen_card)) + Card.get_value_from_hash(hash(self.played_card))\n",
        "\n",
        "        # Set played the chosen card\n",
        "        self.state[hash(chosen_card), self.turn_number] = CardState.PLAYED.value\n",
        "\n",
        "        if self.turn_number % 2 != 0:\n",
        "            # Update scores, assign rewards and draw cards\n",
        "            if winner == 0:\n",
        "                self.p1_score += reward\n",
        "\n",
        "                if not self.briscola_drawn:\n",
        "                    self.p1_hand.append(self.draw_card())\n",
        "                    self.p2_hand.append(self.draw_card())\n",
        "            else:\n",
        "                self.p2_score += reward\n",
        "\n",
        "                if not self.briscola_drawn:\n",
        "                    self.p2_hand.append(self.draw_card())\n",
        "                    self.p1_hand.append(self.draw_card())\n",
        "\n",
        "            # Update the state with both of the drew cards (only if a card is drawn)\n",
        "            if not self.briscola_drawn:\n",
        "                self.state[hash(self.p1_hand[-1]), self.turn_number] = CardState.IN_P1_HAND.value\n",
        "                self.state[hash(self.p2_hand[-1]), self.turn_number] = CardState.IN_P2_HAND.value\n",
        "\n",
        "            # Reset for next round\n",
        "            self.played_card = None\n",
        "\n",
        "        # Remove the used card\n",
        "        self.p1_hand.pop(action) if self.turn == 0 else self.p2_hand.pop(action)\n",
        "\n",
        "        # Switch turns\n",
        "        self.turn_number+=1\n",
        "        if winner != self.turn:\n",
        "            self.turn += 1\n",
        "            self.turn %= 2\n",
        "\n",
        "        # Check for game termination\n",
        "        self.episode_ended = (len(self.p1_hand) == 0 and len(self.p2_hand) == 0)\n",
        "\n",
        "        # Return the time step\n",
        "        return self.state, reward, self.episode_ended\n",
        "\n",
        "    def is_playing(self):\n",
        "        return not self.episode_ended\n",
        "\n",
        "    def get_winner(self):\n",
        "        if self.p1_score > self.p2_score:\n",
        "            return 0\n",
        "        elif self.p2_score > self.p1_score:\n",
        "            return 1\n",
        "        return 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "ZCaXiGwrRYNM"
      },
      "outputs": [],
      "source": [
        "# Training parameters\n",
        "total_episodes = 5000        # Total episodes\n",
        "learning_rate = 0.1           # Learning rate\n",
        "gamma = 0.99                  # Discounting rate\n",
        "\n",
        "# Exploration parameters\n",
        "epsilon = 1.0                 # Exploration rate\n",
        "epsilon_max = 1.0             # Exploration probability at start\n",
        "epsilon_min = 0.01            # Minimum exploration probability\n",
        "epsilon_decay = 0.001         # Exponential decay rate for exploration prob\n",
        "precalc_epsilon_dacay = np.exp(-epsilon_decay) # Pre-calculate the decay\n",
        "\n",
        "# System parameters\n",
        "memory_limit = 500           # Memory limit for the agent\n",
        "saving_rate = 100            # Saving rate for the model (each X episodes)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eQK9JPCMReHM"
      },
      "outputs": [],
      "source": [
        "# List of rewards to write a graph representation of the improvements\n",
        "rewards = []\n",
        "briscolAI = Agent(gamma, memory_limit)\n",
        "\n",
        "for episode in range(1, total_episodes):\n",
        "    print(f\"Episode: {episode}/{total_episodes} | Epsilon: {epsilon}\")\n",
        "\n",
        "    # Reset the environment\n",
        "    game = Briscola()\n",
        "\n",
        "    while game.is_playing():\n",
        "        briscolAI.set_state(game.get_P1_state() if game.turn == 0 else game.get_P2_state())\n",
        "\n",
        "        # If the random si greater than epsilon i'll take the biggest Q value for this state otherwise a random one\n",
        "        if np.random.uniform(0, 1) < epsilon:\n",
        "            action = np.random.randint(0, len(game.p1_hand if game.turn == 0 else game.p2_hand))\n",
        "        else:\n",
        "            action = briscolAI.get_action()\n",
        "\n",
        "        new_state, reward, episode_ended = game.step(action)\n",
        "\n",
        "        # Note: Here the game.turn check is reversed since during the game.step() turn change happen, but for the memory logic is \"not good\"\n",
        "        briscolAI.set_state(game.get_P1_state() if game.turn == 1 else game.get_P2_state())\n",
        "\n",
        "        # Add the memory to the replay buffer\n",
        "        briscolAI.save_in_memory(episode, game.turn, briscolAI.get_previous_state(), action, reward, briscolAI.get_state(), not game.is_playing())\n",
        "\n",
        "    # Update the rewards on the played actions during the last game\n",
        "    last_session_id = briscolAI.memory.iloc[-1][\"game_id\"]\n",
        "    winning_player = game.get_winner()\n",
        "    score_difference = 0\n",
        "\n",
        "    if winning_player != 2:\n",
        "        winning_score = game.p1_score - game.p2_score if winning_player == 0 else game.p2_score - game.p1_score\n",
        "\n",
        "    for sample_id in briscolAI.memory.index:\n",
        "        if briscolAI.memory[\"game_id\"].iloc[-sample_id] != last_session_id or winning_player == 2:\n",
        "            break\n",
        "        before = briscolAI.memory[\"reward\"].iloc[-sample_id]\n",
        "        if briscolAI.memory[\"player\"].iloc[-sample_id] == winning_player:\n",
        "            briscolAI.memory[\"reward\"].iloc[-sample_id] += winning_score\n",
        "        else:\n",
        "            briscolAI.memory[\"reward\"].iloc[-sample_id] -= winning_score\n",
        "\n",
        "    print(f\"Winner: {winning_player}, last ses id: {last_session_id} score: {winning_score}\")\n",
        "    print(f\"Score p1: {game.p1_score}, Score p2: {game.p2_score}\")\n",
        "\n",
        "    # Train the network over the memory\n",
        "    briscolAI.train()\n",
        "\n",
        "    # Save current state of the model\n",
        "    if episode % saving_rate == 0:\n",
        "        briscolAI.model.save('model.h5')\n",
        "\n",
        "    # Reduce of the espsilon factor\n",
        "    epsilon *= precalc_epsilon_dacay\n",
        "    if (epsilon <= epsilon_min):\n",
        "        epsilon = epsilon_min\n",
        "\n",
        "    rewards.append(abs(game.p1_score - game.p2_score))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lLN3zExCD3Zd"
      },
      "outputs": [],
      "source": [
        "# Print results data\n",
        "print (\"Average score difference over time: \" +  str(sum(rewards)/total_episodes))\n",
        "\n",
        "plt.plot(rewards)\n",
        "plt.xlabel('Number of games')\n",
        "plt.ylabel('Score difference')\n",
        "plt.grid(True)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xXoIfNBZx4Cu"
      },
      "outputs": [],
      "source": [
        "from google.colab import output\n",
        "\n",
        "# Play the game\n",
        "game = Briscola()\n",
        "\n",
        "# choose who play first\n",
        "if np.random.uniform(0, 1) < 0.5:\n",
        "    ai_turn = True\n",
        "else:\n",
        "    ai_turn = False\n",
        "\n",
        "game.reset(ai_turn)\n",
        "\n",
        "# start game\n",
        "while game.is_playing():\n",
        "    print(\"---------------------------------------------\")\n",
        "    print(game)\n",
        "\n",
        "    # Variables to display the fight text 5 lines after\n",
        "    previous_played_card = game.played_card\n",
        "\n",
        "    if ai_turn:\n",
        "        print(\"Player turn:\")\n",
        "        print(f\"Select the card by entering the index (ex:\\\"0\\\" -> to select {game.p2_hand[0]}):\")\n",
        "        action = int(input())   # CHECK THE INT TYPE !!!\n",
        "        current_played_card = game.p2_hand[action]\n",
        "        if action < 0 or action > len(game.p2_hand) - 1:\n",
        "            continue\n",
        "        print(f\"Player played {current_played_card}\\n\")\n",
        "        new_state, reward, episode_ended = game.step(action)\n",
        "    else:\n",
        "        print(\"BriscolAI turn:\")\n",
        "        action = np.random.randint(0, len(game.p1_hand))\n",
        "        current_played_card = game.p1_hand[action]\n",
        "        print(f\"BriscolAI played {current_played_card}\\n\")\n",
        "        new_state, reward, episode_ended = game.step(action)\n",
        "    print(f\"Game turn: {game.turn_number}\")\n",
        "\n",
        "    if game.turn_number % 2 == 0:\n",
        "        # Human did last turn\n",
        "        if game.turn == 0:\n",
        "            print(f\"BriscolAI took {previous_played_card} with {current_played_card}\")\n",
        "        else:\n",
        "            print(f\"Human took {previous_played_card} with {current_played_card}\")\n",
        "\n",
        "    ai_turn = not ai_turn\n",
        "    output.clear()\n",
        "\n",
        "print(game)\n",
        "winner = game.check_winner()\n",
        "\n",
        "if winner == ' ':\n",
        "    print(\"It's a draw!\")\n",
        "elif winner == \"BriscolAI\":\n",
        "    print(\"You lost!\")\n",
        "else:\n",
        "    print(\"You won!\")"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.10.14"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}