plot.py

import matplotlib.pyplot as plt
from validation import Validation as Val
import numpy as np


def plot_strategy_comparison(num_games : int):
    """Plot a bar chart comparing average costs of different strategies over specified number of games."""
    
    # Compare strategies and get their costs
    strategy_costs = validation_instance.compare_strategies(num_games=num_games)

     # Plotting the bar chart
    plt.figure(figsize=(10, 6))
    plt.bar(strategy_costs.keys(), strategy_costs.values(), color=['blue', 'green', 'orange', 'red', 'purple'])
    plt.xlabel('Strategies')
    plt.ylabel('Average Cost')
    plt.title('Comparison of Strategies')
    plt.show()


def plot_state_based_turns():
    """Plot the average number of turns per state for different strategies."""
    strategies = [validation_instance.optimal_policy,
                  validation_instance.safe_strategy,
                  validation_instance.normal_strategy,
                  validation_instance.risky_strategy,
                  validation_instance.random_strategy]
    strategy_names = ['Optimal', 'SafeDice', 'NormalDice', 'RiskyDice', 'Random']
    
    plt.figure(figsize=(12, 6))
    # Simulate and plot average turns for each strategy
    for strategy, name in zip(strategies, strategy_names):
        mean_turns = validation_instance.simulate_state(strategy, layout, circle, num_games)
        plt.plot(range(len(mean_turns)), mean_turns, marker='o', linestyle='-', label=name)

    plt.xlabel('State')
    plt.ylabel('Average Turns')
    plt.title('Average Turns per State for Different Strategies')
    plt.grid(True)
    plt.legend()
    plt.show()
    

def plot_state_based_comparison(num_games_list):
    """Plot a comparison between optimal turns and empirical turns per state for different num_games."""
    plt.figure(figsize=(12, 6))  # Create a single figure for all plots

    optimal_turns = None  # Initialize optimal_turns to None

    for num_games in num_games_list:
        _, empirical_turns = validation_instance.compare_state_based_turns(num_games=num_games)

        # Plotting empirical turns per state for the current num_games
        plt.plot(range(len(empirical_turns)), empirical_turns, marker='x', linestyle='-', label=f'Empirical (num_games={num_games})')

        if optimal_turns is None:
            # Only fetch optimal_turns once (for the first num_games)
            optimal_turns, _ = validation_instance.compare_state_based_turns(num_games=num_games)
            plt.plot(range(len(optimal_turns)), optimal_turns, marker='o', linestyle='-', label=f'ValueIteration')

    plt.xlabel('State')
    plt.ylabel('Average Turns')
    plt.title('Average Turns per State - ValueIteration vs. Empirical')
    plt.grid(True)
    plt.legend()
    plt.show()


def plot_state_based_comparison_once(num_games : int):
    optimal_turns, empirical_turns = validation_instance.compare_state_based_turns(num_games=num_games)

    # Plotting the state-based average turns comparison
    plt.figure(figsize=(12, 6))

    # Plot optimal strategy turns
    plt.plot(range(len(optimal_turns)), optimal_turns, marker='o', linestyle='-', label='ValueIteration')

    # Plot empirical strategy turns
    plt.plot(range(len(empirical_turns)), empirical_turns, marker='x', linestyle='-', label='Empirical')

    plt.xlabel('State')
    plt.ylabel('Average Turns')
    plt.title('Average Turns per State - ValueIteration vs. Empirical')
    plt.grid(True)
    plt.legend()

    plt.show()



if __name__ == '__main__':

    ##### Paramètres #####

    # Define the layout of the game board
    layout = [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0]
    # Indicates whether the board is circular or linear
    circle = False
    # Number of games to simulate
    num_games = 10000
    # Initialize Validation instance with the specified layout and circle type
    validation_instance = Val(layout, circle)

     ##### Launch Plots #####

    # Run the defined plotting functions with specified parameters
    plot_strategy_comparison(num_games)
    plot_state_based_turns()
    plot_state_based_comparison(num_games_list = [10, 100, 1000])
    plot_state_based_comparison_once(num_games)